public void SpawnUnit(UnitIdentifier unitIdentifier)
{
var character = Instantiate(baseCharacterMaster, unitRoot);
var initialPosition = unitIdentifier.TeamId == 0
? spawnpointFetcher.GetNextPlayerStartPosition()
: spawnpointFetcher.GetNextEnemyStartPosition();
var unitDataSO = UnitListSO.GetUnitDataSO(unitIdentifier.UnitClass);
var unit = UnitFactory.GetUnit(unitIdentifier, unitDataSO, initialPosition);
character.Initialize(unit, unitDataSO.unitClassMaster);
character.transform.position = initialPosition;
if (unitIdentifier.TeamId == 1)
{
character.transform.rotation = Quaternion.Euler(0f, 180f, 0f);
}
if (!ActiveCharacters.ContainsKey(unitIdentifier))
{
ActiveCharacters.Add(unitIdentifier, character);
}
else
{
Debug.LogError($"[UnitManager] Unit {unitIdentifier.ToString()} was already spawned!");
}
}
public CommonCommandData(UnitIdentifier actor, List <UnitIdentifier> targetsIdentifiers, UnitAbility unitAbility, Action onCommandCompletedCallback)
{
this.actor = actor;
this.targetsIdentifiers = targetsIdentifiers;
this.unitAbility = unitAbility;
this.onCommandCompletedCallback = onCommandCompletedCallback;
}
public BaseCharacterMaster GetActiveCharacter(UnitIdentifier unitIdentifier)
{
if (!ActiveCharacters.TryGetValue(unitIdentifier, out var bcm))
{
Debug.Log($"[UnitManager] Attempted to fetch unitId: {unitIdentifier.UniqueId} which does not exists/was removed");
return(null);
}
return(bcm);
}
public UnitIdentifier GetNextInQueue()
{
if (active != null) // TODO Can probably be avoided
{
queue.Enqueue(active);
}
active = queue.Dequeue();
return(active);
}
public WorldModel(List <Unit> modelActiveCharacters, Queue <UnitIdentifier> queue, UnitIdentifier activeUnit)
{
ModelActiveCharacters = new List <Unit>(modelActiveCharacters);
foreach (var modelActiveCharacter in ModelActiveCharacters)
{
modelActiveCharacter.SimulateActivateActionEffects();
}
Queue = queue;
CurrentlyActiveUnit = activeUnit;
}
public static Unit GetUnit(UnitIdentifier unitIdentifier, UnitDataSO unitDataSO, Vector3 initialPosition)
{
return
(new Unit(unitIdentifier,
new UnitData(unitDataSO,
UnitAbilityFactory.GetUnitAbilities(unitDataSO),
unitDataSO.goalOrientedBehaviourPresetSO.goals,
unitIdentifier.TeamId == 0
? Color.green
: Color.red,
initialPosition)
));
}
public override string ToString()
{
var builder = new StringBuilder();
builder.Append(Designator);
if (UnitIdentifier != null)
{
builder.Append(" ");
builder.Append(UnitIdentifier.ToString());
}
return(builder.ToString());
}
public bool TryGetUnit(UnitIdentifier unitIdentifier, out Unit result)
{
result = null;
foreach (var unit in ModelActiveCharacters)
{
if (unit.UnitIdentifier.Equals(unitIdentifier))
{
result = unit;
return(true);
}
}
return(false);
}
public void Setup(int slotID, UnitRelativeOwner owner, UnityAction <UnitRelativeOwner, int> onCharacterRemoved)
{
this.SlotID = slotID;
this.onCharacterRemoved = onCharacterRemoved;
this.UnitOwner = owner;
this.UnitClass = default;
this.UnitIdentifier = new UnitIdentifier(owner == UnitRelativeOwner.Self ? 0 : 1, slotID, default);
UpdateDescription();
if (owner == UnitRelativeOwner.Opponent)
{
characterSlotPresenter.OverrideColorScheme();
}
}
public void UpdateStatus(List <UnitIdentifier> unitsToRemove)
{
var newQueue = new Queue <UnitIdentifier>();
foreach (var unit in queue)
{
if (!unitsToRemove.Contains(unit))
{
newQueue.Enqueue(unit);
}
}
if (unitsToRemove.Contains(active))
{
active = null;
}
queue = newQueue;
}
private Unit(UnitIdentifier unitIdentifier, UnitData unitData, UnitState unitState)
{
UnitIdentifier = unitIdentifier;
UnitData = unitData;
UnitState = unitState;
}
public Unit(UnitIdentifier unitIdentifier, UnitData unitData)
{
UnitIdentifier = unitIdentifier;
UnitData = unitData;
UnitState = new UnitState(unitData.MaxHp);
}
/// <summary>
/// Constructs a Delphi identifier string for a Delphi unit identifier.
/// </summary>
/// <param name="name">The unit identifier, either a generic name or fully qualified name of the unit</param>
/// <returns>The Delphi identifier string</returns>
public static string ToSourceCode(this UnitIdentifier identifier) => string.Join(".", identifier.Namespace.Append(identifier.Unit));
public void Initialize(List <Unit> unitCopies, Queue <UnitIdentifier> queue, UnitIdentifier activeUnit)
{
WorldModelStack = new Stack <WorldModel>();
WorldModelStack.Push(new WorldModel(unitCopies, queue, activeUnit));
}
public void AddToQueue(UnitIdentifier unitIdentifier)
{
queue.Enqueue(unitIdentifier);
}
