public virtual void InitialiseHealth(ComputerLane computerlane)
{
entityLocation = Camera.main.WorldToScreenPoint(gameObject.transform.position);
if(isServer) {
// if max heath isnt set, as can be set by later function
currentHealth = maxHealth;
percentOfHealth = currentHealth / maxHealth;
healthBarLength = percentOfHealth * healthBarInitialLength;
damageText = gameObject.GetComponent<DamageText>();
damageText.InitialiseDamageText(computerlane);
}
}
public void Repair(float repairAmount)
{
if (integrity == maxIntegrity)
{
return;
}
repairProgress += repairAmount;
int pointsRepaired = 0;
while (repairProgress >= 1f && integrity < maxIntegrity)
{
repairProgress -= 1f;
integrity++;
pointsRepaired++;
}
if (pointsRepaired > 0)
{
DamageText.ShowHealText(gameObject, pointsRepaired);
SetMaterialForDurability();
}
}
public virtual void TakeDamage(float damage, bool isCriticalHit)
{
if (currentHealth - damage > 0)
{
currentHealth = Mathf.Max(currentHealth - damage, 0);
FlashRed();
GameObject dt = (GameObject)Instantiate(damageTextPrefab, this.gameObject.transform.position + Vector3.up * this.gameObject.transform.localScale.y / 2, Camera.main.transform.rotation);
DamageText script = dt.gameObject.GetComponent <DamageText>();
if (isCriticalHit)
{
script.SetColor(Color.blue);
}
script.SetText(Mathf.Round(damage).ToString());
}
else
{
Die();
}
UpdateHealthUI();
}
public void InitData(int i1, int i2, int i3, int i4, int i5, int i6,
int i7, int i8, Arrow ar, GameObject go, Animation anim,
GameObject contr, DamageText t1, DamageText t2,
DamageTexture tx1, DamageTexture tx2)
{
team = i1;
count = i2;
MinDamage = i3;
MaxDamage = i4;
defaultHealth = i5;
currentHealth = i6;
Speed = i7;
Initiative = i8;
arrow = ar;
animation = anim;
gameObject = go;
controller = contr;
HealthDecText = t1;
UnitsDecText = t2;
HealthDecTexture = tx1;
UnitsDecTexture = tx2;
}
public void Damage(int dmg, GameObject eff, Character source)
{
if (gM.GameOver == true)
{
return;
}
health -= dmg;
Vector3 pos = transform.position;
pos.y = 3;
GameObject obj = Instantiate(gM.prefabList[0]);
obj.transform.position = pos;
DamageText dT = obj.GetComponent <DamageText>();
dT.txt.text = "-" + dmg;
dT.lifeTime = 1.5f;
obj = Instantiate(eff);
obj.transform.position = pos;
Destroy(obj, 1);
if (health <= 0)
{
health = 0;
pos = gM.graveyard.transform.position;
transform.position = pos;
Tile t = tilePos.GetComponent <Tile>();
t.refChar = null;
gM.CheckState(this);
}
foreach (Player p in gM.playerList)
{
p.pP.UpdatePanel();
}
}
public int Team; // 0 = player , 1 = Ennemy
void OnTriggerEnter(Collider OtherCollider)
{
Entity TrigEntity = OtherCollider.GetComponent <Entity>();
if (TrigEntity == null)
{
return;
}
if (Team != TrigEntity.GetTeam)
{
Attacker.OnHit(TrigEntity);
int damagedone = TrigEntity.ReceiveAttack(damageOnTouch, Attacker);
GameObject DamageHit = new GameObject("Damage Hit");
DamageHit.transform.SetParent(GameObject.Find("Canvas").transform);
DamageText Script = DamageHit.AddComponent <DamageText>();
Script.Init(damagedone, OtherCollider.transform.position);
//Create Hit
}
}
public void AddDamageText(Vector2 pos, int damage, bool critical)
{
if (damagePoolCount <= 0)
{
NewDamageText(pos, damage, critical);
}
else
{
Transform d = damageTextPool[damagePoolCount - 1];
damageTextPool[damagePoolCount - 1] = null;
damagePoolCount--;
DamageText txt = d.GetComponent <DamageText>();
if (txt != null)
{
txt.SetDamage(pos, damage, critical);
}
else
{
Debug.LogError("BattleInfo.AddDamageText >> no DamageText component");
}
}
}
protected void DamageTextVisible(int damageAmount, SPECIAL_DAMAGE sd = SPECIAL_DAMAGE.NONE, CROWD_CONTROL cc = CROWD_CONTROL.NONE)
{
GameObject m_damageText = ObjectPoolManager.Instance.PopFromPool("DamageText");
DamageText damageTextScripte = m_damageText.GetComponent <DamageText>();
m_damageText.SetActive(true);
if (cc == CROWD_CONTROL.STUN)
{
damageTextScripte.damageAmount = damageAmount.ToString() + "\n[888888]스턴[-]";
}
else if (cc == CROWD_CONTROL.STUN_IMMUNE)
{
damageTextScripte.damageAmount = damageAmount.ToString() + "\n[888888]스턴 면역[-]";
}
else if (cc == CROWD_CONTROL.BACK_ATTACK)
{
damageTextScripte.damageAmount = damageAmount.ToString() + "\n[ff0000]백어택[-]";
}
else
{
damageTextScripte.damageAmount = damageAmount.ToString();
}
if (sd == SPECIAL_DAMAGE.CRITICAL)
{
damageTextScripte.damageAmount = damageAmount.ToString() + "[ff0000]크리티컬[-]";
}
else if (sd == SPECIAL_DAMAGE.BACK_ATTACK)
{
damageTextScripte.damageAmount = damageAmount.ToString() + "[ff00ff]백어택[-]";
}
else if (sd == SPECIAL_DAMAGE.CRITICAL_BACK_ATTACK)
{
damageTextScripte.damageAmount = damageAmount.ToString() + "[ff0000]크리티컬 [ff00ff]백어택[-]";
}
damageTextScripte.targetTransform = transform.position;
}
//this is the final calculated value of damage
public void ReceiveDamage(float _damage)
{
DamageText damage_text = Instantiate(Resources.Load <DamageText>("Prefabs/DamageText"));
damage_text.transform.position = transform.position + new Vector3(0, 5, 0);
if (_damage < 0)
{
//miss
damage_text.SetText("MISS");
return;
}
int rounded_damage = Mathf.RoundToInt(_damage);
health -= rounded_damage;
damage_text.SetText("-" + rounded_damage.ToString());
Debug.Log(name + " took " + rounded_damage + " damage");
if (health <= 0)
{
Debug.Log(name + " fainted");
Delete();
}
}
// Message methods
/// <summary>
/// Handles the OnAttacked message
/// </summary>
/// <param name="attacker">The BaseFighter that attacked this GameObject</param>
void OnAttacked(object attacker)
{
// Make attacker a BaseFighter reference
BaseFighter attackerBF = attacker as BaseFighter;
// Sanity check: attacker should be a BaseFighter
if (attackerBF == null)
{
return;
}
// Grab the damage value
int attack = attackerBF.AttackStr;
// Instantiate a new DamageText with attack
GameObject newDamText = Instantiate(DTPreFab) as GameObject;
Canvas can = FindObjectOfType <Canvas> ();
newDamText.transform.SetParent(can.transform, false);
DamageText newText = newDamText.GetComponent <DamageText> ();
newText.Damage = attack; // Set Damage
newText.ChangePosition(gameObject);
}
public void HitDamage(InBattleUnit other)
{
// int damage = other.data.AttackFactor;
// int calculation = Mathf.Clamp(damage - data.DefenceFactor, 1, damage);
// HitPoints -= calculation;
//data.HitPoints = HitPoints;
int damage = other.data.AttackFactor;
int calculation = Mathf.Clamp(damage - data.DefenceFactor, 1, damage);
//--
int nFinalDmg = this.AdvantageState(calculation, other.unitType);
data.HitPoints -= nFinalDmg;
Debug.Log("HitDamage c= " + calculation + " fianl = " + nFinalDmg);
HitDamageAnimation(nFinalDmg);
DamageText dt = DamageTextPool.Instance.GetDamageText();
Vector3 pos = this.transform.position;
pos.y += 200;
dt.SetDamageText(pos, calculation, false, false, Color.red);
if (data.HitPoints <= 0)
{
data.Destroyed(other.data);
data.Cell.PlayerNumber = -1;
}
}
// Use this for initialization
void Start()
{
curretHeath = maxHealth;
damageText = GetComponentInChildren <DamageText>();
}
public virtual void TakeDamage(IAttackableUnit attacker, float damage, DamageType type, DamageSource source,
DamageText damageText)
{
float defense = 0;
float regain = 0;
var attackerStats = attacker.Stats;
switch (type)
{
case DamageType.DAMAGE_TYPE_PHYSICAL:
defense = Stats.Armor.Total;
defense = (1 - attackerStats.ArmorPenetration.PercentBonus) * defense -
attackerStats.ArmorPenetration.FlatBonus;
break;
case DamageType.DAMAGE_TYPE_MAGICAL:
defense = Stats.MagicPenetration.Total;
defense = (1 - attackerStats.MagicPenetration.PercentBonus) * defense -
attackerStats.MagicPenetration.FlatBonus;
break;
case DamageType.DAMAGE_TYPE_TRUE:
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
switch (source)
{
case DamageSource.DAMAGE_SOURCE_SPELL:
regain = attackerStats.SpellVamp.Total;
break;
case DamageSource.DAMAGE_SOURCE_ATTACK:
regain = attackerStats.LifeSteal.Total;
break;
case DamageSource.DAMAGE_SOURCE_SUMMONER_SPELL:
break;
case DamageSource.DAMAGE_SOURCE_PASSIVE:
break;
default:
throw new ArgumentOutOfRangeException(nameof(source), source, null);
}
//Damage dealing. (based on leagueoflegends' wikia)
damage = defense >= 0 ? 100 / (100 + defense) * damage : (2 - 100 / (100 - defense)) * damage;
ApiEventManager.OnUnitDamageTaken.Publish(this);
Stats.CurrentHealth = Math.Max(0.0f, Stats.CurrentHealth - damage);
if (!IsDead && Stats.CurrentHealth <= 0)
{
IsDead = true;
Die(attacker);
}
int attackerId = 0, targetId = 0;
// todo: check if damage dealt by disconnected players cause anything bad
if (attacker is IChampion attackerChamp)
{
attackerId = (int)_game.PlayerManager.GetClientInfoByChampion(attackerChamp).UserId;
}
if (this is IChampion targetChamp)
{
targetId = (int)_game.PlayerManager.GetClientInfoByChampion(targetChamp).UserId;
}
_game.PacketNotifier.NotifyDamageDone(attacker, this, damage, type, damageText,
_game.Config.IsDamageTextGlobal, attackerId, targetId);
// TODO: send this in one place only
_game.PacketNotifier.NotifyUpdatedStats(this, false);
// Get health from lifesteal/spellvamp
if (regain > 0)
{
attackerStats.CurrentHealth = Math.Min(attackerStats.HealthPoints.Total,
attackerStats.CurrentHealth + regain * damage);
// TODO: send this in one place only
_game.PacketNotifier.NotifyUpdatedStats(attacker, false);
}
}
public DamageDone(IAttackableUnit source, IAttackableUnit target, float amount, DamageType type, DamageText damageText)
: base(PacketCmd.PKT_S2C_DAMAGE_DONE, target.NetId)
{
Write((byte)damageText);
Write((short)((short)type << 8));
Write(amount);
WriteNetId(target);
WriteNetId(source);
}
public void TakeDamage(int damageAmount, ElementType hitElement)
{
PersistentGameManager pgMngr = FindObjectOfType <PersistentGameManager>();
// Modify damageAmount by resistance (via persistentgamemanager?)
damageAmount = PersistentGameManager.CalculateDamage(Element, hitElement, damageAmount);
EntityHUD myHud = GetComponentInChildren <EntityHUD>();
if (damageAmount > 0)
{
if (currentHP <= 0)
{
return;
}
GetComponentInChildren <HPBar>().UpdateBarForDamage(Mathf.Clamp(damageAmount, 0, currentHP));
if (shakeStrength <= 0)
{
StartCoroutine(ShowGotDamaged());
}
else
{
shakeStrength = startShakeStrength;
}
// Display damaged text
DamageText dmgText =
((GameObject)Instantiate(pgMngr.DamagedText,
myHud.transform.GetChild(0).position + Vector3.up,
pgMngr.DamagedText.transform.rotation)).GetComponent <DamageText>();
dmgText.elementType = hitElement;
dmgText.damageAmount = damageAmount;
}
else if (damageAmount < 0)
{
if (currentHP < MaxHP)
{
GetComponentInChildren <HPBar>().UpdateBarForHeal(Mathf.Clamp(-damageAmount, 0, MaxHP - currentHP));
// Display healed text
DamageText healText =
((GameObject)Instantiate(pgMngr.HealedText,
myHud.transform.GetChild(0).position + Vector3.up,
pgMngr.HealedText.transform.rotation)).GetComponent <DamageText>();
healText.elementType = hitElement;
healText.damageAmount = -damageAmount;
}
}
else
{
// Do Blocked
// Display blocked text
DamageText blockText =
((GameObject)Instantiate(pgMngr.BlockedText,
myHud.transform.GetChild(0).position + Vector3.up,
pgMngr.BlockedText.transform.rotation)).GetComponent <DamageText>();
blockText.elementType = hitElement;
return;
}
currentHP = Mathf.Clamp(currentHP - damageAmount, 0, MaxHP);
if (currentHP <= 0)
{
if (!hasDeathThrown && !InParty && Random.value < spareableChance)
{
++currentHP;
// DO THE DERP
StartCoroutine(BecomeSpareable());
hasDeathThrown = true;
}
else
{
Die();
}
}
}
void Awake()
{
staticMainCamera = mainCamera;
staticTextPrefab = textPrefab;
canvas = this.transform;
}
public DamageDone(AttackableUnit source, AttackableUnit target, float amount, DamageType type, DamageText damageText)
: base(PacketCmd.PKT_S2C_DamageDone, target.NetId)
{
buffer.Write((byte)damageText);
buffer.Write((short)((short)type << 8));
buffer.Write((float)amount);
buffer.Write((int)target.NetId);
buffer.Write((int)source.NetId);
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
currKeyState = Keyboard.GetState();
currGamePadState = GamePad.GetState(PlayerIndex.One);
if (currKeyState.IsKeyDown(Keys.Delete))
{
Exit();
}
if (gameState == GameState.MainMenu)
{
processMenuMove();
if (currentMenuChoice < 0)
{
currentMenuChoice = mainMenuMaxChoice - 1;
}
if (currentMenuChoice >= mainMenuMaxChoice)
{
currentMenuChoice = 0;
}
if (currKeyState.IsKeyDown(Keys.Space) && prevKeyState.IsKeyUp(Keys.Space) ||
currGamePadState.IsButtonDown(Buttons.A) && prevGamePadState.IsButtonUp(Buttons.A))
{
if (currentMenuChoice == 0)
{
gameState = GameState.Playing;
GameplayInitialize();
}
if (currentMenuChoice == 1)
{
graphics.IsFullScreen = !graphics.IsFullScreen;
graphics.ApplyChanges();
}
if (currentMenuChoice == 2)
{
Exit();
}
}
}
if (gameState == GameState.Playing)
{
if (!battle)
{
if (!paused)
{
if (prevGamePadState.IsButtonUp(Buttons.Start) && currGamePadState.IsButtonDown(Buttons.Start) ||
prevKeyState.IsKeyUp(Keys.Enter) && currKeyState.IsKeyDown(Keys.Enter))
{
paused = true;
currentMenuChoice = 0;
}
translation.X += player.currentSpeed;
player.Update(gameTime);
foreach (Enemy enemy in enemies)
{
enemy.Update(gameTime);
if (Math.Abs(player.loc.X + player.playerDimensions.X - enemy.loc.X) <= 5 &&
enemy.depth == player.currentDepth)
{
battle = true;
currentEnemy = enemies.IndexOf(enemy);
lastEnemyAtk = new GameTime(gameTime.TotalGameTime, gameTime.ElapsedGameTime);
lastPlayerAtk = new GameTime(gameTime.TotalGameTime, gameTime.ElapsedGameTime);
player.pState = Player.PlayerState.attacking;
player.ResetAnimations();
}
}
}
else
{
processMenuMove();
if (currentMenuChoice < 0)
{
currentMenuChoice = pauseMenuMaxChoice - 1;
}
if (currentMenuChoice >= pauseMenuMaxChoice)
{
currentMenuChoice = 0;
}
if (currKeyState.IsKeyDown(Keys.Space) && prevKeyState.IsKeyUp(Keys.Space) ||
currGamePadState.IsButtonDown(Buttons.A) && prevGamePadState.IsButtonUp(Buttons.A))
{
if (currentMenuChoice == 0)
{
paused = false;
}
if (currentMenuChoice == 1)
{
gameState = GameState.MainMenu;
currentMenuChoice = 0;
}
if (currentMenuChoice == 2)
{
Exit();
}
}
if (prevGamePadState.IsButtonUp(Buttons.Start) && currGamePadState.IsButtonDown(Buttons.Start) ||
prevKeyState.IsKeyUp(Keys.Enter) && currKeyState.IsKeyDown(Keys.Enter))
{
paused = false;
}
}
}
else
{
if (gameTime.TotalGameTime.TotalSeconds - lastEnemyAtk.TotalGameTime.TotalSeconds
>= enemies[currentEnemy].secondaryStats.atkSpeed)
{
enemies[currentEnemy].attackNum++;
player.secondaryStats.health -= enemies[currentEnemy].secondaryStats.attack;
lastEnemyAtk = new GameTime(gameTime.TotalGameTime, gameTime.ElapsedGameTime);
DamageText tempDamText = new DamageText();
tempDamText.pos = player.startLoc;
tempDamText.pos.X += 1;
tempDamText.pos.Y -= 20;
tempDamText.color = new Color(255, 0, 0, 255);
tempDamText.value = enemies[currentEnemy].secondaryStats.attack;
enemyDamageText.Add(tempDamText);
}
if (gameTime.TotalGameTime.TotalSeconds - lastPlayerAtk.TotalGameTime.TotalSeconds
>= player.secondaryStats.atkSpeed)
{
player.attackNum++;
enemies[currentEnemy].secondaryStats.health -= player.secondaryStats.attack;
lastPlayerAtk = new GameTime(gameTime.TotalGameTime, gameTime.ElapsedGameTime);
DamageText tempDamText2 = new DamageText();
tempDamText2.pos = player.startLoc;
tempDamText2.pos.X += 1;
tempDamText2.pos.Y -= 20;
tempDamText2.pos.X += 22;
tempDamText2.color = new Color(255, 0, 0, 255);
playerDamageText.Add(tempDamText2);
player.UpdateAttack();
}
if (enemies[currentEnemy].secondaryStats.health <= 0)
{
enemies.RemoveAt(currentEnemy);
battle = false;
player.pState = Player.PlayerState.walking;
player.attackNum = 0;
player.ResetAnimations();
playerDamageText.Clear();
enemyDamageText.Clear();
}
else
{
for (int x = 0; x < enemyDamageText.Count; x++)
{
DamageText temp = new DamageText();
temp.pos.X = enemyDamageText[x].pos.X;
temp.pos.Y = enemyDamageText[x].pos.Y - .2f;
temp.color = enemyDamageText[x].color;
temp.color.A -= 3;
if (temp.color.A < 3)
{
enemyDamageText.RemoveAt(x);
x--;
}
else
{
enemyDamageText[x] = temp;
}
}
for (int x = 0; x < playerDamageText.Count; x++)
{
DamageText temp = new DamageText();
temp.pos.X = playerDamageText[x].pos.X;
temp.pos.Y = playerDamageText[x].pos.Y - .2f;
temp.color = new Color(255, 0, 0, playerDamageText[x].color.A);
temp.color.A -= 3;
if (temp.color.A < 3)
{
playerDamageText.RemoveAt(x);
x--;
}
else
{
playerDamageText[x] = temp;
}
}
if (!player.BattleUpdate(gameTime))
{
Exit();
}
enemies[currentEnemy].BattleUpdate(gameTime);
}
}
}
prevKeyState = currKeyState;
prevGamePadState = currGamePadState;
base.Update(gameTime);
}
public static void ReturnObject(DamageText obj)
{
obj.gameObject.SetActive(false);
obj.transform.SetParent(Instance.transform);
Instance.poolingObjectQueue.Enqueue(obj);
}
void EnemyAttack()
{
enemyesCurrent[0].animator.Play("attack");
rHit = Random.Range(0, units.Count - 1);
bool targetIsDead = false;
List <TurnBase> enemyesOut = new List <TurnBase>();
foreach (TurnBase enemy in enemyes)
{
enemyesOut.Add(enemy);
}
List <TurnBase> unitsOut = new List <TurnBase>();
foreach (TurnBase unit in units)
{
unitsOut.Add(unit);
}
List <CombatResult> combatResults = Combat.Attack(enemyesCurrent[0], units[rHit], skillName, skillNameB, enemyesOut, unitsOut, skill_lvl);
for (int i = 0; i < combatResults.Count; i++)
{
TurnBase target = combatResults[i].target;
float damage = combatResults[i].damage;
target.general.PARAMS[GENERAL_HP_CURRENT] -= damage;
GameObject gt = Instantiate(ResManager.instance.DamageText, target.transform);
gt.transform.position = target.transform.parent.transform.localPosition;
DamageText dt = gt.GetComponent <DamageText>();
dt.startMitonUnit("-" + damage, Colors.RedColor);
if (target.general.PARAMS[GENERAL_HP_CURRENT] > 0)
{
target.animator.Play("hart");
if (target.general.PARAMS[GENERAL_HP_CURRENT] > target.general.PARAMS[GENERAL_HP] / 4 * 3) //75+%
{
target.text.color = Colors.GreenColor;
}
else if (target.general.PARAMS[GENERAL_HP_CURRENT] < target.general.PARAMS[GENERAL_HP] / 4 * 3 && target.general.PARAMS[GENERAL_HP_CURRENT] > target.general.PARAMS[GENERAL_HP] / 2) //50% + /75%-
{
target.text.color = Colors.YellowColor;
}
else if (target.general.PARAMS[GENERAL_HP_CURRENT] < target.general.PARAMS[GENERAL_HP] / 2 && target.general.PARAMS[GENERAL_HP_CURRENT] > target.general.PARAMS[GENERAL_HP] / 4) //25%+ / 50%-
{
target.text.color = Colors.Orange;
}
else if (target.general.PARAMS[GENERAL_HP_CURRENT] < target.general.PARAMS[GENERAL_HP] / 4 && target.general.PARAMS[GENERAL_HP_CURRENT] > 0) //0+ / 25-
{
target.text.color = Colors.RedColor;
}
target.text.text = target.general.PARAMS[GENERAL_HP_CURRENT].ToString();
}
else
{
targetIsDead = true;
}
}
skillName = SkillName.none;
skillNameB = SkillNameB.none;
skill_lvl = 0;
if (targetIsDead)
{
Invoke("EnemyAttackDelay", 3f);
}
else
{
Invoke("EnemyAttackDelay", 1f);
}
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Update(GameTime gameTime)
{
currKeyState = Keyboard.GetState();
currGamePadState = GamePad.GetState(PlayerIndex.One);
if (currKeyState.IsKeyDown(Keys.Delete))
Exit();
if (gameState == GameState.MainMenu)
{
processMenuMove();
if (currentMenuChoice < 0)
currentMenuChoice = mainMenuMaxChoice - 1;
if (currentMenuChoice >= mainMenuMaxChoice)
currentMenuChoice = 0;
if (currKeyState.IsKeyDown(Keys.Space) && prevKeyState.IsKeyUp(Keys.Space) ||
currGamePadState.IsButtonDown(Buttons.A) && prevGamePadState.IsButtonUp(Buttons.A))
{
if (currentMenuChoice == 0)
{
gameState = GameState.Playing;
GameplayInitialize();
}
if (currentMenuChoice == 1)
{
graphics.IsFullScreen = !graphics.IsFullScreen;
graphics.ApplyChanges();
}
if (currentMenuChoice == 2)
{
Exit();
}
}
}
if (gameState == GameState.Playing)
{
if (!battle)
{
if (!paused)
{
if (prevGamePadState.IsButtonUp(Buttons.Start) && currGamePadState.IsButtonDown(Buttons.Start) ||
prevKeyState.IsKeyUp(Keys.Enter) && currKeyState.IsKeyDown(Keys.Enter))
{
paused = true;
currentMenuChoice = 0;
}
translation.X += player.currentSpeed;
player.Update(gameTime);
foreach (Enemy enemy in enemies)
{
enemy.Update(gameTime);
if (Math.Abs(player.loc.X + player.playerDimensions.X - enemy.loc.X) <= 5
&& enemy.depth == player.currentDepth)
{
battle = true;
currentEnemy = enemies.IndexOf(enemy);
lastEnemyAtk = new GameTime(gameTime.TotalGameTime, gameTime.ElapsedGameTime);
lastPlayerAtk = new GameTime(gameTime.TotalGameTime, gameTime.ElapsedGameTime);
player.pState = Player.PlayerState.attacking;
player.ResetAnimations();
}
}
}
else
{
processMenuMove();
if (currentMenuChoice < 0)
currentMenuChoice = pauseMenuMaxChoice - 1;
if (currentMenuChoice >= pauseMenuMaxChoice)
currentMenuChoice = 0;
if (currKeyState.IsKeyDown(Keys.Space) && prevKeyState.IsKeyUp(Keys.Space) ||
currGamePadState.IsButtonDown(Buttons.A) && prevGamePadState.IsButtonUp(Buttons.A))
{
if (currentMenuChoice == 0)
{
paused = false;
}
if (currentMenuChoice == 1)
{
gameState = GameState.MainMenu;
currentMenuChoice = 0;
}
if (currentMenuChoice == 2)
{
Exit();
}
}
if (prevGamePadState.IsButtonUp(Buttons.Start) && currGamePadState.IsButtonDown(Buttons.Start) ||
prevKeyState.IsKeyUp(Keys.Enter) && currKeyState.IsKeyDown(Keys.Enter))
{
paused = false;
}
}
}
else
{
if (gameTime.TotalGameTime.TotalSeconds - lastEnemyAtk.TotalGameTime.TotalSeconds
>= enemies[currentEnemy].secondaryStats.atkSpeed)
{
enemies[currentEnemy].attackNum++;
player.secondaryStats.health -= enemies[currentEnemy].secondaryStats.attack;
lastEnemyAtk = new GameTime(gameTime.TotalGameTime, gameTime.ElapsedGameTime);
DamageText tempDamText = new DamageText();
tempDamText.pos = player.startLoc;
tempDamText.pos.X += 1;
tempDamText.pos.Y -= 20;
tempDamText.color = new Color(255, 0, 0, 255);
tempDamText.value = enemies[currentEnemy].secondaryStats.attack;
enemyDamageText.Add(tempDamText);
}
if (gameTime.TotalGameTime.TotalSeconds - lastPlayerAtk.TotalGameTime.TotalSeconds
>= player.secondaryStats.atkSpeed)
{
player.attackNum++;
enemies[currentEnemy].secondaryStats.health -= player.secondaryStats.attack;
lastPlayerAtk = new GameTime(gameTime.TotalGameTime, gameTime.ElapsedGameTime);
DamageText tempDamText2 = new DamageText();
tempDamText2.pos = player.startLoc;
tempDamText2.pos.X += 1;
tempDamText2.pos.Y -= 20;
tempDamText2.pos.X += 22;
tempDamText2.color = new Color(255, 0, 0, 255);
playerDamageText.Add(tempDamText2);
player.UpdateAttack();
}
if (enemies[currentEnemy].secondaryStats.health <= 0)
{
enemies.RemoveAt(currentEnemy);
battle = false;
player.pState = Player.PlayerState.walking;
player.attackNum = 0;
player.ResetAnimations();
playerDamageText.Clear();
enemyDamageText.Clear();
}
else
{
for (int x = 0; x < enemyDamageText.Count; x++)
{
DamageText temp = new DamageText();
temp.pos.X = enemyDamageText[x].pos.X;
temp.pos.Y = enemyDamageText[x].pos.Y - .2f;
temp.color = enemyDamageText[x].color;
temp.color.A -= 3;
if (temp.color.A < 3)
{
enemyDamageText.RemoveAt(x);
x--;
}
else
enemyDamageText[x] = temp;
}
for (int x = 0; x < playerDamageText.Count; x++)
{
DamageText temp = new DamageText();
temp.pos.X = playerDamageText[x].pos.X;
temp.pos.Y = playerDamageText[x].pos.Y - .2f;
temp.color = new Color(255, 0, 0, playerDamageText[x].color.A);
temp.color.A -= 3;
if (temp.color.A < 3)
{
playerDamageText.RemoveAt(x);
x--;
}
else
playerDamageText[x] = temp;
}
if (!player.BattleUpdate(gameTime))
{
Exit();
}
enemies[currentEnemy].BattleUpdate(gameTime);
}
}
}
prevKeyState = currKeyState;
prevGamePadState = currGamePadState;
base.Update(gameTime);
}
private void OnEnable()
{
curretHeath = maxHealth;
damageText = GetComponentInChildren <DamageText>();
}
public void notifyDamageDone(Unit source, Unit target, float amount, DamageType type, DamageText damagetext)
{
var dd = new DamageDone(source, target, amount, type, damagetext);
_game.PacketHandlerManager.broadcastPacket(dd, Channel.CHL_S2C);
}
public virtual void dealDamageTo(Unit target, float damage, DamageType type, DamageSource source, bool isCrit)
{
DamageText text = DamageText.DAMAGE_TEXT_NORMAL;
if (isCrit)
{
text = DamageText.DAMAGE_TEXT_CRITICAL;
}
if (_scriptEngine.IsLoaded())
{
try
{
_scriptEngine.SetGlobalVariable("target", target);
_scriptEngine.SetGlobalVariable("damage", damage);
_scriptEngine.SetGlobalVariable("type", type);
_scriptEngine.SetGlobalVariable("source", source);
_scriptEngine.Execute("onDealDamage(target, damage, type, source)");
}
catch (LuaScriptException e)
{
_logger.LogCoreError("ERROR LUA : " + e.Message);
}
}
float defense = 0;
float regain = 0;
switch (type)
{
case DamageType.DAMAGE_TYPE_PHYSICAL:
defense = target.GetStats().Armor.Total;
defense = (1 - stats.ArmorPenetration.PercentBonus) * defense - stats.ArmorPenetration.FlatBonus;
break;
case DamageType.DAMAGE_TYPE_MAGICAL:
defense = target.GetStats().MagicPenetration.Total;
defense = (1 - stats.MagicPenetration.PercentBonus) * defense - stats.MagicPenetration.FlatBonus;
break;
}
switch (source)
{
case DamageSource.DAMAGE_SOURCE_SPELL:
regain = stats.SpellVamp.Total;
break;
case DamageSource.DAMAGE_SOURCE_ATTACK:
regain = stats.LifeSteal.Total;
break;
}
//Damage dealing. (based on leagueoflegends' wikia)
damage = defense >= 0 ? (100 / (100 + defense)) * damage : (2 - (100 / (100 - defense))) * damage;
if (target._scriptEngine.IsLoaded())
{
try
{
target._scriptEngine.SetGlobalVariable("attacker", this);
target._scriptEngine.SetGlobalVariable("damage", damage);
target._scriptEngine.SetGlobalVariable("type", type);
target._scriptEngine.SetGlobalVariable("source", source);
target._scriptEngine.Execute(@"
function modifyIncomingDamage(value)
damage = value
end");
target._scriptEngine.Execute("onDamageTaken(attacker, damage, type, source)");
}
catch (LuaScriptException e)
{
_logger.LogCoreError("LUA ERROR : " + e);
}
}
target.GetStats().CurrentHealth = Math.Max(0.0f, target.GetStats().CurrentHealth - damage);
if (!target.IsDead && target.GetStats().CurrentHealth <= 0)
{
target.IsDead = true;
target.die(this);
}
_game.PacketNotifier.notifyDamageDone(this, target, damage, type, text);
//Get health from lifesteal/spellvamp
if (regain != 0)
{
stats.CurrentHealth = Math.Min(stats.HealthPoints.Total, stats.CurrentHealth + regain * damage);
_game.PacketNotifier.notifyUpdatedStats(this);
}
}
public static void Initialize()
{
canvas = GameObject.FindGameObjectWithTag("UI");
damageText = Resources.Load <DamageText>("Prefabs/Combat/UI/PopUpTextParent");
}
public void Spawn(float damageAmount)
{
DamageText instance = Instantiate <DamageText>(damageTextPrefab, transform);
instance.SetValue(damageAmount);
}
public virtual void TakeDamage(AttackableUnit attacker, float damage, DamageType type, DamageSource source,
DamageText damageText)
{
float defense = 0;
float regain = 0;
var attackerStats = attacker.GetStats();
switch (type)
{
case DamageType.DAMAGE_TYPE_PHYSICAL:
defense = GetStats().Armor.Total;
defense = (1 - attackerStats.ArmorPenetration.PercentBonus) * defense -
attackerStats.ArmorPenetration.FlatBonus;
break;
case DamageType.DAMAGE_TYPE_MAGICAL:
defense = GetStats().MagicPenetration.Total;
defense = (1 - attackerStats.MagicPenetration.PercentBonus) * defense -
attackerStats.MagicPenetration.FlatBonus;
break;
case DamageType.DAMAGE_TYPE_TRUE:
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
switch (source)
{
case DamageSource.DAMAGE_SOURCE_SPELL:
regain = attackerStats.SpellVamp.Total;
break;
case DamageSource.DAMAGE_SOURCE_ATTACK:
regain = attackerStats.LifeSteal.Total;
break;
case DamageSource.DAMAGE_SOURCE_SUMMONER_SPELL:
break;
case DamageSource.DAMAGE_SOURCE_PASSIVE:
break;
default:
throw new ArgumentOutOfRangeException(nameof(source), source, null);
}
//Damage dealing. (based on leagueoflegends' wikia)
damage = defense >= 0 ? (100 / (100 + defense)) * damage : (2 - (100 / (100 - defense))) * damage;
ApiEventManager.OnDamageTaken.Publish(this);
GetStats().CurrentHealth = Math.Max(0.0f, GetStats().CurrentHealth - damage);
if (!IsDead && GetStats().CurrentHealth <= 0)
{
IsDead = true;
die(attacker);
}
ApiEventManager.OnDealDamage.Publish(attacker, this);
_game.PacketNotifier.NotifyDamageDone(attacker, this, damage, type, damageText);
_game.PacketNotifier.NotifyUpdatedStats(this, false);
// Get health from lifesteal/spellvamp
if (regain > 0)
{
attackerStats.CurrentHealth = Math.Min(attackerStats.HealthPoints.Total,
attackerStats.CurrentHealth + regain * damage);
_game.PacketNotifier.NotifyUpdatedStats(attacker, false);
}
}
public void NotifyDamageDone(IAttackableUnit source, IAttackableUnit target, float amount, GameServerCore.Enums.DamageType type, DamageText damagetext, bool isGlobal = true, int sourceId = 0, int targetId = 0)
{
var dd = new DamageDone(source, target, amount, type, damagetext);
if (isGlobal)
{
_packetHandlerManager.BroadcastPacket(dd, Channel.CHL_S2C);
}
else
{
if (sourceId != 0)
{
_packetHandlerManager.SendPacket(sourceId, dd, Channel.CHL_S2C);
}
if (targetId != 0)
{
_packetHandlerManager.SendPacket(targetId, dd, Channel.CHL_S2C);
}
}
}
bool PlayerAttack()
{
bool targetIsDead = false;
List <TurnBase> enemyesOut = new List <TurnBase>();
foreach (TurnBase enemy in enemyes)
{
enemyesOut.Add(enemy);
}
List <TurnBase> unitsOut = new List <TurnBase>();
foreach (TurnBase unit in units)
{
unitsOut.Add(unit);
}
List <CombatResult> combatResults = Combat.Attack(selectedUnit, selectedEnemy, skillName, skillNameB, enemyesOut, unitsOut, skill_lvl);
for (int i = 0; i < combatResults.Count; i++)
{
TurnBase target = combatResults[i].target;
float damage = combatResults[i].damage;
target.general.PARAMS[GENERAL_HP_CURRENT] -= damage;
GameObject gt = Instantiate(ResManager.instance.DamageText, target.transform);
gt.transform.position = new Vector3(target.transform.parent.transform.position.x, target.transform.parent.transform.position.y, 5f);
DamageText dt = gt.GetComponent <DamageText>();
dt.startMitonEnemy("-" + damage, Colors.RedColor);
if (target.general.PARAMS[GENERAL_HP_CURRENT] > 0)
{
target.animator.Play("hart");
if (target.general.PARAMS[GENERAL_HP_CURRENT] > target.general.PARAMS[GENERAL_HP] / 4 * 3) //75+%
{
target.text.color = Colors.GreenColor;
}
else if (target.general.PARAMS[GENERAL_HP_CURRENT] < target.general.PARAMS[GENERAL_HP] / 4 * 3 && target.general.PARAMS[GENERAL_HP_CURRENT] > target.general.PARAMS[GENERAL_HP] / 2) //50% + /75%-
{
target.text.color = Colors.YellowColor;
}
else if (target.general.PARAMS[GENERAL_HP_CURRENT] < target.general.PARAMS[GENERAL_HP] / 2 && target.general.PARAMS[GENERAL_HP_CURRENT] > target.general.PARAMS[GENERAL_HP] / 4) //25%+ / 50%-
{
target.text.color = Colors.Orange;
}
else if (target.general.PARAMS[GENERAL_HP_CURRENT] < target.general.PARAMS[GENERAL_HP] / 4 && target.general.PARAMS[GENERAL_HP_CURRENT] > 0) //0+ / 25-
{
target.text.color = Colors.RedColor;
}
target.text.text = target.general.PARAMS[GENERAL_HP_CURRENT].ToString();
}
else
{
targetIsDead = true;
}
}
skill_0.GetComponent <Image>().color = Colors.WhiteColor;
skill_1.GetComponent <Image>().color = Colors.WhiteColor;
skill_2.GetComponent <Image>().color = Colors.WhiteColor;
skill_B.GetComponent <Image>().color = Colors.WhiteColor;
defaultSkill.GetComponent <Image>().color = Colors.GreenColor;
selectedUnit.animator.Play("attack");
selectedUnit.isEndTurn = true;
skillName = SkillName.none;
skillNameB = SkillNameB.none;
skill_lvl = 0;
CleanSkills();
CheckAdnRegenSkill();
return(targetIsDead);
}
public void Spawn(float damage)
{
DamageText instance = Instantiate <DamageText>(damageText, transform);
instance.SetDamageText(damage);
}
public virtual void DealDamageTo(Unit target, float damage, DamageType type, DamageSource source, DamageText damageText)
{
float defense = 0;
float regain = 0;
switch (type)
{
case DamageType.DAMAGE_TYPE_PHYSICAL:
defense = target.GetStats().Armor.Total;
defense = (1 - stats.ArmorPenetration.PercentBonus) * defense - stats.ArmorPenetration.FlatBonus;
break;
case DamageType.DAMAGE_TYPE_MAGICAL:
defense = target.GetStats().MagicPenetration.Total;
defense = (1 - stats.MagicPenetration.PercentBonus) * defense - stats.MagicPenetration.FlatBonus;
break;
}
switch (source)
{
case DamageSource.DAMAGE_SOURCE_SPELL:
regain = stats.SpellVamp.Total;
break;
case DamageSource.DAMAGE_SOURCE_ATTACK:
regain = stats.LifeSteal.Total;
break;
}
//Damage dealing. (based on leagueoflegends' wikia)
damage = defense >= 0 ? (100 / (100 + defense)) * damage : (2 - (100 / (100 - defense))) * damage;
if (target.HasCrowdControl(CrowdControlType.Invulnerable))
{
bool attackerIsFountainTurret = this is LaneTurret && (this as LaneTurret).Type == TurretType.FountainTurret;
if (attackerIsFountainTurret == false)
{
damage = 0;
damageText = DamageText.DAMAGE_TEXT_INVULNERABLE;
}
}
ApiEventManager.OnUnitDamageTaken.Publish(target);
target.GetStats().CurrentHealth = Math.Max(0.0f, target.GetStats().CurrentHealth - damage);
if (!target.IsDead && target.GetStats().CurrentHealth <= 0)
{
target.IsDead = true;
target.die(this);
}
_game.PacketNotifier.NotifyDamageDone(this, target, damage, type, damageText);
_game.PacketNotifier.NotifyUpdatedStats(target, false);
//Get health from lifesteal/spellvamp
if (regain != 0)
{
stats.CurrentHealth = Math.Min(stats.HealthPoints.Total, stats.CurrentHealth + regain * damage);
_game.PacketNotifier.NotifyUpdatedStats(this, false);
}
}
public DamageDoneResponse(IAttackableUnit source, IAttackableUnit target, float amount, DamageType type, DamageText damagetext, bool isGlobal = true, int sourceId = 0, int targetId = 0)
{
Source = source;
Target = target;
Amount = amount;
Type = type;
DamageText = damagetext;
IsGlobal = isGlobal;
SourceId = sourceId;
TargetId = targetId;
}
