public void AddCombatant(Combatant combatant)
{
List<SkillButton> buttons;
_buttons.TryGetValue(combatant, out buttons);
if (buttons == null) {
buttons = new List<SkillButton>();
foreach (ISkill skill in combatant.Skills) {
SkillButton newButton = CreateButton(skill);
buttons.Add(newButton);
}
_buttons[combatant] = buttons;
} else {
foreach (ISkill skill in combatant.Skills.Except(buttons.Select(b => b.Skill))) {
SkillButton newButton = CreateButton(skill);
buttons.Add(newButton);
}
}
if (_combatant == null) {
_combatant = combatant;
_page = SetPage(0);
}
}
double CalcDamage(Combatant attacker, Combatant defender, Attack attack)
{
System.Random gen = new System.Random();
double crit = 1.0;
double attackPower = 0.0;
double defensePower = 0.0;
//does hit
if(gen.NextDouble() * 100 > (attack.accuracy + attacker.perception))
{
return 0.0;
}
//is crit
if(gen.NextDouble()*100 < (0.05+0.02 * attacker.luck))
{
crit = 1.5;
}
//do damage
attackPower = attack.power * attacker.strength;
defensePower = defender.defense + defender.getArmorValue();
//return
return (attackPower / defensePower) * crit;
}
public ThreadedCalculateAIOrder(Combatant combatant, MapManager map)
{
this.combatant = combatant;
this.map = map;
thread = new System.Threading.Thread(Calculate);
thread.Start();
}
private void OnSkillActivated(Combatant combatant, ISkill skill)
{
// Unbind delegates from old skill
if (_ranged != null) {
_ranged.TargetChanged -= OnTargetChanged;
} else if (_directional != null) {
_directional.DirectionChanged -= OnDirectionChanged;
}
// Figure out origin from ActionQueue
PawnAction lastAction = _combatant.LastAction;
_origin = (lastAction == null) ? _combatant.Position : lastAction.PostRunPosition;
// Figure out what kind of skill it is
_ranged = skill as RangedSkill;
_directional = skill as DirectionalSkill;
// Bind delegates to new skill
if (_ranged != null) {
_ranged.TargetChanged += OnTargetChanged;
OnTargetChanged(_ranged.Target);
} else if (_directional != null) {
_directional.DirectionChanged += OnDirectionChanged;
OnDirectionChanged(_directional.Direction);
}
}
public SquadUnit(Combatant unit)
{
Unit = unit;
Goal = new StateOffset();
IsManual = true;
Planner = new Planner(StateOffset.Heuristic);
}
public void StationaryMelee()
{
Board board = new Board(BoardCommon.GRID_12X8);
Combatant attacker = new Combatant("Attacker", board, new Point(5, 4));
Combatant defender = new Combatant("Defender", board, new Point(7, 4));
board.AddPawn(attacker);
board.AddPawn(defender);
attacker.Health = 10;
defender.Health = 10;
attacker.BaseStats = new Stats() {
Attack = 10,
Stamina = 10
};
MeleeAttackSkill attack = new MeleeAttackSkill(attacker, new Point[] { Point.Right, 2 * Point.Right }) {
ActionPoints = 3
};
attack.SetDirection(CardinalDirection.East);
attacker.AddSkill(attack);
attack.Fire();
board.BeginTurn();
Assert.AreEqual(10, attacker.ActionPoints);
board.Turn();
Assert.AreEqual(0, defender.Health);
Assert.AreEqual(7, attacker.ActionPoints);
}
public MoveAction(Combatant owner, Point start, Point end, bool isContinuous)
: base(owner)
{
_start = start;
_end = end;
_isContinuous = isContinuous;
}
private void OnSkillDeactivated(Combatant combatant, ISkill skill)
{
_gridField.ClearPoints();
_gridField.RebuildMesh();
_ranged = null;
_directional = null;
}
/*
============================================================================
Condition functions
============================================================================
*/
public void ApplyCondition(Combatant c)
{
if(DataHolder.BattleSystem().IsActiveTime())
{
c.timeBar = this.timebar;
if(c.timeBar > DataHolder.BattleSystem().maxTimebar)
{
c.timeBar = DataHolder.BattleSystem().maxTimebar;
}
}
for(int i=0; i<this.setStatus.Length; i++)
{
if(this.setStatus[i])
{
c.status[i].SetValue(this.status[i], true, false, false);
}
}
for(int i=0; i<this.effect.Length; i++)
{
if(SkillEffect.ADD.Equals(this.effect[i]))
{
c.AddEffect(i, c);
}
else if(SkillEffect.REMOVE.Equals(this.effect[i]))
{
c.RemoveEffect(i);
}
}
}
/// <summary>
/// Contruct a new MeleeAttackSkill.
/// </summary>
/// <param name="attacker">Reference to Attacking Combatant</param>
/// <param name="areaOfEffect">
/// Collection of Point offsets indicating which tiles around the attacker are affected by the attack.
/// These offsets are rotated based on this skill's Direction attribute, and are defined based on the
/// attacker facing east.
/// </param>
public MeleeAttackSkill(Combatant attacker, IEnumerable<Point> areaOfEffect = null)
: base(attacker, "Melee Attack", "Attack an adjacent space")
{
if (areaOfEffect == null) {
_areaOfEffect = new List<Point>();
} else {
_areaOfEffect = new List<Point>(areaOfEffect);
}
for (CardinalDirection d = CardinalDirection.East; d < CardinalDirection.Count; d++) {
_transforms[d] = new Point[_areaOfEffect.Count];
}
for (int i = 0; i < _areaOfEffect.Count; i++) {
Point east = _areaOfEffect[i];
Point south = new Point(-east.Y, east.X);
Point west = new Point(-east.X, -east.Y);
Point north = new Point(east.Y, -east.X);
_transforms[CardinalDirection.East][i] = east;
_transforms[CardinalDirection.South][i] = south;
_transforms[CardinalDirection.West][i] = west;
_transforms[CardinalDirection.North][i] = north;
_fullAreaOfEffect.Add(east);
_fullAreaOfEffect.Add(south);
_fullAreaOfEffect.Add(west);
_fullAreaOfEffect.Add(north);
}
}
public void StartThreadToFindTilesInRange(Combatant combatant, MapManager map)
{
this.combatant = combatant;
this.map = map;
thread = new System.Threading.Thread(FindTilesInRange);
thread.Start();
}
public void SetCombatant(Combatant combatant)
{
this.combatant = combatant;
leftPane = CharacterPane.FindLeftPane();
EnablePane();
CreateBattleOrder();
}
public CharacterController(Combatant owner)
{
_owner = owner;
_approachDecision = new Decision.ApproachMeleeRange(_owner);
_planner.AddDecision(_approachDecision);
_attackDecision = new Decision.AttackWithMelee(_owner);
_planner.AddDecision(_attackDecision);
}
public void SetCombatant(Combatant combatant)
{
Debug.Log("setting combant -" + combatant + "-");
this.combatant = combatant;
leftPane = CharacterPane.FindLeftPane();
EnablePane();
}
public void Initialize(Combatant combatant, BoardGridField gridField)
{
_combatant = combatant;
_combatant.SkillActivated += OnSkillActivated;
_combatant.SkillDeactivated += OnSkillDeactivated;
_gridField = gridField;
}
public BattleAction(AttackSelection t, Combatant u, int tID, int id, int ul)
{
this.type = t;
this.user = u;
this.targetID = tID;
this.useID = id;
this.useLevel = ul;
}
public override Queue<Action> GetActions(Combatant me, List<Combatant> allies, List<Combatant> enemies)
{
Queue<Action> actions = new Queue<Action>();
actions.Enqueue(new ActionInfo(me.combatantName + " uses Taunt!"));
actions.Enqueue(new ActionBuff(me,"Taunt", 1));
actions.Enqueue(new ActionPauseForFrames(60));
actions.Enqueue(new ActionHideInfo());
return actions;
}
public void pickUp(Combatant currentCombatant)
{
this.currentCombatant = currentCombatant;
transform.rotation = currentCombatant.transform.rotation;
rb.isKinematic = true;
collider.enabled = false;
pickedUp = true;
onPickUp();
}
//Combatant player;
//Combatant enemy;
public void StartCombat(Combatant player, Combatant enemy)
{
/*
this.player = player;
this.enemy = enemy;
player.Initialize();
enemy.Initialize();
*/
}
public void PopulateOptions(Combatant combatant)
{
//options = combatant.Options;
string message = string.Join("\n", options.ToArray());
headerText.text = combatant.gameObject.name;
optionsText.text = message;
currentSelection = options [0];
}
public void Populate(Combatant combatant)
{
if (combatant == null) {
nameText.text = "--";
hpText.text = "-/-";
return;
}
nameText.text = combatant.name;
hpText.text = combatant.Stats.CurrentHealth + " / " + combatant.Stats.MaxHealth;
}
/// <summary>
/// Adds a Combatant to this TimelineController, creating a new Timeline keyed to that Combatant, and binding
/// the relevant events.
/// </summary>
/// <param name="combatant">Combatant to add</param>
public void AddCombatant(Combatant combatant)
{
if (_timelines.Find(t => t.Source == combatant) == null) {
_timelines.Add(new Timeline(combatant));
combatant.SkillActivated += OnSkillActivated;
combatant.SkillFired += OnSkillFired;
combatant.ActionsCleared += OnActionsCleared;
}
}
/*
============================================================================
In-game functions
============================================================================
*/
public void Init(Animation animation, Combatant c)
{
if(this.name != "" && animation[this.name] != null)
{
animation[this.name].layer = layer;
if(this.setSpeed && c != null)
{
animation[this.name].speed = DataHolder.Formula(this.speedFormula).Calculate(c, c)*GameHandler.AnimationFactor;
}
}
}
void NextTurn()
{
if (activeCombatant == null) {
activeCombatant = combatants[0];
} else {
int i = combatants.IndexOf(activeCombatant);
i = (i + 1) % combatants.Count;
activeCombatant = combatants[0];
}
//menu.PopulateOptions(activeCombatant);
}
public ApproachMeleeRange(Combatant source)
: base(source)
{
_source = (Combatant)source;
if ((_walk = _source.GetSkill<WalkSkill>()) == null) {
throw new ArgumentException("source", "Combatant " + source.Name + " doesn't have a Walk skill");
}
if ((_melee = _source.GetSkill<MeleeAttackSkill>()) == null) {
throw new ArgumentException("source", "Combatant " + source.Name + " doesn't have a Melee Attack skill");
}
}
/*
============================================================================
Animation handling functions
============================================================================
*/
public void SetAnimationLayers(Combatant c)
{
Animation a = c.GetAnimationComponent();
if(a != null)
{
for(int i=0; i<this.animation.Length; i++)
{
this.animation[i].Init(a, c);
}
}
}
public void RemoveCombatant(Combatant combatant)
{
int index = _timelines.FindIndex(t => t.Source == combatant);
if (index != -1) {
_timelines.RemoveAt(index);
combatant.SkillActivated -= OnSkillActivated;
combatant.SkillFired -= OnSkillFired;
combatant.ActionsCleared -= OnActionsCleared;
}
}
private bool BattleAttack(Combatant c)
{
bool ok = false;
if(this.combatant is Enemy)
{
c.AddAction(new BattleAction(
AttackSelection.ATTACK, c, this.combatant.battleID, -1, 0));
ok = true;
}
return ok;
}
void Start()
{
CombatantClick cc = (CombatantClick)this.transform.root.GetComponent(typeof(CombatantClick));
if(cc == null)
{
cc = (CombatantClick)this.transform.root.GetComponentInChildren(typeof(CombatantClick));
}
if(cc != null)
{
this.combatant = cc.combatant;
}
}
public DamageMessage(Combatant target, int amount, Combatant source = null)
{
Target = target;
Source = source;
Amount = amount;
if (Source != null) {
Text = Source.Name + " inflicted " + amount + " damage on " + Target.Name;
} else {
Text = Target.Name + " took " + amount + " damage";
}
}
protected override void OnStart()
{
//CombatEventReceiver.Instance.OnCombatEventTiming(ReactionEvent, eCombatEventTiming.ON_REACTION_START);
StartActionState();
if (ReactionEvent.IsMiss)
{
Combatant.FXHelper.ReportAttackResult(MoveEditor.AttackResult.Missed);
}
else if (ReactionEvent.IsBlocked)
{
Combatant.FXHelper.ReportAttackResult(MoveEditor.AttackResult.Blocked);
}
else
{
Combatant.FXHelper.ReportAttackResult(MoveEditor.AttackResult.Hit);
}
long hp = Combatant.GetHP() - ReactionEvent.Damage;
Combatant.SetHP(hp);
//CombatInfoData.GetInstance().Log("damage applyed, hp = " + hp + ", source = " + ReactionEvent.Sender + ", target = " + ReactionEvent.Target);
//if(ReactionEvent.Damage>0)
// EventManager.instance.Raise(new CombatHitDamageEvent(Combatant.gameObject, ReactionEvent.Damage, ReactionEvent.Show, ReactionEvent.Shield));
// EB.Debug.Log(string.Format("ReactionEventState.OnStart: {0} start action {1}", Combatant.myName, Combatant.ActionState.GetType().ToString()));
if (!Combatant.IsAlive())
{
//CombatSkillEvent skill_event = CombatEventReceiver.Instance.FindEventTree(ReactionEvent).Parent.Event as CombatSkillEvent;
//if (CombatEventReceiver.Instance.IsLastSkill(skill_event))
//{
// CombatEventReceiver.Instance.PlayRadialBlurEffect(Combatant);
//}
}
}
private void UpdateBattleStateEnemyTurn()
{
var combatants = (from c in BattleBoard.Characters where c.Faction == 1 && c.CanMove select c).ToArray();
if (combatants.Any())
{
// find first character that can move
_selectedCharacter = combatants[0];
// find the optimal location
var decision = _commander.CalculateAction(_selectedCharacter);
// create move command to that location
var moveCommand = new Command
{
Ability = Ability.Factory(Game, "move"),
Character = _selectedCharacter,
Target = decision.Destination
};
QueuedCommands.Add(moveCommand);
if (decision.Command.Ability != null)
{
QueuedCommands.Add(decision.Command);
}
ExecuteQueuedCommands();
return;
}
ExecuteQueuedCommands();
// all enemy players have moved / attacked
ChangeFaction(0);
}
public override void Update()
{
base.Update();
if (skipmove)
{
Stop();
return;
}
MoveController.CombatantMoveState move_state = Combatant.GetMoveState();
int state_hash = Combatant.MoveController.GetCurrentAnimHash();
AnimatorStateInfo state_info = Combatant.MoveController.GetCurrentStateInfo();
if (move_state != MoveController.CombatantMoveState.kAttackTarget)
{
EB.Debug.LogError("move state not match");
Stop();
return;
}
if (state_hash != state_info.fullPathHash)
{
EB.Debug.Log("SkillActionState.Update: animator state not ready, {0} != {1}", state_hash.ToString(), state_info.fullPathHash.ToString());
return; //but we do not need to stay here
}
float end_time = 1.0f - timeEpsilon;
if (state_info.normalizedTime > end_time && NormalizedTime > end_time)
{
End();
return;
}
NormalizedTime = state_info.normalizedTime;
}
public void SetTurn(Combatant incoming)
{
if (_bank.Combat.Round == 0)
{
return;
}
if (incoming.TurnTaken)
{
return;
}
var current = _bank.Combat.Turn;
if (!incoming.IsActive)
{
return;
}
_affect.CheckExpirationOnTurn(incoming, current);
if (current != null)
{
current.TurnTaken = true;
current.IsTurn = false;
}
_bank.Combat.Turn = incoming;
incoming.IsTurn = true;
if (OnCombatantChanged != null)
{
OnCombatantChanged(this, new CombatantChangedEventArgs());
}
Notify();
}
public string Use(Combatant user, Combatant target)
{
int damage = 0;
switch (SkillName)
{
case SkillName.Mash:
damage = DamageCalculation(user, target, Amount);
user.Act -= Cost;
return(string.Format("Player used Mash, did [{0}] damage!", damage));
case SkillName.LeanIn:
user.Act -= Cost;
user.Act += Amount;
return(string.Format("Player used LeanIn, +[{0}] speed!", Amount));
case SkillName.Grind:
damage = DamageCalculation(user, target, Amount);
user.Act -= Cost;
return(string.Format("Player used Grind, did [{0}] damage!", damage));
}
return(string.Empty);
}
public void DrawCharacters(SpriteBatch spritebatch, Party party)
{
for (int i = 0; i < party.ActiveMembers.Count; i++)
{
Vector2 start = new Vector2(40, i * 150 + 120);
Combatant comb = party.ActiveMembers[i];
spritebatch.Draw(comb.Face, new Rectangle((int)start.X, (int)start.Y, 92, 92), Color.White);
spritebatch.DrawString(spriteFont, comb.Name, new Vector2(start.X + 100, start.Y),
Color.White);
spritebatch.DrawString(spriteFont, "LV " + comb.Level, new Vector2(start.X + 190, start.Y),
Color.White);
spritebatch.DrawString(spriteFont, "HP", new Vector2(start.X + 100, start.Y + 30), Color.White);
spritebatch.DrawString(spriteFont, "MP", new Vector2(start.X + 100, start.Y + 50), Color.White);
spritebatch.DrawString(spriteFont, "EXP", new Vector2(start.X + 100, start.Y + 70), Color.White);
spritebatch.Draw(emptyBar, new Rectangle((int)start.X + 140, (int)start.Y + 35, 80, 10), Color.White);
spritebatch.Draw(emptyBar, new Rectangle((int)start.X + 140, (int)start.Y + 55, 80, 10), Color.White);
spritebatch.Draw(emptyBar, new Rectangle((int)start.X + 140, (int)start.Y + 75, 80, 10), Color.White);
int curHP = GetBarFill(comb.HP, comb.MaxHP);
int curMP = GetBarFill(comb.MP, comb.MaxMP);
int curEXP = GetBarFill(18, 100);
spritebatch.Draw(fullBar, new Rectangle((int)start.X + 140, (int)start.Y + 35, curHP, 10), Color.White);
spritebatch.Draw(fullBar, new Rectangle((int)start.X + 140, (int)start.Y + 55, curMP, 10), Color.White);
spritebatch.Draw(fullBar, new Rectangle((int)start.X + 140, (int)start.Y + 75, curEXP, 10), Color.White);
spritebatch.DrawString(smallFont, comb.HP + "/" + comb.MaxHP, new Vector2(start.X + 223, start.Y + 32), Color.Red);
spritebatch.DrawString(smallFont, comb.MP + "/" + comb.MaxMP, new Vector2(start.X + 223, start.Y + 52), Color.Red);
spritebatch.DrawString(smallFont, "18/100", new Vector2(start.X + 223, start.Y + 72), Color.Red);
}
}
/// <summary>
/// Cast this ability. The <param name="source">source</param> is the <see cref="Combatant" /> which is responsible for casting the spell.
/// The spell can have one or more <param name="targets">targets</param>.
/// </summary>
/// <param name='source'>
/// Source.
/// </param>
/// <param name='targets'>
/// Targets.
/// </param>
/// <param name='modifiers'>
/// Modifiers.
/// </param>
/// <param name='resetTurnTimer'>
/// If set to <c>true</c> reset turn timer.
/// </param>
public void Use(Combatant source, IEnumerable <Combatant> targets, AbilityModifiers modifiers)
{
bool canUse = true;
if (!modifiers.CostsNothing)
{
if (source.MP >= MPCost)
{
source.UseMP(MPCost);
}
else
{
canUse = false;
}
}
BattleEvent e = null;
if (canUse)
{
e = new AbilityEvent(this, modifiers, source, targets.ToArray());
}
else
{
e = new AbilityFailEvent(source, this, modifiers.ResetTurnTimer);
}
if (modifiers.CounterAttack)
{
source.CurrentBattle.EnqueueCounterAction(e);
}
else
{
source.CurrentBattle.EnqueueAction(e);
}
}
/// <summary>
/// Move an entity
/// </summary>
/// <param name="entity"></param>
/// <param name="destination"></param>
public void MoveEntity(Combatant entity, Coord destination)
{
if (!WalkabilityMap[destination])
{
throw new Exception();
}
if (EntityMap[entity.Coordinate] == null)
{
throw new Exception();
}
EntityMap[entity.Coordinate].Remove(entity);
WalkabilityMap[entity.Coordinate] = EntityMap[entity.Coordinate].IsPassable;
// clean up seems not needed
//if (!EntityMap[entity.Coordinate].Has<AdventureEntity>())
//{
// EntityMap[entity.Coordinate] = null;
//}
if (EntityMap[destination] == null)
{
EntityMap[destination] = new AdventureEntityContainer();
}
EntityMap[destination].Add(entity);
WalkabilityMap[destination] = EntityMap[destination].IsPassable;
entity.Coordinate = destination;
entity.FovCoords = CalculateFoV(entity.Coordinate, entity is Mogwai);
Adventure.Enqueue(AdventureLog.EntityMoved(entity, destination));
}
// Add a combatant to the battle
public void AddCombatant(Combatant c)
{
m_combatants.Add(c); // Add to the list
m_numberOfCombatants++; // Increment the count
if (c.isPlayer)
{
SetButtonText(); // Set the button text only if the passed in combatant is the player
if (m_numberOfCombatants == 1) // if the player is the first combatant
{
m_canAct = true; // Allow the player to act
ActivateButtons(m_canAct); // Set the buttons to be interactable
}
}
else
{
if (m_numberOfCombatants == 1) // if c is the first combatant and not the player start the game
{
StartCoroutine(WaitFor(2)); // NOTE: This needs to be done in a better way. Need to start when all combatants are added
m_canAct = false; // Disallow the player to act
ActivateButtons(m_canAct); // Set the buttons to be non-interactable
}
}
SetDeafultTextDisplay(); // Set the Default text display
}
protected override void OnApplyEffect(Combatant primaryTarget, AbilityDetails details)
{
if (details.command.diagonal)
{
Debug.LogWarning("Knockback cannot be applied on abilities with diagonal reach");
return;
}
GridPos performerPos = details.performer.Point;
foreach (GridObject target in details.targets)
{
int xDelta = 0;
int yDelta = 0;
GridPos defPos = target.Point;
if (defPos.x < performerPos.x)
{
xDelta = -distance;
}
else if (defPos.x > performerPos.x)
{
xDelta = +distance;
}
else if (defPos.y < performerPos.y)
{
yDelta = -distance;
}
else if (defPos.y > performerPos.y)
{
yDelta = +distance;
}
KnockBack(target, defPos, xDelta, yDelta);
}
}
// Update is called once per frame
void LateUpdate()
{
if (player.inCombat == false) //Battle field class follows the player
{
transform.position = player.transform.position + offset;
}
if (player.inCombat == true && player.waitingForFader == false)
{
int enemiesInFight = 0;
for (int i = 0; i < combatantsInFight.Count; i++)
{
Combatant checkedFile = combatantsInFight[i].GetComponent("Combatant") as Combatant;
if (checkedFile.isPC == false)
{
enemiesInFight++;
}
}
if (enemiesInFight == 0 && initiativeList[0].character.isReadyToEndTurn() == true) //If there are no enemies left, end the combat
{
activateEndCombatMenu = true;
//CompleteCombat();
}
}
}
public void UseAbility(int index, double quantity, Combatant target)
{
var unit = this.game.PlayOrder.Peek();
var abilityStats = this.mainGame.Derivates.Of(unit.Owner).DesignStats[unit.Ships.Design].Abilities[index];
var chargesLeft = quantity;
var spent = 0.0;
if (!abilityStats.TargetShips || Methods.HexDistance(target.Position, unit.Position) > abilityStats.Range)
{
return;
}
if (abilityStats.IsInstantDamage)
{
spent = this.doDirectAttack(unit, abilityStats, quantity, target);
}
spent = Math.Min(spent, quantity);
unit.AbilityCharges[index] -= spent;
if (!double.IsInfinity(unit.AbilityAmmo[index]))
{
unit.AbilityAmmo[index] -= spent;
}
}
private void RefreshCombatants()
{
var player = FFXIV.Instance.GetPlayer();
if (player != null)
{
this.player = player;
}
var party = FFXIV.Instance.GetPartyList();
if (party != null)
{
var newList = new List <Combatant>(party);
if (newList.Count < 1 &&
!string.IsNullOrEmpty(this.player.Name))
{
newList.Add(this.player);
}
this.partyList = newList;
}
}
//JSON
public void LoadCombatantData(int id)
{
string filePath = Application.dataPath + gameDataProjectFilePath + id.ToString() + ".json";
if (File.Exists(filePath))
{
string dataAsJson = File.ReadAllText(filePath);
Combatant jsonCombatant = JsonUtility.FromJson <Combatant>(dataAsJson);
m_refId = jsonCombatant.jRefId;
m_name = jsonCombatant.jName;
m_description = jsonCombatant.jDescription;
m_maxhp = jsonCombatant.jMaxhp;
m_maxap = jsonCombatant.jMaxap;
//m_currenthp = jsonCombatant.jCurrenthp;
//m_currentap = jsonCombatant.jCurrentap;
m_deckId = jsonCombatant.jDeckId;
}
else
{
Combatant jsonCombatant = new Combatant();
Debug.Log("json failed");
}
}
public void GetInput()
{
ConsoleKeyInfo key = new ConsoleKeyInfo();
if (_gameState == GameState.ChoosingClass)
{
ConsoleKey[] acceptableKeys = { ConsoleKey.D1, ConsoleKey.D2, ConsoleKey.D3, ConsoleKey.D4 };
bool finished = false;
const int baseHealth = 500;
while (!finished)
{
key = Console.ReadKey(true);
if (acceptableKeys.Contains(key.Key))
{
finished = true;
}
}
switch (key.Key)
{
case ConsoleKey.D1:
_playerCombatant = new Combatant(random: _random)
{
MaxHealth = baseHealth + 80,
Attack = 6,
Defence = 9,
Speed = 2,
Name = "Tank",
Moves = new List <Move>()
{
MoveContainer.Punch,
MoveContainer.BodySlam,
MoveContainer.Toughen,
MoveContainer.UltimateSlam
}
};
break;
case ConsoleKey.D2:
_playerCombatant = new Combatant(random: _random)
{
MaxHealth = baseHealth + 40,
Attack = 8,
Defence = 3,
Speed = 10,
Name = "Ninja",
Moves = new List <Move>()
{
MoveContainer.Punch,
MoveContainer.BodySlam,
MoveContainer.Toughen,
MoveContainer.Shinobi
}
};
break;
case ConsoleKey.D3:
_playerCombatant = new Combatant(random: _random)
{
MaxHealth = baseHealth + 60,
Attack = 8,
Defence = 5,
Speed = 6,
Name = "Mage",
Moves = new List <Move>()
{
MoveContainer.Punch,
MoveContainer.BodySlam,
MoveContainer.Toughen,
MoveContainer.Fireball
}
};
break;
case ConsoleKey.D4:
_playerCombatant = new Combatant(random: _random)
{
MaxHealth = baseHealth + 90,
Attack = 9,
Defence = 2,
Speed = 5,
Name = "Dark Mage",
Moves = new List <Move>()
{
MoveContainer.Punch,
MoveContainer.BodySlam,
MoveContainer.Toughen,
MoveContainer.LifeDrain
}
};
break;
}
const int baseMaximumMoves = 0;
_maximumMoves = 10 + _playerCombatant.Speed;
}
else if (_gameState == GameState.Overworld)
{
ConsoleKey[] acceptableKeys = { ConsoleKey.W, ConsoleKey.A, ConsoleKey.S, ConsoleKey.D };
bool finished = false;
while (!finished)
{
key = Console.ReadKey(true);
if (acceptableKeys.Contains(key.Key))
{
finished = true;
}
}
switch (key.Key)
{
case ConsoleKey.W:
_overworldGrid.MoveCharacter(0, -1);
_moves++;
_overworldGrid.Display();
Console.WriteLine($"Moves left: {_maximumMoves - _moves}");
break;
case ConsoleKey.A:
_overworldGrid.MoveCharacter(-1, 0);
_moves++;
_overworldGrid.Display();
Console.WriteLine($"Moves left: {_maximumMoves - _moves}");
break;
case ConsoleKey.S:
_overworldGrid.MoveCharacter(0, 1);
_moves++;
_overworldGrid.Display();
Console.WriteLine($"Moves left: {_maximumMoves - _moves}");
break;
case ConsoleKey.D:
_overworldGrid.MoveCharacter(1, 0);
_moves++;
_overworldGrid.Display();
Console.WriteLine($"Moves left: {_maximumMoves - _moves}");
break;
}
}
else
{
ConsoleKey[] acceptableKeys = { ConsoleKey.D1, ConsoleKey.D2, ConsoleKey.D3, ConsoleKey.D4 };
bool finished = false;
while (!finished)
{
key = Console.ReadKey(true);
if (acceptableKeys.Contains(key.Key))
{
finished = true;
}
}
_battleController.SetPlayerAttack(key.Key switch
{
ConsoleKey.D1 => 0,
ConsoleKey.D2 => 1,
ConsoleKey.D3 => 2,
ConsoleKey.D4 => 3
});
public RemoteNetworkedPVPMover(EngineRoomNetworkManager ernm, bool isServer, Combatant toOverwrite)
{
ernm.AttachToListenerMover(this, isServer);
this.toOverwrite = toOverwrite;
}
void Start()
{
playerScript = player.GetComponent <Combatant>();
enemyScript = enemy.GetComponent <Combatant>();
}
private void CombatantAdded(object Combatant)
{
Combatant cmb = (Combatant)Combatant;
this.combatantTable[cmb.ID] = cmb;
}
public DefaultBattleAI(Combatant combatant, Combatant initialTarget)
{
Combatant = combatant;
RB = combatant.GetComponent <Rigidbody2D>();
Target = initialTarget;
}
public DefaultBattleAI(Combatant combatant)
{
Combatant = combatant;
RB = combatant.GetComponent <Rigidbody2D>();
}
public void nextTurn()
{
isFirstTurn = false;
this.actionsMenu.SetActive(false);
this.playerHealthName.SetActive(false);
this.playerAvatar.SetActive(false);
this.playerManaName.SetActive(false);
this.enemyUnitsMenu.SetActive(false);
playerAttack = false;
GameObject[] remainEnemyUnit = GameObject.FindGameObjectsWithTag("Enemy");
if (remainEnemyUnit.Length == 0)
{
// GameObject[] playerObject = GameObject.FindGameObjectsWithTag("PlayerUnit");
// for (var i = 0; i < playerObject.Length; i++) {
//if (playerObject[i].gameObject.name == "Player1") {
//playerObject[i].gameObject.GetComponent<PlayerStat>().calculateExp(sumExpCanGet / playerObject.Length);
//DataManager.instance.maxHealthPlayer1 = playerObject[i].gameObject.GetComponent<PlayerStat>().maxHealth;
//DataManager.instance.currentExpPlayer1 = playerObject[i].gameObject.GetComponent<PlayerStat>().currentExp;
//DataManager.instance.levelPlayer1 = playerObject[i].gameObject.GetComponent<PlayerStat>().playerLv;
//DataManager.instance.maxManaPlayer1 = playerObject[i].gameObject.GetComponent<PlayerStat>().maxHealth;
// DataManager.instance.attackPlayer1 = playerObject[i].gameObject.GetComponent<PlayerStat>().attack;
// DataManager.instance.defensePlayer1 = playerObject[i].gameObject.GetComponent<PlayerStat>().defense;
// DataManager.instance.healthPlayer1 = playerObject[i].gameObject.GetComponent<PlayerStat>().health;
// DataManager.instance.magicPlayer1 = playerObject[i].gameObject.GetComponent<PlayerStat>().magic;
// DataManager.instance.manaPlayer1 = playerObject[i].gameObject.GetComponent<PlayerStat>().mana;
// DataManager.instance.speedPlayer1 = playerObject[i].gameObject.GetComponent<PlayerStat>().speed;
// }
// else if(playerObject[i].gameObject.name == "Player2") {
//playerObject[i].gameObject.GetComponent<PlayerStat>().calculateExp(sumExpCanGet / playerObject.Length);
//DataManager.instance.maxHealthPlayer2 = playerObject[i].gameObject.GetComponent<PlayerStat>().maxHealth;
//DataManager.instance.currentExpPlayer2 = playerObject[i].gameObject.GetComponent<PlayerStat>().currentExp;
//DataManager.instance.levelPlayer2 = playerObject[i].gameObject.GetComponent<PlayerStat>().playerLv;
//DataManager.instance.maxManaPlayer2 = playerObject[i].gameObject.GetComponent<PlayerStat>().maxMana;
// DataManager.instance.attackPlayer2 = playerObject[i].gameObject.GetComponent<PlayerStat>().attack;
// DataManager.instance.defensePlayer2 = playerObject[i].gameObject.GetComponent<PlayerStat>().defense;
// DataManager.instance.healthPlayer2 = playerObject[i].gameObject.GetComponent<PlayerStat>().health;
// DataManager.instance.magicPlayer2 = playerObject[i].gameObject.GetComponent<PlayerStat>().magic;
// DataManager.instance.manaPlayer2 = playerObject[i].gameObject.GetComponent<PlayerStat>().mana;
// DataManager.instance.speedPlayer2 = playerObject[i].gameObject.GetComponent<PlayerStat>().speed;
// }
//}
GameManager.instance.LoadMapScene();
}
GameObject[] remainPlayerUnit = GameObject.FindGameObjectsWithTag("PlayerUnit");
if (remainPlayerUnit.Length == 0)
{
GameManager.instance.LoadGameMenu();
}
Debug.Log(isFirstTurn);
isFirstTurn = false;
currentUnit = unitStats[0];
unitStats.Remove(currentUnit);
if (currentUnit.GameObject.tag != "DeadUnit")
{
//GameObject currentUnit = currentUnitStat.gameObject;
unitStats.Add(currentUnit);
//unitStats.Sort();
if (currentUnit.GameObject.tag == "PlayerUnit")
{
//choose enemy
if (isPlayerSelectEnemy == false)
{
for (int i = 0; i < enemyPositionIndex; i++)
{
if (isEnemyDead[i] == false)
{
Instantiate(selector, enemySpawnPositions[i].transform.position,
enemySpawnPositions[i].transform.rotation);
break;
}
}
}
//player turn
if (isPlayerSelectEnemy == true)
{
enemyTurn = false;
playerList.Remove(currentUnit);
currentUnit.GameObject.GetComponent <GetPlayerAction>().
AttackTarget(enemyCombatant[enemySelectedPositionIndex].GameObject,
enemyCombatant[enemySelectedPositionIndex]);
isPlayerSelectEnemy = false;
}
}
else
{
enemyTurn = true;
currentUnit.GameObject.GetComponent <EnemyAction>().Action();
}
}
else
{
unitStats.Add(currentUnit);
this.nextTurn();
}
}
public CombatRemoveCombatantEvent(Combatant combatant)
{
Combatant = combatant;
}
public abstract Ability selectAbility(Combatant performer);
public Defend(Combatant source, Combatant target, int armor) : base(source, target)
{
this.armor = armor;
}
private void RefreshCombatants()
{
var player = default(Combatant);
var party = default(IReadOnlyList <Combatant>);
lock (SimulationLocker)
{
if (this.InSimulation &&
this.SimulationPlayer != null &&
this.SimulationParty.Any())
{
player = this.SimulationPlayer;
party = this.SimulationParty;
}
else
{
player = FFXIVPlugin.Instance?.GetPlayer();
party = FFXIVPlugin.Instance?.GetPartyList();
}
}
if (player != null)
{
this.player = player;
}
if (party != null)
{
var newList = new List <Combatant>(party);
if (newList.Count < 1 &&
!string.IsNullOrEmpty(this.player?.Name))
{
newList.Add(this.player);
}
// パーティリストを入れ替える
this.partyList.Clear();
this.partyList.AddRange(newList);
// 読み仮名リストをメンテナンスする
var newPhonetics =
from x in newList
select new PCPhonetic()
{
ID = x.ID,
NameFI = x.NameFI,
NameIF = x.NameIF,
NameII = x.NameII,
Name = x.Name,
JobID = x.JobID,
};
WPFHelper.BeginInvoke(() =>
{
var phonetics = TTSDictionary.Instance.Phonetics;
var toAdd = newPhonetics.Where(x => !phonetics.Any(y => y.Name == x.Name));
phonetics.AddRange(toAdd);
var toRemove = phonetics.Where(x => !newPhonetics.Any(y => y.Name == x.Name)).ToArray();
foreach (var item in toRemove)
{
phonetics.Remove(item);
}
});
}
}
public override Ability selectAbility(Combatant performer)
{
switch (state)
{
case "start":
selectedAbility = null;
menuTitleText.text = performer.CombatantName;
menuListLoader.menuListProvider = menuListProvider;
menuListLoader.menuItemSelector = menuItemSelector;
menuListLoader.loadMenu();
state = "waitingForAbility";
break;
case "waitingForAbility":
if (menuItemSelector.selectedString != null)
{
selectedAbility = menuItemSelector.selectedString;
// TODO: The combatants we load need to be based off the ability.
// Cure defaults to party (but can switch to enemy)
// ALL isn't for all abilities
loadMenuWithTargets(enemies, "Enemies");
state = "waitingForTarget";
}
break;
case "selectAlly":
// TODO: The combatants we load need to be based off the ability.
// Cure defaults to party (but can switch to enemy)
// ALL isn't for all abilities
loadMenuWithTargets(allies, "Allies");
state = "waitingForTarget";
break;
case "waitingForTarget":
if (menuItemSelector.selectedString != null)
{
string selectedTarget = menuItemSelector.selectedString;
List <Combatant> selectedTargets = new List <Combatant>();
switch (selectedTarget)
{
case "Ally":
state = "selectAlly";
break;
case "ALL Enemies":
selectedTargets = enemies.combatants;
state = "start";
return(abilityFactory.createAbility(selectedAbility, performer, selectedTargets));
case "ALL Allies":
selectedTargets = allies.combatants;
state = "start";
return(abilityFactory.createAbility(selectedAbility, performer, selectedTargets));
default:
selectedTargets.Add(selectedFaction.nameToCombatant[selectedTarget]);
state = "start";
return(abilityFactory.createAbility(selectedAbility, performer, selectedTargets));
}
}
break;
default:
break;
}
return(null);
}
public AITurnPlan(Combatant combatant)
{
this.combatant = combatant;
}
protected override StatusEffect NewStatusEffect(Combatant target)
{
return(new OffBalance(target, duration));
}
public RecoveryIcon(StateOfBattle battle, Combatant receiver)
: base(battle, receiver)
{
Message = RECOVERY;
Color = Colors.GREEN;
}
public void FristTurn()
{
//if (enemyList.Count == 0) {
// GameManager.instance.LoadMapScene();
//}
//if (playerList.Count == 0) {
// GameManager.instance.LoadGameMenu();
//}
//Combatant currentUnit = playerList[0];
//playerList.Remove(currentUnit);
//if (currentUnit.Dead != true) {
// GameObject currentUnitObject = currentUnit.GameObject;
// Instantiate(selector, enemySpawnPositions[0].transform.position, enemySpawnPositions[0].transform.rotation);
//}
//check is game over
GameObject[] remainEnemyUnit = GameObject.FindGameObjectsWithTag("Enemy");
if (remainEnemyUnit.Length == 0)
{
GameManager.instance.LoadMapScene();
}
GameObject[] remainPlayerUnit = GameObject.FindGameObjectsWithTag("PlayerUnit");
if (remainPlayerUnit.Length == 0)
{
GameManager.instance.LoadGameMenu();
}
isFirstTurn = true;
//check enemy turn
if (playerList.Count == 0)
{
//go to next turn
if (playerList.Count == 0 && enemyList.Count == 0)
{
for (int i = 0; i < 2; i++)
{
unitStats.Add(playerCombatant[i]);
}
for (int i = 0; i < enemyPositionIndex; i++)
{
unitStats.Add(enemyCombatant[i]);
}
unitStats.Sort(delegate(Combatant x, Combatant y) {
return(y.Status[9].GetValue().CompareTo(x.Status[9].GetValue()));
});
//create queue for next turn
unitLists = new Queue <Combatant>(unitStats);
this.nextTurn();
}
//enemy turn
else
{
currentUnit = enemyList[0];
enemyList.Remove(currentUnit);
enemyTurn = true;
currentUnit.GameObject.GetComponent <EnemyAction>().Action();
}
}
else
{
currentUnit = playerList[0];
//choose enemy
if (isPlayerSelectEnemy == false)
{
for (int i = 0; i < enemyPositionIndex; i++)
{
if (isEnemyDead[enemyPositionIndex] == false)
{
Instantiate(selector, enemySpawnPositions[i].transform.position, enemySpawnPositions[i].transform.rotation);
break;
}
}
}
//player turn
if (isPlayerSelectEnemy == true)
{
enemyTurn = false;
playerList.Remove(currentUnit);
currentUnit.GameObject.GetComponent <GetPlayerAction>().
AttackTarget(enemyCombatant[enemySelectedPositionIndex].GameObject,
enemyCombatant[enemySelectedPositionIndex]);
isPlayerSelectEnemy = false;
}
}
}
