public static BattleResult ResolveBattle(UnitRank attacker, UnitRank defender)
{
//Assume attacker fails
BattleResult result = BattleResult.Fail;
if (defender == UnitRank.Flag)
{
//Handle flag
result = BattleResult.Success;
}
else if (attacker == defender)
{
//Handle split, same rank
result = BattleResult.Split;
}
else if (attacker == UnitRank.Spy || defender == UnitRank.Spy)
{
if (attacker == UnitRank.Spy && defender != UnitRank.Private)
{
//Handle attacker spy logic
result = BattleResult.Success;
}
else if (defender == UnitRank.Spy && attacker == UnitRank.Private)
{
result = BattleResult.Success;
}
}
else if (attacker > defender)
{
//Handle rank compare
result = BattleResult.Success;
}
return result;
}
/// <summary>
/// Initializes a new instance of the <see cref="UnitBase"/> class.
/// </summary>
/// <param name="row"></param>
public UnitBase(DataRow row)
{
if (row == null)
{
throw new ArgumentNullException("row");
}
this.unitId = Convert.ToInt32(row["UnitID"], CultureInfo.InvariantCulture);
this.Name = Convert.ToString(row["Name"], CultureInfo.InvariantCulture);
this.bombardmentRange = Convert.ToInt32(row["BombardmentRange"], CultureInfo.InvariantCulture);
this.bombardmentPower = Convert.ToInt32(row["Bombardment"], CultureInfo.InvariantCulture);
this.canMergeWithCity = Convert.ToBoolean(row["CanMergeWithCity"], CultureInfo.InvariantCulture);
this.canSettle = Convert.ToBoolean(row["CanSettle"], CultureInfo.InvariantCulture);
this.canWork = Convert.ToBoolean(row["CanWork"], CultureInfo.InvariantCulture);
this.Cost = Convert.ToInt32(row["Cost"], CultureInfo.InvariantCulture);
this.defense = Convert.ToInt32(row["Defense"], CultureInfo.InvariantCulture);
this.rank = UnitRank.Conscript;
this.type = (UnitType)Enum.Parse(typeof(UnitType), row["Type"].ToString(), true);
this.hitPoints = this.MaxHitPoints;
this.movesPerTurn = Convert.ToInt32(row["Movement"], CultureInfo.InvariantCulture);
this.movesLeft = this.movesPerTurn;
this.offensivePower = Convert.ToInt32(row["Attack"], CultureInfo.InvariantCulture);
this.populationPoints = Convert.ToInt32(row["PopulationPoints"], CultureInfo.InvariantCulture);
this.rateOfFire = Convert.ToInt32(row["RateOfFire"], CultureInfo.InvariantCulture);
this.neededResources = new NamedObjectCollection <Resource>();
}
/// <summary>
/// Gets a string representation of the specified <see cref="McKnight.Similization.Core.UnitRank"/>
/// </summary>
/// <param name="rank"></param>
/// <returns></returns>
public static string GetRankString(UnitRank rank)
{
string rankString = string.Empty;
switch (rank)
{
case UnitRank.Conscript:
rankString = GetString(StringKey.RankConscript);
break;
case UnitRank.Elite:
rankString = GetString(StringKey.RankElite);
break;
case UnitRank.Regular:
rankString = GetString(StringKey.RankRegular);
break;
case UnitRank.Veteran:
rankString = GetString(StringKey.RankVeteran);
break;
}
return(rankString);
}
public static BattleResult ResolveBattle(UnitRank attacker, UnitRank defender)
{
//Assume attacker fails
BattleResult result = BattleResult.Fail;
if (defender == UnitRank.Flag)
{
//Handle flag
result = BattleResult.Success;
}
else if (attacker == defender)
{
//Handle split, same rank
result = BattleResult.Split;
}
else if (attacker == UnitRank.Spy || defender == UnitRank.Spy)
{
if (attacker == UnitRank.Spy && defender != UnitRank.Private)
{
//Handle attacker spy logic
result = BattleResult.Success;
}
else if (defender == UnitRank.Spy && attacker == UnitRank.Private)
{
result = BattleResult.Success;
}
}
else if (attacker > defender)
{
//Handle rank compare
result = BattleResult.Success;
}
return(result);
}
public void SetRank(UnitRank rank)
{
this.rank = rank;
//Initialize the values
unitName.text = UnitUtilities.ReadableRank(rank);
image.sprite = UnitImageManager.GetRankImage(rank);
remaining.text = UnitManager.GetPlacementAmountForUnit(rank).ToString();
}
public void SetRank(UnitRank rank)
{
this.rank = rank;
//Initialize the values
unitName.text = UnitUtilities.ReadableRank(rank);
image.sprite = UnitImageManager.GetRankImage(rank);
remaining.text = UnitManager.GetPlacementAmountForUnit(rank).ToString();
}
private void HandleUnitPlaced(UnitPlacedEvent e)
{
//Check if the unit still can be placed. If not, we need to clear the selection.
if (UnitManager.GetPlacementAmountForUnit(placementRank) <= 0)
{
placementRank = UnitRank.Unknown;
}
}
private void UpdateRankString(UnitRank rank)
{
var field = rank.GetType().GetField(rank.ToString());
var attribute = field.GetCustomAttribute <DescriptionAttribute>(false);
RankView.Value = attribute != null ? attribute.Description : rank.ToString();
IsShowRank.Value = rank != UnitRank.None ? Visibility.Visible : Visibility.Collapsed;
}
public static string ReadableRank(UnitRank rank)
{
string readable = "Unknown";
switch (rank)
{
case UnitRank.BrigadierGeneral:
{
readable = "Brigadier General";
break;
}
case UnitRank.FirstLieutenant:
{
readable = "First Lieutenant";
break;
}
case UnitRank.GeneralOfTheArmy:
{
readable = "General Of The Army";
break;
}
case UnitRank.LieutenantColonel:
{
readable = "Lieutenant Colonel";
break;
}
case UnitRank.LieutenantGeneral:
{
readable = "Lieutenant General";
break;
}
case UnitRank.MajorGeneral:
{
readable = "Major General";
break;
}
case UnitRank.SecondLieutenant:
{
readable = "Second Lieutenant";
break;
}
default:
{
readable = rank.ToString();
break;
}
}
return(readable);
}
public void UpgradeToRanged3()
{
new Unit(currentSize, 20, 7, 10, 6, UnitType.RANGED, UnitRank.RANGED3, "Ranged troop rk 3", positionInList);
power = 7;
maxLife = 12;
damage = 6;
unitRank = UnitRank.RANGED3;
name = "ranged troop rank 3";
upgradeCost = 999;
}
public void UpgradeToRanged2()
{
new Unit(currentSize, 20, 4, 10, 4, UnitType.RANGED, UnitRank.RANGED2, "Ranged troop rk 2", positionInList);
power = 4;
maxLife = 10;
damage = 4;
unitRank = UnitRank.RANGED2;
name = "ranged troop rank 2";
upgradeCost = 4;
}
//upgrades unit (called by ai ) TODO
public void UpgradeToMelee1()
{
// Unit(int currentSize, int maxSize, int power, int maxLife, int damage, UnitType type, UnitRank rank, string name, int pos)
// new Unit(currentSize, 20, 2, 10, 2, UnitType.MELEE, UnitRank.MELEE1, "Melee troop rk 1", positionInList);
power = 2;
damage = 2;
unitRank = UnitRank.MELEE1;
name = "Melee troop rank 1";
upgradeCost = 3;
}
public void UpgradeToMelee2()
{
new Unit(currentSize, 20, 4, 15, 3, UnitType.MELEE, UnitRank.MELEE2, "Melee troop rk 2", positionInList);
power = 4;
maxLife = 15;
damage = 3;
unitRank = UnitRank.MELEE2;
name = "Melee troop rank 2";
upgradeCost = 4;
}
public void UpgradeToMelee3()
{
new Unit(currentSize, 20, 6, 20, 4, UnitType.MELEE, UnitRank.MELEE3, "Melee troop rk 3", positionInList);
power = 6;
maxLife = 20;
damage = 4;
maxSize = 30;
unitRank = UnitRank.MELEE3;
name = "Melee troop rank 3";
upgradeCost = 999;
}
public void UpgradeToRanged1()
{
new Unit(currentSize, 20, 2, 8, 3, UnitType.RANGED, UnitRank.RANGED1, "Ranged troop rk 1", positionInList);
power = 2;
maxLife = 8;
damage = 3;
unitRank = UnitRank.RANGED1;
unitType = UnitType.RANGED;
name = "ranged troop rank 1";
upgradeCost = 3;
}
public void UpgradeToCavalry1()
{
new Unit(currentSize, 20, 7, 10, 6, UnitType.CAVALRY, UnitRank.CAVALRY1, "Cavalry troop rk 3", positionInList);
power = 10;
maxLife = 25;
damage = 6;
unitRank = UnitRank.CAVALRY1;
unitType = UnitType.CAVALRY;
name = "cavalry troop rank 1";
upgradeCost = 999;
}
public void AddPiece(BoardPosition position, UnitRank rank)
{
//Check for existing piece, remove it if needed.
//Debug.Log("atteming to add " + UnitUtilities.ReadableRank(rank) + " at " + position.ToString());
bool equal = false;
if (pieces.ContainsKey(position))
{
UnitPiece existing;
if (pieces.TryGetValue(position, out existing))
{
if (existing.Rank.Equals(rank))
{
//We're not going to remove then add the same exact piece to the same position
equal = true;
}
else
{
RemovePiece(position);
}
}
}
if (!equal)
{
Transform target = BoardManager.GetTransformForPosition(position);
if (!EqualityComparer <Transform> .Default.Equals(target, default(Transform)))
{
GameObject plane = Instantiate(UnitPlane);
UnitPiece piece = GeneratePiece(rank, plane);
if (piece.Owner != null)
{
piece.Piece.transform.SetParent(piece.Owner.Holder.transform);
plane.name = UnitUtilities.ReadableRank(rank);
plane.layer = LayerMask.NameToLayer("Pieces");
Vector3 planePos = target.position;
planePos.z = GOLayer.UNIT_LAYER;
plane.transform.position = planePos;
Renderer r = plane.GetComponent <Renderer>();
r.material = MaterialManager.GetRankMaterial(rank);
pieces.Add(position, piece);
EventManager.Raise(new UnitPlacedEvent(position, piece));
}
else
{
piece.Destroy();
Destroy(plane);
}
}
}
}
public int GetPlacementAmountForUnit(UnitRank rank)
{
int amount = 0;
if (GameManager.CurrentMode == GameMode.PlayerOneSetup)
{
playerOnePlacementUnits.TryGetValue(rank, out amount);
}
else if (GameManager.CurrentMode == GameMode.PlayerTwoSetup)
{
playerTwoPlacementUnits.TryGetValue(rank, out amount);
}
return(amount);
}
public static string ReadableRank(UnitRank rank)
{
string readable = "Unknown";
switch(rank)
{
case UnitRank.BrigadierGeneral:
{
readable = "Brigadier General";
break;
}
case UnitRank.FirstLieutenant:
{
readable = "First Lieutenant";
break;
}
case UnitRank.GeneralOfTheArmy:
{
readable = "General Of The Army";
break;
}
case UnitRank.LieutenantColonel:
{
readable = "Lieutenant Colonel";
break;
}
case UnitRank.LieutenantGeneral:
{
readable = "Lieutenant General";
break;
}
case UnitRank.MajorGeneral:
{
readable = "Major General";
break;
}
case UnitRank.SecondLieutenant:
{
readable = "Second Lieutenant";
break;
}
default:
{
readable = rank.ToString();
break;
}
}
return readable;
}
public void AddPiece(BoardPosition position, UnitRank rank)
{
//Check for existing piece, remove it if needed.
//Debug.Log("atteming to add " + UnitUtilities.ReadableRank(rank) + " at " + position.ToString());
bool equal = false;
if (pieces.ContainsKey(position))
{
UnitPiece existing;
if (pieces.TryGetValue(position, out existing))
{
if (existing.Rank.Equals(rank))
{
//We're not going to remove then add the same exact piece to the same position
equal = true;
}
else
{
RemovePiece(position);
}
}
}
if (!equal)
{
Transform target = BoardManager.GetTransformForPosition(position);
if (!EqualityComparer<Transform>.Default.Equals(target, default(Transform)))
{
GameObject plane = Instantiate(UnitPlane);
UnitPiece piece = GeneratePiece(rank, plane);
if (piece.Owner != null)
{
piece.Piece.transform.SetParent(piece.Owner.Holder.transform);
plane.name = UnitUtilities.ReadableRank(rank);
plane.layer = LayerMask.NameToLayer("Pieces");
Vector3 planePos = target.position;
planePos.z = GOLayer.UNIT_LAYER;
plane.transform.position = planePos;
Renderer r = plane.GetComponent<Renderer>();
r.material = MaterialManager.GetRankMaterial(rank);
pieces.Add(position, piece);
EventManager.Raise(new UnitPlacedEvent(position, piece));
}
else
{
piece.Destroy();
Destroy(plane);
}
}
}
}
public Material GetRankMaterial(UnitRank rank)
{
Material material = materials[0].material;
foreach(UnitMaterial um in materials)
{
if(um.rank.Equals(rank))
{
material = um.material;
break;
}
}
return material;
}
public Sprite GetRankImage(UnitRank rank)
{
Sprite sprite = images[0].sprite;
foreach (UnitImage image in images)
{
if (image.rank.Equals(rank))
{
sprite = image.sprite;
break;
}
}
return(sprite);
}
public Material GetRankMaterial(UnitRank rank)
{
Material material = materials[0].material;
foreach (UnitMaterial um in materials)
{
if (um.rank.Equals(rank))
{
material = um.material;
break;
}
}
return(material);
}
public Sprite GetRankImage(UnitRank rank)
{
Sprite sprite = images[0].sprite;
foreach(UnitImage image in images)
{
if(image.rank.Equals(rank))
{
sprite = image.sprite;
break;
}
}
return sprite;
}
public int Armor(DamageType type, UnitRank rank)
{
switch (type)
{
case DamageType.BLUNT: return(_template.BaseArmorBlunt(rank));
case DamageType.SLASH: return(_template.BaseArmorSlash(rank));
case DamageType.PIERCING: return(_template.BaseArmorPiercing(rank));
case DamageType.POISON: return(_template.BaseResistance(rank));
case DamageType.FIRE: return(_template.BaseResistance(rank));
}
return(0);
}
private UnitPiece GeneratePiece(UnitRank rank, GameObject plane)
{
UnitPiece piece = new UnitPiece(rank, plane);
if (GameManager.CurrentMode == GameMode.PlayerOneSetup)
{
piece.Owner = GameManager.PlayerOne;
playerOnePlacementUnits[rank] -= 1;
}
else if (GameManager.CurrentMode == GameMode.PlayerTwoSetup)
{
piece.Owner = GameManager.PlayerTwo;
playerTwoPlacementUnits[rank] -= 1;
}
return(piece);
}
public UnitPlacementSelectedEvent(UnitRank selected)
{
this.rank = selected;
}
//call this from inside button() method
//sets current button, and purchasable buttons
//also can set the text etc
public void SetButtons(Unit unit)
{
oldUnitRef = unit;
purchasableButtons = new Button[2];
disabledButtons = new Button[8]; // dont need/
UnitType t = unit.unitType;
UnitRank r = unit.unitRank;
Debug.Log(" unit type " + t.ToString() + ", unit rank: " + r.ToString());
switch (t)
{
case (UnitType.MELEE):
if (r.Equals(UnitRank.RECRUIT))
{
currentButton = recruitButton;
purchasableButtons[0] = (meleeButtons[0]);
purchasableButtons[1] = (rangedButtons[0]);
}
else if (r.Equals(UnitRank.MELEE1))
{
currentButton = meleeButtons[0];
purchasableButtons = new Button[1];
purchasableButtons[0] = (meleeButtons[1]);
}
else if (r.Equals(UnitRank.MELEE2))
{
currentButton = meleeButtons[1];
purchasableButtons[0] = (cavalryButtons[0]);
purchasableButtons[1] = (meleeButtons[2]);
}
else if (r.Equals(UnitRank.MELEE3))
{
currentButton = meleeButtons[2];
purchasableButtons = new Button[0];
}
break;
case (UnitType.RANGED):
if (r.Equals(UnitRank.RANGED1))
{
currentButton = rangedButtons[0];
purchasableButtons = new Button[1];
purchasableButtons[0] = (rangedButtons[1]);
}
if (r.Equals(UnitRank.RANGED2))
{
currentButton = rangedButtons[1];
purchasableButtons = new Button[1];
purchasableButtons[0] = (rangedButtons[2]);
}
if (r.Equals(UnitRank.RANGED3))
{
currentButton = rangedButtons[2];
purchasableButtons = new Button[0];
//purchasableButtons[0] = (rangedButtons[3]);
}
break;
case (UnitType.CAVALRY):
if (r.Equals(UnitRank.CAVALRY1))
{
currentButton = cavalryButtons[0];
purchasableButtons = new Button[0];
}
break;
}
}
public UnitPiece(UnitRank rank, GameObject piece)
{
this.rank = rank;
this.piece = piece;
}
private void HandleUnitPlacementSelected(UnitPlacementSelectedEvent e)
{
placementRank = e.Rank;
}
private void HandleUnitPlaced(UnitPlacedEvent e)
{
//Check if the unit still can be placed. If not, we need to clear the selection.
if (UnitManager.GetPlacementAmountForUnit(placementRank) <= 0)
{
placementRank = UnitRank.Unknown;
}
}
public int Resistance(UnitRank rank) => _template.BaseResistance(rank);
public int GetPlacementAmountForUnit(UnitRank rank)
{
int amount = 0;
if (GameManager.CurrentMode == GameMode.PlayerOneSetup)
{
playerOnePlacementUnits.TryGetValue(rank, out amount);
}
else if (GameManager.CurrentMode == GameMode.PlayerTwoSetup)
{
playerTwoPlacementUnits.TryGetValue(rank, out amount);
}
return amount;
}
public int BaseMobility(UnitRank rank) => _mobility[(int)rank];
public int BaseArmorBlunt(UnitRank rank) => _armorBlunt[(int)rank];
public int BaseArmorPiercing(UnitRank rank) => _armorPiercing[(int)rank];
public int BaseArmorSlash(UnitRank rank) => _armorSlash[(int)rank];
public Unit(Reign.Unit unit)
{
_id = unit.ID;
_rank = unit.Rank;
_exp = unit.Exp;
_obCount = unit.ObliterateCount;
_acted = unit.Acted;
}
private void HandleUnitPlacementSelected(UnitPlacementSelectedEvent e)
{
placementRank = e.Rank;
}
private UnitPiece GeneratePiece(UnitRank rank, GameObject plane)
{
UnitPiece piece = new UnitPiece(rank, plane);
if (GameManager.CurrentMode == GameMode.PlayerOneSetup)
{
piece.Owner = GameManager.PlayerOne;
playerOnePlacementUnits[rank] -= 1;
}
else if (GameManager.CurrentMode == GameMode.PlayerTwoSetup)
{
piece.Owner = GameManager.PlayerTwo;
playerTwoPlacementUnits[rank] -= 1;
}
return piece;
}
public int BaseResistance(UnitRank rank) => _resistance[(int)rank];
public UnitPiece(UnitRank rank, GameObject piece)
{
this.rank = rank;
this.piece = piece;
}
public int Mobility(UnitRank rank) => _template.BaseMobility(rank);
