protected static double GetTempDamage(BattleBaseAttrs caster, BattleBaseAttrs target, bool isTargetPlayer) { double finalAttack = BattleCalculator.GetFinalAttack(caster, isTargetPlayer); double finalDefence = BattleCalculator.GetFinalDefence(target); return(Math.Max(0.2 * finalAttack, Math.Min(finalAttack - finalDefence, 0.8 * finalAttack + Math.Max(0.0, 0.2 * finalAttack - finalDefence) / (double)Math.Max(1, caster.Lv - target.Lv)))); }
public CombatResult Battle([FromBody] BattleModel battleModel) { var attacker = _monsterCardEntityCrud.GetOne(battleModel.AttackerId); var defender = _monsterCardEntityCrud.GetOne(battleModel.DefenderId); return(BattleCalculator.Attacks((MonsterCard)attacker.CardReference, (MonsterCard)defender.CardReference)); }
public void Init(TileManager tileManager, CharacterBoardEntity boardEntity, BattleCalculator battleCalculator, TurnManager turnManager) { this.tileManager = tileManager; this.boardEntity = boardEntity; this.battleCalculator = battleCalculator; this.turnManager = turnManager; }
public static void AppTheat(Effect effectData, EntityParent caster, List <long> effectTargetIDs, XPoint basePoint, int skillID, bool isAddEffect, bool isCommunicateMix) { if (!LocalAgent.GetEntityCalculatable(caster, isCommunicateMix)) { return; } XDict <GameData.AttrType, long> effectCasterTempAttr = LocalBattleEffectCalculatorHandler.GetEffectCasterTempAttr(effectData, caster, skillID); bool flag = isAddEffect && isCommunicateMix; for (int i = 0; i < effectTargetIDs.get_Count(); i++) { EntityParent entityByID = LocalAgent.GetEntityByID(effectTargetIDs.get_Item(i)); if (LocalAgent.GetEntityIsCurable(entityByID, isCommunicateMix)) { if (!entityByID.IsUnconspicuous || effectData.forcePickup != 0) { long num = BattleCalculator.CalculateTreatment(caster.BattleBaseAttrs, entityByID.BattleBaseAttrs, entityByID.IsEntitySelfType || entityByID.IsEntityPlayerType, effectCasterTempAttr, null); if (num != 0L) { List <ClientDrvBuffInfo> casterBuffInfo = null; List <ClientDrvBuffInfo> targetBuffInfo = null; if (isCommunicateMix) { casterBuffInfo = LocalAgent.MakeClientDrvBuffInfo(caster.ID); targetBuffInfo = LocalAgent.MakeClientDrvBuffInfo(effectTargetIDs.get_Item(i)); } long num2 = LocalAgent.GetSpiritCurHp(entityByID, isCommunicateMix) + num; if (num2 > entityByID.RealHpLmt) { num2 = entityByID.RealHpLmt; } Pos pos = null; if (caster.Actor) { pos = new Pos(); pos.x = caster.Actor.FixTransform.get_position().x * 100f; pos.y = caster.Actor.FixTransform.get_position().z * 100f; } LocalAgent.SetSpiritCurHp(entityByID, num2, isCommunicateMix); if (isCommunicateMix) { GlobalBattleNetwork.Instance.SendClientDriveBattleEffectDamage(caster.ID, effectTargetIDs.get_Item(i), caster.Hp, num2, num, skillID, effectData.id, flag, true, casterBuffInfo, targetBuffInfo, basePoint, new List <long>(), string.Concat(new object[] { caster.TryAddValue(GameData.AttrType.SkillTreatScaleBOAtk, effectCasterTempAttr), "_", caster.TryAddValue(GameData.AttrType.SkillTreatScaleBOHpLmt, effectCasterTempAttr), "_", caster.TryAddValue(GameData.AttrType.SkillIgnoreDefenceHurt, effectCasterTempAttr) }), false); } LocalBattleProtocolSimulator.SendTreat(effectTargetIDs.get_Item(i), (GameObjectType.ENUM)entityByID.WrapType, caster.ID, (GameObjectType.ENUM)caster.WrapType, BattleAction_Treat.TreatSrcType.Treat, num, num2, pos); if (flag) { flag = false; } } } } } }
public ICombatResult Battle(string attackerId, string defenderId, int attackingSide = 1) { IMonsterCard attacker = GetAttacker(attackerId, attackingSide); IMonsterCard defender = GetDefender(defenderId, attackingSide); return(BattleCalculator.Attacks((MonsterCard)attacker, (MonsterCard)defender)); }
public EffectCalculator(Entity u, BattleCalculator calc) { user = u; bc = calc; effects = new List <Effect>(); immunities = new List <string>(); }
// Use this for initialization void Start() { stats = GameObject.FindObjectOfType <PlayerStats>(); battleCalculator = GameObject.FindObjectOfType <BattleCalculator>(); //inventory = GameObject.FindObjectOfType<Inventory>(); //equipment = GameObject.FindObjectOfType<Equipment>(); rigidBody = GetComponent <Rigidbody2D>(); }
/// <summary> /// An assistant class for Entity which calculates all tile and status effects /// </summary> /// <param name="u">The entity this caluclator belongs to</param> /// <param name="calc">The Battle Calculator</param> /// <param name="pos">The Position Calculator</param> public EffectCalculator(Entity u, BattleCalculator calc, PositionCalculator pos) { user = u; //bc = calc; pc = pos; effects = new List <Effect>(); }
void OnEnable() { useOfAbilities = gameObject.GetComponent <UseOfAbilities>(); currentGeneralState = generalBattleState.STARTING; calculator = new BattleCalculator(); //marker = GameObject.Find("Marker"); attackFinished = 0; startAttack = false; }
//Sets base stats, components, and initial display protected virtual void Start() { ec = new EffectCalculator(this, bc); bc = new BattleCalculator(this, ec); bc.ResetStats(); UpdateDisplay(); normal = render.color; //Set the normal color to the sprite's starting color }
public BattleManager(BattleInterface listener) { this.listener = listener; calculate = new BattleCalculator(); activeManager = ActiveSkillManager.GetInstance(); passiveSkill = new PassiveManager(); active = new ActiveUse(this); enemyAI = new EnemyAI(this); playerList = new List <CharacterModel>(); enemyList = new List <CharacterModel>(); }
protected static void AppTreat(Buff buffData, EntityParent caster, EntityParent target, int fromSkillID, int fromSkillLevel, XDict <GameData.AttrType, BattleSkillAttrAdd> fromSkillAttrChange, bool isCommunicateMix) { if (!LocalAgent.GetEntityCalculatable(caster, isCommunicateMix)) { return; } if (!LocalAgent.GetEntityIsCurable(target, isCommunicateMix)) { return; } if (target.IsUnconspicuous && buffData.forceHandle == 0) { return; } XDict <GameData.AttrType, long> buffCasterTempAttr = LocalBattleBuffCalculatorHandler.GetBuffCasterTempAttr(buffData, caster, fromSkillLevel, fromSkillAttrChange); XDict <GameData.AttrType, long> buffTargetTempAttr = LocalBattleBuffCalculatorHandler.GetBuffTargetTempAttr(buffData, caster, fromSkillLevel, fromSkillAttrChange); long num = BattleCalculator.CalculateTreatment(caster.BattleBaseAttrs, target.BattleBaseAttrs, target.IsEntitySelfType || target.IsEntityPlayerType, buffCasterTempAttr, buffTargetTempAttr); if (num != 0L) { List <ClientDrvBuffInfo> casterBuffInfo = null; List <ClientDrvBuffInfo> targetBuffInfo = null; if (isCommunicateMix) { casterBuffInfo = LocalAgent.MakeClientDrvBuffInfo(caster.ID); targetBuffInfo = LocalAgent.MakeClientDrvBuffInfo(target.ID); } long num2 = LocalAgent.GetSpiritCurHp(target, isCommunicateMix) + num; if (num2 > target.RealHpLmt) { num2 = target.RealHpLmt; } Pos pos = null; if (caster.Actor) { pos = new Pos(); pos.x = caster.Actor.FixTransform.get_position().x * 100f; pos.y = caster.Actor.FixTransform.get_position().z * 100f; } LocalAgent.SetSpiritCurHp(target, num2, isCommunicateMix); if (isCommunicateMix) { GlobalBattleNetwork.Instance.SendClientDriveBattleBuffDamage(caster.ID, target.ID, caster.Hp, num2, num, buffData.id, true, casterBuffInfo, targetBuffInfo, new List <long>(), string.Concat(new object[] { caster.TryAddValue(GameData.AttrType.SkillTreatScaleBOAtk, buffCasterTempAttr), "_", caster.TryAddValue(GameData.AttrType.SkillTreatScaleBOHpLmt, buffCasterTempAttr), "_", caster.TryAddValue(GameData.AttrType.SkillIgnoreDefenceHurt, buffCasterTempAttr) })); } LocalBattleProtocolSimulator.SendTreat(target.ID, (GameObjectType.ENUM)target.WrapType, caster.ID, (GameObjectType.ENUM)caster.WrapType, BattleAction_Treat.TreatSrcType.Treat, num, num2, pos); } }
public void Launch() { var result = BattleCalculator.Calculate(Attacker, Defender, HitSelector); if (ShowRounds) { PrintRoundResults(result.Rounds); } Console.WriteLine($"Completed simulation in {result.Rounds.Count} rounds."); Console.WriteLine(WinnerMessage(result)); }
public void CalculateEnemyDamaged() { var fakeDieRoller = new FakeDieRoller(); fakeDieRoller.ClearDieRoll(); fakeDieRoller.SetDieRoll = 2; fakeDieRoller.SetDieRoll = 2; fakeDieRoller.SetDieRoll = 3; var battleCalculator = new BattleCalculator(fakeDieRoller); Assert.Equal(BATTLERESULT.EnemyDamaged, battleCalculator.Result(1)); }
public void CalculateEnemyTripleDamaged() { var fakeDieRoller = new FakeDieRoller(); fakeDieRoller.ClearDieRoll(); fakeDieRoller.SetDieRoll = 5; fakeDieRoller.SetDieRoll = 5; fakeDieRoller.SetDieRoll = 5; // offense > 12 var battleCalculator = new BattleCalculator(fakeDieRoller); Assert.Equal(BATTLERESULT.EnemyTripleDamaged, battleCalculator.Result(13)); }
public void CalculateNoDamage() { var fakeDieRoller = new FakeDieRoller(); fakeDieRoller.ClearDieRoll(); fakeDieRoller.SetDieRoll = 1; fakeDieRoller.SetDieRoll = 1; fakeDieRoller.SetDieRoll = 1; // offense > 12 var battleCalculator = new BattleCalculator(fakeDieRoller); Assert.Equal(BATTLERESULT.None, battleCalculator.Result(1)); }
public override void Init(Position startingPosition, TurnManager turnManager, TileManager tileManager, BoardEntitySelector boardEntitySelector, BattleCalculator battleCalculator, Ka ka = null) { base.Init(startingPosition, turnManager, tileManager, boardEntitySelector, battleCalculator); if (charactersprite != null) { charactersprite.transform.SetParent(FindObjectOfType <CharacterManagerMarker>().transform); } allCharacterBoardEntities.Add(this); if (enemyAIBasic1 != null) { enemyAIBasic1.Init(tileManager, this); } basicAttack = new BasicAttack(); AddSkill(basicAttack); if (charContainer != null) { charContainer.Init(this); } floatingTextGenerator = GetComponent <FloatingTextGenerator>(); this.ka = ka; if (ka != null) { ka.Init(this); if (charKaAura != null) { //charKaAura.SetActive(true); //Color newColor = new Color(ka.KaColor.r, ka.KaColor.g, ka.KaColor.b, charKaAura.GetComponent<Image>().color.a); //charKaAura.GetComponent<Image>().color = newColor; } } initalized = true; foreach (Skill skill in skills) { InitSkill(skill); } foreach (Passive passive in passives) { InitPassive(passive); } foreach (Passive p in Passives) { p.StartBattle(); } }
public static void AppWeakCalculate(EntityParent caster, EntityParent target, XDict <AttrType, long> casterTempAttrs) { if (target.IsWeak) { return; } int num = target.Vp - BattleCalculator.CalculateWeak(caster.BattleBaseAttrs, casterTempAttrs); if (num < 0) { num = 0; } else if (num > target.RealVpLmt) { num = target.RealVpLmt; } target.SetValue(AttrType.Vp, num, true); }
void Start() { //武器、敵のデータベース取得 weaponDatabase = Resources.Load <WeaponDatabase>("weaponDatabase"); enemyDatabase = Resources.Load <EnemyDatabase>("enemyDatabase"); battleCalculator = new BattleCalculator(); messageList = new List <string>(); //成長率、レベルアップ時の感想を読み込み lvUpManager.init(); //battleStateを初期化状態に battleState = BattleState.INIT; //レベルアップ中、経験値ゲージ上昇中ではないのでtrue isLvupEnd = true; isExpGaugeUpdateEnd = true; }
/// <summary> /// /// </summary> /// <param name="caster"></param> /// <param name="enemyTargets"> Contains the single selection for the enemy.</param> /// <param name="allyTargets"></param> /// <returns></returns> public bool Activate(Character caster, Character[] enemyTargets, Character[] allyTargets) { Pensiveness penChar = caster as Pensiveness; if (penChar.PenMeter.CanRemoveAnyFromMeter()) { PensiveMeter.Spirits spirit = penChar.PenMeter.RemoveOldestFromMeter(); int damage = BattleCalculator.CalculateDamage(caster, enemyTargets[0], 2.0f, (Elements.Type)spirit); if (damage != BattleCalculator.AttackMissed) { enemyTargets[0].TakeDamage(damage); return(true); } return(false); } return(false); }
public void OnRollClicked() { BattleCalculator calculator = new BattleCalculator(); if (attackOrDefense == AttackOrDefense.Attack) { playerCalcResult = calculator.GetAttackDiceResult(player); enemyCalcResult = calculator.GetDefenseDiceResult(enemy); } else { playerCalcResult = calculator.GetDefenseDiceResult(player); enemyCalcResult = calculator.GetAttackDiceResult(enemy); } Run.After(DelayManager.Get().battleDiceRollToDiceResultDelay, () => { state = State.ShowRoll; AnimateDice(); }); }
public static void ReleaseManagers() { WarningGraghHandler.Release(); BattleCalculator.Release(); GlobalBattleNetwork.Instance.Release(); BattleBlackboard.Instance.Release(); LocalBattleHandler.Instance.Release(); LocalInstanceHandler.Instance.Release(); CityManager.Instance.Release(); AOIService.Instance.Release(); EntityWorld.Instance.Release(); InstanceManager.Release(); LoginManager.Instance.Release(); ReconnectManager.Instance.Release(); NetworkManager.Instance.Release(); for (int i = 0; i < BaseSubSystemManager.ListManager.get_Count(); i++) { BaseSubSystemManager.ListManager.get_Item(i).Release(); } }
protected void InitBuff(Buff buffData, EntityParent caster, EntityParent target, int fromSkillID, int elementType, bool isCommunicateMix = false) { double num = BattleCalculator.CalculateBuffTime(caster.BattleBaseAttrs.GetBuffCtrlAttrs(elementType), target.BattleBaseAttrs.GetBuffCtrlAttrs(elementType), (double)buffData.time); if (LocalAgent.CheckBuffByTargetIDAndBuffID(target.ID, buffData.id)) { int overlayModeId = buffData.overlayModeId; if (overlayModeId != 1) { if (overlayModeId == 2) { this.buffStateTable[target.ID][buffData.id].removeLeftTime = num; } } else { this.buffStateTable[target.ID][buffData.id].removeLeftTime += num; } return; } BuffState buffState = new BuffState(); buffState.isBlock = false; buffState.isCommunicateMix = isCommunicateMix; buffState.isGlobalBuff = false; buffState.casterID = caster.ID; buffState.fromSkillID = fromSkillID; buffState.fromSkillLevel = caster.GetSkillLevelByID(fromSkillID); buffState.fromSkillAttrChange = caster.GetSkillAttrChangeByID(fromSkillID); buffState.intervalDefaultTime = (float)buffData.interval; buffState.intervalLeftTime = (float)buffData.interval; buffState.removeLeftTime = num; if (!this.buffStateTable.ContainsKey(target.ID)) { this.buffStateTable.Add(target.ID, new XDict <int, BuffState>()); } this.buffStateTable[target.ID].Add(buffData.id, buffState); this.HandleBuff(buffData, caster, target, fromSkillID, buffState.fromSkillLevel, buffState.fromSkillAttrChange, isCommunicateMix); AddBuffAnnouncer.Announce(LocalAgent.GetEntityByID(target.ID), buffData.id); LocalBattleProtocolSimulator.SendAddBuff(caster.ID, target.ID, buffData.id, (int)num); }
private void EnemyVisual_EnemyAttacked(EnemyVisual enemy) { EnemyData enemyData = enemy.data; PlayerData playerData = player.data; Debug.Log(string.Format("{0} is being attacked!", enemyData.name)); bool hit = BattleCalculator.GetHit(playerData.stats, enemyData.stats); if (hit) { int damage = BattleCalculator.GetDamage(playerData.stats, enemyData.stats, TAttackType.Physical); Debug.Log(string.Format("{0} took {1} damage!", enemyData.name, damage)); enemy.ReceiveDamage(damage); Debug.Log(string.Format("{0} has {1} HP left!", enemyData.name, enemyData.Current(TStat.HP))); } else { Debug.Log("Player missed!"); } }
//Sets base stats, components, and initial display protected virtual void Start() { ec = new EffectCalculator(this, bc, pc); bc = new BattleCalculator(this, ec); bc.ResetStats(); UpdateDisplay(); normal = render.color; //Set the normal color to the sprite's starting color //Innate immunites if (type == TYPE.DROID && type != TYPE.MAGIC_DROID) { immunities.Add("POISON"); //Droids immune to poison } if (type != TYPE.DROID) { immunities.Add("CORROSION"); //Non-droids immune to corrosion } }
//Multi-Target Healing/Repairing private string HealProjection(Entity user, string command) { BattleCalculator bc = user.bc; string ret = ""; int damage = 0; switch (command) { case "MAGIC": damage = -bc.MagicDmg; break; case "TECH": damage = -bc.TechDmg; break; } ret = "PWR: " + damage + "\n" + "BONUS: " + bc.Crit + "%" + "\n\n" + user.GetSpecial().description; return(ret); }
//Multi-Target Offensive Attack private string AttackAllProjection(Entity user, string command) { BattleCalculator bc = user.bc; string ret = ""; //Set Power int damage = 0; switch (command) { case "MAGIC": damage = (int)(bc.MagicDmg * user.GetSpecial().basePwr); break; case "TECH": damage = (int)(bc.TechDmg * user.GetSpecial().basePwr); break; } ret = "BASE PWR: ~" + damage + "\n\n" + "Damage and hit chance will vary from target to target"; return(ret); }
//Single-Target Offensive Attack private string SingleTargetProjection(Entity user, string command) { BattleCalculator bc = user.bc; string ret = ""; string description; //Set Description if (user.GetSpecial() != null) { description = user.GetSpecial().description; } else { description = "Physical Attack"; } //Set Power int damage = 0; switch (command) { case "ATTACK": damage = bc.PhysicalDmg; break; case "MAGIC": damage = bc.MagicDmg; break; case "TECH": damage = bc.TechDmg; break; } ret = "PWR: " + damage + "\n" + "HIT: " + bc.Hit + "%\n" + "CRIT: " + bc.Crit + "%" + "\n\n" + description; return(ret); }
public virtual void Init(Position startingPosition, TurnManager turnManager, TileManager tileManager, BoardEntitySelector boardEntitySelector, BattleCalculator battleCalculator, Ka ka = null) { healthBarInstance = Instantiate(healthBar); healthBarInstance.transform.SetParent(FindObjectOfType <HealthBarContainer>().gameObject.transform); healthBarInstance.GetComponent <UIFollow>().target = gameObject; healthBarInstance.transform.SetAsFirstSibling(); healthBarInstance.transform.position = new Vector3(100000, 100000); this.turnManager = turnManager; this.tileManager = tileManager; this.boardEntitySelector = boardEntitySelector; this.battleCalculator = battleCalculator; isInit = true; tileManager.AddBoardEntity(startingPosition, gameObject); position = startingPosition; stats.updateStatHandler += UpdateUi; stats.Start(this); turnManager.AddBoardEntity((CharacterBoardEntity)this); UpdateUi(); }
public MentalBreakScript(BattleCalculator v) { _v = v; }