private static bool Hit(GameCharacter attacker, GameCharacter defender, BattleGame game, Ammo ammo)
{
int bonusDamage = 0;
if (ammo != null)
{
bonusDamage = ammo.bonusDamage;
if (ammo.activeEffects != null)
{
foreach (var ae in ammo.activeEffects)
{
defender.AddActiveEffect(AbilityHelper.cloneActiveEffect(ae), game);
}
}
}
int dmg = game.r.Next(attacker.weapon.minDamage, attacker.weapon.maxDamage) + bonusDamage;
defender.Damage(dmg, game);
game.battleLog.AddEntry(string.Format("{0} hit {1} for {2} damage.", attacker.name, defender.name, dmg));
game.gameControllerScript.StartTempTextOnChar(defender, dmg, true);
game.gameControllerScript.StartTempSpriteOnChar(defender, "DamageEffects", 1);
if (attacker.weapon.activeEffects != null)
{
foreach (var ae in attacker.weapon.activeEffects)
{
defender.AddActiveEffect(AbilityHelper.cloneActiveEffect(ae), game);
}
}
return(true);
}
private static void UseAbilityTempEffect(BattleGame game, GameCharacter character, Tile target, Ability ability)
{
foreach (var ae in ability.activeEffects)
{
switch (ae.effectType)
{
case TempEffectType.Particle:
game.gameControllerScript.StartTempParticles(ae.effectName, new UnityEngine.Vector3(target.x, -target.y));
break;
case TempEffectType.Sprite:
var spriteVector = new UnityEngine.Vector3(target.x, -target.y);
game.gameControllerScript.StartTempSprite(spriteVector, spriteVector, ae.effectName, ae.effectIndex);
break;
case TempEffectType.Text:
game.gameControllerScript.StartTempText(new UnityEngine.Vector3(target.x, -target.y), UnityEngine.Color.grey, ability.name);
break;
case TempEffectType.ProjectileSprite:
var spriteVector1 = new UnityEngine.Vector3(game.ActiveCharacter.x, -game.ActiveCharacter.y);
var spriteVector2 = new UnityEngine.Vector3(target.x, -target.y);
game.gameControllerScript.StartTempSpriteProjectile(spriteVector1, spriteVector2, ae.effectName, ae.effectIndex);
break;
default:
break;
}
}
}
} //updates every turn
public AIActor(GameCharacter character, EnemyType type)
{
this.character = character;
this.enemyType = type;
InitActionWeight();
}
private static void UseAbilityTempEffect(BattleGame game,GameCharacter character, Tile target, Ability ability)
{
foreach (var ae in ability.activeEffects)
{
switch (ae.effectType)
{
case TempEffectType.Particle:
game.gameControllerScript.StartTempParticles(ae.effectName, new UnityEngine.Vector3(target.x, -target.y));
break;
case TempEffectType.Sprite:
var spriteVector = new UnityEngine.Vector3(target.x, -target.y);
game.gameControllerScript.StartTempSprite(spriteVector, spriteVector, ae.effectName, ae.effectIndex);
break;
case TempEffectType.Text:
game.gameControllerScript.StartTempText(new UnityEngine.Vector3(target.x, -target.y), UnityEngine.Color.grey, ability.name);
break;
case TempEffectType.ProjectileSprite:
var spriteVector1 = new UnityEngine.Vector3(game.ActiveCharacter.x, -game.ActiveCharacter.y);
var spriteVector2 = new UnityEngine.Vector3(target.x, -target.y);
game.gameControllerScript.StartTempSpriteProjectile(spriteVector1, spriteVector2, ae.effectName, ae.effectIndex);
break;
default:
break;
}
}
}
public void FillTile(GameCharacter gc, Tile t)
{
t.empty = false;
gc.x = t.x;
gc.y = t.y;
t.TileChar = gc.displayChar;
}
//helper to cleanly remove characters from battle and keep the current character counter correct
public void RemoveCharacter(GameCharacter character)
{
GameCharacter activeChar = ActiveCharacter;
characterList.Remove(character);
currentCharacter = characterList.IndexOf(activeChar);
}
public bool MoveCharacter(GameCharacter gc, Tile Destination)
{
bool retval = false;
if (Destination != null)
{
if (Destination.empty)
{
if (!CoreHelper.checkEffect(gc.activeEffects, gc.passiveEffects, StatType.Stuck))
{
//Use Actionpoints to Move
Tile curTile = getTileFromLocation(gc.x, gc.y);
if (gc.SpendAP(getTileDistance(curTile, Destination)))
{
EmptyTile(board[gc.x, gc.y]);
FillTile(gc, Destination);
retval = true;
}
}
}
}
return(retval);
}
//DEPRECATED
/*
* public static void attackNearestPlayer(GameCharacter enemy, BattleGame game)
* {
*
* var attackTarget= getAttackablePlayer(enemy,game);
* if (attackTarget != null)
* {
* attackPlayer(enemy, attackTarget, game);
* }
* else
* {
* var moveTarget = findNearestPlayer(enemy, game.board, game.characterList);
* moveToPlayer(enemy, moveTarget, game.board);
* }
*
* }
* */
//DEPRECATED
private static void attackPlayer(GameCharacter enemy, GameCharacter player, BattleGame game)
{
if (enemy.SpendAP(enemy.weapon.actionPoints))
{
CombatHelper.Attack(enemy, player, game);
}
}
public static List <BattleAction> attackNearestPlayer(GameCharacter enemy, BattleGame game)
{
List <BattleAction> actionList = new List <BattleAction>();
var attackTarget = findNearestPlayer(enemy, game.board, game.characterList);
var targetTile = game.board.getTileFromLocation(attackTarget.x, attackTarget.y);
//path find to target
List <Point> pointList = PathFind.Pathfind(game.board, enemy.x, enemy.y, targetTile.x, targetTile.y);
pointList.RemoveAt(0); //remove the character from pathfind.
pointList.RemoveAt(pointList.Count - 1); //remove the target from pathfind.
foreach (var p in pointList)
{
actionList.Add(new BattleAction()
{
AP = 1, character = enemy, actionType = BattleActionType.Move, targetTile = game.board.getTileFromPoint(p)
});
}
//attack action
actionList.Add(new BattleAction()
{
AP = enemy.weapon.actionPoints, character = enemy, targetTile = targetTile, actionType = BattleActionType.Attack
});
return(actionList);
}
//DEPRECATED
/*
public static void attackNearestPlayer(GameCharacter enemy, BattleGame game)
{
var attackTarget= getAttackablePlayer(enemy,game);
if (attackTarget != null)
{
attackPlayer(enemy, attackTarget, game);
}
else
{
var moveTarget = findNearestPlayer(enemy, game.board, game.characterList);
moveToPlayer(enemy, moveTarget, game.board);
}
}
* */
//DEPRECATED
private static void attackPlayer(GameCharacter enemy, GameCharacter player, BattleGame game)
{
if(enemy.SpendAP(enemy.weapon.actionPoints))
{
CombatHelper.Attack(enemy, player, game);
}
}
private static EnemyCharacter getEnemyFromGameCharacter(GameCharacter gameChar, EnemyType enemyType)
{
EnemyCharacter enemyChar = new EnemyCharacter(enemyType)
{
abilityList = gameChar.abilityList,
ac = gameChar.ac,
activeEffects = gameChar.activeEffects,
Ammo = gameChar.Ammo,
ap = gameChar.ap,
attack = gameChar.attack,
characterSpriteIndex = gameChar.characterSpriteIndex,
characterSpritesheetName = gameChar.characterSpritesheetName,
displayChar = gameChar.displayChar,
enemyType = enemyType,
equippedArmor = gameChar.equippedArmor,
hp = gameChar.hp,
inventory = gameChar.inventory,
name = gameChar.name,
passiveEffects = gameChar.passiveEffects,
portraitSpriteIndex = gameChar.portraitSpriteIndex,
portraitSpritesheetName = gameChar.portraitSpritesheetName,
totalAP = gameChar.totalAP,
totalHP = gameChar.totalHP,
type = CharacterType.Enemy,
weapon = gameChar.weapon,
x = gameChar.x,
y = gameChar.y,
strength = gameChar.strength,
agility = gameChar.agility,
endurance = gameChar.endurance,
spirit = gameChar.spirit
};
return(enemyChar);
}
public List<AIAction> AIActionList { get; set; } //updates every turn
public AIActor(GameCharacter character, EnemyType type)
{
this.character = character;
this.enemyType = type;
InitActionWeight();
}
public bool UseItem(GameCharacter character, UsableItem item, Tile targetTile)
{
bool usedItem = false;
if (!CoreHelper.checkEffect(character.activeEffects, character.passiveEffects, StatType.Stun))
{
if (character.CheckAP(item.actionPoints))
{
if (item.activeEffects != null)
{
foreach (var a in item.activeEffects)
{
character.AddActiveEffect(a, this);
}
usedItem = true;
character.SpendAP(item.actionPoints);
item.uses--;
}
else if (item.itemAbility != null)
{
bool usedAbility = AbilityHelper.UseAbility(ActiveCharacter, item.itemAbility, targetTile, this);
if (usedAbility)
{
usedItem = true;
character.SpendAP(item.actionPoints);
item.uses--;
}
}
if (item.uses <= 0)
{
//should this logic be here?
battleLog.AddEntry(string.Format("{0} has no more uses.", item.name));
ActiveCharacter.removeUsableItem(item);
//ActiveCharacter.inventory.Remove(item);
}
}
if (usedItem)
{
battleLog.AddEntry(string.Format("{0} used item {1}", character.name, item.name));
return(true);
}
else
{
battleLog.AddEntry(string.Format("{0} was unable to use item {1}", character.name, item.name));
return(false);
}
}
else
{
battleLog.AddEntry(string.Format("{0} is stunned and unable to use {1}.", character.name, item.name));
}
return(false);
}
//iterates over the path find and moves single spaces
public static void moveToPlayer(GameCharacter enemy, GameCharacter target, Board board)
{
var pointList = PathFind.Pathfind(board, enemy.x, enemy.y, target.x, target.y);
foreach (var p in pointList)
{
board.MoveCharacter(enemy, board.getTileFromLocation(p.x, p.y));
}
}
private static bool UseAbilityLOSEmpty(GameCharacter character, Ability ability, Tile target, BattleGame game)
{
if (target.empty)
{
return(UseAbilityLOS(character, ability, target, game));
}
return(false);
}
public void CharacterKill(GameCharacter character)
{
battleLog.AddEntry(string.Format("{0} was killed", character.name));
Tile tempTile = board.getTileFromLocation(character.x, character.y);
board.EmptyTile(tempTile);
RemoveCharacter(character);
}
private static bool UseAbilityLOSEmpty(GameCharacter character, Ability ability, Tile target, BattleGame game)
{
if (target.empty)
{
return UseAbilityLOS(character, ability, target, game);
}
return false;
}
public static bool UseAbility(GameCharacter character, Ability ability, Tile target, BattleGame game)
{
bool useValue = false;
if (ability.cooldownTimer == 0)
{
switch (ability.targetType)
{
case AbilityTargetType.Self:
useValue = UseAbilitySelf(character, ability, target, game);
break;
case AbilityTargetType.SingleFriend:
useValue = UseAbilitySingleFriend(character, ability, target, game);
break;
case AbilityTargetType.SingleFoe:
useValue = UseAbilitySingleFoe(character, ability, target, game);
break;
case AbilityTargetType.AllFriends:
useValue = UseAbilityAllFriends(character, ability, target, game);
break;
case AbilityTargetType.AllFoes:
useValue = UseAbilityAllFoes(character, ability, target, game);
break;
case AbilityTargetType.PointEmpty:
useValue = UseAbilityPointEmpty(character, ability, target, game);
break;
case AbilityTargetType.PointTarget:
useValue = UseAbilityPoint(character, ability, target, game);
break;
case AbilityTargetType.LOSEmpty:
useValue = UseAbilityLOSEmpty(character, ability, target, game);
break;
case AbilityTargetType.LOSTarget:
useValue = UseAbilityLOS(character, ability, target, game);
break;
default:
useValue = false;
break;
}
}
if (useValue)
{
ability.cooldownTimer = ability.cooldown;
}
return(useValue);
}
public static bool Attack(GameCharacter attacker, GameCharacter defender, BattleGame game)
{
if (game.r.Next(20) + attacker.attack > defender.ac)
{
var tempTile = game.board.getTileFromLocation(defender.x, defender.y);
return(Hit(attacker, defender, game, null));
}
else
{
game.battleLog.AddEntry(string.Format("{0} missed {1}.", attacker.name, defender.name));
return(false);
}
}
private static bool UseAbilitySelf(GameCharacter character, Ability ability, Tile target, BattleGame game)
{
if (character.SpendAP(ability.ap))
{
return(UseAbilityOnCharList(character, target, ability, new List <GameCharacter>()
{
character
}, game));
}
else
{
return(false);
}
}
public static bool Attack(GameCharacter attacker, GameCharacter defender, BattleGame game)
{
if(game.r.Next(20) + attacker.attack > defender.ac)
{
var tempTile = game.board.getTileFromLocation(defender.x, defender.y);
return Hit(attacker, defender, game,null);
}
else
{
game.battleLog.AddEntry(string.Format("{0} missed {1}.", attacker.name, defender.name));
return false;
}
}
private static bool UseAbilityPoint(GameCharacter character, Ability ability, Tile target, BattleGame game)
{
Tile ActiveTile = game.board.getTileFromLocation(character.x, character.y);
int dist = PlotLine.GetPointsOnLine(character.x, character.y, target.x, target.y).Count() - 1;
if (dist <= ability.range)
{
if (character.SpendAP(ability.ap))
{
return(UseAbilityAOEHelper(character, ability, target, game));
}
}
return(false);
}
private static bool UseAbilityAllFoes(GameCharacter character, Ability ability, Tile target, BattleGame game)
{
if (character.SpendAP(ability.ap))
{
var foeList = from data in game.characterList
where data.type != character.type
select data;
return(UseAbilityOnCharList(character, target, ability, foeList.ToList(), game));
}
else
{
return(false);
}
}
private static bool UseAbilitySingleFoe(GameCharacter character, Ability ability, Tile target, BattleGame game)
{
if (character.SpendAP(ability.ap))
{
GameCharacter targetChar = game.getCharacterFromTile(target);
if (targetChar != null & targetChar.type != character.type)
{
return(UseAbilityOnCharList(character, target, ability, new List <GameCharacter>()
{
targetChar
}, game));
}
}
return(false);
}
private static bool UseAbilityAOEHelper(GameCharacter character, Ability ability, Tile target, BattleGame game)
{
var tileAOEList = game.board.getTileListFromPattern(target, ability.tilePatternType);
//draw AOE effect
foreach (var t in tileAOEList)
{
game.board.AddTempChar(t, '*');
game.board.AddTempEffect(t, ability.sheetname, ability.spriteindex);
UseAbilityTempEffect(game, character, t, ability);
}
var charAOEList = game.getCharactersFromTileList(tileAOEList);
return(UseAbilityOnCharList(character, target, ability, charAOEList, game));
}
private static bool UseAbilityLOS(GameCharacter character, Ability ability, Tile target, BattleGame game)
{
Tile ActiveTile = game.board.getTileFromLocation(character.x, character.y);
var tileLOSList = game.board.getBoardLOS(ActiveTile, target);
if (tileLOSList.Count <= ability.range && tileLOSList[tileLOSList.Count - 1] == target)
{
if (character.SpendAP(ability.ap))
{
return(UseAbilityAOEHelper(character, ability, target, game));
}
return(false);
}
else
{
return(false);
}
}
//same as Melee attack, but add movement until we are LOS to nearest enemy
private List <AIAction> getAIRangedAttackActions(BattleGame game)
{
List <AIAction> aiActionList = new List <AIAction>();
if (character.weapon != null)
{
if (character.weapon.weaponType == WeaponType.OneHandRanged || character.weapon.weaponType == WeaponType.TwoHandRanged)
{
//should actually find who has easiest LOS
GameCharacter targetCharacter = AI.findNearestPlayer(character, game.board, game.characterList);
Tile characterTile = game.board.getTileFromLocation(character.x, character.y);
Tile targetTile = game.board.getTileFromLocation(targetCharacter.x, targetCharacter.y);
List <Point> pointList = game.board.getPathToLOS(characterTile, targetTile);
int dist = pointList.Count;
int cost = dist + character.weapon.actionPoints;
List <BattleAction> battleActionList = new List <BattleAction>();
foreach (var p in pointList)
{
battleActionList.Add(new BattleAction()
{
AP = 1, character = character, actionType = BattleActionType.Move, targetTile = game.board.getTileFromPoint(p)
});
}
battleActionList.Add(new BattleAction()
{
AP = character.weapon.actionPoints, character = character, targetCharacter = targetCharacter, targetTile = game.board.getTileFromLocation(targetCharacter.x, targetCharacter.y), actionType = BattleActionType.RangedAttack
});
aiActionList.Add(new AIAction()
{
actionType = AIActionType.Attack, cost = cost, battleActionList = battleActionList
});
}
}
return(aiActionList);
}
public static GameCharacter getAttackablePlayer(GameCharacter enemy, BattleGame game)
{
Tile curTile = game.board.getTileFromLocation(enemy.x, enemy.y);
var charList = game.getCharactersFromTileList(game.board.getTileListFromPattern(curTile, TilePatternType.FourAdj));
var playerList = (from data in charList
where data.type == CharacterType.Player
select data).ToList();
//for now, just return a random enemy close
if (playerList.Count > 0)
{
return(charList[game.r.Next(charList.Count - 1)]);
}
else
{
return(null);
}
}
//Move character without spending Action Points
public bool MoveCharacterFree(GameCharacter gc, Tile Destination)
{
bool retval = false;
if (Destination != null)
{
if (Destination.empty)
{
if (!CoreHelper.checkEffect(gc.activeEffects, gc.passiveEffects, StatType.Stuck))
{
EmptyTile(board[gc.x, gc.y]);
FillTile(gc, Destination);
retval = true;
}
}
}
return(retval);
}
public static GameCharacter findNearestPlayer(GameCharacter enemy, Board board, List <GameCharacter> charList)
{
GameCharacter retval = null;
int dist = 999;
foreach (GameCharacter c in charList)
{
if (c.type == CharacterType.Player)
{
var pointList = PathFind.Pathfind(board, enemy.x, enemy.y, c.x, c.y);
if (pointList.Count < dist)
{
dist = pointList.Count;
retval = c;
}
}
}
return(retval);
}
private static bool UseAbilityLOS(GameCharacter character, Ability ability, Tile target, BattleGame game)
{
Tile ActiveTile = game.board.getTileFromLocation(character.x, character.y);
var tileLOSList = game.board.getBoardLOS(ActiveTile, target);
if (tileLOSList.Count <= ability.range && tileLOSList[tileLOSList.Count - 1] == target)
{
if (character.SpendAP(ability.ap))
{
return UseAbilityAOEHelper(character, ability, target, game);
}
return false;
}
else
{
return false;
}
}
//if we have a melee weapon, calculate nearest enemy + weapon ap
private List <AIAction> getAIAttackActions(BattleGame game)
{
List <AIAction> aiActionList = new List <AIAction>();
if (character.weapon != null)
{
if (character.weapon.weaponType == WeaponType.OneHandMelee || character.weapon.weaponType == WeaponType.TwoHandMelee)
{
GameCharacter targetCharacter = AI.findNearestPlayer(character, game.board, game.characterList);
List <Point> pointList = PathFind.Pathfind(game.board, character.x, character.y, targetCharacter.x, targetCharacter.y);
pointList.RemoveAt(0); //remove the character from pathfind.
pointList.RemoveAt(pointList.Count - 1); //remove the target from pathfind.
int dist = pointList.Count;
int cost = dist + character.weapon.actionPoints;
List <BattleAction> battleActionList = new List <BattleAction>();
foreach (var p in pointList)
{
battleActionList.Add(new BattleAction()
{
AP = 1, character = character, actionType = BattleActionType.Move, targetTile = game.board.getTileFromPoint(p)
});
}
battleActionList.Add(new BattleAction()
{
AP = character.weapon.actionPoints, character = character, targetCharacter = targetCharacter, targetTile = game.board.getTileFromLocation(targetCharacter.x, targetCharacter.y), actionType = BattleActionType.Attack
});
aiActionList.Add(new AIAction()
{
actionType = AIActionType.Attack, cost = cost, battleActionList = battleActionList
});
}
}
return(aiActionList);
}
public static GameCharacter getAttackablePlayer(GameCharacter enemy, BattleGame game)
{
Tile curTile = game.board.getTileFromLocation(enemy.x,enemy.y);
var charList = game.getCharactersFromTileList(game.board.getTileListFromPattern(curTile, TilePatternType.FourAdj));
var playerList = (from data in charList
where data.type == CharacterType.Player
select data).ToList();
//for now, just return a random enemy close
if (playerList.Count > 0)
{
return charList[game.r.Next(charList.Count - 1)];
}
else
{
return null;
}
}
private static bool UseAbilityAOEHelper(GameCharacter character, Ability ability, Tile target, BattleGame game)
{
var tileAOEList = game.board.getTileListFromPattern(target, ability.tilePatternType);
//draw AOE effect
foreach (var t in tileAOEList)
{
game.board.AddTempChar(t, '*');
game.board.AddTempEffect(t, ability.sheetname, ability.spriteindex);
UseAbilityTempEffect(game, character, t, ability);
}
var charAOEList = game.getCharactersFromTileList(tileAOEList);
return UseAbilityOnCharList(character,target, ability, charAOEList, game);
}
private bool RangedAttack(GameCharacter character, Tile destination)
{
if (!CoreHelper.checkEffect(character.activeEffects, character.passiveEffects, StatType.Stun))
{
GameCharacter target = getCharacterFromTile(destination);
if (target != null)
{
if (CombatHelper.RangedAttack(character, target, destination, this))
{
return(true);
}
}
}
else
{
battleLog.AddEntry(string.Format("{0} is stunned and unable to attack.", character.name));
}
return(false);
}
private bool Move(GameCharacter character, int x, int y)
{
if (!CoreHelper.checkEffect(character.activeEffects, character.passiveEffects, StatType.Stun))
{
bool canMove = board.MoveCharacter(character, board.getTileFromLocation(x, y));
if (canMove)
{
battleLog.AddEntry(string.Format("{0} moved to {1},{2}", character.name, x, y));
}
else
{
battleLog.AddEntry(string.Format("{0} was unable to move to {1},{2}", character.name, x, y));
}
return(canMove);
}
else
{
battleLog.AddEntry(string.Format("{0} is stunned and unable to move.", character.name));
}
return(false);
}
private bool Attack(GameCharacter character, Tile targetTile)
{
if (!CoreHelper.checkEffect(character.activeEffects, character.passiveEffects, StatType.Stun))
{
GameCharacter target = getCharacterFromTile(targetTile);
if (target != null)
{
if (character.weapon != null)
{
if (character.SpendAP(character.weapon.actionPoints))
{
return(CombatHelper.Attack(character, target, this));
}
}
}
}
else
{
battleLog.AddEntry(string.Format("{0} is stunned and unable attack.", character.name));
}
return(false);
}
public static List<BattleAction> attackNearestPlayer(GameCharacter enemy, BattleGame game)
{
List<BattleAction> actionList = new List<BattleAction>();
var attackTarget = findNearestPlayer(enemy, game.board,game.characterList);
var targetTile = game.board.getTileFromLocation(attackTarget.x, attackTarget.y);
//path find to target
List<Point> pointList = PathFind.Pathfind(game.board, enemy.x, enemy.y, targetTile.x, targetTile.y);
pointList.RemoveAt(0); //remove the character from pathfind.
pointList.RemoveAt(pointList.Count - 1); //remove the target from pathfind.
foreach (var p in pointList)
{
actionList.Add(new BattleAction() { AP=1, character = enemy, actionType = BattleActionType.Move, targetTile = game.board.getTileFromPoint(p) });
}
//attack action
actionList.Add(new BattleAction() { AP=enemy.weapon.actionPoints, character = enemy, targetTile = targetTile, actionType = BattleActionType.Attack });
return actionList;
}
public bool UseAbility(GameCharacter character, Ability ability, Tile target)
{
if (!CoreHelper.checkEffect(character.activeEffects, character.passiveEffects, StatType.Stun))
{
if (character.abilityList.Contains(ability))
{
if (AbilityHelper.UseAbility(character, ability, target, this))
{
battleLog.AddEntry(string.Format("{0} used {1}", character.name, ability.name));
return(true);
}
else
{
battleLog.AddEntry(string.Format("{0} failed to use {1}", character.name, ability.name));
}
}
}
else
{
battleLog.AddEntry(string.Format("{0} is stunned and unable to use {1}.", character.name, ability.name));
}
return(false);
}
//helper to cleanly remove characters from battle and keep the current character counter correct
public void RemoveCharacter(GameCharacter character)
{
GameCharacter activeChar = ActiveCharacter;
characterList.Remove(character);
currentCharacter = characterList.IndexOf(activeChar);
}
public static GameCharacter findNearestPlayer( GameCharacter enemy, Board board,List<GameCharacter> charList)
{
GameCharacter retval = null;
int dist = 999;
foreach(GameCharacter c in charList)
{
if (c.type == CharacterType.Player)
{
var pointList = PathFind.Pathfind(board, enemy.x, enemy.y, c.x, c.y);
if (pointList.Count < dist)
{
dist = pointList.Count;
retval = c;
}
}
}
return retval;
}
//iterates over the path find and moves single spaces
public static void moveToPlayer(GameCharacter enemy, GameCharacter target, Board board)
{
var pointList = PathFind.Pathfind(board, enemy.x, enemy.y, target.x, target.y);
foreach(var p in pointList)
{
board.MoveCharacter(enemy, board.getTileFromLocation(p.x, p.y));
}
}
private static bool UseAbilityPoint(GameCharacter character, Ability ability, Tile target, BattleGame game)
{
Tile ActiveTile = game.board.getTileFromLocation(character.x, character.y);
int dist = PlotLine.GetPointsOnLine(character.x, character.y, target.x, target.y).Count()-1;
if(dist <= ability.range)
{
if (character.SpendAP(ability.ap))
{
return UseAbilityAOEHelper(character, ability, target, game);
}
}
return false;
}
private static bool UseAbilityAllFoes(GameCharacter character, Ability ability, Tile target, BattleGame game)
{
if (character.SpendAP(ability.ap))
{
var foeList = from data in game.characterList
where data.type != character.type
select data;
return UseAbilityOnCharList(character,target, ability, foeList.ToList(), game);
}
else
{
return false;
}
}
public bool MoveCharacter(GameCharacter gc, Tile Destination)
{
bool retval = false;
if (Destination != null)
{
if (Destination.empty)
{
if (!CoreHelper.checkEffect(gc.activeEffects, gc.passiveEffects, StatType.Stuck))
{
//Use Actionpoints to Move
Tile curTile = getTileFromLocation(gc.x, gc.y);
if (gc.SpendAP(getTileDistance(curTile, Destination)))
{
EmptyTile(board[gc.x, gc.y]);
FillTile(gc, Destination);
retval = true;
}
}
}
}
return retval;
}
private static EnemyCharacter getEnemyFromGameCharacter(GameCharacter gameChar, EnemyType enemyType)
{
EnemyCharacter enemyChar = new EnemyCharacter(enemyType)
{
abilityList = gameChar.abilityList,
ac = gameChar.ac,
activeEffects = gameChar.activeEffects,
Ammo = gameChar.Ammo,
ap = gameChar.ap,
attack = gameChar.attack,
characterSpriteIndex = gameChar.characterSpriteIndex,
characterSpritesheetName = gameChar.characterSpritesheetName,
displayChar = gameChar.displayChar,
enemyType = enemyType,
equippedArmor = gameChar.equippedArmor,
hp = gameChar.hp,
inventory = gameChar.inventory,
name = gameChar.name,
passiveEffects = gameChar.passiveEffects,
portraitSpriteIndex = gameChar.portraitSpriteIndex,
portraitSpritesheetName = gameChar.portraitSpritesheetName,
totalAP = gameChar.totalAP,
totalHP = gameChar.totalHP,
type = CharacterType.Enemy,
weapon = gameChar.weapon,
x = gameChar.x,
y = gameChar.y,
strength = gameChar.strength,
agility = gameChar.agility,
endurance = gameChar.endurance,
spirit = gameChar.spirit
};
return enemyChar;
}
private bool Attack(GameCharacter character, Tile targetTile)
{
if (!CoreHelper.checkEffect(character.activeEffects, character.passiveEffects, StatType.Stun))
{
GameCharacter target = getCharacterFromTile(targetTile);
if (target != null)
{
if (character.weapon != null)
{
if (character.SpendAP(character.weapon.actionPoints))
{
return CombatHelper.Attack(character, target, this);
}
}
}
}
else
{
battleLog.AddEntry(string.Format("{0} is stunned and unable attack.", character.name));
}
return false;
}
private static bool UseAbilitySingleFoe(GameCharacter character, Ability ability, Tile target, BattleGame game)
{
if (character.SpendAP(ability.ap))
{
GameCharacter targetChar = game.getCharacterFromTile(target);
if (targetChar != null & targetChar.type != character.type)
{
return UseAbilityOnCharList(character,target, ability, new List<GameCharacter>() { targetChar }, game);
}
}
return false;
}
private static void UseAbilityTempEffect(BattleGame game, GameCharacter character, GameCharacter target, Ability ability)
{
Tile targetTile = game.board.getTileFromPoint(new Point(target.x, target.y));
UseAbilityTempEffect(game, character, targetTile, ability);
}
private static bool UseAbilitySelf(GameCharacter character, Ability ability, Tile target, BattleGame game)
{
if (character.SpendAP(ability.ap))
{
return UseAbilityOnCharList(character,target, ability, new List<GameCharacter>() { character }, game);
}
else
{
return false;
}
}
public void CharacterKill(GameCharacter character)
{
battleLog.AddEntry(string.Format("{0} was killed", character.name));
Tile tempTile = board.getTileFromLocation(character.x,character.y);
board.EmptyTile(tempTile);
RemoveCharacter(character);
}
private static bool UseAbilityOnCharList(GameCharacter sourceCharacter, Tile target, Ability ability, List<GameCharacter> characterList, BattleGame game)
{
//Draw Temp Character
game.board.AddTempChar(target, 'X');
game.board.AddTempEffect(target, ability.sheetname, ability.spriteindex);
foreach(var c in characterList)
{
UseAbilityTempEffect(game, sourceCharacter, c, ability);
}
//special conditions if we're doing something on sourceCharacter
if(characterList.Count ==0)
{
foreach (var ae in ability.activeEffects)
{
if (ae.statType == StatType.Teleport)
{
game.board.MoveCharacterFree(sourceCharacter, target);
}
}
}
foreach (var character in characterList)
{
foreach (var ae in ability.activeEffects)
{
if (ae.statType == StatType.Teleport)
{
game.board.MoveCharacterFree(sourceCharacter, target); //for now, can only teleport self.
}
else if (ae.statType == StatType.Knockback) //move away from sourceCharacter
{
Tile sourceTile = game.board.getTileFromLocation(sourceCharacter.x, sourceCharacter.y);
Tile charTile = game.board.getTileFromLocation(character.x, character.y);
List<Tile> moveTargetList = game.board.getMoveTargetTileList(sourceTile, charTile, ae.minAmount);
if (moveTargetList.Count > 0)
{
Tile moveTile = moveTargetList[moveTargetList.Count - 1];
game.board.MoveCharacterFree(character, moveTile);
}
}
else if(ae.statType == StatType.Explode) //move away from target
{
Tile charTile = game.board.getTileFromLocation(character.x, character.y);
List<Tile> moveTargetList = game.board.getMoveTargetTileList(target, charTile, ae.minAmount);
if (moveTargetList.Count > 0)
{
Tile moveTile = moveTargetList[moveTargetList.Count - 1];
game.board.MoveCharacterFree(character, moveTile);
}
}
else
{
character.AddActiveEffect(cloneActiveEffect(ae), game);
}
}
}
return true;
}
public bool UseAbility(GameCharacter character, Ability ability, Tile target)
{
if (!CoreHelper.checkEffect(character.activeEffects, character.passiveEffects, StatType.Stun))
{
if (character.abilityList.Contains(ability))
{
if (AbilityHelper.UseAbility(character, ability, target, this))
{
battleLog.AddEntry(string.Format("{0} used {1}", character.name, ability.name));
return true;
}
else
{
battleLog.AddEntry(string.Format("{0} failed to use {1}", character.name, ability.name));
}
}
}
else
{
battleLog.AddEntry(string.Format("{0} is stunned and unable to use {1}.", character.name, ability.name));
}
return false;
}
public static bool UseAbility(GameCharacter character, Ability ability, Tile target, BattleGame game)
{
bool useValue = false;
if (ability.cooldownTimer == 0)
{
switch (ability.targetType)
{
case AbilityTargetType.Self:
useValue= UseAbilitySelf(character, ability, target, game);
break;
case AbilityTargetType.SingleFriend:
useValue= UseAbilitySingleFriend(character, ability, target, game);
break;
case AbilityTargetType.SingleFoe:
useValue= UseAbilitySingleFoe(character, ability, target, game);
break;
case AbilityTargetType.AllFriends:
useValue= UseAbilityAllFriends(character, ability, target, game);
break;
case AbilityTargetType.AllFoes:
useValue = UseAbilityAllFoes(character, ability, target, game);
break;
case AbilityTargetType.PointEmpty:
useValue = UseAbilityPointEmpty(character, ability, target, game);
break;
case AbilityTargetType.PointTarget:
useValue = UseAbilityPoint(character, ability, target, game);
break;
case AbilityTargetType.LOSEmpty:
useValue = UseAbilityLOSEmpty(character, ability, target, game);
break;
case AbilityTargetType.LOSTarget:
useValue = UseAbilityLOS(character, ability, target, game);
break;
default:
useValue = false;
break;
}
}
if (useValue)
{
ability.cooldownTimer = ability.cooldown;
}
return useValue;
}
public bool UseItem(GameCharacter character, UsableItem item, Tile targetTile)
{
bool usedItem = false;
if (!CoreHelper.checkEffect(character.activeEffects, character.passiveEffects, StatType.Stun))
{
if (character.CheckAP(item.actionPoints))
{
if (item.activeEffects != null)
{
foreach (var a in item.activeEffects)
{
character.AddActiveEffect(a, this);
}
usedItem = true;
character.SpendAP(item.actionPoints);
item.uses--;
}
else if(item.itemAbility != null)
{
bool usedAbility = AbilityHelper.UseAbility(ActiveCharacter, item.itemAbility, targetTile, this);
if(usedAbility)
{
usedItem = true;
character.SpendAP(item.actionPoints);
item.uses--;
}
}
if (item.uses <= 0)
{
//should this logic be here?
battleLog.AddEntry(string.Format("{0} has no more uses.", item.name));
ActiveCharacter.removeUsableItem(item);
//ActiveCharacter.inventory.Remove(item);
}
}
if(usedItem)
{
battleLog.AddEntry(string.Format("{0} used item {1}", character.name, item.name));
return true;
}
else
{
battleLog.AddEntry(string.Format("{0} was unable to use item {1}", character.name, item.name));
return false;
}
}
else{
battleLog.AddEntry(string.Format("{0} is stunned and unable to use {1}.", character.name, item.name));
}
return false;
}
public static bool RangedAttack(GameCharacter attacker, GameCharacter defender, Tile targetTile, BattleGame game)
{
bool retval = false;
//check for ranged weapon
if(attacker.weapon is RangedWeapon)
{
RangedWeapon w = (RangedWeapon)attacker.weapon;
Ammo a = (Ammo)ItemHelper.getFirstItemWithID(attacker.inventory,attacker.Ammo.itemID);
//check we have ammo
if(attacker.Ammo != null && attacker.Ammo.count > 0 && a.ammoType == w.ammoType)
{
List<Tile> tileLOSList = game.board.getBoardLOS(game.ActiveTile, targetTile);
//check LOS
//check range
if (tileLOSList[tileLOSList.Count - 1] == targetTile )
{
if (tileLOSList.Count <= w.range)
{
if (attacker.SpendAP(attacker.weapon.actionPoints))
{
var attackerPos = new UnityEngine.Vector3(attacker.x, -attacker.y);
var targetPos = new UnityEngine.Vector3(defender.x, -defender.y);
game.gameControllerScript.StartTempSpriteProjectile(attackerPos, targetPos, GameConstants.rangedAttackSpritesheet, GameConstants.rangedAttackSpriteindex);
//check for hit
if (game.r.Next(20) + attacker.attack > defender.ac)
{
retval = Hit(attacker, defender, game,a);
//remove ammo
attacker.inventory.Remove(a);
attacker.Ammo = ItemHelper.getItemSet(attacker.inventory, a);
retval = true;
}
else
{
game.battleLog.AddEntry(string.Format("{0} missed {1}.", attacker.name, defender.name));
}
}
}
else
{
game.battleLog.AddEntry(string.Format("{0} is out of range.", defender.name));
}
}
else
{
game.battleLog.AddEntry(string.Format("Unable to hit {0}", defender.name));
}
}
else
{
game.battleLog.AddEntry(string.Format("{0} requires {1} ammo equipped", w.name,w.ammoType));
}
}
else
{
game.battleLog.AddEntry(string.Format("Equip a ranged weapon for ranged attack"));
}
return retval;
}
public static GameCharacter getGameCharacterFromGameCharacterData(GameCharacterData data, GameDataSet gameDataSet)
{
GameCharacter character = new GameCharacter()
{
level = data.level,
ac = data.ac,
ap = data.ap,
attack = data.attack,
characterSpriteIndex = data.characterSpriteIndex,
characterSpritesheetName = data.characterSpritesheetName,
hp = data.hp,
displayChar = data.displayChar,
name = data.name,
portraitSpriteIndex = data.portraitSpriteIndex,
portraitSpritesheetName = data.portraitSpritesheetName,
totalAP = data.ap,
totalHP = data.hp,
type = data.type,
x = 0,
y = 0,
strength = data.strength,
agility = data.agility,
endurance = data.endurance,
spirit = data.spirit,
xp = ExperienceHelper.getXPAtLevel(data.level),
talentPoints = 0,
statPoints = 0
};
if (data.abilityList.Count > 0)
{
List<Ability> abilityList = new List<Ability>();
foreach (var l in data.abilityList)
{
if(gameDataSet.abilityDataDictionary.ContainsKey(l)){
abilityList.Add(AbilityFactory.getAbilityFromAbilityData(gameDataSet.abilityDataDictionary[l],gameDataSet.effectDataDictionary));
}
}
character.abilityList = abilityList;
}
if(data.inventory.Count > 0){
List<Item> itemList = new List<Item>();
foreach (var i in data.inventory)
{
Item tempItem = ItemFactory.getItemFromIndex(i, gameDataSet);
if (tempItem != null)
{
if (tempItem.type == ItemType.Ammo)
{
character.inventory.Add(tempItem);
character.Ammo = ItemHelper.getItemSet(character.inventory, tempItem);
}
else
{
itemList.Add(tempItem);
}
}
}
character.usableItemList = itemList;
//character.inventory = itemList;
}
if (data.equippedArmor.Count > 0)
{
List<Armor> armorList = new List<Armor>();
foreach (var a in data.equippedArmor)
{
if(gameDataSet.armorDataDictionary.ContainsKey(a)){
armorList.Add(ItemFactory.getArmorFromArmorData(gameDataSet.armorDataDictionary[a], gameDataSet.abilityDataDictionary, gameDataSet.effectDataDictionary));
}
}
character.equippedArmor = armorList;
}
if (data.weapon > 0)
{
Item i = ItemFactory.getItemFromIndex(data.weapon, gameDataSet);
Weapon w = (Weapon)ItemFactory.getItemFromIndex(data.weapon, gameDataSet);
if (w.weaponType == WeaponType.OneHandRanged || w.weaponType == WeaponType.TwoHandRanged)
{
w = (RangedWeapon)w;
}
character.weapon = w;
}
if (data.activeEffects.Count > 0)
{
List<ActiveEffect> aeList = new List<ActiveEffect>();
foreach (long l in data.activeEffects)
{
if (gameDataSet.effectDataDictionary.ContainsKey(l))
{
aeList.Add(AbilityFactory.getActiveEffectFromEffectData(gameDataSet.effectDataDictionary[l]));
}
}
character.activeEffects = aeList;
}
if (data.passiveEffects.Count > 0)
{
List<PassiveEffect> peList = new List<PassiveEffect>();
foreach (long l in data.passiveEffects)
{
if (gameDataSet.effectDataDictionary.ContainsKey(l))
{
peList.Add(AbilityFactory.getPassiveEffectFromEffectData(gameDataSet.effectDataDictionary[l]));
}
}
character.passiveEffects = peList;
}
if (data.type == CharacterType.Enemy)
{
character = getEnemyFromGameCharacter(character, data.enemyType);
}
return character;
}
private static bool Hit(GameCharacter attacker, GameCharacter defender, BattleGame game, Ammo ammo)
{
int bonusDamage = 0;
if(ammo != null)
{
bonusDamage = ammo.bonusDamage;
if (ammo.activeEffects != null)
{
foreach (var ae in ammo.activeEffects)
{
defender.AddActiveEffect(AbilityHelper.cloneActiveEffect(ae), game);
}
}
}
int dmg = game.r.Next(attacker.weapon.minDamage, attacker.weapon.maxDamage) + bonusDamage;
defender.Damage(dmg, game);
game.battleLog.AddEntry(string.Format("{0} hit {1} for {2} damage.", attacker.name, defender.name, dmg));
game.gameControllerScript.StartTempTextOnChar(defender, dmg, true);
game.gameControllerScript.StartTempSpriteOnChar(defender, "DamageEffects", 1);
if(attacker.weapon.activeEffects != null)
{
foreach(var ae in attacker.weapon.activeEffects)
{
defender.AddActiveEffect(AbilityHelper.cloneActiveEffect(ae), game);
}
}
return true;
}
//Move character without spending Action Points
public bool MoveCharacterFree(GameCharacter gc, Tile Destination)
{
bool retval = false;
if (Destination != null)
{
if (Destination.empty)
{
if (!CoreHelper.checkEffect(gc.activeEffects, gc.passiveEffects, StatType.Stuck))
{
EmptyTile(board[gc.x, gc.y]);
FillTile(gc, Destination);
retval = true;
}
}
}
return retval;
}
public void FillTile(GameCharacter gc, Tile t)
{
t.empty=false;
gc.x = t.x;
gc.y = t.y;
t.TileChar = gc.displayChar;
}
