public CombatScreen()
{
ClearColor = Color.Black;
_combatService = Rock.Instance.GetService<CombatOverwatchService>() as CombatOverwatchService;
comState = CombatState.PreCombat;
turState = TurnState.Waiting;
delaySpan = new TimeSpan();
//Menus:
// 0 - main
// 1 - skill
// 2 - item
// 3 - targeting
// 4 - choose skill.attack
menuPositions = new int[5];
menuItems = new List<string[]>();
menuItems.Add(new string[4] { "Std Melee", "Skills", "Items", "Flee" });
menuItems.Add(new string[1] { "Cancel" });
menuItems.Add(new string[1] { "Cancel" });
menuItems.Add(new string[8] { "Enemy: Front", "Enemy: Left", "Enemy: Right", "Enemy: Back", "Team: Front", "Team: Left", "Team: Right", "Team: Back" });
menuItems.Add(new string[1] { "IMessedUp" });
}
public void CombatSetUp()
{
foreach (Character c in combatants)
{
c.controller.combat = this;
}
currentState = CombatState.ActiveCombat;
combatants[0].controller.turnstate = TurnState.StartPhase;
TurnQueue.Instance.FillQueue(combatants);
}
void Start()
{
player.shipMaxHealth = PlayerStatus.ShipHealthMax;
// determine player ship health from world map
player.shipHealth = PlayerStatus.ShipHealthCurrent;
// First state where the weapon will count up until it can be used. Subject to change of course.
currentState = States.PROCESSING;
CSM = GameObject.Find("Combat Manager").GetComponent<CombatState>();
}
public void AbilityDKTest_PlagueStrike_BP()
{
// Needs AP passed in
Stats FFTestStats = new Stats();
FFTestStats.AttackPower = 100;
Item i = new Item("Test", ItemQuality.Common, ItemType.Dagger, 1, "", ItemSlot.MainHand, "", false, new Stats(), new Stats(), ItemSlot.None, ItemSlot.None, ItemSlot.None, 10, 20, ItemDamageType.Physical, 2, "");
CalculationOptionsTankDK c = new CalculationOptionsTankDK();
c.talents = new DeathKnightTalents();
Weapon w = new Weapon(i, FFTestStats, c, 0f);
CombatState combatState = new CombatState();
combatState.m_Stats = FFTestStats;
combatState.MH = w;
combatState.m_Talents = c.talents;
AbilityDK_PlagueStrike PS = new AbilityDK_PlagueStrike(combatState);
// Blood Plauge application.
AbilityDK_BloodPlague BP = new AbilityDK_BloodPlague(combatState);
// A disease dealing [0 + AP * 0.055 * 1.15] Shadow damage every 3 sec .
// Base damage 0
// Bonus from attack power [AP * 0.055 * 1.15]
// Plague Strike Checking
Assert.IsTrue(PS.szName == "Plague Strike", "Name");
Assert.AreEqual(PS.AbilityCost[(int)DKCostTypes.Blood], 0, "Blood Rune");
Assert.AreEqual(PS.AbilityCost[(int)DKCostTypes.Frost], 0, "Frost Rune");
Assert.AreEqual(PS.AbilityCost[(int)DKCostTypes.UnHoly], 1, "UnHoly Rune");
Assert.AreEqual(PS.AbilityCost[(int)DKCostTypes.RunicPower], -10, "RP");
Assert.AreEqual(Math.Floor((378 + PS.wMH.damage) / 2), PS.uBaseDamage, "BaseDamage");
Assert.AreEqual(Math.Floor((378 + PS.wMH.damage) / 2), PS.uBaseDamage, "Total Damage");
Assert.AreEqual(PS.uRange, AbilityDK_Base.MELEE_RANGE, "Range");
Assert.AreEqual(PS.tDamageType, ItemDamageType.Physical, "Damage Type");
Assert.AreEqual(PS.Cooldown, 1500u, "Cooldown");
// Blood Plague Checking
Assert.IsTrue(BP.szName == "Blood Plague", "Name");
Assert.AreEqual(BP.AbilityCost[(int)DKCostTypes.Blood], 0, "Blood Rune");
Assert.AreEqual(BP.AbilityCost[(int)DKCostTypes.Frost], 0, "Frost Rune");
Assert.AreEqual(BP.AbilityCost[(int)DKCostTypes.UnHoly], 0, "UnHoly Rune");
Assert.AreEqual(BP.AbilityCost[(int)DKCostTypes.RunicPower], 0, "Runic Power");
Assert.AreEqual(BP.uBaseDamage, 0u, "Damage");
Assert.AreEqual(BP.tDamageType, ItemDamageType.Shadow, "Damage Type");
// Not sure if this actually needs a Cooldown.
// Assert.AreEqual(BP.Cooldown, 0u, "Cooldown");
Assert.AreEqual(BP.uDuration, 15000u, "Duration");
Assert.AreEqual(BP.uTickRate, 3000u, "TickRate");
Assert.AreEqual((int)(FFTestStats.AttackPower * 0.055f * 1.15f), BP.GetTickDamage(), 0.1, "GetTickDamage");
Assert.AreEqual((int)(BP.GetTickDamage() * (15 / 3)), BP.GetTotalDamage(), 0.1, "GetTotalDamage");
}
public void CheckCombatState()
{
switch (combatState)
{
//Player Turn
case CombatState.PlayerTurn:
//Decision - Attack
//Attack the enemy
BattleRound(playerObj, enemyObj);
//Check if Enemy is defeated
if (enemyObj.GetComponent <Stats>().isDefeated)
{
RemoveEnemy(enemyObj);
SpawnEnemy();
}
//Next Case. Most likely EnemyTurn
combatState = CombatState.EnemyTurn;
break;
//Enemy Turn
case CombatState.EnemyTurn:
//Decision - Attack
//Attack the player
BattleRound(enemyObj, playerObj);
//Check if Player is defeated
if (playerObj.GetComponent <Stats>().isDefeated)
{
//set state to lose cause we died
combatState = CombatState.Loss;
Debug.Log("You Lose...");
break;
}
//Next Case. Most likely PlayerTurn
combatState = CombatState.PlayerTurn;
break;
//Victory
case CombatState.Victory:
Debug.Log("You Win!");
//You will want to assign exp here, before you travel, otherwise it could be an issue where you don't get your reward!
//Travels out to the overworld!
gameManager.GetComponent <GameManager>().TravelToWorld(GameManager.Worlds.Overworld);
break;
//Tell the player they won
//End Game
case CombatState.Loss:
//we lose, reset game
//Loss
//Tell the player they lost
//Restart Game
gameManager.GetComponent <GameManager>().TravelToWorld(GameManager.Worlds.Overworld);
break;
}
}
/*
* ~ Methods found ~
* private void Start(): Initializes variables
* private void Update(): Executes state machine once per frame
* IEnumerator PlayerPhase(): Executes PlayerPhase actions, yields for decision making
* private void PrePlayerPhaseState(): Variables set before PlayerPhase
* private void PostPlayerPhaseState(): Variables set after PlayerPhase
* private void UseSkill(UnitStats stats): Uses the top skill stored in currSkills
* private void UseItem(PlayerStats stats): Uses the item stored in currItem
* private void Damage(UnitStats stats, float movePower): Handles damage calculation, enemy death, and experience gain
* private void AttemptFlee(): Attempt to flee the battle
* private void Flee(): Handles player/enemy unit flee option
* private float ExpValue(UnitStats stats): Calculates the experience value of an enemy unit
* public void AddBattleLog(string textToAdd): Adds a message to the battle log
*/
// Initialize variables
private void Start()
{
playerStats = GameObject.FindGameObjectWithTag("PlayerData").GetComponent <PlayerPrefab>().players; // References the persistent list of player units
Debug.Log("Found players");
enemyStats = GameObject.FindGameObjectWithTag("EnemyData").GetComponent <EnemyPrefab>().enemies; // References the persistent list of enemy units
Debug.Log("Found enemies");
Debug.Log(enemyStats.Count);
skillButtons = new List <List <Button> >();
skillButtons.Add(skillButtons1);
skillButtons.Add(skillButtons2);
skillButtons.Add(skillButtons3);
// TODO: [ Create enemy sprite buttons dynamically ]
currState = CombatState.Init; // Init is the first state
expGain = new List <float>(); // List of experience gained from defeating each enemy
mainCharDefeated = false;
fleeAttempted = false;
battleLog.text = "\n\n\n\n\n\n\n"; // Ingenius way of creating a battle log (assumes ~7~ newline text limit)
// Sets skills/item panels to inactive upon battle start
foreach (GameObject panel in skillsPanels)
{
panel.SetActive(false);
}
itemPanel.SetActive(false);
uIndex = 0;
// Initializes player and enemy properties
foreach (PlayerStats player in playerStats)
{
player.stamina = player.maxStamina; // Reset stamina after every battle
player.itemUsed = false; // True if current player's item has been used (for that turn)
player.currItem = new Item("", 0); // String - name of the current item that player unit will use
player.currOption = ""; // String - name of the current option (Attack, Skills, Item, Flee)
player.currSkills = new Stack <Skill>(); // Stack of Skills - skill(s) that player unit will use during combat phase
player.currEnemy = enemyStats[0]; // UnitStats - reference to the enemy unit that player unit is targeting
}
foreach (UnitStats enemy in enemyStats)
{
enemy.health = enemy.maxHealth;
enemy.stamina = enemy.maxStamina;
enemy.currOption = "";
enemy.currSkills = new Stack <Skill>();
enemy.currEnemy = playerStats[0]; // UnitStats - reference to the player unit that enemy unit is targeting
expGain.Add(ExpValue(enemy)); // Initializes list of experience values for each enemy unit
}
// [ Dialogue box... ]
// Player1HP.text = "HP: " + PlayerStats.GetComponent<UnitStats>().health + "/" + PlayerStats.GetComponent<UnitStats>().maxhealth;
// Player1SP.text = "SP: " + PlayerStats.GetComponent<UnitStats>().stamina + "/" + PlayerStats.GetComponent<UnitStats>().maxstamina;
// Enemy1HP.text = "HP: " + EnemyStats.GetComponent<UnitStats>().health + "/" + EnemyStats.GetComponent<UnitStats>().maxhealth;
// Enemy1SP.text = "SP: " + EnemyStats.GetComponent<UnitStats>().health + "/" + EnemyStats.GetComponent<UnitStats>().maxhealth;
}
public void InitializeCombat()
{
timer = 0.0f;
attackPhaseFinished = false;
foreach (CharCombat cc in ccs)
{
cc.turnIsFinished = false;
cc.animFinished = false;
}
state = CombatState.TIMER;
}
// Selected unit is unselected
public void UnitUnselected()
{
if (state == CombatState.unit)
{
combatUI.HideUnitInspector(true);
combatUI.ShowUndoMove(false);
combatUI.SetHint("Select unit");
state = CombatState.ready;
playerControl = true;
}
}
//3.a if the defender did not defend, we finish the attack
void MA_FinishAttack()
{
currentTargetsCombat.OnEnemyLandsHitOnMe();
currentTargetsHealth.TakeDamage(currentAttack.meleeDamage);
currentTargetsCombat.DamageFlinch();
currentCombatState = CombatState.FinishingMeleeAttack;
unitAnimation.PlayFinishAttackAnimation(currentAttack.finishAttackTime);
invokeTime = currentAttack.finishAttackTime;
}
protected void ChoseActionState()
{
SetInitiativeOrder();
if (currentTurn < initiativeOrder.Count)
{
Character actingCharacter = initiativeOrder[currentTurn];
if (actingCharacter.action != (int)ActionType.NoAction)
{
currentTurn++;
}
else if (actingCharacter.playerControlled)
{
UpdateButtonIcons(actingCharacter);
if (ChoseAction(actingCharacter))
{
if (actingCharacter.action == (int)ActionType.BasicAttack)
{
selectingCharacter = actingCharacter;
selectingSpell = actingCharacter.spells[0];
currentState = CombatState.SelectUnit;
return;
}
if (actingCharacter.action == (int)ActionType.CastSpell)
{
if (actingCharacter.spells[actingCharacter.spellToCast] is TargetSpell)
{
selectingCharacter = actingCharacter;
selectingSpell = actingCharacter.spells[actingCharacter.spellToCast];
currentState = CombatState.SelectUnit;
}
return;
}
currentTurn++;
}
}
else if (!actingCharacter.playerControlled)
{
if (actingCharacter.action != (int)ActionType.PassTurn)
{
// AI decide action
actingCharacter.action = (int)ActionType.BasicAttack;
TargetSpell attackSpell = (TargetSpell)actingCharacter.spells[0];
attackSpell.target = team1[0]; // Attack first character
}
currentTurn++;
}
}
else
{
currentState = CombatState.PlayActions;
currentTurn = 0;
}
}
private void SendingCombatEventsState()
{
RPCBroadcastAttacker(PhotonTargets.All, attacker);
RPCBroadcastDefender(PhotonTargets.All, defender);
RPCBroadcastCombat(PhotonTargets.All, attacker, defender);
combatState = CombatState.ResolvingCombat;
//StartCoroutine(DelayDamage());
}
private void RunBtn_Click(object sender, EventArgs e)
{
CombatState cs = new CombatState();
cs.Encounter = fEncounter;
cs.PartyLevel = fPartyLevel;
CombatForm dlg = new CombatForm(cs);
dlg.Show();
}
public void setTarget()
{
if (enemyList.Count > 0)
{
enemyObj = enemyList[0];
}
else
{
combatState = CombatState.Win;
}
}
void SawPlayer(CombatState _target)
{
if (!_isAlerted && _isActive)
{
UnloadAll();
SetAction(new BasicAction(ActionType.Alert, true));
BSeekAndShoot _behavior = new BSeekAndShoot();
SetAction(new BehaviorAction(ActionType.BSeekAndShoot, _behavior, true));
_behavior.StartBehavior(this, _target);
}
}
IEnumerator EnemySpawnDelay()
{
yield return(new WaitForSeconds(2.0f));
Debug.Log("EnemySpawnDelay activated.");
currState = CombatState.Active;
IncreaseDifficultyLevel();
StartCoroutine(StartCombat());
IncreaseEnemyPower(enemyCharacter);
yield break;
}
void MaskBoard(CombatState combatState)
{
if (combatState != CombatState.Match3Turn)
{
BoardMaskPanel.SetActive(true);
}
else
{
BoardMaskPanel.SetActive(false);
}
}
public CombatAction PullTrigger(float _time, CombatState _target)
{
if (_pullingTrigger)
{
if (_inventory.SelectedWeapon.PullTrigger(_time))
{
return(new CombatAction(ActionType.Fire, _target));
}
}
return(null);
}
public void EndUnitTurn()
{
if (ActingUnits.Count != 0)
{
State = CombatState.ActingList;
}
else
{
State = CombatState.Ticking;
}
}
public void UseCurrentActionActorAndTargetEffects(CombatState combatState)
{
//We begin calculating the abilities speed
this.combatState = combatState;
//Place effects that fire in the current state into the EffectsInPlay list
ActivateEffects(currentAction.provoker);
//Sort the list by resolution order
SortEffectsInPlay(); //TODO
//Resolve the list
ResolveEffectsInPlay();
}
// Check the hitpoints of both characters to see if combat is over
void CheckForCombatEnd()
{
if (playerCharacter.hitpoints <= 0)
{
currState = CombatState.Defeat;
}
else if (enemyCharacter.hitpoints <= 0)
{
currState = CombatState.Victory;
GameController.Score += (int)(difficultyModifier * 10);
}
}
void CheckEnemyDead()
{
if (Enemy.CurrentHP <= 0) // If the enemy dies, player wins. If the enemy is still alive, move to enemies turn.
{
state = CombatState.VICTORY;
EndBattle();
}
else
{
return;
}
}
/// <summary>
/// This method adds a combat input to the queue to be processed.
/// </summary>
/// <param name="animationTimeInfo">The time information of the animation,
/// of type CombatInfo</param>
protected void AddCombatInput()
{
// Condition to check if input is allowed to be accepted
if (IsAcceptInput)
{
// Adding a new input to the queue
_combatInputs.Enqueue(GetAttackAnimation());
// Starting to process the queue
_combatState = CombatState.SetupInput;
}
}
public bool HasState(CombatState State)
{
if (this.BuffList.Exists(b => b.state == State))
{
return(true);
}
else
{
return(false);
}
}
public void UseCurrentActionActorEffects(CombatState combatState)
{
Debug.Log("USECURRENTACTIONACTOREFFECTS: " + combatState.ToString());
//We begin calculating the abilities speed
this.combatState = combatState;
//Place effects that fire in the current state into the EffectsInPlay list
ActivateEffects(currentAction);
//Sort the list by resolution order
SortEffectsInPlay(); //TODO
//Resolve the list
ResolveEffectsInPlay();
}
IEnumerator SetupStandbyState()
{
yield return(StartCoroutine(turn.HandleTurnEvents(player.gameObject)));
state = CombatState.STANDBY;
FindObjectOfType <StateHolder>().SetPhaseToCombat();
enemyDice.gameObject.SetActive(true);
enemyDice.GetComponent <SpriteRenderer>().sprite = enemy.GetCurrentEnemyDice().repSprite;
combatMessage.text = enemy.GetCurrentDiceDescription();
}
// Start is called before the first frame update
void Start()
{
currState = CombatState.PlayerPhase;
Enemy1type = EnemyStats.GetComponent <UnitStats>().entityType;
PlayerStats.GetComponent <UnitStats>().stamina = PlayerStats.GetComponent <UnitStats>().maxstamina;
EnemyStats.GetComponent <UnitStats>().health = EnemyStats.GetComponent <UnitStats>().maxhealth;
EnemyStats.GetComponent <UnitStats>().stamina = EnemyStats.GetComponent <UnitStats>().maxstamina;
Player1HP.text = "HP: " + PlayerStats.GetComponent <UnitStats>().health + "/" + PlayerStats.GetComponent <UnitStats>().maxhealth;
Player1SP.text = "SP: " + PlayerStats.GetComponent <UnitStats>().stamina + "/" + PlayerStats.GetComponent <UnitStats>().maxstamina;
Enemy1HP.text = "HP: " + EnemyStats.GetComponent <UnitStats>().health + "/" + EnemyStats.GetComponent <UnitStats>().maxhealth;
Enemy1SP.text = "SP: " + EnemyStats.GetComponent <UnitStats>().health + "/" + EnemyStats.GetComponent <UnitStats>().maxhealth;
}
// Start is called before the first frame update
void Start()
{
collider = GetComponent <Collider>();
combatState = GameObject.Find("GM").GetComponent <CombatState>();
enemyDamage = GetComponent <EnemyDamage>();
target = PlayerManager.instance.player.transform;
agent = GetComponent <NavMeshAgent>();
enemyAttack = GetComponent <EnemyAttack>();
animator = GetComponent <Animator>();
changeBehaviour = false;
tomb = GameObject.Find("Base_Tumulo");
}
private void Update()
{
var scene = currentScene;
currentScene = SceneManager.GetActiveScene().name;
if (scene != currentScene && currentScene == "Combat")
{
_combatState = FindObjectOfType <CombatState>();
_combatState.LoadWorld += SwitchToWorldScene;
}
}
// Start is called before the first frame update
void Awake()
{
state = CombatState.START;
turn = 1;
lowHealthLineIsSaid = false;
_audioSource = FindObjectOfType <Persistant>().GetComponent <AudioSource>();
_information = FindObjectOfType <LastEnemy>();
SetEnemyInfo(_information.GetMemory().Item1, _information.GetMemory().Item2);
StartCoroutine(PrepareCombat());
_player = FindObjectOfType <PlayerController>().gameObject;
_player.SetActive(false);
}
public CombatManagerNotificationServer(string path, CombatState state)
: base(path, true)
{
this.state = state;
state.CharacterAdded += State_CharacterAdded;
state.CharacterRemoved += State_CharacterRemoved;
state.CharacterPropertyChanged += State_CharacterPropertyChanged;
state.CharacterSortCompleted += State_CharacterSortCompleted;
state.PropertyChanged += State_PropertyChanged;
state.TurnChanged += State_TurnChanged;
}
private void CombatThread()
{
_combatState = CombatState.Active;
_eventQueue.EnqueueEvent(new CombatStateChangedEvent(_combatState));
_eventQueue.EnqueueEvent(new CombatStartedEvent());
uint winningParty = LoopUntilCombatComplete();
_combatState = CombatState.Completed;
_eventQueue.EnqueueEvent(new CombatStateChangedEvent(_combatState));
_eventQueue.EnqueueEvent(new CombatCompletedEvent(winningParty));
}
private void FoundryChangeCombatState(CombatState RequiredState)
{
try
{
//If entering Magic mode, must have a caster equipped. If no caster, exit this action and equip a wand.
if(RequiredState == CombatState.Magic && Core.WorldFilter.GetInventory().Where(x => x.Values(LongValueKey.EquippedSlots) == 0x1000000).Count() == 0)
{
FoundryActionList.Find(x => x.Action == FoundryActionTypes.EquipWand).FireAction = true;
return;
}
if(Core.Actions.CombatMode != RequiredState)
{
Core.Actions.SetCombatMode(RequiredState);
}
}catch(Exception ex){LogError(ex);}
}
void Awake()
{
me = GetComponent<Entity>();
combat = CombatState.Idle;
}
//Firing gun state
IEnumerator CFiringState()
{
while (combatState == CombatState.CFiring)
{
if(!isFocusedOnPlayer)
combatState = CombatState.CIdle;
fireTimer--;
if(ammo > 0)
{
if(chamber > 0)
{
if(fireTimer <= 0)
{
for(int i = 0; i < bulletsFired;i++)
{
GameObject temp = (GameObject) Instantiate (bulletClone,transform.position + transform.forward,transform.rotation);
temp.rigidbody.AddForce(transform.forward*500);
}
fireTimer = 60 / fireRate;
ammo--;
chamber--;
}
}
else
{
chamber = maxChamber;
fireTimer = (int)(60/chamberTime);
}
}
else
{
if(!flee)
{
combatState = CombatState.CReloading;
}
}
yield return 0;
}
NextCombatState ();
}
IEnumerator CReloadingState()
{
reloadTimer = reloadTime * 60;
while (combatState == CombatState.CReloading)
{
reloadTimer--;
if(reloadTimer <= 0 && !flee)
{
ammo = maxAmmo;
combatState = CombatState.CIdle;
}
yield return 0;
}
NextCombatState ();
}
IEnumerator CIdleState()
{
while (combatState == CombatState.CIdle)
{
if(isFocusedOnPlayer && !flee)
combatState = CombatState.CFiring;
yield return 0;
}
NextCombatState ();
}
public override void Update(GameTime gameTime, InputService input)
{
switch (comState)
{
case CombatState.PreCombat:
//TODO: pre fight stuff, priority hit if needs be
comState = CombatState.TurnManage;
break;
case CombatState.TurnManage:
//Player chooses action, time progresses, eventually player chooses enxt action
//based on speed stat
if (turState == TurnState.Delay)
{
delaySpan = delaySpan.Subtract(new TimeSpan(0, 0, 0, 0, gameTime.ElapsedGameTime.Milliseconds));
if (delaySpan.TotalMilliseconds <= 0)
{
turState = TurnState.Waiting;
}
}
else if (turState == TurnState.Waiting)
{
if (_combatService.Enemy.First().Stats.HPCurrent <= 0)
{
DelayMessage = "Your enemy has fainted! You won!";
comState = CombatState.FinalCombat;
delaySpan = new TimeSpan(0, 0, 0, 0, delayMilliToAdd);
_combatService.Player.AddExp(_combatService.Enemy.First().Stats.Level);
return;
}
else if (_combatService.Player.GetPlayer().Stats.HPCurrent <= 0)
{
DelayMessage = "You have died! You lost!";
comState = CombatState.FinalCombat;
delaySpan = new TimeSpan(0, 0, 0, 0, delayMilliToAdd);
return;
}
bool moveHappened = false;
while (!moveHappened)
{
playerSpeedNext -= 1;
enemySpeedNext -= 1;
if (playerSpeedNext <= 0)
{
playerSpeedNext += _combatService.Player.GetPlayer().Stats.Get(EntityStatsContainer.AT_SPEED);
turState = TurnState.ChooseAction; //Players turn
currentMenu = 0; //Always start at the top yo
moveHappened = true;
}
else if (enemySpeedNext <= 0)
{
enemySpeedNext += _combatService.Enemy.First().Stats.Get(EntityStatsContainer.AT_SPEED);
turState = TurnState.Delay;
_combatService.Enemy.First().TakeCombatTurn(_combatService);
Delay(_combatService.Enemy.First().CombatMessage);
moveHappened = true;
}
}
}
else if (turState == TurnState.ChooseAction)
{
if (input.Keyboard.KeyPress(Microsoft.Xna.Framework.Input.Keys.Up))
{
menuPositions[currentMenu] -= 1;
}
else if (input.Keyboard.KeyPress(Microsoft.Xna.Framework.Input.Keys.Down))
{
menuPositions[currentMenu] += 1;
}
menuPositions[currentMenu] = (menuPositions[currentMenu] + menuItems[currentMenu].Length) % menuItems[currentMenu].Length;
if (input.Keyboard.KeyPress(Microsoft.Xna.Framework.Input.Keys.Enter))
{
switch (currentMenu)
{
case 0: //Main menu
switch (menuPositions[currentMenu])
{
case 0: //melee default
selectedAttack = AttackID.Default;
currentMenu = 3; //Target select!
break;
case 1:
//Choose skill page
menuItems[4] = (from item in _combatService.Player.GetPlayer().Stats.SkillsList
select item.ToString()).ToArray();
currentMenu = 4;
break;
case 2:
break;
case 3:
{
int roll = rndm.Next(2);
if (roll == 0)
{
Delay("You failed to flee!");
}
else
{
Rock.Screen.Remove();
return;
}
}
break;
}
break;
case 1: //Skills menu
break;
case 2: //Items menu
break;
case 3: //Target selection menu
{
//TODO: self targeting / etc
AttackResult res;
if (menuPositions[3] < 4)
{
//enemy!
var target = _combatService.Enemy.Get((Party.PartySlot)menuPositions[3]);
res = _combatService.Attack(_combatService.Player.GetPlayer(), target, selectedAttack);
}
else
{
//teammate
var target = _combatService.Player.Get((Party.PartySlot)(menuPositions[3] - 4));
res = _combatService.Attack(_combatService.Player.GetPlayer(), target, selectedAttack);
}
if (res == AttackResult.Hit)
{
Delay("Your attack hits!");
}
else if (res == AttackResult.Critical)
{
Delay("Your attack hits for a critical!");
}
else if (res == AttackResult.Miss)
{
Delay("Your attack misses!");
}
}
break;
case 4:
{
selectedAttack = _combatService.Player.GetPlayer().Stats.SkillsList[menuPositions[4]];
currentMenu = 3; //target select!
}
break;
}
}
}
break;
case CombatState.FinalCombat:
{
delaySpan = delaySpan.Subtract(new TimeSpan(0, 0, 0, 0, gameTime.ElapsedGameTime.Milliseconds));
if (delaySpan.TotalMilliseconds <= 0)
{
if (_combatService.Player.MessageStack.Count > 0)
{
DelayMessage = _combatService.Player.MessageStack.Pop();
delaySpan = new TimeSpan(0, 0, 0, 0, delayMilliToAdd * 2);
}
else
{
Rock.Screen.Remove();
return;
}
}
}
break;
}
}
/// <summary>
/// Services one tick of combat.
/// </summary>
public void Service()
{
if (_combatState == CombatState.InCombat)
{
Faction winner = CheckVictoryCondition();
// check victory condition
if (winner == Faction.NoFaction)
{
ServiceProjectiles();
ServiceUnits();
}
else if (winner == Faction.TowerSide)
{
Debug.Log("############################################# yay, tower side won");
_combatState = CombatState.PostCombat;
}
else
{
Debug.Log("############################################# boo, lemming side won");
_combatState = CombatState.PostCombat;
}
}
else if (_combatState == CombatState.OutOfCombat)
{
ServiceProjectiles();
ServiceOnlyTowers();
}
}
/// <summary>
/// Starts a combat sequence in the CombatController.
/// </summary>
public void StartCombat()
{
_combatState = CombatState.InCombat;
GridPoint[,] map = NavigationController.Instance.NavigationGrid;
}
public void EndTurn()
{
if (_combatState == CombatState.EnemyTurn)
{
_combatState = CombatState.PlayerTurn;
}
else if (_combatState == CombatState.PlayerTurn)
{
_combatState = CombatState.EnemyTurn;
}
}
// Use this for initialization
void Start ()
{
_combatState = CombatState.PlayerTurn;
Fighter _fight = new Fighter();
InitBattle(_player, _enemy, 8);
}
private CombatController()
{
_spawnedUnits = new Dictionary<UnitTypes, int>();
_slainUnits = new Dictionary<UnitTypes, int>();
foreach (UnitTypes type in Enum.GetValues(typeof(UnitTypes)))
{
_spawnedUnits[type] = 0;
_slainUnits[type] = 0;
}
_activeProjectiles = new List<Projectile>();
_pendingProjectiles = new List<Projectile>();
_deadProjectiles = new List<Projectile>();
_activeUnits = new List<Unit>();
_pendingUnits = new List<Unit>();
_deadUnits = new List<Unit>();
_combatState = CombatState.PreCombat;
// TODO: hook this up to a button
StartCombat();
}
private void Foundry_ChangeCombatState(CombatState RequiredState)
{
try
{
if(Core.Actions.CombatMode != RequiredState){Core.Actions.SetCombatMode(RequiredState);}
}catch(Exception ex){LogError(ex);}
}
