public void SetAttackedHitStatus(AttackedHitStatusOwner status)
{
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
attackInfoName = status.attackInfo.name;
attackInfoRate = status.attackInfo.rateInfoRate;
fromObjectID = status.fromObjectID;
fromType = (int)status.fromType;
fromPos = status.fromPos;
hitPos = status.hitPos;
fromClientID = status.fromClientID;
if (status.skillParam != null)
{
skillIndex = status.skillParam.skillIndex;
}
regionID = status.regionID;
weakState = (int)status.weakState;
damage = status.damage;
validDamage = status.validDamage;
downAddBase = status.downAddBase;
downAddWeak = status.downAddWeak;
isArrowBleed = status.isArrowBleed;
arrowBleedDamage = status.arrowBleedDamage;
arrowBurstDamage = status.arrowBurstDamage;
badStatusAdd.Copy(status.badStatusAdd);
isSpAttackHit = status.IsSpAttackHit;
damageDetails = status.damageDetails;
isShadowSealing = status.isShadowSealing;
}
public virtual void OnAttackedHitOwner(AttackedHitStatusOwner status)
{
if (enableSend && !owner.IsCoopNone())
{
Coop_Model_ObjectAttackedHitOwner coop_Model_ObjectAttackedHitOwner = new Coop_Model_ObjectAttackedHitOwner();
coop_Model_ObjectAttackedHitOwner.id = owner.id;
coop_Model_ObjectAttackedHitOwner.SetAttackedHitStatus(status);
SendTo(owner.coopClientId, coop_Model_ObjectAttackedHitOwner, false, null, null);
}
}
public override void OnAttackedHitOwner(AttackedHitStatusOwner status)
{
if (!isDead)
{
Enemy enemy = status.fromObject as Enemy;
if (!(enemy == null))
{
status.damage = ((!enemy.isWaveMatchBoss) ? param.enemyNormalDamage : param.enemyBossDamage);
status.afterHP = _nowHp - status.damage;
base.OnAttackedHitOwner(status);
}
}
}
public void Add(Character to_chara, AttackedHitStatusOwner status)
{
if (!to_chara.isDead && status.validDamage)
{
int skill_id = 0;
if (status.skillParam != null)
{
skill_id = status.skillParam.baseInfo.id;
}
int damage = status.validDamage ? status.damage : 0;
Add(to_chara, status.fromObjectID, skill_id, status.attackInfo.name, damage);
}
}
public virtual void OnCharacterAttackedHitOwner(AttackedHitStatusOwner status)
{
if (brain != null)
{
if (status.downAddWeak > 0f)
{
brain.HandleEvent(BRAIN_EVENT.ATTACKED_WEAK_POINT, status);
}
else
{
brain.HandleEvent(BRAIN_EVENT.ATTACKED_HIT, status);
}
}
}
public void CopyAttackedHitStatus(out AttackedHitStatusOwner status)
{
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
AttackedHitStatus attackedHitStatus = new AttackedHitStatus();
attackedHitStatus.fromObjectID = fromObjectID;
attackedHitStatus.fromObject = MonoBehaviourSingleton <StageObjectManager> .I.FindCharacter(fromObjectID);
if (attackedHitStatus.fromObject != null)
{
attackedHitStatus.attackInfo = (attackedHitStatus.fromObject.FindAttackInfoExternal(attackInfoName, true, attackInfoRate) as AttackHitInfo);
}
if (attackedHitStatus.attackInfo == null)
{
attackedHitStatus.attackInfo = new AttackHitInfo();
}
attackedHitStatus.fromType = (StageObject.OBJECT_TYPE)fromType;
attackedHitStatus.fromPos = fromPos;
attackedHitStatus.hitPos = hitPos;
attackedHitStatus.fromClientID = fromClientID;
if (attackedHitStatus.fromObject != null)
{
attackedHitStatus.skillParam = attackedHitStatus.fromObject.GetSkillParam(skillIndex);
}
attackedHitStatus.regionID = regionID;
attackedHitStatus.weakState = (Enemy.WEAK_STATE)weakState;
attackedHitStatus.damage = damage;
attackedHitStatus.validDamage = validDamage;
attackedHitStatus.downAddBase = downAddBase;
attackedHitStatus.downAddWeak = downAddWeak;
attackedHitStatus.isArrowBleed = isArrowBleed;
attackedHitStatus.arrowBleedDamage = arrowBleedDamage;
attackedHitStatus.arrowBurstDamage = arrowBurstDamage;
attackedHitStatus.badStatusAdd.Copy(badStatusAdd);
attackedHitStatus.isSpAttackHit = isSpAttackHit;
attackedHitStatus.damageDetails = damageDetails;
attackedHitStatus.isShadowSealing = isShadowSealing;
status = new AttackedHitStatusOwner(attackedHitStatus);
}
public virtual void OnAttackedHitOwner(AttackedHitStatusOwner status)
{
}
public override void HandleEvent(BRAIN_EVENT ev, object param = null)
{
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00af: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_0144: Unknown result type (might be due to invalid IL or missing references)
//IL_014b: Unknown result type (might be due to invalid IL or missing references)
//IL_0150: Unknown result type (might be due to invalid IL or missing references)
//IL_0155: Unknown result type (might be due to invalid IL or missing references)
switch (ev)
{
case BRAIN_EVENT.END_ACTION:
if (base.opponentMem != null)
{
base.opponentMem.Update();
}
break;
case BRAIN_EVENT.OWN_ATTACK_HIT:
if (base.opponentMem != null)
{
OpponentMemory.OpponentRecord opponentRecord = base.opponentMem.Find(param as StageObject);
if (opponentRecord != null)
{
opponentRecord.record.isDamaged = true;
}
}
break;
case BRAIN_EVENT.ATTACKED_HIT:
{
AttackedHitStatusOwner attackedHitStatusOwner2 = (AttackedHitStatusOwner)param;
if (base.opponentMem != null)
{
OpponentMemory opponentMem2 = base.opponentMem;
Vector3 val2 = attackedHitStatusOwner2.fromPos - attackedHitStatusOwner2.hitPos;
DISTANCE distance2 = opponentMem2.GetDistance(val2.get_sqrMagnitude());
int num = (int)((float)attackedHitStatusOwner2.damage * base.opponentMem.hateParam.distanceAttackRatio[(int)distance2]);
if (isNPC(attackedHitStatusOwner2.fromObject))
{
num = (int)((float)num * 0.5f);
}
base.opponentMem.AddHate(attackedHitStatusOwner2.fromObject, num, Hate.TYPE.Damage);
}
break;
}
case BRAIN_EVENT.ATTACKED_WEAK_POINT:
{
AttackedHitStatusOwner attackedHitStatusOwner = (AttackedHitStatusOwner)param;
if (base.opponentMem != null)
{
int attackedWeakPointHate = base.opponentMem.hateParam.attackedWeakPointHate;
OpponentMemory opponentMem = base.opponentMem;
Vector3 val = attackedHitStatusOwner.fromPos - attackedHitStatusOwner.hitPos;
DISTANCE distance = opponentMem.GetDistance(val.get_sqrMagnitude());
attackedWeakPointHate = (int)((float)attackedWeakPointHate * base.opponentMem.hateParam.distanceAttackRatio[(int)distance]);
if (isNPC(attackedHitStatusOwner.fromObject))
{
attackedWeakPointHate = (int)((float)attackedWeakPointHate * 0.5f);
}
base.opponentMem.AddHate(attackedHitStatusOwner.fromObject, attackedWeakPointHate, Hate.TYPE.SpecialDamage);
}
break;
}
case BRAIN_EVENT.PLAYER_HEAL:
if (base.opponentMem != null)
{
Player.HateInfo hateInfo2 = param as Player.HateInfo;
base.opponentMem.AddHate(hateInfo2.target, hateInfo2.val, Hate.TYPE.Heal);
}
break;
case BRAIN_EVENT.PLAYER_SKILL:
if (base.opponentMem != null)
{
base.opponentMem.AddHate(param as StageObject, base.opponentMem.hateParam.skillHate, Hate.TYPE.Skill);
}
break;
case BRAIN_EVENT.REVIVE_REGION:
if (actionCtrl != null)
{
actionCtrl.OnReviveRegion((int)param);
}
break;
case BRAIN_EVENT.DECOY:
if (base.opponentMem != null)
{
DecoyBulletObject.HateInfo hateInfo = param as DecoyBulletObject.HateInfo;
base.opponentMem.AddHate(hateInfo.target, hateInfo.value, hateInfo.type);
}
break;
case BRAIN_EVENT.WAVE_TARGET:
if (base.opponentMem != null)
{
base.opponentMem.AddHate(param as StageObject, 1000, Hate.TYPE.Damage);
}
break;
}
base.HandleEvent(ev, param);
}
