public void SacerdotistSkills(int skill, CharacterBattle target)
{
switch (skill)
{
case 0:
activeCharacterBattle.Attack(target, () => {
ChooseNextActiveCharacter();
});
break;
case 1:
activeCharacterBattle.HollyWater(getMinimumHealth(), () =>
{
ChooseNextActiveCharacter();
});
break;
case 2:
activeCharacterBattle.PreciseShot(target, () =>
{
ChooseNextActiveCharacter();
});
break;
case 3:
activeCharacterBattle.Smoke(enemyCharacterBattle, () =>
{
ChooseNextActiveCharacter();
});
break;
default:
break;
}
}
public void LethalThreat(CharacterBattle targetCharacterBattle, Action onAttackComplete)
{
Vector3 slideTargetPosition = (targetCharacterBattle.GetPosition() + (GetPosition() - targetCharacterBattle.GetPosition()).normalized * 10f) + new Vector3(30, 0);
Vector3 startingPosition = GetPosition();
string LoginScreen = CharStats.name + " uses Lethal Threat on " + targetCharacterBattle.CharStats.name;
TextScript.Create(new Vector3(-50, -40), LoginScreen, 45, true);
foreach (ParticleSystem ps in particles)
{
if (ps.name == "Dash")
{
toDestroy = Instantiate(ps, this.transform).gameObject;
}
}
// Slide to Target
going = true;
SlideToPosition(slideTargetPosition, () => {
// Arrived at Target, attack him
state = State.Busy;
targetCharacterBattle.Damage(this, CharStats.Damage);
SlideToPosition(startingPosition, () =>
{
// Slide back completed, back to idle
state = State.Idle;
onAttackComplete();
});
}, "JabMelee2H");
}
public void BlindingDart(CharacterBattle targetCharacterBattle, Action onAttackComplete)
{
int blindDuration = 0;
if (CharStats.Level < 9)
{
blindDuration = 2;
}
else if (CharStats.Level < 10)
{
blindDuration = 3;
}
else
{
blindDuration = 4;
}
targetCharacterBattle.CharStats.Blinded = true;
targetCharacterBattle.CharStats.BlindDuration = blindDuration;
int damageAmount = CharStats.Damage / 6;
targetCharacterBattle.Damage(this, damageAmount);
onAttackComplete();
}
// defines the damage done and does attack
public void Attack(CharacterBattle targetCharacterBattle, Action onAttackComplete)
{
Vector3 slideTargetPosition = targetCharacterBattle.GetPosition() + (GetPosition() - targetCharacterBattle.GetPosition()).normalized * 10f;
Vector3 startingPosition = GetPosition();
// Slide to Target
SlideToPosition(slideTargetPosition, () => {
// Arrived at Target, attack him
state = State.Busy;
Vector3 attackDir = (targetCharacterBattle.GetPosition() - GetPosition()).normalized;
characterBase.PlayAnimAttack(attackDir, () => {
// Target hit
int crit = UnityEngine.Random.Range(1, 100);
if (crit < 95)
{
int damageAmount = 1 + upgradedamagevalue;
targetCharacterBattle.Damage(this, damageAmount);
}
else
{
int damageAmount = UnityEngine.Random.Range(7, 8) + upgradedamagevalue;
targetCharacterBattle.Damage(this, damageAmount);
}
// targetCharacterBattle.Damage(this, damageAmount);
}, () => {
// Attack completed, slide back
SlideToPosition(startingPosition, () => {
// Slide back completed, back to idle
state = State.Idle;
characterBase.PlayAnimIdle(attackDir);
onAttackComplete();
});
});
});
}
private void RefreshSelectedTargetCharacterBattle()
{
if (selectedTargetCharacterBattle != null && selectedTargetCharacterBattle.IsDead())
{
selectedTargetCharacterBattle.HideSelectionCircle();
selectedTargetCharacterBattle = null;
}
if (selectedTargetCharacterBattle == null)
{
// Select next valid target
List <CharacterBattle> characterBattleList = GetAliveTeamCharacterBattleList(false);
if (characterBattleList.Count == 0)
{
// No more targets available
return;
}
else
{
// There are still targets available
CharacterBattle newTargetCharacterBattle =
characterBattleList[Random.Range(0, characterBattleList.Count)];
SetSelectedTargetCharacterBattle(newTargetCharacterBattle);
}
}
else
{
SetSelectedTargetCharacterBattle(selectedTargetCharacterBattle);
}
}
// Start is called before the first frame update
private void Start()
{
playerCharacterBattle = SpawnCharacter(playerCharacter, true);
enemyCharacterBattle = SpawnCharacter(enemyCharacter, false);
state = State.WaitingForPlayer;
}
public void WarriorSkills(int skill, CharacterBattle target)
{
switch (skill)
{
case 0:
activeCharacterBattle.Attack(currentTarget, () => {
ChooseNextActiveCharacter();
});
state = State.Busy;
break;
case 1:
activeCharacterBattle.Camouflage(() => {
ChooseNextActiveCharacter();
});
state = State.Busy;
break;
case 2:
activeCharacterBattle.Slice(currentTarget, () => {
ChooseNextActiveCharacter();
});
state = State.Busy;
break;
default:
break;
}
}
public void MonkSkills(int skill, CharacterBattle target)
{
switch (skill)
{
case 0:
activeCharacterBattle.Attack(target, () => {
ChooseNextActiveCharacter();
});
break;
case 1:
activeCharacterBattle.PurifyingStrike(enemyCharacterBattle, () => {
ChooseNextActiveCharacter();
});
break;
case 2:
activeCharacterBattle.LethalThreat(target, () => {
ChooseNextActiveCharacter();
});
break;
case 3:
activeCharacterBattle.SheerWill(() => {
ChooseNextActiveCharacter();
});
break;
default:
break;
}
}
public void StartScene()
{
playerVsBoot = info.PlayerVsBot;
currentScene = SceneStatus.Battle;
for (int i = 0; i < 3; i++)
{
playerCharacterBattle.Add(SpawnCharacter(true, Player[IndexCreatorPlayers]));
enemyCharacterBattle.Add(SpawnCharacter(false, Enemy[(int)info.EnemyList[i]]));
QueueOfCharacterBattles.Add(playerCharacterBattle[i]);
QueueOfCharacterBattles.Add(enemyCharacterBattle[i]);
}
//QueueOfCharacterBattles.Sort(SortBySpeed);
//playerCharacterBattle = SpawnCharacter(true, Player);
//enemyCharacterBattle = SpawnCharacter(false,Enemy);
SetActiveCharacterBattle(QueueOfCharacterBattles[0]);
currentTarget = enemyCharacterBattle[Random.Range(0, enemyCharacterBattle.Count)];
currentTarget.EnableCursor();
if (activeCharacterBattle.isPlayerTeam)
{
state = State.WaitingForPlayer;
}
else
{
state = State.Busy;
}
UI_Menu.SetActive(false);
UIinBattle.SetActive(true);
}
// Checks with player is doing damage and minus the damage done from the other players health
public void Damage(CharacterBattle attacker, int damageAmount)
{
healthSystem.Damage(damageAmount);
// CodeMonkey.CMDebug.TextPopup("health " + healthSystem.GetHealthAmount(), GetPosition());
Vector3 dirFromAttacker = (GetPosition() - attacker.GetPosition()).normalized;
if (isPlayerTeam)
{
GameObject.FindGameObjectWithTag("P1Life").GetComponent <Health>().health -= damageAmount;
}
else
{
GameObject.FindGameObjectWithTag("P2Life").GetComponent <Health>().health -= damageAmount;
}
DamagePopup.Create(GetPosition(), damageAmount, false);
characterBase.SetColorTint(new Color(1, 0, 0, 1f));
Blood_Handler.SpawnBlood(GetPosition(), dirFromAttacker);
if (healthSystem.IsDead())
{
// Died
Debug.Log("level" + " " + level + " " + "complete");
}
}
public void ToAttack(Stats.CharacterClass charclass, CharacterBattle target)
{
int indexSkill = RandomizeAttack();
switch (charclass)
{
case Stats.CharacterClass.None:
break;
case Stats.CharacterClass.Monk:
MonkSkills(indexSkill, target);
break;
case Stats.CharacterClass.Warrior:
WarriorSkills(indexSkill, target);
break;
case Stats.CharacterClass.Sacerdotist:
SacerdotistSkills(indexSkill, target);
break;
case Stats.CharacterClass.Enemy:
//only to Test
activeCharacterBattle.Attack(target, () => {
ChooseNextActiveCharacter();
});
break;
default:
break;
}
}
public CharacterBattle getMinimumHealth()
{
if (activeCharacterBattle.isPlayerTeam)
{
CharacterBattle temp = new CharacterBattle();
foreach (CharacterBattle pt in playerCharacterBattle)
{
if (temp.Health < pt.Health)
{
temp = pt;
}
}
return(temp);
}
else
{
CharacterBattle temp = new CharacterBattle();
foreach (CharacterBattle et in enemyCharacterBattle)
{
if (temp.Health < et.Health)
{
temp = et;
}
}
return(temp);
}
}
private void Update()
{
if (TestBattleOver())
{
return;
}
if (currentScene == SceneStatus.Battle)
{
if (playerVsBoot)
{
ClickOnObjective();
if (state == State.WaitingForPlayer)
{
if (Input.GetKeyDown(KeyCode.G))
{
currentTarget = enemyCharacterBattle[Random.Range(0, enemyCharacterBattle.Count)];
state = State.Busy;
ToAttack(activeCharacterBattle.charclass, currentTarget);
}
}
}
else
{
if (state == State.WaitingForPlayer)
{
currentTarget = enemyCharacterBattle[Random.Range(0, enemyCharacterBattle.Count)];
state = State.Busy;
ToAttack(activeCharacterBattle.charclass, currentTarget);
}
}
}
}
private CharacterBattle GetNextCharacterBattle(LanePosition lanePosition, bool moveUp, bool isPlayerTeam)
{
List <CharacterBattle> characterBattleList = GetAliveTeamCharacterBattleList(isPlayerTeam);
if (characterBattleList.Count == 0)
{
return(null);
}
CharacterBattle characterBattle = null;
do
{
// Get next lane position
lanePosition = GetNextLanePosition(lanePosition, moveUp);
// Find character at that position
characterBattle = GetCharacterBattleAt(lanePosition, isPlayerTeam);
if (characterBattle != null && characterBattle.IsDead())
{
characterBattle = null; // Ignore dead
}
} while (characterBattle == null);
return(characterBattle);
}
private float ArcherSKill1(CharacterBattle character)
{
CharacterBattle enemy = battleManager.GetFrontCharacter(character.tag);
enemy.GetDamage((int)(character.Damage * archerSkill1Multiply), true);
return(archerSKill1Cooldown);
}
/// <summary>
/// attack function
/// call when player is attacking
/// </summary>
/// <param name="targetCharacter"></param>
/// <param name="onAttackComplete"></param>
public void Attack(CharacterBattle targetCharacter, Action onAttackComplete)
{
Vector3 slideTargetPosition = targetCharacter.GetPosition() + (GetPosition() - targetCharacter.GetPosition()).normalized * 10f; //get target`s position
Vector3 startingPos = GetPosition(); //get start pos
anim.SetBool("Move", true); //start moving animation
///call sliding function
SlideToPosition(targetCharacter.GetPosition(), () =>
{
state = State.Busy; //change state to busy
if (targetCharacter.CompareTag("Enemy")) //check tag to enemy
{
targetCharacter.Damage(GameManager.Instance.playerDamage); //take damage
}
else if (targetCharacter.CompareTag("Player")) //check tag to player
{
targetCharacter.Damage(random.Next(5, 10)); //take damage
GameManager.Instance.Health -= random.Next(5, 10);
print(GameManager.Instance.Health);
}
//slide back to starting pos
SlideToPosition(startingPos, () =>
{
anim.SetBool("Move", false); //stop moving anim
state = State.Idle; //change state to idle
onAttackComplete(); //call action
});
});
}
public void SetTargetCharacter(CharacterBattle characterBattle)
{
audioSource.PlayOneShot(selectionChangedAudioClip);
targetPosition = characterBattle.transform.position;
targetPosition.y += 5;
}
public static void SpawnCharacter(Character.Type characterType, BattleHandler.LanePosition lanePosition, bool isPlayerTeam, Character.Stats stats)
{
Transform characterTransform = Object.Instantiate(GameAssets.i.pfCharacterBattle, GetPosition(lanePosition, isPlayerTeam), Quaternion.identity);
CharacterBattle characterBattle = characterTransform.GetComponent <CharacterBattle>();
characterBattle.Setup(characterType, lanePosition, GetPosition(lanePosition, isPlayerTeam), isPlayerTeam, stats);
instance.characterBattleList.Add(characterBattle);
}
IEnumerator Regeneration(CharacterBattle character)
{
tankSKill2RegenValue = (int)(character.GetMaxHP() * 2 / 100);
character.AddRegeneration(tankSKill2RegenValue);
yield return(new WaitForSeconds(tankSkill2Duration));
character.AddRegeneration(-tankSKill2RegenValue);
}
//Spawing Characters and setting states and activeplayers
private void Start()
{
playerCharacterBattle = SpawnCharacter(true);
enemyCharacterBattle = SpawnCharacter(false);
SetActiveCharacterBattle(playerCharacterBattle);
state = State.WaitingForPlayer;
}
private void SetSelectedTargetCharacterBattle(CharacterBattle characterBattle)
{
if (selectedTargetCharacterBattle != null)
{
selectedTargetCharacterBattle.HideSelectionCircle();
}
selectedTargetCharacterBattle = characterBattle;
selectedTargetCharacterBattle.ShowSelectionCircle(new Color(1, 0, 0, 1));
}
private void SetActiveCharacterBattle(CharacterBattle characterBattle)
{
if (activeCharacterBattle != null)
{
activeCharacterBattle.HideSelectionCircle();
}
activeCharacterBattle = characterBattle;
activeCharacterBattle.ShowSelectionCircle();
}
private void HandleEnemiesTurn()
{
CharacterBattle attackingEnemy = ChooseAttackingEnemy();
CharacterBattle attackedHero = ChooseAttackedHero();
state = State.Busy;
attackingEnemy.Attack(attackedHero, () => {
OnEnemyAttackComplete(attackingEnemy);
});
}
private void Update()
{
healthPotionAmountText.text = GameData.healthPotionCount.ToString();
healthPotionBlocker.gameObject.SetActive(GameData.healthPotionCount <= 0);
CharacterBattle characterBattle = BattleHandler.GetInstance().GetActiveCharacterBattle();
specialAmountText.text = characterBattle.GetSpecial().ToString();
specialAmountText.gameObject.SetActive(characterBattle.GetSpecial() > 0);
specialBlocker.gameObject.SetActive(characterBattle.GetSpecial() > 0);
}
public void PopulateList(string tag, CharacterBattle hero)
{
if (tag == "Player")
{
playerCharacters.Add(hero);
}
else
{
enemiesCharacters.Add(hero);
}
}
// 敵の攻撃処理
public void EnemyAttack(GameObject character)
{
CharacterBattle characterBattleScript = character.GetComponent <CharacterBattle>();
BaseStatus characterStatus = characterBattleScript.GetCharacterStatus();
if (characterStatus.GetSkillList().Count <= 0)
{
return;
}
// 敵の行動アルゴリズム
int randomValue = (int)(Random.value * characterStatus.GetSkillList().Count);
var nowSkill = characterStatus.GetSkillList()[randomValue];
// テスト用（特定のスキルで確認）
//nowSkill = characterStatus.GetSkillList()[0];
if (nowSkill.GetSkillType() == Skill.Type.DirectAttack)
{
var targetNum = (int)(Random.value * allyCharacterInBattleList.Count);
// 攻撃相手のCharacterBattleScript
characterBattleScript.ChooseAttackOptions(CharacterBattle.BattleState.DirectAttack, allyCharacterInBattleList[targetNum], nowSkill);
}
else if (nowSkill.GetSkillType() == Skill.Type.MagicAttack)
{
var targetNum = (int)(Random.value * allyCharacterInBattleList.Count);
if (characterBattleScript.GetMp() >= ((Magic)nowSkill).GetAmountToUseMagicPoints())
{
// 攻撃相手のCharacterBattleScript
characterBattleScript.ChooseAttackOptions(CharacterBattle.BattleState.MagicAttack, allyCharacterInBattleList[targetNum], nowSkill);
}
else
{
// MPが足りない場合は直接攻撃を行う
ShowMessage("MPが足りない!");
characterBattleScript.ChooseAttackOptions(CharacterBattle.BattleState.DirectAttack, allyCharacterInBattleList[targetNum], characterStatus.GetSkillList().Find(skill => skill.GetSkillType() == Skill.Type.DirectAttack));
}
}
else if (nowSkill.GetSkillType() == Skill.Type.RecoveryMagic)
{
if (characterBattleScript.GetMp() >= ((Magic)nowSkill).GetAmountToUseMagicPoints())
{
var targetNum = (int)(Random.value * enemyCharacterInBattleList.Count);
// 回復相手のCharacterBattleScript
characterBattleScript.ChooseAttackOptions(CharacterBattle.BattleState.Healing, enemyCharacterInBattleList[targetNum], nowSkill);
}
else
{
ShowMessage("MPが足りない!");
var targetNum = (int)(Random.value * allyCharacterInBattleList.Count);
// MPが足りない場合は直接攻撃を行う
characterBattleScript.ChooseAttackOptions(CharacterBattle.BattleState.DirectAttack, allyCharacterInBattleList[targetNum], characterStatus.GetSkillList().Find(skill => skill.GetSkillType() == Skill.Type.DirectAttack));
}
}
}
private void Awake()
{
instance = this;
playerBase = gameObject.GetComponent <Player_Base>();
material = transform.Find("Body").GetComponent <MeshRenderer>().material;
materialTintColor = new Color(1, 0, 0, 0);
selectionCircleTransform = transform.Find("SelectionCircle");
attackUnitAnimType = GameAssets.UnitAnimTypeEnum.dSwordTwoHandedBack_Sword;
HideSelectionCircle();
SetStateIdle();
}
private void Start()
{
AllyBattle3 = SpawnCharacter(true);
AllyBattle2 = SpawnCharacter(true);
AllyBattle1 = SpawnCharacter(true);
enemyBattle = SpawnCharacter(false);
enemy2Battle = SpawnCharacter(false);
enemy3Battle = SpawnCharacter(false);
SetActiveCharacterBattle(AllyBattle1);
selectedEnemy = enemy3Battle;
selectedEnemy.ShowArrow();
allyTarget = AllyBattle1;
enemyTarget = enemyBattle;
state = State.WaitingForPlayer;
//Ally1
AllyBattle1.Originaldamagemin = AllyBattle1.damagemin;
AllyBattle1.Originaldamagemax = AllyBattle1.damagemax;
AllyBattle1.Originalhealmax = AllyBattle1.healmax;
AllyBattle1.Originalhealmin = AllyBattle1.healmin;
AllyBattle1.OriginalhealthMax = AllyBattle1.healthMax;
//Ally2
AllyBattle2.Originaldamagemin = AllyBattle2.damagemin;
AllyBattle2.Originaldamagemax = AllyBattle2.damagemax;
AllyBattle2.Originalhealmax = AllyBattle2.healmax;
AllyBattle2.Originalhealmin = AllyBattle2.healmin;
AllyBattle2.OriginalhealthMax = AllyBattle2.healthMax;
//Ally3
AllyBattle3.Originaldamagemin = AllyBattle3.damagemin;
AllyBattle3.Originaldamagemax = AllyBattle3.damagemax;
AllyBattle3.Originalhealmax = AllyBattle3.healmax;
AllyBattle3.Originalhealmin = AllyBattle3.healmin;
AllyBattle3.OriginalhealthMax = AllyBattle3.healthMax;
//Enemy1
enemyBattle.Originaldamagemin = enemyBattle.damagemin;
enemyBattle.Originaldamagemax = enemyBattle.damagemax;
enemyBattle.Originalhealmax = enemyBattle.healmax;
enemyBattle.Originalhealmin = enemyBattle.healmin;
enemyBattle.OriginalhealthMax = enemyBattle.healthMax;
//Enemy2
enemy2Battle.Originaldamagemin = enemy2Battle.damagemin;
enemy2Battle.Originaldamagemax = enemy2Battle.damagemax;
enemy2Battle.Originalhealmax = enemy2Battle.healmax;
enemy2Battle.Originalhealmin = enemy2Battle.healmin;
enemy2Battle.OriginalhealthMax = enemy2Battle.healthMax;
//Enemy3
enemy3Battle.Originaldamagemin = enemy3Battle.damagemin;
enemy3Battle.Originaldamagemax = enemy3Battle.damagemax;
enemy3Battle.Originalhealmax = enemy3Battle.healmax;
enemy3Battle.Originalhealmin = enemy3Battle.healmin;
enemy3Battle.OriginalhealthMax = enemy3Battle.healthMax;
}
public void Damage(CharacterBattle attacker, int damageAmount)
{
//damageAmount = 1; Debug.Log("##### No Damage");
Vector3 bloodDir = (GetPosition() - attacker.GetPosition()).normalized;
Blood_Handler.SpawnBlood(GetPosition(), bloodDir);
SoundManager.PlaySound(SoundManager.Sound.CharacterDamaged);
DamagePopup.Create(GetPosition(), damageAmount, false);
healthSystem.Damage(damageAmount);
DamageFlash();
playerBase.GetUnitAnimation().PlayAnimForced(hitUnitAnimType, GetTargetDir(), 1f, (UnitAnim unitAnim) => {
PlayIdleAnim();
}, null, null);
if (IsDead())
{
if (!IsPlayerTeam())
{
// Enemy
if (characterType != Character.Type.EvilMonster && characterType != Character.Type.EvilMonster_2 && characterType != Character.Type.EvilMonster_3)
{
// Don't spawn Flying Body for Evil Monster
FlyingBody.Create(GameAssets.i.pfEnemyFlyingBody, GetPosition(), bloodDir);
SoundManager.PlaySound(SoundManager.Sound.CharacterDead);
}
gameObject.SetActive(false);
}
else
{
// Player Team
stats.special = 0;
SoundManager.PlaySound(SoundManager.Sound.OooohNooo);
}
playerBase.GetUnitAnimation().PlayAnimForced(UnitAnim.GetUnitAnim("LyingUp"), 1f, null);
healthWorldBar.Hide();
transform.localScale = new Vector3(-1, 1, 1);
//gameObject.SetActive(false);
//Destroy(gameObject);
}
else
{
// Knockback
/*
* transform.position += bloodDir * 5f;
* if (hitUnitAnim != null) {
* state = State.Busy;
* enemyBase.PlayHitAnimation(bloodDir * (Vector2.one * -1f), SetStateNormal);
* }
*/
}
}
// Start is called before the first frame update
protected virtual void Start()
{
ThisEntity = GetComponent <CharacterBattle>();
currentState = TurnState.PROCESSING;
BSM = FindObjectOfType <BattleStateMachine>();
startposition = transform.position;
currentCooldown = Random.Range(0, 2.5f);
Selector = this.gameObject.transform.Find("Selector").gameObject;
HandCursor = this.gameObject.transform.Find("HandCursor").gameObject;
Selector.SetActive(false);
HandCursor.SetActive(false);
}