protected override void RemoveEffect(TacticsMove user, TacticsMove enemy)
{
if (enemy.GetWeapon() != null && enemy.GetWeapon().weaponType == weaponType)
{
user.ReceiveBuff(boost.InvertStats(), true, false);
}
}
public void BeginDrag(int x, int y)
{
MapTile tile = mapCreator.GetTile(x, y);
TacticsMove clickedChar = tile.currentCharacter;
currentMode.value = ActionMode.NONE;
lastTarget.value = null;
attackTarget.value = null;
mapCreator.ResetMap();
tile.current = true;
if (clickedChar)
{
lastSelectedCharacter.value = clickedChar;
if (!clickedChar.hasMoved)
{
lastSelectedCharacter.value.FindAllMoveTiles(false);
if (clickedChar.faction == currentTurn.value)
{
currentMode.value = ActionMode.MOVE;
}
}
}
characterClicked.Invoke();
hideTooltipEvent.Invoke();
}
private bool CheckReq(TacticsMove user, TacticsMove enemy)
{
bool terrainOk = false;
for (int i = 0; i < terrainReq.Count; i++)
{
if (user.currentTile.terrain == terrainReq[i])
{
terrainOk = true;
break;
}
}
int dist = BattleMap.DistanceTo(user, enemy);
bool rangeOk = (range <= dist && dist <= rangeMax);
bool retaliateOk = (enemyCanAttack == EnemyCanAttack.BOTH);
if (enemyCanAttack != EnemyCanAttack.BOTH)
{
InventoryTuple tuple = enemy.GetEquippedWeapon(ItemCategory.WEAPON);
bool inRange = (!string.IsNullOrEmpty(tuple.uuid) && tuple.InRange(range));
retaliateOk = ((inRange && enemyCanAttack == EnemyCanAttack.ATTACK) ||
(!inRange && enemyCanAttack == EnemyCanAttack.NO_ATTACK));
}
return(retaliateOk && (terrainOk || rangeOk));
}
public void ActivateForEach(Activation act, TacticsMove user, CharacterListVariable list)
{
if (act == activation)
{
ForEachBoost(list, user);
}
}
/// <summary>
/// Uses the item at the given index and removes it if there are no more charges left.
/// </summary>
/// <param name="index"></param>
/// <param name="player"></param>
public void UseItem(int index, TacticsMove player)
{
InventoryTuple useItem = inventory[index];
if (useItem.itemCategory == ItemCategory.CONSUME)
{
if (useItem.weaponType == WeaponType.C_HEAL)
{
player.TakeHeals(useItem.power);
}
else if (useItem.attackType == AttackType.KEY)
{
//Door is done in another place
}
else
{
Boost boost = useItem.boost;
player.stats.BoostBaseStats(boost);
}
}
else
{
Debug.LogWarning("WTF!?");
return;
}
useItem.currentCharges--;
if (useItem.currentCharges <= 0)
{
inventory[index] = new InventoryTuple(null);
CleanupInventory();
}
player.End();
}
public BattleAction(bool leftSide, bool damage, TacticsMove atk, TacticsMove def)
{
this.leftSide = leftSide;
isDamage = damage;
attacker = atk;
defender = def;
}
public void ActivateSkill(Activation act, TacticsMove user, TacticsMove enemy)
{
if (act == activation)
{
UseSkill(user, enemy);
}
}
public static void EndTurn()
{
CurrentSelected.passedTurn = true;
CurrentSelected.EndTurn();
if (TeamUnits.ContainsKey(CurrentTeam))
{
foreach (TacticsMove unit in TeamUnits[CurrentTeam].ToArray())
{
if (!unit.passedTurn)
{
CurrentSelected = unit;
StartTurn();
return;
}
}
}
foreach (Actions action in CurrentSelected.charChar.ActionCost.Keys.ToArray())
{
CurrentSelected.charChar.SetActionState(action, true);
}
NextTeam();
}
static void InitTeamTurnQueue()
{
if (!QueueReady)
{
foreach (TacticsMove unit in UnitList)
{
if (TeamUnits.ContainsKey(unit.tag))
{
TeamUnits[unit.tag].Add(unit);
}
else
{
TeamUnits.Add(unit.tag, new List <TacticsMove> {
unit
});
}
}
foreach (string team in TeamUnits.Keys)
{
TeamQueue.Enqueue(team);
}
QueueReady = true;
}
CurrentTeam = TeamQueue.Peek();
CurrentSelected = TeamUnits[CurrentTeam][0];
PrepareTeam();
}
public int GetExperience()
{
if (defender.faction == Faction.WORLD)
{
return(0);
}
//Exp for support skills
if (type != Type.DAMAGE)
{
return((attacker.faction == Faction.PLAYER) ? BattleCalc.GetExperienceSupport(staffAtk, attacker.stats) : 0);
}
//Exp for fights
TacticsMove player = (attacker.faction == Faction.PLAYER) ? attacker : defender;
TacticsMove enemy = (attacker.faction == Faction.PLAYER) ? defender : attacker;
if (!player.IsAlive())
{
return(0);
}
bool killed = (!enemy.IsAlive());
bool isBoss = (enemy is NPCMove && ((NPCMove)enemy).aggroType == AggroType.BOSS);
return(BattleCalc.GetExperienceDamage(player.stats, enemy.stats, killed, isBoss));
}
public static void RemoveUnit(TacticsMove unit)
{
List <TacticsMove> list;
list = units[unit.tag];
list.Remove(unit);
}
/// <summary>
/// Adds a new player with the information in the TacticsMove and default values for the rest.
/// </summary>
/// <param name="player"></param>
public void AddNewPlayer(TacticsMove player)
{
stats.Add(player.stats);
inventory.Add(player.inventory);
skills.Add(player.skills);
baseInfo.Add(new SupportContainer(null));
}
// this func will allow the units to add themselves to the Dictionary units
// change this to a Character type
public static void AddUnit(TacticsMove unit)
{
//this list will be a part of the Dictionary
List<TacticsMove> list;
if (!units.ContainsKey(unit.tag))
{
// adding a team with the tag to the Dictionary
list = new List<TacticsMove>();
units[unit.tag] = list;
// adding the team to the turn que
if (!turnKey.Contains(unit.tag))
{
turnKey.Enqueue(unit.tag);
}
}
else
{
// regardless if there are units in the Dictionary at the end of this statment there will be a list in the Dictionary
list = units[unit.tag];
}
list.Add(unit);
}
protected override void UseSkill(TacticsMove user, TacticsMove enemy)
{
if (enemy.GetWeapon() != null && enemy.GetWeapon().weaponType == weaponType)
{
user.ReceiveBuff(boost, true, false);
}
}
public static void AddUnit(TacticsMove unit)
{
List <TacticsMove> list;
if (units.ContainsKey("NPC"))
{
Debug.Log("NPC is present");
}
if (!units.ContainsKey(unit.tag))
{
list = new List <TacticsMove>();
units[unit.tag] = list;
if (!turnKey.Contains(unit.tag))
{
turnKey.Enqueue(unit.tag);
}
}
else
{
list = units[unit.tag];
}
list.Add(unit);
}
private MapTile FindNearestTarget(CharacterListVariable list)
{
TacticsMove closest = null;
int distance = 1000;
for (int i = 0; i < list.values.Count; i++)
{
if (list.values[i] == this || !list.values[i].IsAlive())
{
continue;
}
int tempDist = MapCreator.DistanceTo(this, list.values[i]);
if (tempDist < distance)
{
distance = tempDist;
closest = list.values[i];
}
}
if (closest != null)
{
Debug.Log("Closest is at " + closest.posx + " , " + closest.posy);
}
return((closest != null) ? mapCreator.GetTile(closest.posx, closest.posy) : null);
}
private void ShowHealForecast(TacticsMove healer, TacticsMove receiver, InventoryTuple staff)
{
StatsContainer stats = healer.stats;
colorBackground.color = (healer.faction == Faction.PLAYER) ? new Color(0.7f, 0.7f, 1f) : new Color(1f, 0.7f, 0.7f);
eColorBackground.color = (receiver.faction == Faction.PLAYER) ? new Color(0.7f, 0.7f, 1f) : new Color(1f, 0.7f, 0.7f);
hCharacterName.text = stats.charData.entryName;
hPortrait.sprite = stats.charData.portraitSet.small;
stats = receiver.stats;
hCharacterName2.text = stats.charData.entryName;
hPortrait2.sprite = stats.charData.portraitSet.small;
if (inBattle)
{
hHpBar.SetAmount(healer.currentHealth, healer.stats.hp);
hHpBar2.SetAmount(receiver.currentHealth, receiver.stats.hp);
}
hWpnIcon.sprite = staff.icon;
hWpnName.text = staff.entryName;
if (!inBattle)
{
hWpnCharge.text = (string.IsNullOrEmpty(staff.uuid)) ? staff.currentCharges.ToString() : "";
hHealText.text = string.Format("{0} → {1} ({2})",
_defenderTactics.currentHealth,
Mathf.Min(_defenderTactics.currentHealth + BattleCalc.CalculateHeals(staff, _attackerTactics.stats), _defenderTactics.stats.hp),
_defenderTactics.stats.hp);
}
}
/// <summary>
/// Moves the player to the currently selected move tile.
/// </summary>
private bool SelectMoveTile(bool playing)
{
if (!playing)
{
if (moveTile.value.deployable > 0 && selectCharacter.value.currentTile.deployable == moveTile.value.deployable)
{
TacticsMove dual = moveTile.value.currentCharacter;
MapTile startTile = selectCharacter.value.currentTile;
selectCharacter.value.MoveDirectSwap(moveTile.value);
if (dual)
{
dual.MoveDirectSwap(startTile);
}
else
{
startTile.currentCharacter = null;
}
return(true);
}
}
else
{
if (moveTile.value != null)
{
selectCharacter.value.StartMove();
return(true);
}
}
return(false);
// Add features to allow the player to attack and heal target with movement.
}
void OnMouseDown()
{
if (TacticsMove.gameState == GameState.BuyingRound)
{
if (selected)
{
selected = false;
if (GetCurrentTile() != null && GetCurrentTile().homeTile)
{
gameObject.transform.position = new Vector3(GetCurrentTile().transform.position.x, gameObject.transform.position.y, GetCurrentTile().transform.position.z);
}
else
{
gameObject.transform.position = new Vector3(currentPlacedTile.transform.position.x, gameObject.transform.position.y, currentPlacedTile.transform.position.z);
}
TacticsMove.ClearSelectedTiles();
}
else if (!selected)
{
selected = true;
TacticsMove.MakeHomeTilesSelectable();
currentPlacedTile = GetCurrentTile();
}
}
}
/// <summary>
/// Shows a basic overview of the character with some stats and combat stats.
/// </summary>
/// <param name="tactics"></param>
private void ShowBasicStats(TacticsMove tactics)
{
if (tactics == null)
{
return;
}
StatsContainer stats = tactics.stats;
SkillsContainer skills = tactics.skills;
menuView.SetActive(true);
statsObject.SetActive(false);
basicObject.SetActive(true);
inventoryObject.SetActive(false);
// colorBackground.color = (tactics.faction == Faction.PLAYER) ?
// new Color(0.2f,0.2f,0.5f) : new Color(0.5f,0.2f,0.2f);
characterName.text = stats.charData.entryName;
portrait.enabled = true;
portrait.sprite = stats.charData.portraitSet.small;
levelClass.text = string.Format("Level {0} {1}", stats.level, stats.currentClass.entryName);
healthBar.SetAmount(tactics.currentHealth, tactics.stats.hp);
expBar.SetAmount(tactics.stats.currentExp, 100);
expBar.gameObject.SetActive(tactics.faction == Faction.PLAYER);
weakIcon1.sprite = weaknessIcons.icons[(int)stats.currentClass.classType];
weakIcon1.enabled = (weakIcon1.sprite != null);
InventoryTuple weapon = tactics.GetEquippedWeapon(ItemCategory.WEAPON);
wpnIcon.sprite = weapon?.icon;
wpnIcon.enabled = (weapon != null);
wpnName.text = (weapon != null) ? weapon.entryName : "---";
for (int i = 0; i < skillImages.Length; i++)
{
if (i >= skills.skills.Length || skills.skills[i] == null)
{
skillImages[i].sprite = noSkillImage;
}
else
{
skillImages[i].sprite = skills.skills[i].icon;
}
}
int pwer = BattleCalc.CalculateDamage(weapon, stats);
pwrText.text = (pwer != -1) ? "Pwr: " + pwer : "Pwr: --";
int hitrate = BattleCalc.GetHitRate(weapon, stats);
hitText.text = (hitrate != -1) ? "Hit: " + hitrate : "Hit: --";
avoidText.text = "Avo: " + (BattleCalc.GetAvoid(stats) + tactics.currentTile.terrain.avoid);
for (int i = 0; i < fatigueLevels.Length; i++)
{
fatigueLevels[i].SetActive(i == tactics.stats.fatigueAmount);
}
//Terrain
boostAvoid.enabled = (tactics.currentTile.terrain.avoid > 0);
}
public void EndSkill(Activation act, TacticsMove user, TacticsMove enemy)
{
if (act == activation)
{
RemoveEffect(user, enemy);
}
}
public static void PlayerEndTurn()
{
TacticsMove unit = turnTeam.Dequeue();
unit.move = 0;
if (unit.attacking)
{
unit.countTurn += 1;
unit.EndTurn();
}
if (unit.spawn && unit.attacking)
{
unit.spawnTurn += 1;
}
//unit.move = 0;
if (turnTeam.Count > 0)
{
StartTurn();
}
else
{
string team = turnKey.Dequeue();
turnKey.Enqueue(team);
InitTeamTurnQueue();
}
}
private void Move()
{
TacticsMove currentPlayer = _turnManager.GetActivePlayer();
if (currentPlayer != this)
{
return;
}
if (_path.Count > 0)
{
Tile t = _path.Peek();
Vector3 target = new Vector3(t.transform.position.x, transform.position.y, t.transform.position.z);
if (Vector3.Distance(transform.position, target) >= 0.5f)
{
CalculateHeading(target);
SetHorizontalVelocity();
transform.forward = heading; // update player to look towards target
transform.position += velocity * Time.deltaTime; // adjust position based on current velocity
}
else
{
transform.position = target;
_path.Pop(); // remove the target from our path, we will reach the next one
}
}
else
{
_moving = false;
hasMoved = true;
RemoveSelectableTiles();
}
}
private void ShowHealForecast(TacticsMove lefter, TacticsMove righter, int heal)
{
StatsContainer stats = lefter.stats;
int currentHp = lefter.currentHealth;
fullBackground.SetActive(true);
attackBackground.SetActive(false);
playerNormalObject.SetActive(false);
playerForecastObject.SetActive(true);
characterName.text = stats.charName;
portrait.enabled = true;
portrait.sprite = stats.portrait;
typeIcon.enabled = true;
typeIcon.color = (lefter.GetWeapon() != null) ? lefter.GetWeapon().GetTypeColor() : Color.white;
hpText.text = currentHp + " -> " + currentHp;
damageTextObj.SetActive(false);
advIcon.enabled = false;
extraSkillName.text = (stats.GetSkill() != null) ? stats.GetSkill().skillName : "";
extraSkillValue.text = (stats.GetSkill() != null) ? Mathf.Max(0, stats.GetSkill().maxCharge - lefter.skillCharge).ToString() : "";
extraSkillObject.gameObject.SetActive(true);
playerStatsObject.SetActive(true);
stats = righter.stats;
currentHp = righter.currentHealth;
eCharacterName.text = stats.charName;
ePortrait.enabled = true;
ePortrait.sprite = stats.portrait;
eTypeIcon.enabled = true;
eTypeIcon.color = (righter.GetWeapon() != null) ? righter.GetWeapon().GetTypeColor() : Color.white;
eHpText.text = currentHp + " -> " + Mathf.Min(currentHp + heal, stats.hp);
eDamageTextObj.SetActive(false);
eAdvIcon.enabled = false;
targetStatsObject.SetActive(true);
}
/// <summary>
/// Exchanges turns between a unit and its relative prev/next one
/// </summary>
/// <param name="playedUnit">unit currently playing</param>
/// <param name="isNext">if true : unit to play is the next one in queue, else the previous one</param>
public static void ExchangeTurn(TacticsMove playedUnit, bool isNext)
{
if (turnTeam.Count > 1)
{
string team = turnKey.Peek();
int unitId = units[team].IndexOf(playedUnit);
int unitToPlayId = -1;
do
{
if (isNext)
{
unitToPlayId = (unitId + 1) % units[team].Count;
}
else //isPrevious
{
if (unitId == 0)
{
unitToPlayId = units[team].Count - 1;
}
else
{
unitToPlayId = unitId - 1;
}
}
unitId = unitToPlayId;
} while (!ExchangeTurn(playedUnit, units[team][unitToPlayId]));
}
}
public static void RemoveUnit(TacticsMove unit)
{
//TODO doing this solo. may be buggy
//list.Remove(unit);
}
public override void EndSkill(TacticsMove user, TacticsMove enemy)
{
if (CheckReq(user, enemy))
{
user.ReceiveBuff(boost.InvertStats(), true, false);
}
}
public void GenerateActions(TacticsMove attacker, TacticsMove defender)
{
// Add battle init boosts
attacker.ActivateSkills(Activation.INITCOMBAT, defender);
attacker.ActivateSkills(Activation.PRECOMBAT, defender);
defender.ActivateSkills(Activation.PRECOMBAT, attacker);
_currentCharacter = attacker;
actions.Clear();
actions.Add(new BattleAction(true, true, attacker, defender));
int range = Mathf.Abs(attacker.posx - defender.posx) + Mathf.Abs(attacker.posy - defender.posy);
if (defender.GetWeapon() != null && defender.GetWeapon().InRange(range))
{
actions.Add(new BattleAction(false, true, defender, attacker));
}
//Compare speeds
int spdDiff = attacker.stats.spd - defender.stats.spd;
if (spdDiff >= 5)
{
actions.Add(new BattleAction(true, true, attacker, defender));
}
else if (spdDiff <= -5)
{
if (defender.GetWeapon() != null && defender.GetWeapon().InRange(range))
{
actions.Add(new BattleAction(false, true, defender, attacker));
}
}
}
public override void UseSkill(TacticsMove user, TacticsMove enemy)
{
if (CheckReq(user, enemy))
{
user.ReceiveBuff(boost, true, false);
}
}
protected void Heal(TacticsMove ally)
{
TurnController.busy = true;
characterClicked.Invoke();
BattleContainer.instance.GenerateHealAction(this, ally);
BattleContainer.instance.PlayBattleAnimations();
}
