public void CenterCameraOnActiveToken(BodToken token)
{
Debug.Log("Centered Position: " + activeToken.transform.position);
Vector3 pos = activeToken.transform.position;
Camera.main.transform.position = new Vector3(pos.x, pos.y, Camera.main.transform.position.z);
}
public void PerformMove(BodToken token, Vector2 pos)
{
MoveToken(token, pos);
isMoving = false;
hasMoved = true;
}
private void MoveToken(BodToken token, Vector2 pos)
{
Debug.Log("Moving Token");
battleBoard.tokenPositions[token.posX, token.posY] = null;
battleBoard.SetBodTokenToPosition(token, (int)pos.x, (int)pos.y);
}
private void DeselectAll(BodToken ignoreToken = null)
{
foreach (BodToken token in tokens)
{
if (token != ignoreToken)
{
token.selectionArrow.SetActive(false);
}
}
}
private void ShowSkillUseAvailability(Skill skill, Vector2 space)
{
// Debug.Log ("ShowSkillUseAvailability - 1");
if (trackedSpaces.Contains(space))
{
return;
}
Vector2 currentSpace = new Vector2(activeToken.posX, activeToken.posY);
Vector2 checkSpace = new Vector2(space.x, space.y);
BodToken checkToken = battleBoard.tokenPositions[(int)space.x, (int)space.y];
trackedSpaces.Add(checkSpace);
// Debug.Log ("MaxRange: " + skill.rangeMax);
if (Vector2.Distance(currentSpace, checkSpace) > skill.rangeMax)
{
return;
}
Debug.Log("Checking: " + skill.name + " at pos: " + space.x + ", " + space.y);
// Check usability of Skill
if (skill.usable(activeToken.bodRef, (checkToken == null) ? null : checkToken.bodRef, currentSpace, checkSpace))
{
battleBoard.ShowSpaceAvailable(checkSpace, skill);
}
// Recursive Case: Check adjacent spaces
// Up
if (space.y > 0)
{
ShowSkillUseAvailability(skill, new Vector2(space.x, (space.y - 1)));
}
// Left
if (space.x > 0)
{
ShowSkillUseAvailability(skill, new Vector2((space.x - 1), space.y));
}
// Down
if (space.y < (battleBoard.dimensionY - 1))
{
ShowSkillUseAvailability(skill, new Vector2(space.x, (space.y + 1)));
}
// Right
if (space.x < (battleBoard.dimensionX - 1))
{
ShowSkillUseAvailability(skill, new Vector2((space.x + 1), space.y));
}
}
public void SelectTokenButtonPress(BodToken token)
{
BattleSpace space = battleBoard.battleSpaces[token.posX, token.posY];
if (space.loadedSkill != null)
{
space.PerformLoadedSkill();
}
else
{
battleBoard.ResetSpaces();
token.ToggleBodMenu();
}
}
public void PerformLoadedSkill()
{
if (!isActive || loadedSkill == null)
{
return;
}
Debug.Log("Battle Space - Performing " + loadedSkill.name);
List <BodToken> tokenList = new List <BodToken>();
BodToken user = BattleManager.instance.ActiveToken;
user.SetBodSpriteForSkill(loadedSkill.skillType);
if (loadedSkill.userEffectSpritePath != "")
{
Debug.Log("User effect anim: " + loadedSkill.userEffectSpritePath + ".");
user.SetEffectSprite(loadedSkill.userEffectSpritePath);
tokenList.Add(user);
}
BodToken target = BattleManager.instance.battleBoard.tokenPositions[posX, posY];
if (loadedSkill.targetEffectSpritePath != "")
{
Debug.Log("Target effect anim: " + loadedSkill.targetEffectSpritePath + ".");
target.SetEffectSprite(loadedSkill.targetEffectSpritePath);
tokenList.Add(target);
}
// Invoke the skill
loadedSkill.action.Invoke(loadedSkill.user, (target == null) ? null : target.bodRef, new Vector2(posX, posY));
user.UpdateStatsBars();
if (target != null)
{
target.UpdateStatsBars();
}
BattleManager.instance.battleBoard.ResetSpaces();
}
public bool SetBodTokenToPosition(BodToken token, int x, int y, bool initial = false)
{
if (tokenPositions[x, y] == null)
{
tokenPositions[x, y] = token;
token.posX = x;
token.posY = y;
RectTransform tokenRect = token.transform as RectTransform;
tokenRect.SetParent(battleSpaces[x, y].objectRef.transform, false);
tokenRect.pivot = new Vector2(0.5f, 0f);
tokenRect.anchoredPosition = Vector2.zero;
if (initial)
{
tokenRect.Rotate(new Vector2(-50, 0));
}
return(true);
}
return(false);
}
public void SelectToken(BodToken token)
{
activeToken = token;
DeselectAll(token);
token.selectionArrow.SetActive(true);
battleBoard.ResetSpaces();
actionMenu.SetBod(activeToken.bodRef);
if (actionMenu.IsOpen() == false)
{
actionMenu.OpenActionMenu();
}
isMoving = false;
hasMoved = false;
CenterCameraOnActiveToken(token);
AddActionDisplayText("Next Turn: " + activeToken.bodRef.name);
}
private void GenerateSkillDictionary()
{
skillDictionary = new Dictionary <string, Skill>();
Skill newSkill = null;
string skillId = "";
// Physical Skills ------------------------------------------------------------------------
// Basic Strike Attack
skillId = "basic_strike";
newSkill = new Skill(
skillId,
"Strike",
"",
"",
SkillType.Physical,
1,
1,
delegate(Bod user, Bod target, Vector2 targetPos)
{
// Add action text for attack
BattleManager.instance.AddActionDisplayText(user.name + " strikes " + target.name);
// Get Token Refs
BodToken userToken = BattleManager.instance.GetToken(user);
BodToken targetToken = BattleManager.instance.GetToken(target);
// Get Attack Power and Aim
int atkPower = user.str;
int atkAim = user.dex;
Debug.Log("Attack Power: " + atkPower + ", Aim: " + atkAim);
// Declare audio string for audio effect
string audioStr = "";
// Get Dodge Rate
int dodgeVal = BodManager.instance.AgilRoll(target);
Debug.Log((target.ap > 0) ? "Dodge: " + dodgeVal : target.name + " is too tired to dodge");
if (dodgeVal >= atkAim && target.ap > 0)
{
BattleManager.instance.AddActionDisplayText(target.name + " dodges!");
audioStr = "miss_sound";
target.ap--;
}
else
{
// Add action text for target being hit
BattleManager.instance.AddActionDisplayText("Hit!");
// Get Block/Dmg Absorption
int blockVal = BodManager.instance.FortRoll(target);
Debug.Log((target.ap > 0) ? "Block/Absorb: " + blockVal : target.name + " is too tired to block");
if (blockVal > 0 && target.ap > 0)
{
// Adjust block val if its greater than the power
if (blockVal > atkPower)
{
blockVal = atkPower;
}
// Add action text for absorbed/blocked damage
BattleManager.instance.AddActionDisplayText(target.name + " absorbs " + blockVal + " damage.");
atkPower -= blockVal;
target.ap--;
}
// Apply remaining power as damage
if (atkPower > 0)
{
BodManager.instance.TakeDamage(target, atkPower);
targetToken.spritePackage.SetTakeDamage();
audioStr = "hit_sound";
// TODO: Knockback
int knockbackVal = blockVal * 2;
Debug.Log("Knockback: " + knockbackVal);
if (target.dead == false && atkPower > knockbackVal)
{
// Add action text for knockback effect
BattleManager.instance.AddActionDisplayText(target.name + " is knocked back!");
BattleManager.instance.Knockback(targetPos);
atkPower -= knockbackVal;
}
targetToken.spritePackage.StartWaitToSetStanding();
}
}
// Adjust user action points
user.ap--;
// Play audio clip
AudioManager.instance.PlayAudioClip(audioStr);
},
delegate(Bod user)
{
// Debug.Log ("Basic Strike Requirements");
return(true);
},
delegate(Bod user, Bod target, Vector2 pos1, Vector2 pos2)
{
Debug.Log("Basic Strike Usable Check, AP: " + user.ap);
int dist = Mathf.Abs((int)pos1.x - (int)pos2.x) + Mathf.Abs((int)pos1.y - (int)pos2.y);
if (user == null || target == null || target == user)
{
Debug.Log("Invalid user/target");
return(false);
}
else if (user.ap <= 0)
{
Debug.Log("User out of ap");
return(false);
}
else if (dist != 1)
{
Debug.Log("Target out of range");
return(false);
}
Debug.Log("True");
Debug.Log("User: "******" can strike " + target.name);
return(true);
}
);
skillDictionary.Add(skillId, newSkill);
// Burst Skills ---------------------------------------------------------------------------
// Psy Bolt: Attack with a concentrated bolt of Psy energy, does not miss
skillId = "psy_bolt";
newSkill = new Skill(
skillId,
"Psy Bolt",
"PsyBolt_cast",
"",
SkillType.Burst,
2,
2,
delegate(Bod user, Bod target, Vector2 targetPos)
{
Debug.Log("Psy Bolt Action");
// Get Token Refs
BodToken userToken = BattleManager.instance.GetToken(user);
BodToken targetToken = BattleManager.instance.GetToken(target);
BattleManager.instance.AddActionDisplayText(user.name + " fires a Psy Bolt at " + target.name + "!");
int pow = user.burst;
int resist = (target.stress < BodManager.instance.GetBodMind(target)) ? BodManager.instance.MindRoll(target) : 0;
if (resist > pow)
{
resist = pow;
}
Debug.Log("Power: " + pow + ", Resist: " + resist);
if (resist > 0)
{
BattleManager.instance.AddActionDisplayText(target.name + " resists " + resist + " effect");
pow -= resist;
target.stress++;
// TODO: Target Sprite = Resist Damage
}
if (pow > 0)
{
BodManager.instance.TakeDamage(target, pow);
targetToken.spritePackage.SetTakeDamage();
targetToken.spritePackage.StartWaitToSetStanding();
}
AudioManager.instance.PlayAudioClip("psy_laser_sound");
user.stress++;
},
delegate(Bod user)
{
// Debug.Log ("Psy Bolt Requirements");
if (user.burst > 0)
{
return(true);
}
else
{
return(false);
}
},
delegate(Bod user, Bod target, Vector2 pos1, Vector2 pos2)
{
Debug.Log("Psy Bolt Usable Check: " + user.stress + "/" + BodManager.instance.GetBodMind(user));
int dist = Mathf.Abs((int)pos1.x - (int)pos2.x) + Mathf.Abs((int)pos1.y - (int)pos2.y);
if (user == null || target == null || target == user)
{
Debug.Log("Invalid user/target");
return(false);
}
else if (user.stress >= BodManager.instance.GetBodMind(user))
{
Debug.Log(user.name + " is too stressed to use power");
return(false);
}
else if (dist != 2)
{
Debug.Log("Target out of range: " + dist);
return(false);
}
// Debug.Log ("True");
Debug.Log("User: "******" can use Psy Bolt on " + target.name);
return(true);
}
);
skillDictionary.Add(skillId, newSkill);
// Telekenetic Push: Shift a target's position away from self
skillId = "psy_push";
newSkill = new Skill
(
skillId,
"Psy Push",
"",
"",
SkillType.Burst,
1,
1,
delegate(Bod user, Bod target, Vector2 targetPos)
{
Debug.Log("Psy Push Action");
// Get Token Refs
BodToken userToken = BattleManager.instance.GetToken(user);
BodToken targetToken = BattleManager.instance.GetToken(target);
BattleManager.instance.AddActionDisplayText(user.name + " telekinetically pushes " + target.name + "!");
int pow = user.burst;
int resist = (target.stress < BodManager.instance.GetBodMind(target)) ? BodManager.instance.MindRoll(target) : 0;
if (resist > pow)
{
resist = pow;
}
Debug.Log("Power: " + pow + ", Resist: " + resist);
if (resist > 0)
{
BattleManager.instance.AddActionDisplayText(target.name + " resists " + resist + " effect");
pow -= resist;
target.stress++;
// TODO: Target Sprite = Resist Damage
}
if (pow > 0)
{
BattleManager.instance.AddActionDisplayText(target.name + " is pushed back");
targetToken.spritePackage.SetTakeDamage();
BattleManager.instance.Knockback(targetPos);
// while (target.dead == false && atkPower > knockbackVal)
// {
// // Add action text for knockback effect
// BattleManager.instance.AddActionDisplayText(target.name + " is knocked back!");
// BattleManager.instance.Knockback(targetPos);
// atkPower -= knockbackVal;
// }
targetToken.spritePackage.StartWaitToSetStanding();
}
// TODO: Push Sound Effect
// AudioManager.instance.PlayAudioClip("psy_laser_sound");
user.stress++;
},
delegate(Bod user)
{
// Debug.Log ("Psy Bolt Requirements");
if (user.burst > 0)
{
return(true);
}
else
{
return(false);
}
},
delegate(Bod user, Bod target, Vector2 pos1, Vector2 pos2)
{
return(true);
}
);
skillDictionary.Add(skillId, newSkill);
// Telekenetic Pull: Shift a target's position toward self
// Barrier: Erect a barrier that cannot be passed through by person or attack
// Rise Skills ----------------------------------------------------------------------------
// Raise Strength: Psychically raise strength stat
skillId = "raise_str";
newSkill = new Skill(
skillId,
"Strength",
"Raise",
"",
SkillType.Rise,
0,
0,
delegate(Bod user, Bod target, Vector2 targetPos)
{
Debug.Log("Raise Str Action");
// Get Token Refs
BodToken userToken = BattleManager.instance.GetToken(user);
BodToken targetToken = BattleManager.instance.GetToken(target);
int pow = user.rise;
BattleManager.instance.AddActionDisplayText(user.name + " raises str by : " + pow);
AudioManager.instance.PlayAudioClip("power_up_sound");
user.str += pow;
user.stress++;
},
delegate(Bod user)
{
// Debug.Log ("Raise Str Requirements");
if (user.rise > 0)
{
return(true);
}
else
{
return(false);
}
},
delegate(Bod user, Bod target, Vector2 pos1, Vector2 pos2)
{
Debug.Log("Raise Str Usable Check: " + user.stress + "/" + BodManager.instance.GetBodMind(user));
if (user == null)
{
Debug.Log("Invalid user/target");
return(false);
}
else if (user.stress >= BodManager.instance.GetBodMind(user))
{
Debug.Log(user.name + " is too stressed to use power");
return(false);
}
Debug.Log("User: "******" Strength");
return(true);
}
);
skillDictionary.Add(skillId, newSkill);
// Fortify - Raise Endurance: Psychically raise endurance stat
// Sharpen - Raise Dexterity: Psychically raise dexterity stat
// Quicken - Raise Speed: Psychically raise speed stat
// Trance Skills --------------------------------------------------------------------------
// Scan: Get stat info of target
skillId = "scan";
newSkill = new Skill(
skillId,
"Scan",
"TranceWave",
"TranceWave",
SkillType.Trance,
1,
3,
delegate(Bod user, Bod target, Vector2 targetPos)
{
Debug.Log("Scan Action");
int pow = user.trance;
int resist = (target.stress < BodManager.instance.GetBodMind(target)) ? BodManager.instance.MindRoll(target) : 0;
if (resist > pow)
{
resist = pow;
}
Debug.Log("Power: " + pow + ", Resist: " + resist);
if (resist >= pow)
{
BattleManager.instance.AddActionDisplayText(target.name + " resists " + resist + " effect from Scan");
pow -= resist;
target.stress++;
}
else
{
BattleManager.instance.AddActionDisplayText(user.name + " scans info from " + target.name + ":\n" + BodManager.instance.GetStats(target));
}
user.stress++;
},
delegate(Bod user)
{
// Debug.Log ("Scan Requirements");
if (user.trance > 0)
{
return(true);
}
else
{
return(false);
}
},
delegate(Bod user, Bod target, Vector2 pos1, Vector2 pos2)
{
Debug.Log("Scan Usable Check: " + user.stress + "/" + BodManager.instance.GetBodMind(user));
int dist = Mathf.Abs((int)pos1.x - (int)pos2.x) + Mathf.Abs((int)pos1.y - (int)pos2.y);
if (user == null || target == null || target == user)
{
Debug.Log("Invalid user/target");
return(false);
}
else if (user.stress >= BodManager.instance.GetBodMind(user))
{
Debug.Log(user.name + " is too stressed to use power");
return(false);
}
else if (dist < 1 || dist > 3)
{
Debug.Log("Target out of range: " + dist);
return(false);
}
Debug.Log("User: "******" can use Scan on " + target.name);
return(true);
}
);
skillDictionary.Add(skillId, newSkill);
// Antagonize: Add stress to a target to inhibit their ability to use Psy powers
// Calm: Reduce stress in self
// Copy Image: Make an illusion copy of target that is indistinguishable to others
// Hypnosis: Gain control over a target's next action
}
public void Start1v1Battle(BattleTeam tOne, BattleTeam tTwo)
{
ResetBattle();
battleBoard.Set3x7Board();
battleTeams.Add(tOne);
battleTeams.Add(tTwo);
// Team One Positions
if (tOne.numUnits > 0)
{
BodManager.instance.ResetBod(tOne.GetMember(0));
BodToken token1 = Instantiate(BodManager.instance.bodTokenPrefab).GetComponent <BodToken>();
token1.SetTokenBod(tOne.GetMember(0), false);
battleBoard.SetBodTokenToPosition(token1, 1, 1, true);
tokens.Add(token1);
}
if (tOne.numUnits > 1)
{
BodManager.instance.ResetBod(tOne.GetMember(1));
BodToken token2 = Instantiate(BodManager.instance.bodTokenPrefab).GetComponent <BodToken>();
token2.SetTokenBod(tOne.GetMember(1), false);
battleBoard.SetBodTokenToPosition(token2, 1, 0, true);
tokens.Add(token2);
}
if (tOne.numUnits > 2)
{
BodManager.instance.ResetBod(tOne.GetMember(2));
BodToken token3 = Instantiate(BodManager.instance.bodTokenPrefab).GetComponent <BodToken>();
token3.SetTokenBod(tOne.GetMember(2), false);
battleBoard.SetBodTokenToPosition(token3, 1, 2, true);
tokens.Add(token3);
}
if (tOne.numUnits > 3)
{
BodManager.instance.ResetBod(tOne.GetMember(3));
BodToken token4 = Instantiate(BodManager.instance.bodTokenPrefab).GetComponent <BodToken>();
token4.SetTokenBod(tOne.GetMember(3), false);
battleBoard.SetBodTokenToPosition(token4, 0, 0, true);
tokens.Add(token4);
}
if (tOne.numUnits > 4)
{
BodManager.instance.ResetBod(tOne.GetMember(4));
BodToken token5 = Instantiate(BodManager.instance.bodTokenPrefab).GetComponent <BodToken>();
token5.SetTokenBod(tOne.GetMember(4), false);
battleBoard.SetBodTokenToPosition(token5, 0, 2, true);
tokens.Add(token5);
}
// Team Two Positions
if (tTwo.numUnits > 0)
{
BodManager.instance.ResetBod(tTwo.GetMember(0));
BodToken token6 = Instantiate(BodManager.instance.bodTokenPrefab).GetComponent <BodToken>();
token6.SetTokenBod(tTwo.GetMember(0));
battleBoard.SetBodTokenToPosition(token6, 5, 1, true);
tokens.Add(token6);
}
if (tTwo.numUnits > 1)
{
BodManager.instance.ResetBod(tTwo.GetMember(1));
BodToken token7 = Instantiate(BodManager.instance.bodTokenPrefab).GetComponent <BodToken>();
token7.SetTokenBod(tTwo.GetMember(1));
battleBoard.SetBodTokenToPosition(token7, 5, 2, true);
tokens.Add(token7);
}
if (tTwo.numUnits > 2)
{
BodManager.instance.ResetBod(tTwo.GetMember(2));
BodToken token8 = Instantiate(BodManager.instance.bodTokenPrefab).GetComponent <BodToken>();
token8.SetTokenBod(tTwo.GetMember(2));
battleBoard.SetBodTokenToPosition(token8, 5, 0, true);
tokens.Add(token8);
}
if (tTwo.numUnits > 3)
{
BodManager.instance.ResetBod(tTwo.GetMember(3));
BodToken token9 = Instantiate(BodManager.instance.bodTokenPrefab).GetComponent <BodToken>();
token9.SetTokenBod(tTwo.GetMember(3));
battleBoard.SetBodTokenToPosition(token9, 6, 2, true);
tokens.Add(token9);
}
if (tTwo.numUnits > 4)
{
BodManager.instance.ResetBod(tTwo.GetMember(4));
BodToken token10 = Instantiate(BodManager.instance.bodTokenPrefab).GetComponent <BodToken>();
token10.SetTokenBod(tTwo.GetMember(4));
battleBoard.SetBodTokenToPosition(token10, 6, 0, true);
tokens.Add(token10);
}
StartBattle();
}
public void Knockback(Vector2 targetPos, int knockVal = 1)
{
Debug.Log("Knockback, Knock Val: " + knockVal);
int diffX = Mathf.Abs(activeToken.posX - (int)targetPos.x);
int diffY = Mathf.Abs(activeToken.posY - (int)targetPos.y);
BodToken token = battleBoard.tokenPositions[(int)targetPos.x, (int)targetPos.y];
Vector2 knockbackPos = Vector2.zero;
// Resolve equal diffs
if (diffX == diffY)
{
Debug.Log("rolling for random diff");
if (Random.Range(0, 2) == 0)
{
diffX++;
}
else
{
diffY++;
}
}
Debug.Log("Diff X: " + diffX + ", Diff Y: " + diffY);
if (diffX > diffY)
{
Debug.Log("Horizontal");
// Horizontal move
if (activeToken.posX > (int)targetPos.x)
{
// Kockback left
if (targetPos.x > 0 && battleBoard.tokenPositions[((int)targetPos.x - 1), (int)targetPos.y] == null)
{
knockbackPos = new Vector2((targetPos.x - 1), targetPos.y);
}
else
{
Debug.Log("Hit something!");
}
}
else
{
// Knockback right
if (targetPos.x < (battleBoard.dimensionX - 1) && battleBoard.tokenPositions[((int)targetPos.x + 1), (int)targetPos.y] == null)
{
knockbackPos = new Vector2((targetPos.x + 1), targetPos.y);
}
else
{
Debug.Log("Hit something!");
}
}
}
else
{
Debug.Log("Vertical");
// Veritical move
if (activeToken.posY > (int)targetPos.y)
{
// Knockback up
if (targetPos.y > 0 && battleBoard.tokenPositions[(int)targetPos.x, ((int)targetPos.y - 1)] == null)
{
knockbackPos = new Vector2(targetPos.x, (targetPos.y - 1));
}
else
{
Debug.Log("Hit something!");
}
}
else
{
// Knockback down
if (targetPos.y < (battleBoard.dimensionY - 1) && battleBoard.tokenPositions[(int)targetPos.x, ((int)targetPos.y + 1)] == null)
{
knockbackPos = new Vector2(targetPos.x, (targetPos.y + 1));
}
else
{
Debug.Log("Hit something!");
}
}
}
if (knockbackPos != Vector2.zero)
{
Debug.Log("Setting Knockback position");
MoveToken(token, knockbackPos);
}
}
