tommy/tbd-station-14
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

GatherableSystem/Component (#8041)

Browse Source 
Co-authored-by: metalgearsloth <comedian_vs_clown@hotmail.com>
This commit is contained in:
Chris V
2022-05-12 05:53:31 -07:00
committed by GitHub
parent 0de06cb9c0
commit 6cb2a01723
12 changed files with 244 additions and 192 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Content.Client/Entry/IgnoredComponents.cs
View File

@@ -7,7 +7,6 @@ namespace Content.Client.Entry
{
"AirlockPainter",
"AmmoBox",
"Pickaxe",
"IngestionBlocker",
"Charger",
"CloningPod",
@@ -49,7 +48,6 @@ namespace Content.Client.Entry
"DiseaseZombie",
"DiseaseBuildup",
"ZombieTransfer",
"Mineable",
"RangedMagazine",
"RandomMetadata",
"Ammo",
@@ -307,6 +305,7 @@ namespace Content.Client.Entry
"ExtensionCableReceiver",
"ExtensionCableProvider",
"ApcNetworkConnection",
"Gatherable",
"SuitSensor",
"CrewMonitoringConsole",
"ApcNetSwitch",
@@ -321,6 +320,7 @@ namespace Content.Client.Entry
"FireAlarm",
"AirAlarm",
"RadarConsole",
"GatheringTool",
"Guardian",
"GuardianCreator",
"GuardianHost",

33
Content.Server/Gatherable/Components/GatherableComponent.cs Normal file
View File

@@ -0,0 +1,33 @@
using Content.Shared.EntityList;
using Content.Shared.Whitelist;
namespace Content.Server.Gatherable.Components;
[RegisterComponent]
[Friend(typeof(GatherableSystem))]
public sealed class GatherableComponent : Component
{
/// <summary>
/// Whitelist for specifying the kind of tools can be used on a resource
/// Supports multiple tags.
/// </summary>
[ViewVariables]
[DataField("whitelist", required: true)]
public EntityWhitelist? ToolWhitelist;
/// <summary>
/// YAML example below
/// (Tag1, Tag2, LootTableID1, LootTableID2 are placeholders for example)
/// --------------------
/// useMappedLoot: true
/// whitelist:
/// tags:
/// - Tag1
/// - Tag2
/// mappedLoot:
/// Tag1: LootTableID1
/// Tag2: LootTableID2
/// </summary>
[DataField("loot")]
public Dictionary<string, string>? MappedLoot = new();
}

44
Content.Server/Gatherable/Components/GatheringToolComponent.cs Normal file
View File

@@ -0,0 +1,44 @@
using System.Threading;
using Content.Shared.Damage;
using Content.Shared.Sound;
namespace Content.Server.Gatherable.Components
{
/// <summary>
/// When interacting with an <see cref="GatherableComponent"/> allows it to spawn entities.
/// </summary>
[RegisterComponent]
public sealed class GatheringToolComponent : Component
{
/// <summary>
/// Sound that is made once you completed gathering
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
[DataField("sound")]
public SoundSpecifier GatheringSound { get; set; } = new SoundPathSpecifier("/Audio/Items/Mining/pickaxe.ogg");
/// <summary>
/// This directly plugs into the time delay for gathering.
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
[DataField("gatheringTime")]
public float GatheringTime { get; set; } = 1f;
/// <summary>
/// What damage should be given to objects when
/// gathered using this tool? (0 for infinite gathering)
/// </summary>
[DataField("damage", required: true)]
public DamageSpecifier Damage { get; set; } = default!;
/// <summary>
/// How many entities can this tool gather from at once?
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
[DataField("maxEntities")]
public int MaxGatheringEntities = 1;
[ViewVariables]
public readonly Dictionary<EntityUid, CancellationTokenSource> GatheringEntities = new();
}
}

111
Content.Server/Gatherable/GatherableSystem.cs Normal file
View File

@@ -0,0 +1,111 @@
using System.Threading;
using Content.Server.DoAfter;
using Content.Server.Gatherable.Components;
using Content.Shared.Damage;
using Content.Shared.EntityList;
using Content.Shared.Interaction;
using Content.Shared.Tag;
using Robust.Shared.Audio;
using Robust.Shared.Player;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
namespace Content.Server.Gatherable;
public sealed class GatherableSystem : EntitySystem
{
[Dependency] private readonly DoAfterSystem _doAfterSystem = default!;
[Dependency] private readonly DamageableSystem _damageableSystem = default!;
[Dependency] private readonly IRobustRandom _random = null!;
[Dependency] private readonly TagSystem _tagSystem = Get<TagSystem>();
[Dependency] private readonly IPrototypeManager _prototypeManager = default!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<GatherableComponent, InteractUsingEvent>(OnInteractUsing);
SubscribeLocalEvent<GatheringDoafterCancel>(OnDoafterCancel);
SubscribeLocalEvent<GatherableComponent, GatheringDoafterSuccess>(OnDoafterSuccess);
}
private void OnInteractUsing(EntityUid uid, GatherableComponent component, InteractUsingEvent args)
{
if (!TryComp<GatheringToolComponent>(args.Used, out var tool) ||
component.ToolWhitelist?.IsValid(args.Used) == false ||
tool.GatheringEntities.TryGetValue(uid, out var cancelToken))
return;
// Can't gather too many entities at once.
if (tool.MaxGatheringEntities < tool.GatheringEntities.Count + 1)
return;
cancelToken = new CancellationTokenSource();
tool.GatheringEntities[uid] = cancelToken;
var doAfter = new DoAfterEventArgs(args.User, tool.GatheringTime, cancelToken.Token, uid)
{
BreakOnDamage = true,
BreakOnStun = true,
BreakOnTargetMove = true,
BreakOnUserMove = true,
MovementThreshold = 0.25f,
BroadcastCancelledEvent = new GatheringDoafterCancel { Tool = args.Used, Resource = uid },
TargetFinishedEvent = new GatheringDoafterSuccess { Tool = args.Used, Resource = uid, Player = args.User }
};
_doAfterSystem.DoAfter(doAfter);
}
private void OnDoafterSuccess(EntityUid uid, GatherableComponent component, GatheringDoafterSuccess ev)
{
if (!TryComp(ev.Tool, out GatheringToolComponent? tool))
return;
// Complete the gathering process
_damageableSystem.TryChangeDamage(ev.Resource, tool.Damage);
SoundSystem.Play(Filter.Pvs(ev.Resource, entityManager: EntityManager), tool.GatheringSound.GetSound(), ev.Resource);
tool.GatheringEntities.Remove(ev.Resource);
// Spawn the loot!
if (component.MappedLoot == null) return;
var playerPos = Transform(ev.Player).MapPosition;
foreach (var (tag, table) in component.MappedLoot)
{
if (tag != "All")
{
if (!_tagSystem.HasTag(tool.Owner, tag)) continue;
}
var getLoot = _prototypeManager.Index<EntityLootTablePrototype>(table);
var spawnLoot = getLoot.GetSpawns();
var spawnPos = playerPos.Offset(_random.NextVector2(0.3f));
Spawn(spawnLoot[0], spawnPos);
}
}
private void OnDoafterCancel(GatheringDoafterCancel ev)
{
if (!TryComp<GatheringToolComponent>(ev.Tool, out var tool))
return;
tool.GatheringEntities.Remove(ev.Resource);
}
private sealed class GatheringDoafterCancel : EntityEventArgs
{
public EntityUid Tool;
public EntityUid Resource;
}
private sealed class GatheringDoafterSuccess : EntityEventArgs
{
public EntityUid Tool;
public EntityUid Resource;
public EntityUid Player;
}
}

12
Content.Server/Mining/Components/MineableComponent.cs
View File

@@ -1,12 +0,0 @@
using System.Threading;
using Content.Shared.Storage;
namespace Content.Server.Mining.Components;
[RegisterComponent]
[Friend(typeof(MineableSystem))]
public sealed class MineableComponent : Component
{
[DataField("ores")] public List<EntitySpawnEntry> Ores = new();
public float BaseMineTime = 1.0f;
}

38
Content.Server/Mining/Components/PickaxeComponent.cs
View File

@@ -1,38 +0,0 @@
using System.Threading;
using Content.Shared.Damage;
using Content.Shared.Sound;
namespace Content.Server.Mining.Components
{
/// <summary>
/// When interacting with an <see cref="MineableComponent"/> allows it to spawn entities.
/// </summary>
[RegisterComponent]
public sealed class PickaxeComponent : Component
{
[ViewVariables(VVAccess.ReadWrite)]
[DataField("sound")]
public SoundSpecifier MiningSound { get; set; } = new SoundPathSpecifier("/Audio/Items/Mining/pickaxe.ogg");
[ViewVariables(VVAccess.ReadWrite)]
[DataField("timeMultiplier")]
public float MiningTimeMultiplier { get; set; } = 1f;
/// <summary>
/// What damage should be given to objects when
/// mined using a pickaxe?
/// </summary>
[DataField("damage", required: true)]
public DamageSpecifier Damage { get; set; } = default!;
/// <summary>
/// How many entities can this pickaxe mine at once?
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
[DataField("maxEntities")]
public int MaxMiningEntities = 1;
[ViewVariables]
public readonly Dictionary<EntityUid, CancellationTokenSource> MiningEntities = new();
}
}

99
Content.Server/Mining/MineableSystem.cs
View File

@@ -1,99 +0,0 @@
using System.Threading;
using Content.Server.DoAfter;
using Content.Server.Mining.Components;
using Content.Shared.Damage;
using Content.Shared.Interaction;
using Content.Shared.Storage;
using Robust.Shared.Audio;
using Robust.Shared.Player;
using Robust.Shared.Random;
namespace Content.Server.Mining;
public sealed class MineableSystem : EntitySystem
{
[Dependency] private readonly DoAfterSystem _doAfterSystem = default!;
[Dependency] private readonly DamageableSystem _damageableSystem = default!;
[Dependency] private readonly IRobustRandom _random = null!;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<MineableComponent, InteractUsingEvent>(OnInteractUsing);
SubscribeLocalEvent<MiningDoafterCancel>(OnDoafterCancel);
SubscribeLocalEvent<MineableComponent, MiningDoafterSuccess>(OnDoafterSuccess);
}
private void OnInteractUsing(EntityUid uid, MineableComponent component, InteractUsingEvent args)
{
if (!TryComp<PickaxeComponent>(args.Used, out var pickaxe))
return;
if (pickaxe.MiningEntities.TryGetValue(uid, out var cancelToken))
{
cancelToken.Cancel();
pickaxe.MiningEntities.Remove(uid);
return;
}
// Can't mine too many entities at once.
if (pickaxe.MaxMiningEntities < pickaxe.MiningEntities.Count + 1)
return;
cancelToken = new CancellationTokenSource();
pickaxe.MiningEntities[uid] = cancelToken;
var doAfter = new DoAfterEventArgs(args.User, component.BaseMineTime * pickaxe.MiningTimeMultiplier, cancelToken.Token, uid)
{
BreakOnDamage = true,
BreakOnStun = true,
BreakOnTargetMove = true,
BreakOnUserMove = true,
MovementThreshold = 0.25f,
BroadcastCancelledEvent = new MiningDoafterCancel { Pickaxe = args.Used, Rock = uid },
TargetFinishedEvent = new MiningDoafterSuccess { Pickaxe = args.Used, Rock = uid, Player = args.User }
};
_doAfterSystem.DoAfter(doAfter);
}
private void OnDoafterSuccess(EntityUid uid, MineableComponent component, MiningDoafterSuccess ev)
{
if (!TryComp(ev.Pickaxe, out PickaxeComponent? pickaxe))
return;
_damageableSystem.TryChangeDamage(ev.Rock, pickaxe.Damage);
SoundSystem.Play(Filter.Pvs(ev.Rock, entityManager: EntityManager), pickaxe.MiningSound.GetSound(), ev.Rock);
pickaxe.MiningEntities.Remove(ev.Rock);
var spawnOre = EntitySpawnCollection.GetSpawns(component.Ores, _random);
var playerPos = Transform(ev.Player).MapPosition;
var spawnPos = playerPos.Offset(_random.NextVector2(0.3f));
EntityManager.SpawnEntity(spawnOre[0], spawnPos);
pickaxe.MiningEntities.Remove(uid);
}
private void OnDoafterCancel(MiningDoafterCancel ev)
{
if (!TryComp<PickaxeComponent>(ev.Pickaxe, out var pickaxe))
return;
pickaxe.MiningEntities.Remove(ev.Rock);
}
private sealed class MiningDoafterCancel : EntityEventArgs
{
public EntityUid Pickaxe;
public EntityUid Rock;
}
}
// grumble grumble
public sealed class MiningDoafterSuccess : EntityEventArgs
{
public EntityUid Pickaxe;
public EntityUid Rock;
public EntityUid Player;
}

