public UnitItem Create(string aUnitFileName)
{
UnitItem vResult = new UnitItem();
vResult.Name = Path.GetFileNameWithoutExtension(aUnitFileName);
return vResult;
}
protected override bool ProcessUnit(UnitList aUnits, UnitItem aUnit)
{
int vUnitIdx = aUnits.IndexOf(aUnit.Name);
UnitItem iToFix = aUnits[vUnitIdx];
iToFix.UsePath = aUnit.UsePath;
iToFix.Path = aUnit.Path;
return true;
}
protected override bool ProcessUnit(UnitList aUnits, UnitItem aUnit)
{
int vUnitIdx = aUnits.IndexOf(aUnit.Name);
if (aUnits[vUnitIdx].Form == aUnit.Form)
return false;
UnitItem vToFix = aUnits[vUnitIdx];
vToFix.Form = aUnit.Form;
return true;
}
/// <summary>
/// Creates new UnitItem object and fills it will all required information that can be used in a project file. Requires valid RelativePath builder and UnitFormFinder.
/// It finds corresponding form for the unit automatically. Path is always set relatively to the BasePath.
/// </summary>
/// <param name="aUnitFileName"></param>
/// <returns></returns>
public UnitItem Create(string aUnitFileName)
{
UnitItem vResult = new UnitItem();
vResult.Name = Path.GetFileNameWithoutExtension(aUnitFileName);
vResult.UsePath = UsePaths;
if (!aUnitFileName.Equals(""))
vResult.Path = Path.GetDirectoryName(aUnitFileName);
vResult.Path = RelativePath.GetRelativeFileName(BasePath, vResult.Path);
vResult.Form = UnitFormReader.GetUnitForm(aUnitFileName);
return vResult;
}
protected override bool ProcessUnit(UnitList aUnits, UnitItem aUnit)
{
int vUnitIdx = aUnits.IndexOf(aUnit.Name);
UnitItem vToDelete = aUnits[vUnitIdx];
if (vToDelete.HasStartingConditions && !vToDelete.HasEndingConditions && vUnitIdx < aUnits.Count - 1)
aUnits[vUnitIdx + 1].StartingConditions = vToDelete.StartingConditions;
else
if (vToDelete.HasEndingConditions && !vToDelete.HasStartingConditions && vUnitIdx > 0)
aUnits[vUnitIdx - 1].EndingConditions = vToDelete.EndingConditions;
aUnits.RemoveAt(vUnitIdx);
return true;
}
protected void DoTestHasForm(UnitItem iUnitItem, string iExpectedFormName, bool iExpectedHasForm)
{
Assert.AreEqual(iExpectedHasForm, iUnitItem.HasForm, "HasForm value is wrong. " + iUnitItem.Name);
Assert.AreEqual(iExpectedFormName, iUnitItem.Form, "Form value is wrong. " + iUnitItem.Name);
}
protected void DoTestPathChange(UnitItem iUnitItem, string iInitialPath, string iNewPath, string iMessage)
{
Assert.AreEqual(iInitialPath, iUnitItem.Path, "Path wasn't set properly. " + iMessage);
iUnitItem.Path = iNewPath;
Assert.AreEqual(iNewPath, iUnitItem.Path, "Path wasn't changed correctly. " + iMessage);
}
protected void DoTestNameChange(UnitItem iUnitItem, string iInitialName, string iNewName)
{
Assert.AreEqual(iInitialName, iUnitItem.Name, "Name wasn't set properly.");
iUnitItem.Name = iNewName;
Assert.AreEqual(iNewName, iUnitItem.Name, "Name wasn't changed correctly.");
}
protected virtual bool CanProcessUnit(UnitItem aUnit)
{
return (aUnit.Name != "" && State.Units.Contains(aUnit.Name));
}
public override bool Visit(UnitItem node)
{
Visit((Node)node);
return(true);
}
internal override void Process()
{
Player Player = this.Device.GameMode.Level.Player;
if (Player.InAlliance)
{
Alliance Alliance = Player.Alliance;
StreamEntry Stream = Alliance.Streams.Get(this.StreamId);
if (Stream != null)
{
if (Stream is DonateStreamEntry)
{
DonateStreamEntry DonationStream = (DonateStreamEntry)Stream;
Player Target = Resources.Accounts.LoadAccount(Stream.SenderHighId, Stream.SenderLowId)?.Player;
if (Target != null)
{
if (Target.InAlliance)
{
if (Target.AllianceId == Player.AllianceId)
{
if (this.UnitType == 1)
{
if (this.Unit is SpellData)
{
SpellData SpellData = (SpellData)this.Unit;
if (DonationStream.MaxSpell >= DonationStream.UsedSpell + SpellData.HousingSpace)
{
if (this.UseDiamonds)
{
int Cost = SpellData.DonateCost;
if (Player.HasEnoughDiamonds(Cost))
{
Player.UseDiamonds(Cost);
}
else
{
Logging.Error(this.GetType(), "Unable to donate unit. The player use diamonds to donate but doesn't have enough diamonds!");
return;
}
}
int UnitLevel = Player.GetUnitUpgradeLevel(SpellData);
UnitItem Unit = new UnitItem(SpellData.GlobalId, 1, UnitLevel);
DonationStream.New = false;
Target.AllianceUnits.Add(Unit);
Unit.DonatorId = Player.UserId;
DonationStream.Units.Add(Unit, Player.UserId);
int HousingSpace = SpellData.HousingSpace;
DonationStream.UsedSpell += HousingSpace;
Target.CastleUsedSpellCapacity += HousingSpace;
Player.Donation += HousingSpace;
Target.DonationReceived += HousingSpace;
Player.AddExperience(HousingSpace);
this.Device.GameMode.CommandManager.AddCommand(new Donate_Unit_Callback(this.Device)
{
StreamId = this.StreamId, UnitType = this.UnitType, UnitId = SpellData.GlobalId, UseDiamonds = this.UseDiamonds
});
if (Target.Connected)
{
Target.Level.GameMode.CommandManager.AddCommand(new Alliance_Unit_Received(Target.Level.GameMode.Device)
{
Donator = Player.Name, UnitType = this.UnitType, UnitId = SpellData.GlobalId, Level = UnitLevel
});
}
Alliance.Streams.Update(Stream);
}
}
}
else
{
if (this.Unit is CharacterData)
{
CharacterData CharacterData = (CharacterData)this.Unit;
if (DonationStream.MaxTroop >= DonationStream.UsedTroop + CharacterData.HousingSpace)
{
if (this.UseDiamonds)
{
int Cost = CharacterData.DonateCost;
if (Player.HasEnoughDiamonds(Cost))
{
Player.UseDiamonds(Cost);
}
else
{
Logging.Error(this.GetType(), "Unable to donate unit. The player use diamonds to donate but doesn't have enough diamonds!");
return;
}
}
int UnitLevel = Player.GetUnitUpgradeLevel(CharacterData);
UnitItem Unit = new UnitItem(CharacterData.GlobalId, 1, UnitLevel);
DonationStream.New = false;
Target.AllianceUnits.Add(Unit);
Unit.DonatorId = Player.UserId;
DonationStream.Units.Add(Unit, Player.UserId);
int HousingSpace = CharacterData.HousingSpace;
DonationStream.UsedTroop += HousingSpace;
Target.CastleUsedCapacity += HousingSpace;
Player.Donation += HousingSpace;
Target.DonationReceived += HousingSpace;
Player.AddExperience(HousingSpace);
this.Device.GameMode.CommandManager.AddCommand(new Donate_Unit_Callback(this.Device)
{
StreamId = this.StreamId, UnitType = this.UnitType, UnitId = CharacterData.GlobalId, UseDiamonds = this.UseDiamonds
});
if (Target.Connected)
{
Target.Level.GameMode.CommandManager.AddCommand(new Alliance_Unit_Received(Target.Level.GameMode.Device)
{
Donator = Player.Name, UnitType = this.UnitType, UnitId = CharacterData.GlobalId, Level = UnitLevel
});
}
Alliance.Streams.Update(Stream);
}
}
}
}
}
}
}
}
}
}
private void DistroyUnitItem(UnitItem item)
{
GameObject.Destroy(item.gameObject); item = null;
}
public UpdateModel(UnitItem item)
{
Success = true;
Item = item;
}
public OrderActivated(int orderId, int byMemberId, UnitItem affectedUnitItem = null)
{
OrderId = orderId;
ByMemberId = byMemberId;
AffectedUnitItem = affectedUnitItem;
}
protected virtual bool CanProcessUnit(UnitItem aUnit)
{
return(aUnit.Name != "" && State.Units.Contains(aUnit.Name));
}
public UpdateModel(UnitItem item, OrderStatusId newStatus)
{
Success = true;
UnitItem = item;
NewStatus = newStatus;
}
public OrderCompleted(int orderId, int memberId, UnitItem affectedUnitItem)
{
OrderId = orderId;
MemberId = memberId;
AffectedUnitItem = affectedUnitItem;
}
public virtual T Visit(UnitItem node)
{
return(Visit((Node)node));
}
protected abstract bool ProcessUnit(UnitList aUnits, UnitItem aUnit);
protected override bool CanProcessUnit(UnitItem aUnit)
{
return (aUnit.Name != "") && !State.Units.Contains(aUnit.Name);
}
protected override bool ProcessUnit(UnitList aUnits, UnitItem aUnit)
{
aUnits.Add(aUnit);
return true;
}
public DeviceDoor() : base()
{
this.unitItem = new UnitItem(DataAccRes.AppSettings("WorkConfig"), "门禁监控");
this.query = new QueryDataRes(this.unitItem.DataSrcFile);
}
protected void DoTestContains_NotExisting(UnitList iList, string iUnitPrefix, int iUnitIdx)
{
UnitItem vNotExisting = CreateItem(iUnitPrefix, iUnitIdx, true);
Assert.IsFalse(iList.Contains(vNotExisting.Name), "Wrong Contains result. Item shouldn't be on the list: " + vNotExisting.Name);
}
public void SetItemValues()
{
#region Planet Items Set
for (int i = 0; i < Celestials.Count; i++)
{
if (Celestials[i].GetComponent <ResourceObject>() == null)
{
PlanetItem planetItem = new PlanetItem();
planetItem.celestialName = Celestials[i].name;
planetItem.posX = Celestials[i].transform.position.x;
planetItem.posY = Celestials[i].transform.position.y;
planetItem.posZ = Celestials[i].transform.position.z;
planetItem.systemName = Celestials[i].transform.parent.parent.name;
itemDB.planets.Add(planetItem);
}
}
#endregion
#region Asteriod Items Set
for (int i = 0; i < Celestials.Count; i++)
{
if (Celestials[i].GetComponent <ResourceObject>() != null)
{
AsteriodItem asteroidItem = new AsteriodItem();
asteroidItem.celestialName = Celestials[i].name;
asteroidItem.posX = Celestials[i].transform.position.x;
asteroidItem.posY = Celestials[i].transform.position.y;
asteroidItem.posZ = Celestials[i].transform.position.z;
asteroidItem.systemName = Celestials[i].transform.parent.parent.name;
itemDB.asteriods.Add(asteroidItem);
}
}
#endregion
#region Systems Items Set
for (int i = 0; i < SystemPrefabs.Count; i++)
{
SystemItem systemItem = new SystemItem();
systemItem.systemName = SystemPrefabs[i].name;
for (int j = 0; j < SystemPrefabs[i].transform.Find("Planets").childCount; j++) //Naprendszer bolygóelemek nevei
{
systemItem.celestials.Add(SystemPrefabs[i].transform.Find("Planets").GetChild(j).name);
}
itemDB.systems.Add(systemItem);
}
#endregion
#region Galaxy Stars Items Set
for (int i = 0; i < GalaxyStarPrefabs.Count; i++)
{
StarItem starItem = new StarItem();
starItem.starName = GalaxyStarPrefabs[i].name;
starItem.posX = GalaxyStarPrefabs[i].transform.position.x;
starItem.posY = GalaxyStarPrefabs[i].transform.position.y;
starItem.posZ = GalaxyStarPrefabs[i].transform.position.z;
itemDB.stars.Add(starItem);
}
#endregion
#region Unit Items Set
for (int i = 0; i < Units.Count; i++)
{
UnitItem unit = new UnitItem();
unit.unitName = Units[i].name;
unit.posX = Units[i].transform.position.x;
unit.posY = Units[i].transform.position.y;
unit.posZ = Units[i].transform.position.z;
unit.starName = Units[i].transform.parent.parent.name;
itemDB.units.Add(unit);
}
#endregion
}
public void ToString_WithoutPath()
{
UnitItem vUnit = new UnitItem("unit_name");
Assert.AreEqual("unit_name", vUnit.ToString("", "", false));
}
protected void DoTestNameChange(string iInitialName, string iNewName)
{
UnitItem vUnit = new UnitItem(iInitialName);
DoTestNameChange(vUnit, iInitialName, iNewName);
}
private void ValidateUnits(UnitItem myUnit)
{
// BUGBUG write this code
}
protected abstract bool ProcessUnit(UnitList aUnits, UnitItem aUnit);
