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;
}
