private void explosion(DamageTokenBasis token)
{
GameController.FieldActionController.explosion(token.Target.CurrentPosition, FieldActionController.ExplisionLevel.THREE);
GameController.PlayingLogger.addLogFormat("{0} は爆発した！", token.Target.Parameter.Name);
token.Target.isDead = true;
Awaked = true;
}
public float damagedOwn(DamageTokenBasis damagetoken, float damage)
{
if (canConvert(damagetoken)) {
damage = 2;
}
return damage;
}
public override DamageOffset calcOffsetWhenOffensiveSide(DamageOffset offset, DamageTokenBasis token)
{
if (token.Target.Parameter.CharacterElement == this.TargetElemental) {
offset.addOffensiveSideFinalDamageOffset(levelrate[(int)this.CurrentAbilityLevel]);
}
return offset;
}
public float damagedOwn(DamageTokenBasis damagetoken, float damage)
{
Debug.logger.Log("ダメージ反射",string.Format("T{0} D:{1}",damagetoken,damage));
var value = Mathf.Max(1, damage * ReflectionRate);
//damagetoken.Attacker.damaged(new FixDamage(damagetoken.Target,damagetoken.Attacker,(int)value,new CommonCOD(damagetoken.Target as PlayerController)));
GameController.ActResultController.add(new ReflectionDamageResult(damagetoken.Target, damagetoken.Attacker, value));
return damage;
}
public float damagedOwn(DamageTokenBasis token, float damage)
{
//GameController.PlayingLogger.addLogFormat("Current:{0} Next:{1}",damagetoken.Target.Parameter.CurrentHP, damagetoken.Target.Parameter.CurrentHP-damage);
var nextHP = token.Target.Parameter.CurrentHP - damage;
if (nextHP > 0 && nextHP <= token.Target.Parameter.MaxHP * ExplosionHPRate) {
explosion(token);
}
return damage;
}
public float damagedOwn(DamageTokenBasis damagetoken, float damage)
{
var p = damagetoken.Target as PlayerController;
if (p != null)
{
p.Parameter.recoveryHunger(HealRate, false);
}
return damage;
}
public float damagedOwn(DamageTokenBasis damagetoken, float damage)
{
//GameController.PlayingLogger.addLog(Equipment.ToString());
if (Equipment.IsEquipping) {
Equipment.subEnhancementPoint(1);
}
return damage;
}
public float damagedOwn(DamageTokenBasis damagetoken, float damage)
{
var p = damagetoken.Target as PlayerController;
if (p != null)
{
int value = (int)Mathf.Max(1, (damage / 10f));
p.gainExp(value, false);
}
return damage;
}
public float damagedOwn(DamageTokenBasis damagetoken, float damage)
{
var p = damagetoken.Target as PlayerController;
if (p != null) {
int value = (int)Mathf.Max(1, (damage/ 10f));
//GameController.PlayingLogger.addLogFormat("{0} {1} {2}", p.Parameter.Name, damage,value);
p.Parameter.Inventory.addMoney(value);
}
return damage;
}
public static float calcDamage(DamageTokenBasis token, IDamageOffsetNode[] offensiveside, IDamageOffsetNode[] deffensiveside,bool iscritical)
{
var offset = new DamageOffset();
foreach (IDamageOffsetNode node in offensiveside)
{
//GameController.PlayingLogger.addLog(node.GetType().ToString());
offset = node.calcOffsetWhenOffensiveSide(offset, token);
}
foreach (IDamageOffsetNode node in deffensiveside)
{
offset = node.calcOffestWhenDefensiveSide(offset, token);
}
return calcDamage(token.Attacker.Parameter.RealAtk * token.Attacker.ParameterOffset.AtkOffset1, token.Target.Parameter.RealDef * token.Target.ParameterOffset.DefOffset1, offset,iscritical);
}
public bool canExertion(DamageTokenBasis token)
{
return canConvert(token);
}
private void callDead(DamageTokenBasis token)
{
callDead(token.COD);
}
public override float damaged(DamageTokenBasis token)
{
var damage = base.damaged(token);
Parameter.damagedBangles(token);
if (isDead) { callDead(token); }
return damage;
}
public override void damaged(DamageTokenBasis token)
{
}
public bool isDamageCalculationSkip(DamageTokenBasis token)
{
return false;
}
public bool canExertion(DamageTokenBasis token)
{
return token.GetType() != typeof(DOTDamage);
}
public virtual float damaged(DamageTokenBasis token)
{
if (isDead) return 0;
var actives = this.Parameter.Abilities.FindAll(a => a is IDamageReactionAbility && !a.IsSealed).ConvertAll(a=> a as IDamageReactionAbility);
//GameController.PlayingLogger.addLogFormat("B:{0}",actives.Count);
actives.RemoveAll(a => !a.canExertion(token));
//GameController.PlayingLogger.addLogFormat("A:{0}", actives.Count);
var find = this.Parameter.findDamageCalculationSkipAbility(token,actives);
float ret = 0;
if (find.Count != 0)
{
find.ForEach(f=> {
f.applyDamageCalcurationSkipAbility(token);
});
}
else {
float damage = token.calcDamage();
damage = token.applyDamageOffsetFromAbilities(damage,actives);
token.applyDamage(damage);
if (this.isDead) {
if (token.Attacker != null && token.AllowGainExp)
{
token.Attacker.killedTarget(this);
}
ItemBasis drop = null;
if (GameController.Rnd.lottery(this.Parameter.ItemDropProbability)) {
drop = this.getDropItem();
}
var abilities = token.Attacker.Parameter.Abilities.FindAll(a => {
var reaction = a as IKilledEnemyDropedItemReactionAbility;
if (reaction == null) return false;
return reaction.canExertion(token) && GameController.Rnd.lottery(reaction.ExertionProbability);
}).ConvertAll(a => a as IKilledEnemyDropedItemReactionAbility);
if (abilities.Count != 0) {
int idx = GameController.Rnd.Next(abilities.Count);
drop = abilities[idx].operation();
}
if (drop != null) ObjectEntityFactory.enableItemEntity(drop, token.Target.Position);
}
token.ShowLogAction(damage);
ret = damage;
if(token.Attacker != null) token.Attacker.gainExp();
}
actives.ForEach(a => (a as AbilityBasis).exertion(token.Attacker,token.Target));
return ret;
}
public bool canExertion(DamageTokenBasis token)
{
return true;
}
public new void attackHit(DamageTokenBasis token, float damage)
{
var amount = (int)Mathf.Max(1, damage * 0.25f);
token.Attacker.heal(amount, false, false);
}
public virtual DamageOffset calcOffsetWhenOffensiveSide(DamageOffset offset,DamageTokenBasis token)
{
return offset;
}
public virtual float attackHit(DamageTokenBasis damagetoken,float damage)
{
return damage;
}
bool canConvert(DamageTokenBasis token)
{
bool b1 = token.GetType() != typeof(NormalAttackDamage) && token.GetType() != typeof(ExplosionDamage);
bool b2 = token.GetType() == typeof(ExplosionDamage) && (token as ExplosionDamage).Level == FieldActionController.ExplisionLevel.ONE;
//GameController.PlayingLogger.addLogFormat("CanConvert:{0} {1}", b1, b2);
if (b2) return true;
return b1;
}
public void applyDamageCalcurationSkipAbility(DamageTokenBasis token)
{
}
public float damagedOwn(DamageTokenBasis damagetoken, float damage)
{
return damage / 2;
}
public bool canExertion(DamageTokenBasis token)
{
var t = token as ElementalDamage;
if (t != null && t.Elemental == CharacterParameterBasis.Elemental.FIRE) return true;
return false;
}
public bool canExertion(DamageTokenBasis token)
{
return token is NormalAttackDamage;
}
public void damagedBangles(DamageTokenBasis token)
{
Array.ForEach(Bangles, b => {
b.damaged(token);
if (b.CurrentDamageState == BangleBasis.DamageState.BREAK) {
b.remove();
Bangles[Array.IndexOf(Bangles, b)] = BangleBasis.Dummy;
}
});
Inventory.removeAll(item => {
return item is BangleBasis && (item as BangleBasis).CurrentDamageState == BangleBasis.DamageState.BREAK;
});
}
public virtual void damaged(DamageTokenBasis token)
{
CurrentDurability -= (int)token.BangleDamageLevel;
if (!token.BreakableBangle || CurrentDamageState == DamageState.BRANDNEW) CurrentDurability = Mathf.Max(1, CurrentDurability);
//GameController.PlayingLogger.addLogFormat("Dur:{0}",CurrentDurability);
tryNextDamageState();
}
public override DamageOffset calcOffsetWhenOffensiveSide(DamageOffset offset, DamageTokenBasis token)
{
if (token is NormalAttackDamage && token.Target.Parameter.hasCategory(TargetCategory)) {
offset.mulOffensiveSideFinalDamageOffset(OffsetRate);
}
return offset;
}
public bool isDamageCalculationSkip(DamageTokenBasis token)
{
return !Awaked && token.GetType() == typeof(ExplosionDamage);
}
