public void FinalizeCharacterRound()
{
BattleGUI.End();
bPlayerMustSelectAction = false;
selectedCharTurn.bIsCompleted = true;
if (selectedCharTurn.character.bSaveAP)
{
var MaxAP = selectedCharTurn.character.trueSTATChart().currentPassiveStats[(int)STATChart.PASSIVESTATS.AP];
BasicTile finalTile = selectedCharTurn.returnCompleteArea().Find(t => t.mapPosition.Location == PathMoveHandler.finalPos.ToPoint());
var expendedAP = selectedCharTurn.characterArea.IndexOf(selectedCharTurn.characterArea.Find(area => area.Contains(finalTile))) + 1;
selectedCharTurn.character.statChart.currentActiveStats[(int)STATChart.ACTIVESTATS.STORED_AP] += MaxAP - expendedAP;
}
//Console.WriteLine(selectedCharTurn.character.statChart.currentActiveStats[(int)STATChart.ACTIVESTATS.STORED_AP]);
BattleScriptHandler.Execute(LUA.LuaBScriptEvent.EventType.postCT, this.toLuaTurnSetInfo());
EncounterInfo.ClearDeathChars();
selectedCharTurn = null;
EncounterInfo.UpdateAllStats();
}
public void Start()
{
bIsCompleted = true;
selectedCharTurn = null;
GenerateTurns();
BattleGUI.UpdateGUIElements();
if (bIsPlayerTurnSet)
{
BattleScriptHandler.Execute(LUA.LuaBScriptEvent.EventType.startPT, this.toLuaTurnSetInfo());
}
else
{
BattleScriptHandler.Execute(LUA.LuaBScriptEvent.EventType.startET, this.toLuaTurnSetInfo());
}
PlayerController.previousSelected = null;
groupTurnSet.ForEach(gts => gts.stepsSet = 0);
EncounterInfo.UpdateAllStats();
selectedCharTurn = null;
bFirstTurn = false;
PlayerController.selectedSprite = null;
}
public static void AIPreCalculate(List <BasicTile> moveRadius, CharacterTurn ct)
{
BaseCharacter caster = ct.character;
List <List <BasicTile> > abilityRangesAttack = new List <List <BasicTile> >();
List <List <BasicTile> > abilityRangesSupport = new List <List <BasicTile> >();
List <BaseCharacter> possibleTargetCharsAttack = new List <BaseCharacter>();
List <BaseCharacter> possibleTargetCharsSupport = new List <BaseCharacter>();
List <BaseCharacter> possibleAITargetsAttack = new List <BaseCharacter>();
List <BaseCharacter> possibleAITargetsSupport = new List <BaseCharacter>();
possibleAITargets.Clear();
List <BasicAbility> attackAbilities = caster.AbilityList().FindAll(abi => abi.abilityType == (int)BasicAbility.ABILITY_TYPE.ATTACK);
List <BasicAbility> supportAbilities = caster.AbilityList().FindAll(abi => abi.abilityType == (int)BasicAbility.ABILITY_TYPE.SUPPORT);
bool bCharHasSupportAbis = supportAbilities.Count > 0;
#region supportCheck
if (bCharHasSupportAbis)
{
var listOfCharactersTemp = ct.parentTS.charactersInGroup;
foreach (var character in listOfCharactersTemp)
{
if (character.bIsAlive)
{
possibleTargetCharsSupport.Add(character);
}
}
foreach (var ability in supportAbilities)
{
foreach (var character in possibleTargetCharsSupport)
{
if (character.NeedsHealing(3))
{
abilityRangesSupport.Add(MapListUtility.returnValidMapRadius(ability.abilityMinRange, ability.abilityMaxRange, CombatProcessor.zoneTiles, (character.position / 64).ToPoint().ToVector2() * 64));
Vector2 positionGridCaster = new Vector2((int)(caster.position.X / 64), (int)(caster.position.Y / 64));
var test = abilityRangesSupport[abilityRangesSupport.Count - 1].Find(t => moveRadius.Contains(t) || (t.positionGrid.X == positionGridCaster.X && t.positionGrid.Y == positionGridCaster.Y));
if (test != null)
{
if (!possibleAITargetsSupport.Contains(character))
{
possibleAITargetsSupport.Add(character);
}
}
}
}
}
}
#endregion
var listOfCharacters = ct.parentTS.targetGroups[GamePlayUtility.Randomize(0, ct.parentTS.targetGroups.Count - 1)].charactersInGroup;
if (attackAbilities.Count != 0)
{
foreach (var character in listOfCharacters)
{
if (character.bIsAlive)
{
possibleTargetCharsAttack.Add(character);
}
}
}
if (possibleAITargetsSupport.Count == 0 && attackAbilities.Count != 0)
{
bCharHasSupportAbis = false; //If nothing is in need of healing, try prioiritize attacking instead.
}
foreach (var ability in attackAbilities)
{
if (ability.IsAbilityAvailable(caster.trueSTATChart()))
{
if (ability.abilityFightStyle == (int)BasicAbility.ABILITY_CAST_TYPE.MELEE)
{
foreach (var character in possibleTargetCharsAttack)
{
abilityRangesAttack.Add(MapListUtility.returnValidMapRadius(ability.abilityMinRange, ability.abilityMaxRange, CombatProcessor.zoneTiles, (character.position / 64).ToPoint().ToVector2() * 64));
Vector2 positionGridCaster = new Vector2((int)(caster.position.X / 64), (int)(caster.position.Y / 64));
var test = abilityRangesAttack[abilityRangesAttack.Count - 1].Find(t => moveRadius.Contains(t) || (t.positionGrid.X == positionGridCaster.X && t.positionGrid.Y == positionGridCaster.Y));
if (test != null)
{
if (!possibleAITargetsAttack.Contains(character))
{
possibleAITargetsAttack.Add(character);
}
}
}
}
else if (ability.abilityFightStyle == (int)BasicAbility.ABILITY_CAST_TYPE.RANGED || ability.abilityFightStyle == (int)BasicAbility.ABILITY_CAST_TYPE.MAGIC)
{
abilityRangesAttack.Add(MapListUtility.returnValidMapRadius(ability.abilityMinRange, ability.abilityMaxRange, CombatProcessor.zoneTiles, (caster.position / 64).ToPoint().ToVector2() * 64));
foreach (var item in possibleTargetCharsAttack)
{
if (ability.abilityCanHitTargetInRange(caster, item))
{
if (!possibleAITargetsAttack.Contains(item))
{
possibleAITargetsAttack.Add(item);
}
}
}
}
//else if (ability.abilityFightStyle == (int)BasicAbility.ABILITY_CAST_TYPE.RANGED)
//{
// abilityRanges.Add(MapListUtility.returnValidMapRadius(ability.abilityMinRange, ability.abilityMaxRange, CombatProcessor.zoneTiles, (caster.position / 64).ToPoint().ToVector2() * 64));
// foreach (var item in heroCharactersStillAlive)
// {
// if (ability.abilityCanHitTargetInRange(caster, item))
// {
// if (!possibleAITargets.Contains(item))
// {
// possibleAITargets.Add(item);
// }
// }
// }
//}
}
}
if (!bCharHasSupportAbis)
{
possibleAITargets = new List <BaseCharacter>(possibleAITargetsAttack);
}
else
{
bool bShouldSupport = false;
float percentageSupportAbis = (float)((float)supportAbilities.Count / (float)caster.AbilityList().Count);
float percentageAttackAbis = 1 - percentageSupportAbis;
percentageSupportAbis *= 100f;
percentageAttackAbis *= 100f;
int amountOfEnemies = possibleAITargetsAttack.Count();
int amountOfAlliesInNeed = possibleAITargetsSupport.Count();
if (amountOfAlliesInNeed > amountOfEnemies)
{
int percent = GamePlayUtility.Randomize(30, (int)(percentageSupportAbis + 20));
if (percent > GamePlayUtility.Randomize(40, 70))
{
bShouldSupport = true;
}
}
if (bShouldSupport)
{
possibleAITargets = new List <BaseCharacter>(possibleAITargetsSupport);
bDoSupport = true;
}
else if (possibleTargetCharsAttack.Count != 0)
{
possibleAITargets = new List <BaseCharacter>(possibleAITargetsAttack);
bDoSupport = false;
}
}
}
internal MindControlInfo(CharacterTurn ct, TurnSet ogFrom, TurnSet currentlyIn)
{
this.ct = ct;
this.ogFrom = ogFrom;
this.currentlyIn = currentlyIn;
}
public void Update()
{
var gts = groupTurnSet.Find(g => !g.bIsCompleted);
//CombatProcessor.encounterEnemies
if (bIsPlayerTurnSet && !EncounterInfo.currentTurn().bPlayerTurnEnemyOverriden&& !BattleGUI.bIsRunning && !bSelectingArea)
{
if (!KeyboardMouseUtility.AnyButtonsPressed() && Keyboard.GetState().IsKeyDown(Keys.X))
{
var temp = EncounterInfo.encounterGroups.FindAll(eg => eg.bIsPlayerTurnSet);
foreach (var item in temp)
{
item.bIsCompleted = true;
}
}
if (EncounterInfo.currentTurn().selectedCharTurn != null && bRegenerateRadius)
{
RegenerateRadius();
}
currentEnemy = null;
if (selectedCharTurn != null && !selectedCharTurn.bIsCompleted)
{
var tempTile = selectedCharTurn.returnCompleteArea().Find(t => t.mapPosition.Contains(GameProcessor.EditorCursorPos));
if (tempTile != null)
{
if (CombatArrowLayout.bShouldRecheck(tempTile))
{
CombatArrowLayout.Start(tempTile, selectedCharTurn);
}
}
else
{
CombatArrowLayout.bMustDraw = false;
CombatArrowLayout.Clear();
}
}
else
{
if (CombatArrowLayout.CanClear())
{
CombatArrowLayout.Clear();
}
}
}
else if (bIsPlayerTurnSet && BattleGUI.bIsRunning)
{
}
else if (bIsEnemyTurnSet || EncounterInfo.currentTurn().bPlayerTurnEnemyOverriden)
{
UpdateEnemyLogic(gts);
}
if (bSelectingArea)
{
}
if (gts == null)
{
bIsCompleted = true;
}
if (bIsCompleted && !bPlayerTurnEnemyOverriden && !LUA.LuaExecutionList.DemandOverride() && !PathMoveHandler.bIsBusy && BattleGUI.TurnEffectsList.Find(te => te.bMustShow) == default(ChangeTurnEffect))
{
ResetAndChangeGroup();
}
}
internal void UpdateEnemyLogic(CharacterTurn gts)
{
if (!PathMoveHandler.bIsBusy)
{
PathMoveHandler.SkipPathMovement();
}
if (gts != null && !LUA.LuaExecutionList.DemandOverride() && !PathMoveHandler.bIsBusy && !bTest && BattleGUI.TurnEffectsList.Find(te => te.bMustShow) == null)
{
if (bPlayerTurnEnemyOverriden)
{
gts = currentEnemy;
}
if (GameProcessor.cameraFollowTarget != gts.character)
{
GameProcessor.cameraFollowTarget = gts.character;
}
bTest = true;
//randomEnemy = GamePlayUtility.Randomize(0, CombatProcessor.heroCharacters.Count - 1);
selectedCharTurn = null;
currentEnemy = gts;
AIUtility.AIPreCalculate(gts.returnCompleteArea(), gts);
//AIUtility.Report(AIBehaviour.ProcessBehaviour(currentEnemy.character,AIUtility.possibleAITargets));
BaseCharacter target = null;
var temp = AIBehaviour.ProcessBehaviour(currentEnemy.character, AIUtility.possibleAITargets);
if (temp.Count != 0)
{
target = AIUtility.SelectTargetBasedOnBehaviour(temp);
}
var playableMap = GameProcessor.loadedMap.possibleTilesGameZoneForEnemy(CombatProcessor.zoneTiles, currentEnemy.character);
var beep = new KeyValuePair <List <List <BasicTile> >, List <BasicAbility> >();
if (target != null)
{
// var beep = AIUtility.returnTilesToAttackFrom(CombatProcessor.zoneTiles,gts.character,target);
beep = AIUtility.returnTilesToAttackFrom(gts.returnCompleteArea(), playableMap, gts.character, target);
while (beep.Key.Count == 0 && beep.Value.Count == 0 && AIUtility.possibleAITargets.Count - 1 > 0)
{
AIUtility.possibleAITargets.Remove(target);
target = AIUtility.SelectTargetBasedOnBehaviour(AIBehaviour.ProcessBehaviour(currentEnemy.character, AIUtility.possibleAITargets));
beep = AIUtility.returnTilesToAttackFrom(playableMap, playableMap, gts.character, target);
}
}
if (target != null && beep.Key.Count == 0 && beep.Value.Count == 0)
{
target = null;
}
gts.ReGenerateTurn(playableMap);
List <Node> allPossibleNodes;
if (target != null)
{
//allPossibleNodes = PathFinder.NewPathSearch(gts.character.position, target.position + new Vector2(64, 0), playableMap);
var enemyFavor = AIUtility.returnFavoredAttackAndPosition(beep, gts.character, target);
if (enemyFavor.Key != null)
{
allPossibleNodes = PathFinder.NewPathSearch(gts.character.position, enemyFavor.Key.mapPosition.Location.ToVector2(), playableMap);
}
else
{
allPossibleNodes = null;
}
AITarget = target;
AIbtba = enemyFavor;
}
else
{
List <int> amountOfCharsForEachGroup = new List <int>();
List <float> percentagesForEachGroup = new List <float>();
int totalChars = 0;
foreach (var item in gts.parentTS.targetGroups)
{
int tempCount = item.charactersInGroup.FindAll(c => c.IsAlive()).Count;
totalChars += tempCount;
amountOfCharsForEachGroup.Add(tempCount);
}
foreach (var item in amountOfCharsForEachGroup)
{
percentagesForEachGroup.Add(((float)item / (float)totalChars) * 100);
}
TurnSet targetGroup = null;
int tempIndex = 0;
while (targetGroup == null)
{
int randomNumber = GamePlayUtility.Randomize(0, 100);
if (percentagesForEachGroup[tempIndex] >= randomNumber)
{
targetGroup = targetGroups[tempIndex];
}
tempIndex++;
if (tempIndex > percentagesForEachGroup.Count)
{
targetGroup = targetGroups[0];
}
}
BaseCharacter randomCharacter = targetGroup.charactersInGroup.FindAll(c => c.IsAlive())[GamePlayUtility.Randomize(0, targetGroup.charactersInGroup.FindAll(c => c.IsAlive()).Count)];
allPossibleNodes = PathFinder.NewPathSearch(gts.character.position, randomCharacter.position + new Vector2(64, 0), playableMap);
}
if (allPossibleNodes != null)
{
CombatProcessor.what = new List <Node>(allPossibleNodes);
var NodesWithinRange = MapListUtility.findEqualNodesToTileList(allPossibleNodes, gts.returnCompleteArea());
PathMoveHandler.Start(gts.character, NodesWithinRange);
}
//FinalizeEnemyRound();
}
if (gts != null && !PathMoveHandler.bIsBusy && bTest && !GameProcessor.bStartCombatZoom)
{
//THIS IS THE VERY LAST LINE BEFORE AN ENEMY HAS IT'S TURN COMPLETED
if (!AIbtba.Equals(default(KeyValuePair <BasicTile, BasicAbility>)))
{
if ((AIbtba.Key == null || AIbtba.Key.mapPosition.Location.ToVector2() == gts.character.position) && AIbtba.Value.abilityCanHitTargetInRange(gts.character, AITarget) && AIbtba.Value.IsAbilityAvailable(gts.character.trueSTATChart()))
{
FaceCharacterInCorrectDirection(gts.character, AITarget);
GameProcessor.StartBattleSoon(gts.character, AITarget, gts.character.AbilityList().IndexOf(AIbtba.Value));
//GameProcessor.StartBattleSoon(gts.character, AITarget, gts.character.AbilityList().IndexOf(gts.character.AbilityList().Find(ba => ba.abilityName.Equals(AIbtba.Value.abilityName))));
}
else
{
if (!currentEnemy.character.attackedAsAI)
{
LastDitchEffortAttack();
}
else
{
FinalizeEnemyRound();
}
}
}
else
{
if (!currentEnemy.character.attackedAsAI)
{
LastDitchEffortAttack();
}
else
{
FinalizeEnemyRound();
}
}
//
}
else if (gts == null)
{
if (bPlayerTurnEnemyOverriden)
{
bPlayerTurnEnemyOverriden = false;
}
}
}
public void TabSelect()
{
if (!bPlayerMustSelectAction && !PathMoveHandler.bIsBusy)
{
if (EncounterInfo.currentTurn().selectedCharTurn != null)
{
PlayerController.previousSelected = EncounterInfo.currentTurn().selectedCharTurn.character;
}
else
{
PlayerController.previousSelected = null;
}
// selectedCharTurn = groupTurnSet.Find(sct => sct.character == CombatProcessor.heroCharacters.Find(c => c.spriteGameSize.Contains(GameProcessor.EditorCursorPos)) && !sct.bIsCompleted);
int index = 0;
var availableChars = groupTurnSet.FindAll(ct => !ct.bIsCompleted);
if (availableChars.Count == 0)
{
selectedCharTurn = availableChars[index];
}
else
{
index = availableChars.IndexOf(EncounterInfo.currentTurn().selectedCharTurn);
if (index == -1)
{
index = 0;
}
else if (index + 1 != availableChars.Count)
{
index++;
}
else
{
index = 0;
}
selectedCharTurn = availableChars[index];
}
var v = PlayerController.originalPositionCharacter;
if (selectedCharTurn != null && !selectedCharTurn.bIsCompleted && selectedCharTurn.character != PlayerController.selectedSprite || (bFirstTurn && selectedCharTurn != null))
{
var selectedChar = EncounterInfo.currentTurn().selectedCharTurn.character;
if (PlayerController.previousSelected != null && !EncounterInfo.currentTurn().groupTurnSet.Find(gts2 => gts2.character == PlayerController.previousSelected).bIsCompleted&& !bFirstTurn)
{
//PlayerController.previousSelected.position = PlayerController.originalPositionCharacter;
PlayerController.previousSelected.changePosition(PlayerController.originalPositionCharacter);
groupTurnSet.Find(sct => sct.character == PlayerController.previousSelected).stepsSet = 0;
}
PlayerController.selectedSprite = selectedChar;
GameProcessor.cameraFollowTarget = selectedChar;
bFirstTurn = false;
PlayerController.originalPositionCharacter = selectedChar.position;
// GameProcessor.sceneCamera = ((new Vector2(-(selectedChar.position.X + 32 - 1366 / GameProcessor.zoom / 2), -(selectedChar.position.Y + 32 - 768 / GameProcessor.zoom / 2))));
ReGenerateTurn();
}
if (selectedCharTurn != null && selectedCharTurn.bIsCompleted)
{
var selectedChar = EncounterInfo.currentTurn().selectedCharTurn.character;
// GameProcessor.sceneCamera = ((new Vector2(-(selectedChar.position.X + 32 - 1366 / GameProcessor.zoom / 2), -(selectedChar.position.Y + 32 - 768 / GameProcessor.zoom / 2))));
}
if (selectedCharTurn == null)
{
if (PlayerController.previousSelected != null && !EncounterInfo.currentTurn().groupTurnSet.Find(gts2 => gts2.character == PlayerController.previousSelected).bIsCompleted&& !bFirstTurn)
{
PlayerController.previousSelected.changePosition(PlayerController.originalPositionCharacter);
groupTurnSet.Find(sct => sct.character == PlayerController.previousSelected).stepsSet = 0;
}
// PlayerController.selectedSprite.position = PlayerController.originalPositionCharacter;
bFirstTurn = true;
GameProcessor.cameraFollowTarget = null;
}
}
}
