public void Initialize(BuffConfiguration newConfiguration, ElementType[] newAffinity, BattleNPC newCaster = null) { m_Configuration = newConfiguration; m_BuffActiveObject = _createBuffActive(newConfiguration); m_SkillAffinity = newAffinity; m_Caster = newCaster; }
public BuffByte(BuffByteConfig newConfiguration, BuffActive newController, BattleNPC caster) { Configuration = newConfiguration; Controller = newController; BuffCaster = caster; BuffDiff = 0; }
public override void OnSkillByteHit(BattleNPC collisionNPC, float damageMultiplier = 1.0f) { base.OnSkillByteHit(collisionNPC, damageMultiplier); ParentSkill.SkillOwner.FlipBattleNPCSpriteX(); ParentSkill.SkillSpriteRenderer.enabled = false; ParentSkill.AdvanceToNextByte(); }
/* * Check if this skill is configured to hit this BattleNPC * @param: b - BattleNPC beam says it hit * @returns: bool - true if configured to hit b, false if not configured to hit b */ private bool _checkValidDamage(BattleNPC hitNPC) { bool heroTeam = BattleGlobals.IsHeroTeamTag(hitNPC.tag); return(otherTeamValidTargets || (Target == TargetType.AnyTarget) || ((Target == TargetType.AlliedTargets) && heroTeam) || ((Target == TargetType.EnemyTargets) && !heroTeam)); }
private void Update() { if (!changedToAlly && isAlly) { changedToAlly = true; me = new BattleNPC(myBaseDamage, myBaseDefense, myStrength, myWeakness, true); me.SetName(myName); } }
protected float ChannelingOnSkillHit(BattleNPC hitNPC, float timeToCheck) { bool intervalTime = _channelInterval(timeToCheck); if (intervalTime) { OnSkillByteHit(hitNPC); return(Time.fixedTime); } return(-1.0f); }
/* * Because TargetSignature affords more than one target, need to check more than one index now */ public override int CheckValidTarget(BattleNPC checkNPC) { for (int index = 0; index < NPCTargets.Length; index++) { if (NPCTargets[index].Focus == checkNPC) { return(index); } } return(-1); }
private void _createBuffBytes(List <BuffByteConfig> configArray, BattleNPC caster) { List <BuffByte> temporaryList = new List <BuffByte>(); foreach (BuffByteConfig config in configArray) { BuffByte buff = config.GenerateBuffByteFromByteType(this, caster); buff.Configuration.CustomFloat = m_Configuration.CustomFloat; temporaryList.Add(buff); } m_ManagedBuffs = temporaryList.ToArray(); }
/* * This function checks our damage pulse time per target * (e.g. Target 2 can be hit by damage even if the pulse time on Target1 isn't up) * @param: BattleNPC - BattleNPC that intercepted the beam */ private void _checkConditionsOnSkillHit(BattleNPC hitNPC) { bool canHit = _checkValidDamage(hitNPC); if (canHit) { int prevTimeIndex = _hitBattleNPCbefore(hitNPC); float temp = ChannelingOnSkillHit(hitNPC, m_PreviousTargetTime[prevTimeIndex]); m_PreviousTargetTime[prevTimeIndex] = (temp > 0) ? temp : m_PreviousTargetTime[prevTimeIndex]; } }
/* * Gets the PrevTargetHit entry for BattleNPC, b * or creates one based on the time * param: b - BattleNPC to check and see if we've hit before * returns: int - index of prevTargetTime for the battleNPC (even if it's a new battleNPC) */ private int _hitBattleNPCbefore(BattleNPC hitNPC) { int i = m_PreviousTarget.IndexOf(hitNPC); if (i == -1) { m_PreviousTarget.Add(hitNPC); m_PreviousTargetTime.Add(Time.fixedTime - DamageInterval); i = (m_PreviousTargetTime.Count - 1); } return(i); }
/* * When a skill hits it's target, apply OnHit buffs * @param: target - if (de)buffs are to be applied to target, this is the target * @param: dmg - the damage the skill did, if the buff relies on dmg dealt */ protected virtual void ApplyOnHitBuffs(BattleNPC target, int damage) { if (OnHitBuffs.Count > 0) { foreach (BuffApplicator tempBuffController in OnHitBuffs) { BattleNPC buffTarget = (tempBuffController.CheckTargetType(BuffConfiguration.TargetType.Self)) ? ParentSkill.SkillOwner : target; tempBuffController.OnSkillHit(buffTarget, damage); } } }
private void _applyBuffWhenPassesChance(BattleNPC targetNPC) { bool passedChanceToHit = GameGlobals.CheckPercentHitChance(m_Configuration.ChanceToApply); if (passedChanceToHit) { BuffActive newActive = Instantiate(m_BuffActiveObject, targetNPC.transform); newActive.gameObject.SetActive(true); targetNPC.RegisterBuff(newActive); newActive.Initialize(m_Configuration, m_SkillAffinity, m_Caster); newActive.StartBuffs(targetNPC); } }
// Use this for initialization void Awake() { m_Rigid2d = GameGlobals.AttachCheckComponent <Rigidbody2D>(this.gameObject); m_ParentSkillByte = GameGlobals.AttachCheckComponentParent <ProjectileAttackByte>(this.gameObject); m_SpriteRenderer = GameGlobals.AttachCheckComponent <SpriteRenderer>(this.gameObject); this.tag = (BattleGlobals.IsHeroTeamTag(m_ParentSkillByte.ParentSkill.SkillOwner.tag)) ? BattleGlobals.TAG_FOR_HERO_PROJ : BattleGlobals.TAG_FOR_ENEMY_PROJ; this.name = GameGlobals.TrimCloneFromName(this.name) + "(" + m_ParentSkillByte.ParentSkill.SkillOwner + ")"; // If the object is homing, this does not matter m_ProjDirection = (this.gameObject.CompareTag(BattleGlobals.TAG_FOR_HERO_PROJ)) ? Vector2.left : Vector2.right; m_mainTarget = null; }
/* * This is called separately because in multi-target spells it's better the skill set the target, * than the projectile query the skill for a target */ public void SetTargetAndDamage(BattleNPC target, float damageMultiplier) { m_mainTarget = target; m_ProjectileDamageMultiplier = damageMultiplier; if (m_ProjectileDamageMultiplier == 0) { m_ParentSkillByte.DeRegisterProjectile(this); } else { m_Rigid2d.transform.rotation = BattleGlobals.LookAt(this.gameObject, target.StartPuck.transform.position, this.tag); } }
public virtual void OnSkillByteHit(BattleNPC collisionNPC, float damageMultiplier = 1.0f) { // Hit *a* target if (collisionNPC != null) { int damage = (m_Damage != null) ? _applyDamageToBattleNPC(collisionNPC, damageMultiplier) : 0; SetSkillHitStatus(damage, collisionNPC.Alive); ApplyOnHitBuffs(collisionNPC, damage); ParentSkill.RegisterCumulative(damage); } else // Missed Target { SetSkillHitStatus(0, true); } }
public override void DoByte() { AnimateOwner(BattleGlobals.ANIMATE_NPC_ATTACK); ApplyOnCastBuffs(); // Check if byte should end bool interrupted = CheckInterruptedByDamage(); bool channelOver = CheckChannelTime(); if (interrupted || !channelOver) { ParentSkill.SkillSpriteRenderer.enabled = false; ParentSkill.AdvanceToNextByte(); return; } if (Homing) { m_TargetPosition = NPCTargets[BEAM_PRIMARY_TARGET].Focus.transform.position; } RaycastHit2D[] hit = Physics2D.LinecastAll(m_BeamStart.transform.position, m_TargetPosition, m_TargetMask); Vector3 endPosition = m_TargetPosition; foreach (RaycastHit2D r in hit) { if (r.collider != null) { BattleNPC b = GameGlobals.AttachCheckComponentChildren <BattleNPC>(r.collider.gameObject); if ((b != null) && b.Alive) { endPosition = r.point; _checkConditionsOnSkillHit(b); break; } } } GameGlobals.Stretch(m_BeamMiddle.gameObject, m_BeamStart.transform.position, endPosition, m_PositiveDirection); m_BeamEnd.transform.position = endPosition; if (Homing) { _updateRotation(); } }
private void SelectAlly() { allySelectionEffectController.SelectingOneTarget(indexOfAllyList[indexOfAlly]); if (Input.GetKeyDown(KeyCode.UpArrow)) { if (indexOfAlly == 0) { indexOfAlly = 0; // currentAllyList.Count-1; } else { indexOfAlly -= 1; } } else if (Input.GetKeyDown(KeyCode.DownArrow)) { if (indexOfAlly == currentAllyList.Count - 1) { indexOfAlly = currentAllyList.Count - 1; // 0; } else { indexOfAlly += 1; } } if (Input.GetKeyDown(KeyCode.Z)) { // store selected ally from the index selectedAlly = currentAllyList[indexOfAlly]; // remove selected ally from allyList currentAllyList.RemoveAt(indexOfAlly); // add selected and stored ally into selectedAllyList for further function or add action respectively selectedAllyList.Add(selectedAlly); currentState = SelectionState.ACTION; indexOfAllyList.RemoveAt(indexOfAlly); indexOfAlly = 0; // off indicator allySelectionEffectController.SelectingOneTarget(-1); // debug Debug.Log("Selected Ally: " + selectedAlly.GetName()); } }
public override void Behavior() { base.Behavior(); for (int i = 0; i < myTargetList.Count; i++) { BattleNPC temp = myTargetList[i]; Monster tempTarget = (Monster)temp; float hp = tempTarget.GetMyHP(); float damage = thisNPC.GetBaseDamage() + thisNPC.GetDamage(); float defense = tempTarget.GetBaseDefense() + tempTarget.GetDefense(); if (damage > defense) { damage = damage - defense; hp -= damage; } tempTarget.SetMyHP(hp); } }
public override void Behavior() { base.Behavior(); for (int i = 0; i < myTargetList.Count; i++) { BattleNPC temp = myTargetList[i]; Monster tempTarget = (Monster)temp; float hp = tempTarget.GetMyHP(); float damage = GirlController.Instance.GetEQ() + thisKnowledge.GetValue(); float defense = tempTarget.GetBaseDefense() + tempTarget.GetDefense(); if (damage > defense) { damage = damage - defense; hp -= damage; } tempTarget.SetMyHP(hp); } }
private int _applyDamageToBattleNPC(BattleNPC target, float damageMultiplier) { int damage = 0; for (int index = 0; index < m_Damage.NumberOfHits; index++) { int baseDamage = Convert.ToInt32(damageMultiplier * m_Damage.GetSkillDamage(m_StartFlightTime, ParentSkill.CumulativeDamage)); target.DeltaHitPointsList.Add( new SkillDamagePacket() { Affinity = ParentSkill.AffinityTypes, Caster = ParentSkill.SkillOwner, BaseSkillDelta = baseDamage }); damage += baseDamage; } return(damage); }
protected override void OnEnable() { base.OnEnable(); m_PreviousTarget = new List <BattleNPC>(); m_PreviousTargetTime = new List <float>(); m_BeamStart.flipX = m_DefaultStartFlipX; m_BeamEnd.flipX = m_DefaultEndFlipX; Vector3 beamStartPos = BEAM_START_OFFSET; if (ParentSkill.SkillOwner.CompareTag(BattleGlobals.TAG_FOR_ENEMIES)) { ParentSkill.ToggleSpriteFlipX(); beamStartPos = -1 * beamStartPos; } beamStartPos += this.gameObject.transform.position; beamStart.tag = BattleGlobals.TAG_FOR_ENEMY_PROJ; m_PositiveDirection = true; m_BeamStart.transform.position = beamStartPos; if ((NPCTargets != null)) { BattleNPC primary = NPCTargets[BEAM_PRIMARY_TARGET].Focus; if (beamStartPos.x > primary.transform.position.x) { m_BeamStart.flipX = !m_DefaultStartFlipX; m_BeamEnd.flipX = !m_DefaultEndFlipX; m_PositiveDirection = false; m_BeamStart.tag = BattleGlobals.TAG_FOR_HERO_PROJ; } m_TargetPosition = primary.StartPuck.transform.position; } _updateRotation(); m_BeamStart.enabled = true; m_BeamMiddle.enabled = true; m_BeamEnd.enabled = true; }
// controllable action constructor public Action(BattleNPC me) { thisNPC = me; if (myTargetList != null) { // clear target list in case myTargetList is the previous list myTargetList.Clear(); } else { // initiate myTargetList = new List <BattleNPC>(); } //reset defense point if (thisNPC.GetDefendBool() == true) { thisNPC.SetDefense(thisNPC.GetDefense() + 10); thisNPC.SetDefendBool(false); } }
// This handles the logic for the projectile "connecting" with it's target public void OnTriggerEnter2D(Collider2D collision) { BattleNPC colNPC = collision.gameObject.GetComponentInChildren <BattleNPC>(); if (colNPC != null) { if (!m_ParentSkillByte.Blockable) { if ((m_mainTarget != null) && (m_mainTarget == colNPC)) { if (m_ProjectileDamageMultiplier != 0) { m_ParentSkillByte.OnSkillByteHit(colNPC, m_ProjectileDamageMultiplier); } m_ParentSkillByte.DeRegisterProjectile(this); } } else { SkillByte.TargetType targetType = m_ParentSkillByte.Target; bool isValidTarget = (targetType == SkillByte.TargetType.AnyTarget) || ((targetType == SkillByte.TargetType.AlliedTargets) && !BattleGlobals.IsHostileToTag(this.tag, colNPC.tag)) || ((targetType == SkillByte.TargetType.EnemyTargets) && BattleGlobals.IsHostileToTag(this.tag, colNPC.tag)); if (colNPC.Alive && isValidTarget) { if (m_ProjectileDamageMultiplier != 0) { m_ParentSkillByte.OnSkillByteHit(colNPC, m_ProjectileDamageMultiplier); } m_ParentSkillByte.DeRegisterProjectile(this); } } } }
public virtual void OnTriggerEnter2D(Collider2D collision) { BattleNPC colNPC = collision.gameObject.GetComponentInChildren <BattleNPC>(); if (colNPC != null) { if (!Blockable) { int targetIndex = CheckValidTarget(colNPC); if ((targetIndex != -1)) { OnSkillByteHit(NPCTargets[targetIndex].Focus, NPCTargets[targetIndex].Multiplier); } } else { if (colNPC.Alive && BattleGlobals.IsHostileToTag(ParentSkill.SkillOwner.tag, colNPC.tag)) { OnSkillByteHit(colNPC); } } } }
public void StartBuffs(BattleNPC target) { BuffTarget = target; foreach (BuffByte temporaryByte in m_ManagedBuffs) { temporaryByte.ApplyBuff(temporaryByte.Configuration.BuffAmount); if (m_Configuration.DurationMeasure == BuffConfiguration.DurationType.Permanent) { m_CompletedBuffBytes++; } else { m_SpriteRenderer.enabled = true; float interval = (m_Configuration.DegradeSecondsInterval < m_Configuration.DurationSeconds) ? m_Configuration.DegradeSecondsInterval : m_Configuration.DurationSeconds; secondsTimer = new TimerSeconds(m_Configuration.DurationSeconds, interval); int currentSkills = (m_Configuration.DurationMeasure == BuffConfiguration.DurationType.SkillDamage) ? BuffTarget.SkillsHitByThisBattle : BuffTarget.SkillsDoneThisBattle; skillTimer = new TimerSkillCount(currentSkills, currentSkills + m_Configuration.DurationSkills, BuffTarget, m_Configuration.DurationMeasure); m_Active = true; } } }
public CurrentHealthBuffByte(BuffByteConfig newConfiguration, BuffActive newController, BattleNPC caster) : base(newConfiguration, newController, caster) { }
public ReadinessBuffByte(BuffByteConfig newConfiguration, BuffActive newController, BattleNPC caster) : base(newConfiguration, newController, caster) { }
public SkillDropBuffByte(BuffByteConfig newConfiguration, BuffActive newController, BattleNPC caster) : base(newConfiguration, newController, caster) { }
/* * returns -1 if NPC isn't a valid target */ public virtual int CheckValidTarget(BattleNPC checkNPC) { return((NPCTargets[PRIMARY_SKILL_BYTE_TARGET_INDEX].Focus == checkNPC) ? PRIMARY_SKILL_BYTE_TARGET_INDEX : -1); }
public BuffByte GenerateBuffByteFromByteType(BuffActive newController, BattleNPC caster) { BuffByte returnObject = null; switch (ByteType) { case BuffByteType.Cleanse: returnObject = new CleanseBuffByte(this, newController, caster); break; case BuffByteType.Current_Health: returnObject = new CurrentHealthBuffByte(this, newController, caster); break; case BuffByteType.Delayed_Revive: returnObject = new DelayedReviveBuffByte(this, newController, caster); break; case BuffByteType.Experience: returnObject = new ExperienceBuffByte(this, newController, caster); break; case BuffByteType.Flat_Resistance: returnObject = new FlatResistanceBuffByte(this, newController, caster); break; case BuffByteType.Martyr: returnObject = new MartyrBuffByte(this, newController, caster); break; case BuffByteType.Maximum_Health: returnObject = new MaxHealthBuffByte(this, newController, caster); break; case BuffByteType.Move_Speed: returnObject = new MoveSpeedBuffByte(this, newController, caster); break; case BuffByteType.Readiness: returnObject = new ReadinessBuffByte(this, newController, caster); break; case BuffByteType.Resistance: returnObject = new ResistanceBuffByte(this, newController, caster); break; case BuffByteType.Retaliate: returnObject = new RetaliateBuffByte(this, newController, caster); break; case BuffByteType.Skill_Drop: returnObject = new SkillDropBuffByte(this, newController, caster); break; case BuffByteType.Skill_Level: returnObject = new SkillLevelBuffByte(this, newController, caster); break; case BuffByteType.Stun: returnObject = new StunDebuffByte(this, newController, caster); break; case BuffByteType.Taunt: returnObject = new TauntDebuffByte(this, newController, caster); break; default: break; } return(returnObject); }