5
Resources/Prototypes/Entities/Objects/Misc/paper.yml
View File

@@ -85,14 +85,11 @@
- type: Tag
tags:
- Write
- Pickaxe
- type: Sprite
sprite: Objects/Misc/bureaucracy.rsi
state: overpriced_pen
netsync: false
- type: Pickaxe
damage:
types:
Piercing: 5
- type: ItemCooldown
- type: MeleeWeapon
damage:

12
Resources/Prototypes/Entities/Objects/Weapons/Melee/pickaxe.yml
View File

@@ -4,10 +4,13 @@
id: Pickaxe
description: Notched to perfection, for jamming it into rocks
components:
- type: Tag
tags:
- Pickaxe
- type: Sprite
sprite: Objects/Weapons/Melee/pickaxe.rsi
state: pickaxe
- type: Pickaxe
- type: GatheringTool
damage:
types:
Piercing: 25
@@ -29,14 +32,17 @@
id: MiningDrill
description: Powerful tool used to quickly drill through rocks
components:
- type: Tag
tags:
- Pickaxe
- type: Sprite
sprite: Objects/Tools/handdrill.rsi
state: handdrill
- type: Pickaxe
- type: GatheringTool
damage:
types:
Piercing: 25
timeMultiplier: 0.75
gatheringTime: 0.75
- type: ItemCooldown
- type: MeleeWeapon
damage:

