857 lines
29 KiB
C#
857 lines
29 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using GameFramework.DataTable;
|
|
using GeometryTD.DataTable;
|
|
using GeometryTD.Definition;
|
|
using GeometryTD.UI;
|
|
using UnityEngine;
|
|
using UnityGameFramework.Runtime;
|
|
|
|
namespace GeometryTD.CustomComponent
|
|
{
|
|
public class PlayerInventoryComponent : GameFrameworkComponent
|
|
{
|
|
private const int TowerLevelCount = 5;
|
|
private const int MaxParticipantTowerCount = 4;
|
|
private BackpackInventoryData _inventory = new BackpackInventoryData();
|
|
private long _nextInstanceId = 1;
|
|
private bool _initialized;
|
|
private IDataTable<DRMuzzleComp> _drMuzzleComp;
|
|
private IDataTable<DRBearingComp> _drBearingComp;
|
|
private IDataTable<DRBaseComp> _drBaseComp;
|
|
|
|
public int Gold
|
|
{
|
|
get
|
|
{
|
|
EnsureInitialized();
|
|
return _inventory.Gold;
|
|
}
|
|
}
|
|
|
|
public void OnInit()
|
|
{
|
|
_inventory = CloneInventory(RepoFormUseCase.SampleInventory());
|
|
NormalizeParticipantState();
|
|
RebuildNextInstanceId();
|
|
_initialized = true;
|
|
Log.Info(
|
|
"PlayerInventory initialized. Gold={0}, Tower={1}, Muzzle={2}, Bearing={3}, Base={4}.",
|
|
_inventory.Gold,
|
|
_inventory.Towers.Count,
|
|
_inventory.MuzzleComponents.Count,
|
|
_inventory.BearingComponents.Count,
|
|
_inventory.BaseComponents.Count);
|
|
}
|
|
|
|
public BackpackInventoryData GetInventorySnapshot()
|
|
{
|
|
EnsureInitialized();
|
|
return CloneInventory(_inventory);
|
|
}
|
|
|
|
public void MergeInventory(BackpackInventoryData gainedInventory)
|
|
{
|
|
EnsureInitialized();
|
|
if (gainedInventory == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int gainedGold = Mathf.Max(0, gainedInventory.Gold);
|
|
int gainedMuzzleCount = 0;
|
|
int gainedBearingCount = 0;
|
|
int gainedBaseCount = 0;
|
|
int gainedTowerCount = 0;
|
|
|
|
if (gainedGold > 0)
|
|
{
|
|
_inventory.Gold += gainedGold;
|
|
}
|
|
|
|
if (gainedInventory.MuzzleComponents != null)
|
|
{
|
|
for (int i = 0; i < gainedInventory.MuzzleComponents.Count; i++)
|
|
{
|
|
MuzzleCompItemData source = gainedInventory.MuzzleComponents[i];
|
|
if (source == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
MuzzleCompItemData cloned = CloneMuzzleComp(source);
|
|
cloned.InstanceId = AllocateInstanceId();
|
|
_inventory.MuzzleComponents.Add(cloned);
|
|
gainedMuzzleCount++;
|
|
}
|
|
}
|
|
|
|
if (gainedInventory.BearingComponents != null)
|
|
{
|
|
for (int i = 0; i < gainedInventory.BearingComponents.Count; i++)
|
|
{
|
|
BearingCompItemData source = gainedInventory.BearingComponents[i];
|
|
if (source == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
BearingCompItemData cloned = CloneBearingComp(source);
|
|
cloned.InstanceId = AllocateInstanceId();
|
|
_inventory.BearingComponents.Add(cloned);
|
|
gainedBearingCount++;
|
|
}
|
|
}
|
|
|
|
if (gainedInventory.BaseComponents != null)
|
|
{
|
|
for (int i = 0; i < gainedInventory.BaseComponents.Count; i++)
|
|
{
|
|
BaseCompItemData source = gainedInventory.BaseComponents[i];
|
|
if (source == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
BaseCompItemData cloned = CloneBaseComp(source);
|
|
cloned.InstanceId = AllocateInstanceId();
|
|
_inventory.BaseComponents.Add(cloned);
|
|
gainedBaseCount++;
|
|
}
|
|
}
|
|
|
|
if (gainedInventory.Towers != null)
|
|
{
|
|
for (int i = 0; i < gainedInventory.Towers.Count; i++)
|
|
{
|
|
TowerItemData source = gainedInventory.Towers[i];
|
|
if (source == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
TowerItemData cloned = CloneTower(source);
|
|
cloned.InstanceId = AllocateInstanceId();
|
|
_inventory.Towers.Add(cloned);
|
|
gainedTowerCount++;
|
|
}
|
|
}
|
|
|
|
if (gainedGold > 0 || gainedMuzzleCount > 0 || gainedBearingCount > 0 || gainedBaseCount > 0 ||
|
|
gainedTowerCount > 0)
|
|
{
|
|
Log.Info(
|
|
"PlayerInventory merged reward. Gold+{0}, Tower+{1}, Muzzle+{2}, Bearing+{3}, Base+{4}.",
|
|
gainedGold,
|
|
gainedTowerCount,
|
|
gainedMuzzleCount,
|
|
gainedBearingCount,
|
|
gainedBaseCount);
|
|
}
|
|
}
|
|
|
|
public bool TryConsumeGold(int costGold)
|
|
{
|
|
EnsureInitialized();
|
|
int resolvedCost = Mathf.Max(0, costGold);
|
|
if (resolvedCost <= 0)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (_inventory.Gold < resolvedCost)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
_inventory.Gold -= resolvedCost;
|
|
return true;
|
|
}
|
|
|
|
public void AddGold(int gainGold)
|
|
{
|
|
EnsureInitialized();
|
|
int resolvedGain = Mathf.Max(0, gainGold);
|
|
if (resolvedGain <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_inventory.Gold += resolvedGain;
|
|
}
|
|
|
|
public bool TryAddParticipantTower(long towerInstanceId, int maxCount = 4)
|
|
{
|
|
EnsureInitialized();
|
|
int resolvedMaxCount = Mathf.Max(1, maxCount);
|
|
resolvedMaxCount = Mathf.Min(resolvedMaxCount, MaxParticipantTowerCount);
|
|
if (!TryGetTowerById(towerInstanceId, out TowerItemData tower))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
_inventory.ParticipantTowerInstanceIds ??= new List<long>();
|
|
if (_inventory.ParticipantTowerInstanceIds.Contains(towerInstanceId))
|
|
{
|
|
tower.IsParticipatingInCombat = true;
|
|
return false;
|
|
}
|
|
|
|
if (_inventory.ParticipantTowerInstanceIds.Count >= resolvedMaxCount)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
_inventory.ParticipantTowerInstanceIds.Add(towerInstanceId);
|
|
tower.IsParticipatingInCombat = true;
|
|
return true;
|
|
}
|
|
|
|
public bool TryRemoveParticipantTower(long towerInstanceId)
|
|
{
|
|
EnsureInitialized();
|
|
if (towerInstanceId <= 0 || _inventory.ParticipantTowerInstanceIds == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool removed = _inventory.ParticipantTowerInstanceIds.Remove(towerInstanceId);
|
|
if (!removed)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (TryGetTowerById(towerInstanceId, out TowerItemData tower))
|
|
{
|
|
tower.IsParticipatingInCombat = false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public bool TryAssembleTower(
|
|
long muzzleInstanceId,
|
|
long bearingInstanceId,
|
|
long baseInstanceId,
|
|
out TowerItemData assembledTower)
|
|
{
|
|
EnsureInitialized();
|
|
assembledTower = null;
|
|
if (muzzleInstanceId <= 0 || bearingInstanceId <= 0 || baseInstanceId <= 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!TryGetComponentById(_inventory.MuzzleComponents, muzzleInstanceId,
|
|
out MuzzleCompItemData muzzleComp) ||
|
|
!TryGetComponentById(_inventory.BearingComponents, bearingInstanceId,
|
|
out BearingCompItemData bearingComp) ||
|
|
!TryGetComponentById(_inventory.BaseComponents, baseInstanceId, out BaseCompItemData baseComp))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (muzzleComp.IsAssembledIntoTower || bearingComp.IsAssembledIntoTower || baseComp.IsAssembledIntoTower)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!TryBuildTowerStats(muzzleComp, bearingComp, baseComp, out TowerStatsData stats))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
long towerInstanceId = AllocateInstanceId();
|
|
TowerItemData tower = new TowerItemData
|
|
{
|
|
InstanceId = towerInstanceId,
|
|
Name = $"组装防御塔-{towerInstanceId}",
|
|
Rarity = ResolveAverageRarity(muzzleComp.Rarity, bearingComp.Rarity, baseComp.Rarity),
|
|
MuzzleComponentInstanceId = muzzleComp.InstanceId,
|
|
BearingComponentInstanceId = bearingComp.InstanceId,
|
|
BaseComponentInstanceId = baseComp.InstanceId,
|
|
Stats = stats
|
|
};
|
|
|
|
muzzleComp.IsAssembledIntoTower = true;
|
|
bearingComp.IsAssembledIntoTower = true;
|
|
baseComp.IsAssembledIntoTower = true;
|
|
_inventory.Towers.Add(tower);
|
|
assembledTower = CloneTower(tower);
|
|
return true;
|
|
}
|
|
|
|
public int ReduceAllTowerEndurance(float enduranceLoss)
|
|
{
|
|
EnsureInitialized();
|
|
float resolvedLoss = Mathf.Max(0f, enduranceLoss);
|
|
if (resolvedLoss <= 0f || _inventory.Towers == null || _inventory.Towers.Count <= 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
Dictionary<long, MuzzleCompItemData> muzzleMap = BuildComponentMap(_inventory.MuzzleComponents);
|
|
Dictionary<long, BearingCompItemData> bearingMap = BuildComponentMap(_inventory.BearingComponents);
|
|
Dictionary<long, BaseCompItemData> baseMap = BuildComponentMap(_inventory.BaseComponents);
|
|
|
|
int affectedCount = 0;
|
|
foreach (var tower in _inventory.Towers)
|
|
{
|
|
if (tower == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
bool towerAffected = false;
|
|
if (muzzleMap.TryGetValue(tower.MuzzleComponentInstanceId, out MuzzleCompItemData muzzleComp))
|
|
{
|
|
towerAffected |= TryReduceComponentEndurance(muzzleComp, resolvedLoss);
|
|
}
|
|
|
|
if (bearingMap.TryGetValue(tower.BearingComponentInstanceId, out BearingCompItemData bearingComp))
|
|
{
|
|
towerAffected |= TryReduceComponentEndurance(bearingComp, resolvedLoss);
|
|
}
|
|
|
|
if (baseMap.TryGetValue(tower.BaseComponentInstanceId, out BaseCompItemData baseComp))
|
|
{
|
|
towerAffected |= TryReduceComponentEndurance(baseComp, resolvedLoss);
|
|
}
|
|
|
|
if (towerAffected)
|
|
{
|
|
affectedCount++;
|
|
}
|
|
}
|
|
|
|
return affectedCount;
|
|
}
|
|
|
|
private static bool TryReduceComponentEndurance(TowerCompItemData component, float enduranceLoss)
|
|
{
|
|
if (component == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
float originalEndurance = component.Endurance;
|
|
float nextEndurance = Mathf.Clamp(originalEndurance - Mathf.Max(0f, enduranceLoss), 0f, 100f);
|
|
if (nextEndurance >= originalEndurance)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
component.Endurance = nextEndurance;
|
|
return true;
|
|
}
|
|
|
|
private static Dictionary<long, TComp> BuildComponentMap<TComp>(List<TComp> components)
|
|
where TComp : TowerCompItemData
|
|
{
|
|
Dictionary<long, TComp> map = new Dictionary<long, TComp>();
|
|
if (components == null || components.Count <= 0)
|
|
{
|
|
return map;
|
|
}
|
|
|
|
foreach (var component in components)
|
|
{
|
|
if (component == null || component.InstanceId <= 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
map[component.InstanceId] = component;
|
|
}
|
|
|
|
return map;
|
|
}
|
|
|
|
private static bool TryGetComponentById<TComp>(List<TComp> components, long instanceId, out TComp result)
|
|
where TComp : TowerCompItemData
|
|
{
|
|
result = null;
|
|
if (components == null || instanceId <= 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
foreach (TComp component in components)
|
|
{
|
|
if (component != null && component.InstanceId == instanceId)
|
|
{
|
|
result = component;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private bool TryGetTowerById(long towerInstanceId, out TowerItemData tower)
|
|
{
|
|
tower = null;
|
|
if (towerInstanceId <= 0 || _inventory.Towers == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < _inventory.Towers.Count; i++)
|
|
{
|
|
TowerItemData candidate = _inventory.Towers[i];
|
|
if (candidate != null && candidate.InstanceId == towerInstanceId)
|
|
{
|
|
tower = candidate;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private bool TryBuildTowerStats(
|
|
MuzzleCompItemData muzzleComp,
|
|
BearingCompItemData bearingComp,
|
|
BaseCompItemData baseComp,
|
|
out TowerStatsData stats)
|
|
{
|
|
stats = null;
|
|
if (muzzleComp == null || bearingComp == null || baseComp == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
DRMuzzleComp muzzleConfig = EnsureMuzzleTable()?.GetDataRow(muzzleComp.ConfigId);
|
|
DRBearingComp bearingConfig = EnsureBearingTable()?.GetDataRow(bearingComp.ConfigId);
|
|
DRBaseComp baseConfig = EnsureBaseTable()?.GetDataRow(baseComp.ConfigId);
|
|
if (muzzleConfig == null || bearingConfig == null || baseConfig == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
stats = new TowerStatsData
|
|
{
|
|
AttackDamage = BuildLevelIntArray(muzzleComp.AttackDamage, muzzleComp.Rarity,
|
|
muzzleConfig.AttackDamagePerLevel),
|
|
DamageRandomRate = Mathf.Max(0f, muzzleComp.DamageRandomRate),
|
|
RotateSpeed = BuildLevelFloatArray(bearingComp.RotateSpeed, bearingComp.Rarity,
|
|
bearingConfig.RotateSpeedPerLevel),
|
|
AttackRange = BuildLevelFloatArray(bearingComp.AttackRange, bearingComp.Rarity,
|
|
bearingConfig.AttackRangePerLevel),
|
|
AttackSpeed =
|
|
BuildLevelFloatArray(baseComp.AttackSpeed, baseComp.Rarity, baseConfig.AttackSpeedPerLevel),
|
|
AttackMethodType = muzzleComp.AttackMethodType,
|
|
AttackPropertyType = baseComp.AttackPropertyType,
|
|
Tags = MergeTags(muzzleComp.Tags, bearingComp.Tags, baseComp.Tags)
|
|
};
|
|
|
|
return true;
|
|
}
|
|
|
|
private static int[] BuildLevelIntArray(int[] rarityBaseArray, RarityType rarity, int perLevel)
|
|
{
|
|
int baseValue = ResolveRarityBaseValue(rarityBaseArray, rarity);
|
|
int[] values = new int[TowerLevelCount];
|
|
for (int i = 0; i < values.Length; i++)
|
|
{
|
|
values[i] = baseValue + perLevel * i;
|
|
}
|
|
|
|
return values;
|
|
}
|
|
|
|
private static float[] BuildLevelFloatArray(float[] rarityBaseArray, RarityType rarity, float perLevel)
|
|
{
|
|
float baseValue = ResolveRarityBaseValue(rarityBaseArray, rarity);
|
|
float[] values = new float[TowerLevelCount];
|
|
for (int i = 0; i < values.Length; i++)
|
|
{
|
|
values[i] = baseValue + perLevel * i;
|
|
}
|
|
|
|
return values;
|
|
}
|
|
|
|
private static float[] BuildConstantLevelFloatArray(float value)
|
|
{
|
|
float[] values = new float[TowerLevelCount];
|
|
for (int i = 0; i < values.Length; i++)
|
|
{
|
|
values[i] = value;
|
|
}
|
|
|
|
return values;
|
|
}
|
|
|
|
private static int ResolveRarityBaseValue(int[] rarityBaseArray, RarityType rarity)
|
|
{
|
|
if (rarityBaseArray == null || rarityBaseArray.Length <= 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int rarityIndex = Mathf.Clamp((int)rarity - 1, 0, rarityBaseArray.Length - 1);
|
|
return rarityBaseArray[rarityIndex];
|
|
}
|
|
|
|
private static float ResolveRarityBaseValue(float[] rarityBaseArray, RarityType rarity)
|
|
{
|
|
if (rarityBaseArray == null || rarityBaseArray.Length <= 0)
|
|
{
|
|
return 0f;
|
|
}
|
|
|
|
int rarityIndex = Mathf.Clamp((int)rarity - 1, 0, rarityBaseArray.Length - 1);
|
|
return rarityBaseArray[rarityIndex];
|
|
}
|
|
|
|
private static TagType[] MergeTags(params TagType[][] sources)
|
|
{
|
|
HashSet<TagType> uniqueTags = new HashSet<TagType>();
|
|
if (sources != null)
|
|
{
|
|
for (int i = 0; i < sources.Length; i++)
|
|
{
|
|
TagType[] tags = sources[i];
|
|
if (tags == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
for (int j = 0; j < tags.Length; j++)
|
|
{
|
|
uniqueTags.Add(tags[j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
TagType[] mergedTags = new TagType[uniqueTags.Count];
|
|
uniqueTags.CopyTo(mergedTags);
|
|
return mergedTags;
|
|
}
|
|
|
|
private static RarityType ResolveAverageRarity(RarityType muzzleRarity, RarityType bearingRarity,
|
|
RarityType baseRarity)
|
|
{
|
|
float avg = ((int)muzzleRarity + (int)bearingRarity + (int)baseRarity) / 3f;
|
|
int rounded = Mathf.RoundToInt(avg);
|
|
int clamped = Mathf.Clamp(rounded, (int)RarityType.White, (int)RarityType.Red);
|
|
return (RarityType)clamped;
|
|
}
|
|
|
|
private IDataTable<DRMuzzleComp> EnsureMuzzleTable()
|
|
{
|
|
_drMuzzleComp ??= GameEntry.DataTable.GetDataTable<DRMuzzleComp>();
|
|
return _drMuzzleComp;
|
|
}
|
|
|
|
private IDataTable<DRBearingComp> EnsureBearingTable()
|
|
{
|
|
_drBearingComp ??= GameEntry.DataTable.GetDataTable<DRBearingComp>();
|
|
return _drBearingComp;
|
|
}
|
|
|
|
private IDataTable<DRBaseComp> EnsureBaseTable()
|
|
{
|
|
_drBaseComp ??= GameEntry.DataTable.GetDataTable<DRBaseComp>();
|
|
return _drBaseComp;
|
|
}
|
|
|
|
private void EnsureInitialized()
|
|
{
|
|
if (_initialized)
|
|
{
|
|
return;
|
|
}
|
|
|
|
OnInit();
|
|
}
|
|
|
|
private long AllocateInstanceId()
|
|
{
|
|
if (_nextInstanceId < 1)
|
|
{
|
|
_nextInstanceId = 1;
|
|
}
|
|
|
|
return _nextInstanceId++;
|
|
}
|
|
|
|
private void RebuildNextInstanceId()
|
|
{
|
|
long maxInstanceId = 0;
|
|
if (_inventory.Towers != null)
|
|
{
|
|
foreach (var item in _inventory.Towers)
|
|
{
|
|
if (item != null)
|
|
{
|
|
maxInstanceId = Math.Max(maxInstanceId, item.InstanceId);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (_inventory.MuzzleComponents != null)
|
|
{
|
|
foreach (var item in _inventory.MuzzleComponents)
|
|
{
|
|
if (item != null)
|
|
{
|
|
maxInstanceId = Math.Max(maxInstanceId, item.InstanceId);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (_inventory.BearingComponents != null)
|
|
{
|
|
foreach (var item in _inventory.BearingComponents)
|
|
{
|
|
if (item != null)
|
|
{
|
|
maxInstanceId = Math.Max(maxInstanceId, item.InstanceId);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (_inventory.BaseComponents != null)
|
|
{
|
|
foreach (var item in _inventory.BaseComponents)
|
|
{
|
|
if (item != null)
|
|
{
|
|
maxInstanceId = Math.Max(maxInstanceId, item.InstanceId);
|
|
}
|
|
}
|
|
}
|
|
|
|
_nextInstanceId = Math.Max(1, maxInstanceId + 1);
|
|
}
|
|
|
|
private void NormalizeParticipantState()
|
|
{
|
|
if (_inventory == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_inventory.ParticipantTowerInstanceIds ??= new List<long>();
|
|
Dictionary<long, TowerItemData> towerMap = new Dictionary<long, TowerItemData>();
|
|
if (_inventory.Towers != null)
|
|
{
|
|
for (int i = 0; i < _inventory.Towers.Count; i++)
|
|
{
|
|
TowerItemData tower = _inventory.Towers[i];
|
|
if (tower == null || tower.InstanceId <= 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
tower.IsParticipatingInCombat = false;
|
|
towerMap[tower.InstanceId] = tower;
|
|
}
|
|
}
|
|
|
|
List<long> normalizedIds = new List<long>(_inventory.ParticipantTowerInstanceIds.Count);
|
|
HashSet<long> uniqueIds = new HashSet<long>();
|
|
for (int i = 0; i < _inventory.ParticipantTowerInstanceIds.Count; i++)
|
|
{
|
|
if (normalizedIds.Count >= MaxParticipantTowerCount)
|
|
{
|
|
break;
|
|
}
|
|
|
|
long id = _inventory.ParticipantTowerInstanceIds[i];
|
|
if (id <= 0 || !uniqueIds.Add(id))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (!towerMap.TryGetValue(id, out TowerItemData tower))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
tower.IsParticipatingInCombat = true;
|
|
normalizedIds.Add(id);
|
|
}
|
|
|
|
_inventory.ParticipantTowerInstanceIds = normalizedIds;
|
|
}
|
|
|
|
private static BackpackInventoryData CloneInventory(BackpackInventoryData source)
|
|
{
|
|
BackpackInventoryData cloned = new BackpackInventoryData();
|
|
if (source == null)
|
|
{
|
|
return cloned;
|
|
}
|
|
|
|
cloned.Gold = Mathf.Max(0, source.Gold);
|
|
|
|
if (source.MuzzleComponents != null)
|
|
{
|
|
for (int i = 0; i < source.MuzzleComponents.Count; i++)
|
|
{
|
|
MuzzleCompItemData item = source.MuzzleComponents[i];
|
|
if (item != null)
|
|
{
|
|
cloned.MuzzleComponents.Add(CloneMuzzleComp(item));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (source.BearingComponents != null)
|
|
{
|
|
for (int i = 0; i < source.BearingComponents.Count; i++)
|
|
{
|
|
BearingCompItemData item = source.BearingComponents[i];
|
|
if (item != null)
|
|
{
|
|
cloned.BearingComponents.Add(CloneBearingComp(item));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (source.BaseComponents != null)
|
|
{
|
|
for (int i = 0; i < source.BaseComponents.Count; i++)
|
|
{
|
|
BaseCompItemData item = source.BaseComponents[i];
|
|
if (item != null)
|
|
{
|
|
cloned.BaseComponents.Add(CloneBaseComp(item));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (source.Towers != null)
|
|
{
|
|
for (int i = 0; i < source.Towers.Count; i++)
|
|
{
|
|
TowerItemData item = source.Towers[i];
|
|
if (item != null)
|
|
{
|
|
cloned.Towers.Add(CloneTower(item));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (source.ParticipantTowerInstanceIds != null)
|
|
{
|
|
for (int i = 0; i < source.ParticipantTowerInstanceIds.Count; i++)
|
|
{
|
|
long id = source.ParticipantTowerInstanceIds[i];
|
|
if (id > 0)
|
|
{
|
|
cloned.ParticipantTowerInstanceIds.Add(id);
|
|
}
|
|
}
|
|
}
|
|
|
|
return cloned;
|
|
}
|
|
|
|
private static MuzzleCompItemData CloneMuzzleComp(MuzzleCompItemData source)
|
|
{
|
|
return new MuzzleCompItemData
|
|
{
|
|
InstanceId = source.InstanceId,
|
|
ConfigId = source.ConfigId,
|
|
Name = source.Name,
|
|
Rarity = source.Rarity,
|
|
Endurance = source.Endurance,
|
|
IsAssembledIntoTower = source.IsAssembledIntoTower,
|
|
Constraint = source.Constraint,
|
|
Tags = CloneTags(source.Tags),
|
|
AttackDamage = CloneIntArray(source.AttackDamage),
|
|
DamageRandomRate = source.DamageRandomRate,
|
|
AttackMethodType = source.AttackMethodType
|
|
};
|
|
}
|
|
|
|
private static BearingCompItemData CloneBearingComp(BearingCompItemData source)
|
|
{
|
|
return new BearingCompItemData
|
|
{
|
|
InstanceId = source.InstanceId,
|
|
ConfigId = source.ConfigId,
|
|
Name = source.Name,
|
|
Rarity = source.Rarity,
|
|
Endurance = source.Endurance,
|
|
IsAssembledIntoTower = source.IsAssembledIntoTower,
|
|
Constraint = source.Constraint,
|
|
Tags = CloneTags(source.Tags),
|
|
RotateSpeed = CloneFloatArray(source.RotateSpeed),
|
|
AttackRange = CloneFloatArray(source.AttackRange)
|
|
};
|
|
}
|
|
|
|
private static BaseCompItemData CloneBaseComp(BaseCompItemData source)
|
|
{
|
|
return new BaseCompItemData
|
|
{
|
|
InstanceId = source.InstanceId,
|
|
ConfigId = source.ConfigId,
|
|
Name = source.Name,
|
|
Rarity = source.Rarity,
|
|
Endurance = source.Endurance,
|
|
IsAssembledIntoTower = source.IsAssembledIntoTower,
|
|
Constraint = source.Constraint,
|
|
Tags = CloneTags(source.Tags),
|
|
AttackSpeed = CloneFloatArray(source.AttackSpeed),
|
|
AttackPropertyType = source.AttackPropertyType
|
|
};
|
|
}
|
|
|
|
private static TowerItemData CloneTower(TowerItemData source)
|
|
{
|
|
return new TowerItemData
|
|
{
|
|
InstanceId = source.InstanceId,
|
|
Name = source.Name,
|
|
Rarity = source.Rarity,
|
|
IsParticipatingInCombat = source.IsParticipatingInCombat,
|
|
MuzzleComponentInstanceId = source.MuzzleComponentInstanceId,
|
|
BearingComponentInstanceId = source.BearingComponentInstanceId,
|
|
BaseComponentInstanceId = source.BaseComponentInstanceId,
|
|
Stats = CloneTowerStats(source.Stats)
|
|
};
|
|
}
|
|
|
|
private static TowerStatsData CloneTowerStats(TowerStatsData source)
|
|
{
|
|
if (source == null)
|
|
{
|
|
return new TowerStatsData();
|
|
}
|
|
|
|
return new TowerStatsData
|
|
{
|
|
AttackDamage = CloneIntArray(source.AttackDamage),
|
|
DamageRandomRate = source.DamageRandomRate,
|
|
RotateSpeed = CloneFloatArray(source.RotateSpeed),
|
|
AttackRange = CloneFloatArray(source.AttackRange),
|
|
AttackSpeed = CloneFloatArray(source.AttackSpeed),
|
|
AttackMethodType = source.AttackMethodType,
|
|
AttackPropertyType = source.AttackPropertyType,
|
|
Tags = CloneTags(source.Tags)
|
|
};
|
|
}
|
|
|
|
private static int[] CloneIntArray(int[] source)
|
|
{
|
|
return source != null ? (int[])source.Clone() : Array.Empty<int>();
|
|
}
|
|
|
|
private static float[] CloneFloatArray(float[] source)
|
|
{
|
|
return source != null ? (float[])source.Clone() : Array.Empty<float>();
|
|
}
|
|
|
|
private static TagType[] CloneTags(TagType[] source)
|
|
{
|
|
return source != null ? (TagType[])source.Clone() : Array.Empty<TagType>();
|
|
}
|
|
}
|
|
}
|