Cinka/OldThink
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Refactors smoking to ECS, smoking actually makes you inhale reagents. (#4678)

Browse Source
This commit is contained in:
Vera Aguilera Puerto
2021-09-26 15:19:00 +02:00
committed by GitHub
parent 0767bd3777
commit f913d8361d
19 changed files with 284 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
Content.Server/Nutrition/Components/CigarComponent.cs Normal file
View File

@@ -0,0 +1,15 @@
using Content.Server.Nutrition.EntitySystems;
using Robust.Shared.Analyzers;
using Robust.Shared.GameObjects;
namespace Content.Server.Nutrition.Components
{
/// <summary>
/// A disposable, single-use smokable.
/// </summary>
[RegisterComponent, Friend(typeof(SmokingSystem))]
public class CigarComponent : Component
{
public override string Name => "Cigar";
}
}

27
Content.Server/Nutrition/Components/SmokableComponent.cs Normal file
View File

@@ -0,0 +1,27 @@
using Content.Server.Nutrition.EntitySystems;
using Content.Shared.Chemistry.Reagent;
using Content.Shared.Smoking;
using Robust.Shared.Analyzers;
using Robust.Shared.GameObjects;
using Robust.Shared.Serialization.Manager.Attributes;
namespace Content.Server.Nutrition.Components
{
[RegisterComponent, Friend(typeof(SmokingSystem))]
public class SmokableComponent : Component
{
public override string Name => "Smokable";
[DataField("solution")]
public string Solution { get; } = "smokable";
/// <summary>
/// Solution inhale amount per second.
/// </summary>
[DataField("inhaleAmount")]
public ReagentUnit InhaleAmount { get; } = ReagentUnit.New(0.05f);
[DataField("state")]
public SmokableState State { get; set; } = SmokableState.Unlit;
}
}

98
Content.Server/Nutrition/Components/SmokingComponent.cs
View File

@@ -1,98 +0,0 @@
using System.Threading.Tasks;
using Content.Server.Clothing.Components;
using Content.Shared.Interaction;
using Content.Shared.Smoking;
using Content.Shared.Temperature;
using Robust.Server.GameObjects;
using Robust.Shared.GameObjects;
using Robust.Shared.Serialization.Manager.Attributes;
using Robust.Shared.ViewVariables;
namespace Content.Server.Nutrition.Components
{
/// <summary>
/// This item acts as a representation for smokable consumables.
///
/// To smoke a cigar, you need:
/// <list type="bullet">
/// <item><description> a hot item (implements IHotItem interface)</description></item>
/// <item><description> that's a alight.</description></item>
/// <item><description> for the target cigar be Unlit. Lit cigars are already lit and butt's don't have any "fuel" left.</description></item>
///</list>
/// TODO: Add reagents that interact when smoking
/// TODO: Allow suicide via excessive Smoking
/// </summary>
[RegisterComponent]
public class SmokingComponent : Component, IInteractUsing
{
public override string Name => "Smoking";
private SharedBurningStates _currentState = SharedBurningStates.Unlit;
[ComponentDependency] private readonly ClothingComponent? _clothingComponent = default!;
[ComponentDependency] private readonly AppearanceComponent? _appearanceComponent = default!;
/// <summary>
/// Duration represents how long will this item last.
/// Generally it ticks down whether it's time-based
/// or consumption-based.
/// </summary>
[ViewVariables] [DataField("duration")]
private int _duration = 30;
/// <summary>
/// What is the temperature of the cigar?
///
/// For a regular cigar, the temp approaches around 400°C or 580°C
/// dependant on where you measure.
/// </summary>
//[ViewVariables] [DataField("temperature")]
//private float _temperature = 673.15f;
[ViewVariables]
public SharedBurningStates CurrentState
{
get => _currentState;
set
{
_currentState = value;
if (_clothingComponent != null)
{
switch (_currentState)
{
case SharedBurningStates.Lit:
_clothingComponent.EquippedPrefix = "lit";
_clothingComponent.ClothingEquippedPrefix = "lit";
break;
default:
_clothingComponent.EquippedPrefix = "unlit";
_clothingComponent.ClothingEquippedPrefix = "unlit";
break;
}
}
_appearanceComponent?.SetData(SmokingVisuals.Smoking, _currentState);
}
}
// TODO: ECS this method and component.
async Task<bool> IInteractUsing.InteractUsing(InteractUsingEventArgs eventArgs)
{
if (CurrentState != SharedBurningStates.Unlit)
return false;
var isHotEvent = new IsHotEvent();
Owner.EntityManager.EventBus.RaiseLocalEvent(eventArgs.Using.Uid, isHotEvent, false);
if (!isHotEvent.IsHot)
return false;
CurrentState = SharedBurningStates.Lit;
// TODO More complex handling of cigar consumption
Owner.SpawnTimer(_duration * 1000, () => CurrentState = SharedBurningStates.Burnt);
return true;
}
}
}

60
Content.Server/Nutrition/EntitySystems/SmokingSystem.Cigar.cs Normal file
View File

@@ -0,0 +1,60 @@
using Content.Server.Nutrition.Components;
using Content.Shared.Chemistry.Components.SolutionManager;
using Content.Shared.Interaction;
using Content.Shared.Smoking;
using Content.Shared.Temperature;
using Robust.Shared.GameObjects;
namespace Content.Server.Nutrition.EntitySystems
{
public partial class SmokingSystem
{
private void InitializeCigars()
{
SubscribeLocalEvent<CigarComponent, ActivateInWorldEvent>(OnCigarActivatedEvent);
SubscribeLocalEvent<CigarComponent, InteractUsingEvent>(OnCigarInteractUsingEvent);
SubscribeLocalEvent<CigarComponent, SmokableSolutionEmptyEvent>(OnCigarSolutionEmptyEvent);
}
private void OnCigarActivatedEvent(EntityUid uid, CigarComponent component, ActivateInWorldEvent args)
{
if (args.Handled)
return;
if (!ComponentManager.TryGetComponent(uid, out SmokableComponent? smokable))
return;
if (smokable.State != SmokableState.Lit)
return;
SetSmokableState(uid, SmokableState.Burnt, smokable);
args.Handled = true;
}
private void OnCigarInteractUsingEvent(EntityUid uid, CigarComponent component, InteractUsingEvent args)
{
if (args.Handled)
return;
if (!ComponentManager.TryGetComponent(uid, out SmokableComponent? smokable))
return;
if (smokable.State != SmokableState.Unlit)
return;
var isHotEvent = new IsHotEvent();
RaiseLocalEvent(args.Used.Uid, isHotEvent, false);
if (!isHotEvent.IsHot)
return;
SetSmokableState(uid, SmokableState.Lit, smokable);
args.Handled = true;
}
private void OnCigarSolutionEmptyEvent(EntityUid uid, CigarComponent component, SmokableSolutionEmptyEvent args)
{
SetSmokableState(uid, SmokableState.Burnt);
}
}
}

103
Content.Server/Nutrition/EntitySystems/SmokingSystem.cs
View File

@@ -1,20 +1,115 @@
using System.Collections.Generic;
using System.Linq;
using Content.Server.Body.Circulatory;
using Content.Server.Nutrition.Components;
using Content.Shared.Chemistry;
using Content.Shared.Chemistry.EntitySystems;
using Content.Shared.Chemistry.Reagent;
using Content.Shared.Interaction;
using Content.Shared.Smoking;
using Content.Shared.Temperature;
using Robust.Server.GameObjects;
using Robust.Shared.Containers;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
namespace Content.Server.Nutrition.EntitySystems
{
public class SmokingSystem : EntitySystem
public partial class SmokingSystem : EntitySystem
{
[Dependency] private readonly ChemistrySystem _chemistrySystem = default!;
[Dependency] private readonly SolutionContainerSystem _solutionContainerSystem = default!;
private const float UpdateTimer = 3f;
private float _timer = 0f;
/// <summary>
/// We keep a list of active smokables, because iterating all existing smokables would be dumb.
/// </summary>
private readonly HashSet<EntityUid> _active = new();
public override void Initialize()
{
SubscribeLocalEvent<SmokingComponent, IsHotEvent>(OnIsHotEvent);
SubscribeLocalEvent<SmokableComponent, IsHotEvent>(OnSmokableIsHotEvent);
SubscribeLocalEvent<SmokableComponent, ComponentShutdown>(OnSmokableShutdownEvent);
InitializeCigars();
}
private void OnIsHotEvent(EntityUid uid, SmokingComponent component, IsHotEvent args)
public void SetSmokableState(EntityUid uid, SmokableState state, SmokableComponent? smokable = null, AppearanceComponent? appearance = null)
{
args.IsHot = component.CurrentState == SharedBurningStates.Lit;
if (!Resolve(uid, ref smokable, ref appearance))
return;
smokable.State = state;
appearance.SetData(SmokingVisuals.Smoking, state);
if (state == SmokableState.Lit)
_active.Add(uid);
else
_active.Remove(uid);
}
private void OnSmokableIsHotEvent(EntityUid uid, SmokableComponent component, IsHotEvent args)
{
args.IsHot = component.State == SmokableState.Lit;
}
private void OnSmokableShutdownEvent(EntityUid uid, SmokableComponent component, ComponentShutdown args)
{
_active.Remove(uid);
}
public override void Update(float frameTime)
{
_timer += frameTime;
if (_timer < UpdateTimer)
return;
foreach (var uid in _active.ToArray())
{
if (!ComponentManager.TryGetComponent(uid, out SmokableComponent? smokable))
{
_active.Remove(uid);
continue;
}
if (!_solutionContainerSystem.TryGetSolution(uid, smokable.Solution, out var solution))
{
_active.Remove(uid);
continue;
}
var inhaledSolution = _solutionContainerSystem.SplitSolution(uid, solution, smokable.InhaleAmount * _timer);
if (solution.TotalVolume == ReagentUnit.Zero)
{
RaiseLocalEvent(uid, new SmokableSolutionEmptyEvent());
}
if (inhaledSolution.TotalVolume == ReagentUnit.Zero)
continue;
// This is awful. I hate this so much.
// TODO: Please, someone refactor containers and free me from this bullshit.
if (!smokable.Owner.TryGetContainerMan(out var containerManager) ||
!containerManager.Owner.TryGetComponent(out BloodstreamComponent? bloodstream))
continue;
_chemistrySystem.ReactionEntity(containerManager.Owner, ReactionMethod.Ingestion, inhaledSolution);
bloodstream.TryTransferSolution(inhaledSolution);
}
_timer -= UpdateTimer;
}
}
/// <summary>
/// Directed event raised when the smokable solution is empty.
/// </summary>
public class SmokableSolutionEmptyEvent : EntityEventArgs
{
}
}