26
Resources/Prototypes/Entities/Structures/Walls/asteroid.yml
View File

@@ -4,26 +4,12 @@
name: asteroid rock
description: An asteroid.
components:
- type: Mineable
ores:
- id: SteelOre1
prob: 0.25
orGroup: Asteroid
- id: GoldOre1
prob: 0.05
orGroup: Asteroid
- id: SpaceQuartz1
prob: 0.20
orGroup: Asteroid
- id: PlasmaOre1
prob: 0.10
orGroup: Asteroid
- id: SilverOre1
prob: 0.025
orGroup: Asteroid
- id: UraniumOre1
prob: 0.025
orGroup: Asteroid
- type: Gatherable
whitelist:
tags:
- Pickaxe
loot:
Pickaxe: MiningLootTable
- type: Sprite
sprite: Structures/Walls/asteroid_rock.rsi
state: full

21
Resources/Prototypes/LootTables/mining_loot_table.yml Normal file
View File

@@ -0,0 +1,21 @@
- type: entityLootTable
id: MiningLootTable
entries:
- id: SteelOre1
prob: 0.25
orGroup: Asteroid
- id: GoldOre1
prob: 0.05
orGroup: Asteroid
- id: SpaceQuartz1
prob: 0.20
orGroup: Asteroid
- id: PlasmaOre1
prob: 0.10
orGroup: Asteroid
- id: SilverOre1
prob: 0.025
orGroup: Asteroid
- id: UraniumOre1
prob: 0.025
orGroup: Asteroid

5
Resources/Prototypes/tags.yml
View File

@@ -244,7 +244,7 @@
id: PercussionInstrument
- type: Tag
id: Plastic
id: Pickaxe
- type: Tag
id: Pill
@@ -267,6 +267,9 @@
- type: Tag
id: PlantSampleTaker
- type: Tag
id: Plastic
- type: Tag
id: Powerdrill