/// <summary>
/// Search given <see cref="FighterObject"/> in lists and remove it.
/// also that <paramref name="fighterObject"/> is finished.
/// </summary>
/// <returns><c>true</c>, if fighter object was removed, <c>false</c> otherwise.</returns>
/// <param name="fighterObject">Fighter object.</param>
public bool RemoveFighterObject(FighterObject fighterObject)
{
int index = 0;
if (fighterObject is EnemyObject ||
(fighterObject is NullFighterObject && ((NullFighterObject)fighterObject).type == FighterType.Enemy))
{
if (fighterObject.state == FighterState.Behind)
{
index = 0;
}
else if (fighterObject.state == FighterState.Front)
{
index = 1;
}
}
else if (fighterObject is HeroObject ||
(fighterObject is NullFighterObject && ((NullFighterObject)fighterObject).type == FighterType.Hero))
{
if (fighterObject.state == FighterState.Front)
{
index = 2;
}
else if (fighterObject.state == FighterState.Behind)
{
index = 3;
}
}
else
{
throw new InvalidFighterObjectException();
}
return(fighterLists[index].Remove(fighterObject));
}
private void SummonFighterObject(FighterObject summon)
{
if (summon != null)
{
stage.AddFighterObject(summon);
}
RemoveDeadFighters();
}
public Presentation(BattleStage stage, FighterObject user, List <FighterObject> targetList, ActionFinishHandler handler = null)
{
bottomEffectLayer = (EffectLayer)Global.world.GetLayer("BottomEffectLayer");
bottomEffects = new List <Effect>();
this.stage = stage;
this.user = user;
this.targetList = targetList;
this.handler = handler;
}
public override void Execute(BattleStage stage, FighterObject user, List <FighterObject> targetList, ActionFinishHandler handler)
{
foreach (FighterObject target in targetList)
{
target.RestoreHP(((Hero)user.fighter).intelligence * 2);
}
handler(null);
base.Execute(stage, user, targetList, handler);
}
public override bool IsAvailable(BattleStage stage, FighterObject user)
{
if (user.state == FighterState.Front)
{
return(stage.fighterLists[3].Count < 5 && (stage.fighterLists[2].Count > 1 ||
(stage.fighterLists[2].Count == 1 && stage.fighterLists[3].Count > 0)));
}
else
{
return(stage.fighterLists[2].Count < 5);
}
}
public override void Execute(BattleStage stage, FighterObject user, List <FighterObject> targetList, ActionFinishHandler handler)
{
PresentationGroup p = new PresentationGroup(2, stage, user, targetList, handler);
p[0].AddEffect(new SlashEffect(targetList[0].x, targetList[0].y, 0));
p[0].SetUserAnimation(SpriteAnimation.GetSpriteAnimation("MeleeAttackDown"));
p[1].AddEffect(targetList[0].DealDamage(user.fighter.strength));
p[1].SetTargetAnimation(SpriteAnimation.GetSpriteAnimation("Shake"));
p.Start();
base.Execute(stage, user, targetList, handler);
}
/// <summary>
/// Add <see cref="FighterObject"/> to right list and <see cref="GameObjectLayer"/>
/// </summary>
/// <returns><c>true</c>, if fighter object was added, <c>false</c> otherwise.</returns>
/// <param name="fighterObject">Fighter object.</param>
public bool AddFighterObject(FighterObject fighterObject, int i = -1)
{
int index = 0;
if (fighterObject is EnemyObject ||
(fighterObject is NullFighterObject && ((NullFighterObject)fighterObject).type == FighterType.Enemy))
{
if (fighterObject.state == FighterState.Behind)
{
index = 0;
}
else if (fighterObject.state == FighterState.Front)
{
index = 1;
}
}
else if (fighterObject is HeroObject ||
(fighterObject is NullFighterObject && ((NullFighterObject)fighterObject).type == FighterType.Hero))
{
if (fighterObject.state == FighterState.Front)
{
index = 2;
}
else if (fighterObject.state == FighterState.Behind)
{
index = 3;
}
}
else
{
throw new InvalidFighterObjectException();
}
if (fighterLists[index].Count >= Global.Properties.FIGHTER_IN_ROW)
{
return(false);
}
if (i == -1)
{
fighterLists[index].Add(fighterObject);
}
else
{
fighterLists[index].Insert(i, fighterObject);
}
gameObjectLayer.elements.Add(fighterObject);
return(true);
}
public PresentationGroup(int length, BattleStage stage, FighterObject user, List <FighterObject> targetList,
ActionFinishHandler handler)
{
list = new Presentation[length];
for (int i = 0; i < length - 1; i++)
{
list[i] = new Presentation(stage, user, targetList);
}
list[length - 1] = new Presentation(stage, user, targetList, handler);
for (int i = 0; i < length - 1; i++)
{
list[i].ConnectPresentation(list[i + 1]);
}
}
public override void Execute(BattleStage stage, FighterObject user, List <FighterObject> targetList, ActionFinishHandler handler)
{
PresentationGroup p = new PresentationGroup(3, stage, user, targetList, handler);
p[0].AddEffect(new SlashEffect(targetList[0].x, targetList[0].y, 0));
p[0].SetUserAnimation(SpriteAnimation.GetSpriteAnimation("MeleeAttackUp"));
p[1].SetTargetAnimation(SpriteAnimation.GetSpriteAnimation("Shake"));
p[1].AddEffect(targetList[0].DealDamage(((Hero)user.fighter).strength));
p[2].SetExtraMethod(() => targetList[0].AddBuff(new Frozen(), Global.Properties.FRAME_PER_SECOND * 3));
p.Start();
base.Execute(stage, user, targetList, handler);
}
private void SetSelectedEffect(FighterObject fighterObject)
{
if (fighterObject == null)
{
return;
}
if (selectedEffect == null)
{
selectedEffect = new SelectedEffect(fighterObject.x - Global.camera.x,
fighterObject.y - (int)fighterObject.fighter.sprite.origin.Y - Global.camera.y - 30, 10);
topEffectLayer.elements.Add(selectedEffect);
}
else
{
selectedEffect.x = fighterObject.x - Global.camera.x;
selectedEffect.y = fighterObject.y - (int)fighterObject.fighter.sprite.origin.Y - Global.camera.y - 30;
}
}
/// <summary>
/// Gets the fighter object location. Each character indicates row and column.
/// </summary>
/// <returns>The fighter object location.</returns>
/// <param name="fighterObject">Fighter object.</param>
public string GetFighterObjectLocation(FighterObject fighterObject)
{
int index = 0;
if (fighterObject is EnemyObject ||
(fighterObject is NullFighterObject && ((NullFighterObject)fighterObject).type == FighterType.Enemy))
{
if (fighterObject.state == FighterState.Behind)
{
index = 0;
}
else if (fighterObject.state == FighterState.Front)
{
index = 1;
}
}
else if (fighterObject is HeroObject ||
(fighterObject is NullFighterObject && ((NullFighterObject)fighterObject).type == FighterType.Hero))
{
if (fighterObject.state == FighterState.Front)
{
index = 2;
}
else if (fighterObject.state == FighterState.Behind)
{
index = 3;
}
}
else
{
throw new InvalidFighterObjectException();
}
if (fighterLists[index].Contains(fighterObject))
{
return(index.ToString() + fighterLists[index].IndexOf(fighterObject));
}
throw new FighterObjectNotFoundException();
}
public void SwitchLocation(FighterObject fighterObject1, FighterObject fighterObject2)
{
if (fighterObject1.GetType() != fighterObject2.GetType() && !(fighterObject1 is NullFighterObject) &&
!(fighterObject2 is NullFighterObject))
{
throw new InvalidFighterObjectException();
}
string fl1 = GetFighterObjectLocation(fighterObject1);
string fl2 = GetFighterObjectLocation(fighterObject2);
// Sort fighterObject if both have same state.
if (fl1[0] == fl2[0] && fl1[1] > fl2[1])
{
string tempString = fl1;
fl1 = fl2;
fl2 = tempString;
FighterObject tempObject = fighterObject1;
fighterObject1 = fighterObject2;
fighterObject2 = tempObject;
}
// Remove fighterObjects
fighterLists[int.Parse(fl1[0].ToString())].Remove(fighterObject1);
fighterLists[int.Parse(fl2[0].ToString())].Remove(fighterObject2);
// Add fighterObjects in proper location
fighterLists[int.Parse(fl1[0].ToString())].Insert(int.Parse(fl1[1].ToString()), fighterObject2);
fighterLists[int.Parse(fl2[0].ToString())].Insert(int.Parse(fl2[1].ToString()), fighterObject1);
// Change state
FighterState tempState = fighterObject1.state;
fighterObject1.ChangeState(fighterObject2.state);
fighterObject2.ChangeState(tempState);
}
public override void Execute(BattleStage stage, FighterObject user, List <FighterObject> targetList, ActionFinishHandler handler)
{
((HeroObject)user).DecreaseSP(manaUsage);
}
public bool MoveLocation(FighterObject fighterObject, FighterState state)
{
RemoveFighterObject(fighterObject);
fighterObject.ChangeState(state);
return(AddFighterObject(fighterObject));
}
public void SetSummon(FighterObject summon)
{
this.summon = summon;
}
private void RestartTime()
{
actingFighterObject?.ResetAP();
actingFighterObject = null;
timePaused = false;
}
public void SetTarget(FighterObject target)
{
this.target = target;
}
public void AddTargetBuffer(FighterObject target)
{
targetBuffer.Add(target);
targetBufferFilled = true;
}
public abstract bool IsAvailable(BattleStage stage, FighterObject user);
public override bool IsAvailable(BattleStage stage, FighterObject user)
{
return(((HeroObject)user).SP >= manaUsage);
}
public override void Execute(BattleStage stage, FighterObject user, List <FighterObject> targetList, ActionFinishHandler handler)
{
stage.SwitchLocation(user, targetList[0]);
handler(null);
base.Execute(stage, user, targetList, handler);
}
public override void Update(GameTime gameTime)
{
if (transforming) // Starting
{
timespan++;
if (timespan > TRANSFORMING_TIME)
{
#region Summon Enemy and Hero objects.
foreach (Enemy enemy in combat.enemyFrontList)
{
EnemyObject enemyObject = new EnemyObject(0, 0, enemy, FighterState.Front, Global.soulBox.GetRandomHeros(1, enemy.soulCount));
guiLayer.AddGUI(new EnemyGages(enemy.name + "Gages", null, enemyObject));
stage.AddFighterObject(enemyObject);
}
foreach (Enemy enemy in combat.enemyBehindList)
{
EnemyObject enemyObject = new EnemyObject(0, 0, enemy, FighterState.Behind, Global.soulBox.GetRandomHeros(1, enemy.soulCount));
guiLayer.AddGUI(new EnemyGages(enemy.name + "Gages", null, enemyObject));
stage.AddFighterObject(enemyObject);
}
foreach (Hero hero in player.heros)
{
if (hero.defaultFighterState == FighterState.Stored)
{
continue;
}
HeroObject heroObject = new HeroObject(0, 0, hero);
guiLayer.AddGUI(new HeroGages(hero.name + "Gages", null, heroObject));
stage.AddFighterObject(heroObject);
}
SetFighterObjects();
#endregion
#region Set Selector
int i = 0;
foreach (ISelectable element in actionMenu.GetChild())
{
selector.SetItemToMatrix("ActionMenuGroup", element, i++, 0);
}
selector.SetItemToMatrix("ActionSelectGroup", actionSelect, 0, 0);
SetFighterGroupMatrix();
#endregion
transforming = false;
timePaused = false;
}
else
{
Global.camera.offsetY += (float)PLAYEROFFSET_Y / TRANSFORMING_TIME;
}
}
else // Battle Started.
{
if (timePaused)
{
// If targetBuffer is filled, do current action.
if (targetBuffer.Count > 0 && targetBufferFilled)
{
currentAction?.Execute(stage, actingFighterObject, targetBuffer, SummonFighterObject);
actionMenu.Deactivate();
actionSelect.Deactivate();
instruction.Deactivate();
selector.Reset();
targetBufferFilled = false;
return;
}
KeyCheck();
}
else
{
// Buff trigger check.
foreach (FighterObject fighterObject in stage)
{
foreach (Buff buff in fighterObject.buffList)
{
string method = buff.TriggerCheck();
if (method != "")
{
readiedBuff.Enqueue(new BuffAction(buff, method));
}
}
}
if (readiedBuff.Count > 0)
{
timePaused = true;
BuffAction buffAction = readiedBuff.Dequeue();
switch (buffAction.method)
{
case "Start": buffAction.buff.Start(SummonFighterObject); break;
case "Finish": buffAction.buff.Finish(SummonFighterObject); break;
case "Attack": buffAction.buff.Attack(SummonFighterObject); break;
case "Hit": buffAction.buff.Hit(SummonFighterObject); break;
case "Ready": buffAction.buff.Ready(SummonFighterObject); break;
case "Tick": buffAction.buff.Tick(SummonFighterObject); break;
}
}
else if (readiedFighterObjects.Count > 0)
{
timePaused = true;
actingFighterObject = readiedFighterObjects.Dequeue();
// Check if fighter is paused.
while (actingFighterObject.paused)
{
actingFighterObject = readiedFighterObjects.Dequeue();
}
if (actingFighterObject.fighter is Hero)
{
ActionMenuEnable((HeroObject)actingFighterObject);
}
if (actingFighterObject is EnemyObject)
{
EnemySkill enemySkill = ((EnemyObject)actingFighterObject).GetAction();
enemySkill.Execute(stage, actingFighterObject, enemySkill.SelectTarget(stage), SummonFighterObject);
}
}
else // Time goes here.
{
foreach (FighterObject fighterObject in stage)
{
if (fighterObject == null)
{
continue;
}
if (fighterObject.IncreaseGage(60))
{
readiedFighterObjects.Enqueue(fighterObject);
}
foreach (Buff buff in fighterObject.buffList)
{
buff.Update(gameTime);
}
}
}
}
}
base.Update(gameTime);
}
public override void Execute(BattleStage stage, FighterObject user, List <FighterObject> targetList, ActionFinishHandler handler)
{
}
public abstract void Execute(BattleStage stage, FighterObject user, List <FighterObject> targetList, ActionFinishHandler handler);
public override bool IsAvailable(BattleStage stage, FighterObject user)
{
return(user.state == FighterState.Front);
}
public override bool IsAvailable(BattleStage stage, FighterObject user)
{
return(stage.fighterLists[(int)StageRow.HeroFront].Count > 0);
}
public override bool IsAvailable(BattleStage stage, FighterObject user)
{
return(user.HP > hpUsage);
}
