public Unit(UnitId unitId, IUnitData unitData, IUnit[] petUnits, Transform transform)
{
UnitId = unitId;
UnitData = unitData;
Transform = transform;
_petUnits.AddRange(petUnits);
}
public void UpgradeNullRatity(IUnitData data)
{
if (data.Stars > 0)
{
return;
}
var countShards = GetShardsForUpgrage(data.Id, data.Stars);
if (countShards > data.Shards)
{
return;
}
var allAbilities = Static.Abilities.Where(x => x.Value.Params.UnitId == data.Id);
foreach (var temp in allAbilities)
{
data.Abilities[temp.Key] = 1;
}
var allPerks = Static.Perks.Where(x => x.Value.UnitId == data.Id);
foreach (var temp in allPerks)
{
data.PerkStars[temp.Key] = 1;
}
data.EquipmentStars = 1;
data.Stars = 1;
data.Level = 1;
data.Shards -= countShards;
LogicLog.UpgradeRarityUnit(data.Id, data.Stars);
}
public IObservable <UniRx.Unit> Run()
{
IUnitData[] unitDatas = _unitSpawnSettings.GetUnits(_data.unitCommandData.UnitType);
if (_data.unitCommandData.UnitIndex >= unitDatas.Length)
{
string errorMsg = string.Format("Unit Index not in unit datas range: {0}",
_data.unitCommandData.UnitIndex);
_logger.LogError(LoggedFeature.Units, errorMsg);
return(Observable.Throw <UniRx.Unit>(new IndexOutOfRangeException(errorMsg)));
}
IUnitData unitData = unitDatas[(int)_data.unitCommandData.UnitIndex];
// First, spawn the pets recursively.
// We create commands that we execute directly, because
// we don't want to treat these as standalone commands (they are only ever children of this command)
IUnit[] pets = new IUnit[_data.unitCommandData.pets.Length];
for (var i = 0; i < _data.unitCommandData.pets.Length; i++)
{
SpawnUnitData petSpawnUnitData =
new SpawnUnitData(_data.unitCommandData.pets[i], _data.tileCoords, _data.isInitialSpawn);
ICommand petSpawnCommand =
_commandFactory.Create(typeof(SpawnUnitCommand), typeof(SpawnUnitData), petSpawnUnitData);
petSpawnCommand.Run();
pets[i] = _unitRegistry.GetUnit(_data.unitCommandData.pets[i].unitId);
}
// Now, spawn the unit itself.
IUnit unit = _unitPool.Spawn(_data.unitCommandData.unitId, unitData, pets);
_gridUnitManager.PlaceUnitAtTile(unit, _data.tileCoords);
_logger.Log(LoggedFeature.Units, "Spawned: {0}. Id: {1}", unitData.Name, unit.UnitId);
return(Observable.ReturnUnit());
}
private void SpawnUnit(IUnitData unitData, IntVector2 tileCoords)
{
UnitCommandData unitCommandData = _unitCommandDataFactory.Create(unitData);
SpawnUnitData spawnUnitData = new SpawnUnitData(unitCommandData, tileCoords, isInitialSpawn: true);
_commandQueue.Enqueue <SpawnUnitCommand, SpawnUnitData>(spawnUnitData, CommandSource.Game);
}
#pragma warning restore 649
public void Initialize(IUnitData data)
{
_icon = data.Icon;
_healthable.Initialize(data.HealthableData);
_magicable.Initialize(data.MagicableData);
_armorable.Initialize(data.ArmorableData);
_aggroable.Initialize(data.AggroableData);
_attackerable.Initialize(data.AttackerableData);
_movable.Initialize(data.MovableData);
}
public BattleParamData CalculateInitiative(IUnitData data, FormulaController formula)
{
var unit = Static.Units[data.Id];
return(new BattleParamData
{
Value = (int)formula.Calculate(unit.Initiative),
Equip = CalculateEquipInit(data.Id),
Base = unit.Rarities.Where(x => x.Value.Stars == data.Stars).Sum(x => x.Value.Initiative),
});
}
public bool TryGetUnit(int unitId, bool assist, out IUnitData data)
{
if (assist)
{
if (State.Assist != null && State.Assist.Id == unitId)
{
data = State.Assist;
return(true);
}
}
data = State.Units.FirstOrDefault(x => x.Id == unitId);
return(data != null && data.Level > 0);
}
public static UnitData Clone(IUnitData unitData)
{
var clonedData = CreateInstance <UnitData>();
clonedData.name = unitData.Name;
clonedData.unitType = unitData.UnitType;
clonedData.pets = unitData.Pets.Select(Clone).ToArray();
clonedData.sprite = unitData.Sprite;
clonedData.avatarSprite = unitData.AvatarSprite;
clonedData.unitStats = unitData.UnitStats;
return(clonedData);
}
public void TryUpdateNullRarity(IUnitData temp)
{
if (temp.Stars == 0)
{
_units.UpgradeNullRatity(temp);
if (temp.Stars > 0)
{
var unit = _units.Static.Units[temp.Id];
_impact.ExecuteImpact(unit.ImpactInit);
_units.UpdateLastTeamSlots();
}
}
}
public uint?ResolveUnitIndex(IUnitData unitData)
{
IUnitData[] unitDatas = _unitSpawnSettings.GetUnits(unitData.UnitType);
for (var i = unitDatas.Length - 1; i >= 0; i--)
{
if (unitDatas[i] == unitData)
{
return((uint)i);
}
}
return(null);
}
public IUnit Spawn(UnitId unitId, IUnitData unitData, IUnit[] pets)
{
// Create Initializer
UnitRenderer unitRenderer = _unitRendererPool.Spawn();
_unitBehaviours[unitId] = unitRenderer;
// Create Unit and register it
IUnit unit = new Unit(unitId, unitData, pets, _unitBehaviours[unitId].transform);
unitRenderer.SetUnit(unit);
_unitRegistry.RegisterUnit(unit);
return(unit);
}
private void SpawnUnit(UnitDataReference unitDataReference, IntVector2 tileCoords)
{
IUnitData unitData =
_unitDataIndexResolver.ResolveUnitData(unitDataReference.UnitType, unitDataReference.UnitIndex);
if (unitData == null)
{
_logger.LogError(LoggedFeature.Units, "UnitData reference not found: {0}", unitDataReference);
return;
}
UnitCommandData unitCommandData = _unitCommandDataFactory.Create(unitData);
SpawnUnitData spawnUnitData = new SpawnUnitData(unitCommandData, tileCoords, isInitialSpawn: true);
_commandQueue.Enqueue <SpawnUnitCommand, SpawnUnitData>(spawnUnitData, CommandSource.Game);
}
void Awake()
{
damageReceived = 0;
rotationSpeed = 2;
isMoving = false;
isRotating = false;
isCasting = false;
isDead = false;
isStunned = false;
graphics = gameObject.AddComponent <UnitGraphics>();
if (unitDataEditor != null)
{
unitData = new UnitData(unitDataEditor);
}
}
UnitCost GetOverInfusionCosts(IUnitData unitData, int infusion, int excessKills)
{
// over infuse logic. Because this is annoyingly complex, it gets comments
// We use recursion to get the cost of the previous infuse, then add on our current infusion
var previousInfCost = GetInfusionCosts(unitData, infusion - 1, excessKills);
var material = new UnitRecepePiece(unitData.BasicType, 10, UnitRankType.None, 1);
// Get the material count - this may not be correct, I only tested inf10->11, which was 11 units
var materialQty = infusion;
// check see if any qs charges will be involved in the cost of the infuse materials
UnitCost qsMaterialCost = default;
var remainingQsCharges = qsCharges;
if (remainingQsCharges > 0)
{
// cost of the infuse feed if we have a qs charge
qsMaterialCost = GetRawUnitCost(material);
// as we need 10+ mats, we are going to exhaust our QS charges
// at this stage it isn't possible to have more than 10 QS charges
qsCharges = 0;
}
// get the cost of our unit without any qs charges
var fullMaterialCost = GetRawUnitCost(material);
// cost of feed, e.g, 3000 for inf 11, 4000 for inf 12;
var mainUnitFeedCost = 2000 + (infusion - 10) * 1000;
// at this stage it seems unrealistic we will get more than 11,000 vet, so it's unlikely there will be any kills on our materials.
var killRecycleRefund = 0;
// as we use recursion for each infuse, we should only get the bonus of one here
var infuseRecycleRefund = GetInfuseRecycleRefund(1);
// finally we can total it all together
var materialKills = fullMaterialCost.Kills * (materialQty - remainingQsCharges) + qsMaterialCost.Kills * remainingQsCharges;
var materialMinerals = fullMaterialCost.Minerals * (materialQty - remainingQsCharges) + qsMaterialCost.Minerals * remainingQsCharges;
var totalKillCost = materialKills + mainUnitFeedCost - infuseRecycleRefund - killRecycleRefund;
return(new UnitCost(previousInfCost.Minerals + materialMinerals, previousInfCost.Kills + totalKillCost, 0));
}
public void InitData(IUnitData data, ChangeStorage storage)
{
_storage = storage;
Id = data.Id;
Shards = data.Shards;
Stars = data.Stars;
Exp = data.Exp;
Level = data.Level;
LD_Abilities.Init(data.Abilities, storage);
LD_PerkStars.Init(data.PerkStars, storage);
LD_PerkCharges.Init(data.PerkCharges, storage);
LD_Equipment.Init(data.Equipment, storage);
EquipmentStars = data.EquipmentStars;
LD_Buffs.Init(data.Buffs, storage);
ExplorerPosition = data.ExplorerPosition;
Reserve = data.Reserve;
CurrentHp = data.CurrentHp;
FamiliarUnlock = data.FamiliarUnlock;
MissionCounter = data.MissionCounter;
}
public (IUnitData data, IUnit unit) GetUnit(int unitId)
{
IUnitData data;
if (State.Assist != null && State.Assist.Id == unitId)
{
data = State.Assist;
}
else
{
data = State.Units.FirstOrDefault(x => x.Id == unitId);
if (data == null || data.Level < 1)
{
throw new Exception($"Unit id {unitId} missing");
}
}
var unit = Static.Units[unitId];
return(data, unit);
}
UnitCost GetInfusionCosts(IUnitData unitData, int infusion, int excessKills)
{
#if DEBUG
RecordDNAStartUnit(unitData, infusion);
#endif
if (infusion < 11)
{
if (infusion == 0)
{
return(new UnitCost(0, 0, excessKills));
}
var infuseDiscount = 0;
if (unitData.Type.IsCoreBasic() && infusion >= 3 && TryUseQSCharge())
{
infuseDiscount = 3;
}
if (unitData.Type.IsDNA1() && infusion >= loadout.Perks.DNAStart.DesiredLevel && TryUseDNAStart())
{
infuseDiscount = loadout.Perks.DNAStart.DesiredLevel;
}
else if (shouldGrantDNAFreeInf1 && unitData.Type.IsDNA1())
{
infuseDiscount = 1;
}
var material = new UnitRecepePiece(unitData.BasicType, (int)unitData.Evolution, UnitRankType.None, 1);
var materialCost = GetRawUnitCost(material);
var(Cost, ExcessKills) = GetFeedCost(infusion, unitData.Type, excessKills, infuseDiscount);
var materialQty = UnitsRequiredForInfuse(infusion, infuseDiscount);
var killRecycleRefund = GetKillRecycleRefund(materialCost, infusion, infuseDiscount, materialQty);
var infuseRecycleRefund = GetInfuseRecycleRefund(infusion, infuseDiscount);
var totalKillCost = materialCost.Kills * materialQty + Cost - infuseRecycleRefund - killRecycleRefund;
return(new UnitCost(materialCost.Minerals * materialQty, totalKillCost, ExcessKills));
}
else
{
return(GetOverInfusionCosts(unitData, infusion, excessKills));
}
}
public void AddUnitShard(int unitId, int shards)
{
var data = State.Units.FirstOrDefault(x => x.Id == unitId);
if (data == null)
{
data = Factory.CreateUnit(unitId);
State.Units.Add(data);
}
var value = data.Shards + shards;
if (value < 0)
{
value = 0;
}
data.Shards = value;
if (data.Stars == 0 && data.Shards == 0)
{
State.Units.Remove(data);
}
}
public IMemberBattleData CreateBattleUnit(IUnitData unit, bool assist)
{
_context.NeedExploreParam = true;
_context.SetContextFormula(unit.Id);
var data = _battle.Factory.CreateBattleMember(
unit.Id,
unit.ExplorerPosition,
_units.CalculateMaxHp(unit, _formula),
_units.CalculateStrength(unit, _formula),
_units.CalculateInitiative(unit, _formula),
BattleMemberType.Unit
);
_context.SetContextFormula(null);
_context.NeedExploreParam = false;
data.Assist = assist;
data.CurrentHp = unit.CurrentHp;
var abilities = _units.Static.Abilities.Values.Where(x => x.Params.UnitId == unit.Id).ToArray();
UpdateParams(data, abilities);
return(data);
}
public static void UpdateData(this IMutableUnitData data, IUnitData update)
{
data.DisplayID = update.DisplayID ?? data.DisplayID;
data.Flags = update.Flags ?? data.Flags;
data.Flags2 = update.Flags2 ?? data.Flags2;
data.Flags3 = update.Flags3 ?? data.Flags3;
data.RangedAttackRoundBaseTime = update.RangedAttackRoundBaseTime ?? data.RangedAttackRoundBaseTime;
data.BoundingRadius = update.BoundingRadius ?? data.BoundingRadius;
data.CombatReach = update.CombatReach ?? data.CombatReach;
data.MountDisplayID = update.MountDisplayID ?? data.MountDisplayID;
data.StandState = update.StandState ?? data.StandState;
data.PetTalentPoints = update.PetTalentPoints ?? data.PetTalentPoints;
data.VisFlags = update.VisFlags ?? data.VisFlags;
data.AnimTier = update.AnimTier ?? data.AnimTier;
data.CreatedBySpell = update.CreatedBySpell ?? data.CreatedBySpell;
data.EmoteState = update.EmoteState ?? data.EmoteState;
data.SheatheState = update.SheatheState ?? data.SheatheState;
data.PvpFlags = update.PvpFlags ?? data.PvpFlags;
data.PetFlags = update.PetFlags ?? data.PetFlags;
data.ShapeshiftForm = update.ShapeshiftForm ?? data.ShapeshiftForm;
data.HoverHeight = update.HoverHeight ?? data.HoverHeight;
data.InteractSpellID = update.InteractSpellID ?? data.InteractSpellID;
data.ScalingLevelMin = update.ScalingLevelMin ?? data.ScalingLevelMin;
data.ScalingLevelMax = update.ScalingLevelMax ?? data.ScalingLevelMax;
data.StateSpellVisualID = update.StateSpellVisualID ?? data.StateSpellVisualID;
data.StateAnimID = update.StateAnimID ?? data.StateAnimID;
data.StateAnimKitID = update.StateAnimKitID ?? data.StateAnimKitID;
data.Charm = update.Charm ?? data.Charm;
data.Summon = update.Summon ?? data.Summon;
data.Critter = update.Critter ?? data.Critter;
data.CharmedBy = update.CharmedBy ?? data.CharmedBy;
data.DemonCreator = update.DemonCreator ?? data.DemonCreator;
data.LookAtControllerTarget = update.LookAtControllerTarget ?? data.LookAtControllerTarget;
data.Target = update.Target ?? data.Target;
data.Race = update.Race ?? data.Race;
data.DisplayPower = update.DisplayPower ?? data.DisplayPower;
data.EffectiveLevel = update.EffectiveLevel ?? data.EffectiveLevel;
data.AuraState = update.AuraState ?? data.AuraState;
data.DisplayScale = update.DisplayScale ?? data.DisplayScale;
data.CreatureFamily = update.CreatureFamily ?? data.CreatureFamily;
data.CreatureType = update.CreatureType ?? data.CreatureType;
data.NativeDisplayID = update.NativeDisplayID ?? data.NativeDisplayID;
data.NativeXDisplayScale = update.NativeXDisplayScale ?? data.NativeXDisplayScale;
data.BaseMana = update.BaseMana ?? data.BaseMana;
data.BaseHealth = update.BaseHealth ?? data.BaseHealth;
data.SummonedBy = update.SummonedBy ?? data.SummonedBy;
data.CreatedBy = update.CreatedBy ?? data.CreatedBy;
data.ClassId = update.ClassId ?? data.ClassId;
data.Sex = update.Sex ?? data.Sex;
data.Health = update.Health ?? data.Health;
data.MaxHealth = update.MaxHealth ?? data.MaxHealth;
data.Level = update.Level ?? data.Level;
data.ContentTuningID = update.ContentTuningID ?? data.ContentTuningID;
data.ScalingLevelDelta = update.ScalingLevelDelta ?? data.ScalingLevelDelta;
data.FactionTemplate = update.FactionTemplate ?? data.FactionTemplate;
for (int i = 0; i < Math.Min(data.NpcFlags.Length, update.NpcFlags.Length); i++)
{
data.NpcFlags[i] = update.NpcFlags[i] ?? data.NpcFlags[i];
}
for (int i = 0; i < Math.Min(data.Power.Length, update.Power.Length); i++)
{
data.Power[i] = update.Power[i] ?? data.Power[i];
}
for (int i = 0; i < Math.Min(data.MaxPower.Length, update.MaxPower.Length); i++)
{
data.MaxPower[i] = update.MaxPower[i] ?? data.MaxPower[i];
}
for (int i = 0; i < Math.Min(data.AttackRoundBaseTime.Length, update.AttackRoundBaseTime.Length); i++)
{
data.AttackRoundBaseTime[i] = update.AttackRoundBaseTime[i] ?? data.AttackRoundBaseTime[i];
}
for (int i = 0; i < Math.Min(data.Resistances.Length, update.Resistances.Length); i++)
{
data.Resistances[i] = update.Resistances[i] ?? data.Resistances[i];
}
for (int i = 0; i < Math.Min(data.VirtualItems.Length, update.VirtualItems.Length); i++)
{
if (update.VirtualItems[i] != null)
{
if (data.VirtualItems[i] == null)
{
data.VirtualItems[i] = update.VirtualItems[i];
}
else if (data.VirtualItems[i] is IMutableVisibleItem mut)
{
mut.UpdateData(update.VirtualItems[i]);
}
}
}
}
public virtual IUnitData ReadUpdateUnitData(Packet packet, IUnitData existingData, params object[] indexes)
{
return(existingData);
}
public static void UpdateData(this UpdateValuesObjectDataFields fields, IUnitData data)
{
var unit = fields.Unit ??= new();
unit.DisplayID = data.DisplayID;
unit.ClassId = data.ClassId;
unit.Sex = data.Sex;
unit.Health = data.Health;
unit.MaxHealth = data.MaxHealth;
unit.Level = data.Level;
unit.ContentTuningID = data.ContentTuningID;
unit.ScalingLevelMin = data.ScalingLevelMin;
unit.ScalingLevelMax = data.ScalingLevelMax;
unit.ScalingLevelDelta = data.ScalingLevelDelta;
unit.FactionTemplate = data.FactionTemplate;
unit.Flags = data.Flags;
unit.Flags2 = data.Flags2;
unit.Flags3 = data.Flags3;
unit.RangedAttackRoundBaseTime = data.RangedAttackRoundBaseTime;
unit.BoundingRadius = data.BoundingRadius;
unit.CombatReach = data.CombatReach;
unit.MountDisplayID = data.MountDisplayID;
unit.StandState = data.StandState;
unit.PetTalentPoints = data.PetTalentPoints;
unit.VisFlags = data.VisFlags;
unit.AnimTier = data.AnimTier;
unit.CreatedBySpell = data.CreatedBySpell;
unit.EmoteState = data.EmoteState;
unit.SheatheState = data.SheatheState;
unit.PvpFlags = data.PvpFlags;
unit.PetFlags = data.PetFlags;
unit.ShapeshiftForm = data.ShapeshiftForm;
unit.HoverHeight = data.HoverHeight;
unit.InteractSpellID = data.InteractSpellID;
unit.StateSpellVisualID = data.StateSpellVisualID;
unit.StateAnimID = data.StateAnimID;
unit.StateAnimKitID = data.StateAnimKitID;
unit.Race = data.Race;
unit.DisplayPower = data.DisplayPower;
unit.EffectiveLevel = data.EffectiveLevel;
unit.AuraState = data.AuraState;
unit.DisplayScale = data.DisplayScale;
unit.CreatureFamily = data.CreatureFamily;
unit.CreatureType = data.CreatureType;
unit.NativeDisplayID = data.NativeDisplayID;
unit.NativeXDisplayScale = data.NativeXDisplayScale;
unit.BaseMana = data.BaseMana;
unit.BaseHealth = data.BaseHealth;
if (data.Charm != null)
{
unit.Charm = data.Charm;
}
if (data.Summon != null)
{
unit.Summon = data.Summon;
}
if (data.Critter != null)
{
unit.Critter = data.Critter;
}
if (data.CharmedBy != null)
{
unit.CharmedBy = data.CharmedBy;
}
if (data.DemonCreator != null)
{
unit.DemonCreator = data.DemonCreator;
}
if (data.LookAtControllerTarget != null)
{
unit.LookAtControllerTarget = data.LookAtControllerTarget;
}
if (data.Target != null)
{
unit.Target = data.Target;
}
if (data.SummonedBy != null)
{
unit.SummonedBy = data.SummonedBy;
}
if (data.CreatedBy != null)
{
unit.CreatedBy = data.CreatedBy;
}
unit.NpcFlags.Reserve(data.NpcFlags.Length);
for (int i = 0; i < data.NpcFlags.Length; ++i)
{
unit.NpcFlags[i] = data.NpcFlags[i].ToProto();
}
unit.Power.Reserve(data.Power.Length);
for (int i = 0; i < data.Power.Length; ++i)
{
unit.Power[i] = data.Power[i].ToProto();
}
unit.MaxPower.Reserve(data.MaxPower.Length);
for (int i = 0; i < data.MaxPower.Length; ++i)
{
unit.MaxPower[i] = data.MaxPower[i].ToProto();
}
unit.AttackRoundBaseTime.Reserve(data.AttackRoundBaseTime.Length);
for (int i = 0; i < data.AttackRoundBaseTime.Length; ++i)
{
unit.AttackRoundBaseTime[i] = data.AttackRoundBaseTime[i].ToProto();
}
unit.Resistances.Reserve(data.Resistances.Length);
for (int i = 0; i < data.Resistances.Length; ++i)
{
unit.Resistances[i] = data.Resistances[i].ToProto();
}
unit.VirtualItems.Reserve(data.VirtualItems.Length);
for (int i = 0; i < data.VirtualItems.Length; ++i)
{
if (data.VirtualItems[i] != null)
{
unit.VirtualItems[i] = data.VirtualItems[i].ToProto();
}
}
}
public Unit() : base()
{
UnitData = new UnitData(this);
}
public UnitController(IUnitData unitData)
{
_unitData = unitData;
}
