/// <summary>
/// Resets the values to default.
/// </summary>
public override void ResetValues()
{
base.ResetValues();
icon = null;
description = "";
itemCategory = ItemCategory.WEAPON;
weaponType = WeaponType.NONE;
attackType = AttackType.PHYSICAL;
keyType = KeyType.STAR;
cost = 0;
maxCharge = 0;
researchNeeded = false;
skillReq = WeaponRank.NONE;
power = 0;
hitRate = 0;
critRate = 0;
range = new WeaponRange(1, 1);
advantageType = new List <MovementType>();
boost = new Boost();
}
public void OnActivation(EntityController entity)
{
if (Input.GetKeyDown(KeyCode.E))
{
if (this.weapon is WeaponMelee)
{
WeaponMelee weaponMeleeToEquip = this.weapon as WeaponMelee;
if (entity.entityProperties.weaponMelee != null)
{
Debug.Log("Drop a " + entity.entityProperties.weaponMelee.weaponName + " and get a " + this.weapon.weaponName);
weaponPrefab.GetComponent <WeaponDisplay>().weapon = entity.entityProperties.weaponMelee;
Instantiate(weaponPrefab, this.transform);
}
entity.entityProperties.weaponMelee = weaponMeleeToEquip;
}
else if (this.weapon is WeaponRange)
{
WeaponRange weaponRangeToEquip = this.weapon as WeaponRange;
if (entity.entityProperties.weaponRange != null)
{
Debug.Log("Drop a " + entity.entityProperties.weaponRange.weaponName + " and get a " + this.weapon.weaponName);
weaponPrefab.GetComponent <WeaponDisplay>().weapon = entity.entityProperties.weaponRange;
Instantiate(weaponPrefab, this.transform);
}
entity.entityProperties.weaponRange = weaponRangeToEquip;
}
Destroy(this.gameObject);
}
}
// Functions for checking if the character can do stuff.
#region Can do stuff
/// <summary>
/// Takes the range of the character's weapons and checks if any enemy is in range.
/// </summary>
/// <returns></returns>
public bool CanAttack()
{
WeaponRange range = inventory.GetReach(ItemCategory.WEAPON);
if (range.max == 0)
{
return(false);
}
for (int i = 0; i < enemyList.values.Count; i++)
{
if (!enemyList.values[i].IsAlive() || enemyList.values[i].hasEscaped)
{
continue;
}
int distance = BattleMap.DistanceTo(this, enemyList.values[i]);
if (range.InRange(distance))
{
return(true);
}
}
for (int i = 0; i < battleMap.breakables.Count; i++)
{
if (!battleMap.breakables[i].blockMove.IsAlive())
{
continue;
}
int distance = BattleMap.DistanceTo(this, battleMap.breakables[i]);
if (range.InRange(distance))
{
return(true);
}
}
return(false);
}
public void ShowSupportTiles(MapTile startTile, WeaponRange range, Faction faction, bool isDanger, bool isBuff)
{
if (isDanger)
{
return;
}
for (int i = 0; i < tiles.Length; i++)
{
int tempDist = DistanceTo(startTile, tiles[i]);
if (!range.InRange(tempDist))
{
continue;
}
if (tiles[i].IsEmpty())
{
tiles[i].supportable = true;
}
else if (tiles[i].currentCharacter.faction == faction)
{
if (isBuff || tiles[i].currentCharacter.IsInjured())
{
tiles[i].supportable = true;
}
}
}
}
private void applyRangeAttributes(WeaponRange weaponRange, RangeBasedWeaponAttributesPatch rangePatch, WeaponAttributesWrapper weaponWrapper)
{
if (rangePatch == null)
{
return;
}
var ranges = weaponWrapper.Ranges;
var newRanges = ranges.Where(r => r.Range < weaponRange);
var range = ranges.SingleOrDefault(r => r.Range == weaponRange);
using (logger.BeginScope($"RangeAttributes{weaponRange}:"))
{
if (rangePatch.Remove)
{
logger.Log("(removed)");
}
else
{
RangeBasedWeaponAttributesWrapper rangeWrapper;
if (range != null)
{
rangeWrapper = new RangeBasedWeaponAttributesWrapper(range);
}
else
{
logger.Log("(created)");
rangeWrapper = new RangeBasedWeaponAttributesWrapper(weaponRange);
}
ApplyRangeBasedWeaponAttributesPatch(rangePatch, rangeWrapper);
newRanges = newRanges.Concat(new[] { rangeWrapper });
}
}
newRanges = newRanges.Concat(ranges.Where(r => r.Range > weaponRange));
weaponWrapper.Ranges = newRanges.ToArray();
}
/// <summary>
/// Adds attackable to all tiles surrounding the character depending on range.
/// </summary>
/// <param name="range1"></param>
/// <param name="range2"></param>
public void ShowAttackTiles(WeaponRange range, int damage)
{
if (!IsAlive())
{
return;
}
for (int i = 0; i < battleMap.tiles.Length; i++)
{
if (range.InRange(BattleMap.DistanceTo(this, battleMap.tiles[i])))
{
battleMap.tiles[i].attackable = true;
if (damage >= currentHealth)
{
damage += 100;
}
battleMap.tiles[i].value = damage;
}
}
}
/// <summary>
/// Shows which tiles are attackable from the startTile given the weapon range.
/// isDanger is used to show the enemy danger area.
/// </summary>
/// <param name="startTile"></param>
/// <param name="range"></param>
/// <param name="faction"></param>
/// <param name="isDanger"></param>
public void ShowAttackTiles(MapTile startTile, WeaponRange range, Faction faction, bool isDanger)
{
for (int i = 0; i < tiles.Length; i++)
{
int tempDist = DistanceTo(startTile, tiles[i]);
if (!range.InRange(tempDist))
{
continue;
}
if (isDanger)
{
tiles[i].dangerous = true;
}
else if (tiles[i].IsEmpty() || tiles[i].currentCharacter.faction != faction)
{
tiles[i].attackable = true;
}
}
}
/// <summary>
/// Takes a list of characters and finds all which are in range and picks one randomly.
/// </summary>
/// <param name="list"></param>
/// <param name="category"></param>
/// <param name="checkInjured"></param>
/// <returns></returns>
private MapTile FindRandomTarget(List <TacticsMove> list, ItemCategory category, bool checkInjured)
{
List <MapTile> hits = new List <MapTile>();
WeaponRange range = inventory.GetReach(category);
for (int i = 0; i < list.Count; i++)
{
if (list[i] == this || !list[i].IsAlive() || (checkInjured && !list[i].IsInjured()))
{
continue;
}
int distance = BattleMap.DistanceTo(this, list[i]);
if (range.InRange(distance))
{
hits.Add(list[i].currentTile);
}
}
hits.Shuffle();
return(hits[0]);
}
int IComparable <BProtoObjectVeterancy> .CompareTo(BProtoObjectVeterancy other)
{
if (XP != other.XP)
{
return(XP.CompareTo(other.XP));
}
if (Damage != other.Damage)
{
return(Damage.CompareTo(other.Damage));
}
if (Velocity != other.Velocity)
{
return(Velocity.CompareTo(other.Velocity));
}
if (Accuracy != other.Accuracy)
{
return(Accuracy.CompareTo(other.Accuracy));
}
if (WorkRate != other.WorkRate)
{
return(WorkRate.CompareTo(other.WorkRate));
}
if (WeaponRange != other.WeaponRange)
{
return(WeaponRange.CompareTo(other.WeaponRange));
}
if (DamageTaken != other.DamageTaken)
{
return(DamageTaken.CompareTo(other.DamageTaken));
}
return(0);
}
/// <summary>
/// Adds supportable to all tiles surrounding the character depending on range.
/// </summary>
/// <param name="range1"></param>
/// <param name="range2"></param>
public void ShowSupportTiles(WeaponRange range, bool isBuff)
{
if (!IsAlive())
{
return;
}
for (int i = 0; i < battleMap.tiles.Length; i++)
{
if (range.InRange(BattleMap.DistanceTo(this, battleMap.tiles[i])))
{
battleMap.tiles[i].supportable = true;
if (isBuff)
{
battleMap.tiles[i].value = 5;
}
else
{
battleMap.tiles[i].value = stats.hp - currentHealth;
}
}
}
}
/// <summary>
/// Takes the range of the character's staffs and checks if any supportable is in range.
/// </summary>
/// <returns></returns>
public bool CanSupport()
{
WeaponRange range = inventory.GetReach(ItemCategory.SUPPORT);
if (range.max == 0)
{
return(false);
}
List <InventoryTuple> staffs = inventory.GetAllUsableItemTuple(ItemCategory.SUPPORT);
bool isBuff = false;
for (int i = 0; i < staffs.Count; i++)
{
if (staffs[i].weaponType == WeaponType.BARRIER)
{
isBuff = true;
break;
}
}
for (int i = 0; i < playerList.values.Count; i++)
{
bool usable = (playerList.values[i].IsAlive() && playerList.values[i].IsInjured() || isBuff);
if (!usable || playerList.values[i] == this)
{
continue;
}
int distance = BattleMap.DistanceTo(this, playerList.values[i]);
if (range.InRange(distance))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Takes a weapon and shows the possible tiles it can be used on to define where the AI
/// can do things. Each opponent or each ally depending on weapon type.
/// </summary>
/// <param name="weapon"></param>
private void GenerateHitTiles(List <InventoryTuple> weapons)
{
battleMap.ResetMap();
//Sort characters
enemies.Clear();
friends.Clear();
if (faction == Faction.ALLY)
{
for (int i = 0; i < enemyList.values.Count; i++)
{
if (enemyList.values[i].IsAlive() && !enemyList.values[i].hasEscaped)
{
enemies.Add(enemyList.values[i]);
}
}
for (int i = 0; i < playerList.Count; i++)
{
if (playerList.values[i].IsAlive() && !playerList.values[i].hasEscaped)
{
friends.Add(playerList.values[i]);
}
}
for (int i = 0; i < allyList.Count; i++)
{
if (this != allyList.values[i] && allyList.values[i].IsAlive() && !allyList.values[i].hasEscaped)
{
friends.Add(allyList.values[i]);
}
}
}
else if (faction == Faction.ENEMY)
{
for (int i = 0; i < enemyList.values.Count; i++)
{
if (this != enemyList.values[i] && enemyList.values[i].IsAlive() && !enemyList.values[i].hasEscaped)
{
friends.Add(enemyList.values[i]);
}
}
for (int i = 0; i < playerList.Count; i++)
{
if (playerList.values[i].IsAlive() && !playerList.values[i].hasEscaped)
{
enemies.Add(playerList.values[i]);
}
}
for (int i = 0; i < allyList.Count; i++)
{
if (allyList.values[i].IsAlive() && !allyList.values[i].hasEscaped)
{
enemies.Add(allyList.values[i]);
}
}
}
//Calculate range
//Generate attack/support tiles
if (weapons[0].itemCategory == ItemCategory.WEAPON)
{
int damage = BattleCalc.CalculateDamage(weapons[0], stats);
WeaponRange reach = inventory.GetReach(ItemCategory.WEAPON);
for (int i = 0; i < enemies.Count; i++)
{
int defense = (weapons[0].attackType == AttackType.PHYSICAL) ? enemies[i].stats.def : enemies[i].stats.mnd;
enemies[i].ShowAttackTiles(reach, damage - defense);
}
}
else
{
WeaponRange reach = inventory.GetReach(ItemCategory.SUPPORT);
for (int i = 0; i < friends.Count; i++)
{
bool isBuff = (weapons[0].weaponType == WeaponType.BARRIER);
if (isBuff || friends[i].IsInjured())
{
friends[i].ShowSupportTiles(reach, isBuff);
}
}
}
}
public Sprite GetIcon(WeaponRange range) => WeaponRangeIcons[(int)range];
void SwapWeapon(PropWeaponUserRangePlayer userRangePlayer)
{
weapon = (WeaponRange)userRangePlayer.GetWeapon();
UpdateUI();
}
public RangeBasedWeaponAttributesWrapper(WeaponRange range)
{
Range = range;
}
