// Damage enemies that enter this hitbox. May want to change to OnTriggerStay if
// we want hitboxes with continuous damage.
protected virtual void OnTriggerEnter(Collider other)
{
CombatActor otherActor = other.gameObject.GetComponent <CombatActor>();
if (otherActor != null && (otherActor.faction != faction || friendlyFire))
{
otherActor.Health -= Mathf.FloorToInt(damage);
// for debugging
print(otherActor.Health);
}
/**
* // Commenting out this code b/c it means hitboxes colliding also damages user
*
* else
* {
* CombatActor dmg = other.gameObject.GetComponentInParent<CombatActor>();
* if (dmg != null)
* {
* dmg.health -= Mathf.FloorToInt(damage);
* print(dmg.health);
* }
* }
**/
}
// Token: 0x06003895 RID: 14485 RVA: 0x00100E68 File Offset: 0x000FF068
public void AddDelayHit(int frame, Vector2i pos, CombatActor target)
{
if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_AddDelayHitInt32Vector2iCombatActor_hotfix != null)
{
this.m_AddDelayHitInt32Vector2iCombatActor_hotfix.call(new object[]
{
this,
frame,
pos,
target
});
return;
}
BJLuaObjHelper.IsSkipLuaHotfix = false;
if (this.m_hitCount >= this.m_skillInfo.HitCountMax)
{
return;
}
int index = 0;
for (int i = this.m_delayHits.Count - 1; i >= 0; i--)
{
if (this.m_delayHits[i].m_frame <= frame)
{
index = i + 1;
break;
}
}
DelayHit item = default(DelayHit);
item.m_frame = frame;
item.m_position = pos;
item.m_targetActor = target;
this.m_delayHits.Insert(index, item);
}
/// <summary>
/// Creates a new traveling state with the given actor and intervals.
/// </summary>
/// <param name="actor">The actor to travel.</param>
/// <param name="repathInterval">The period of time between repathing.</param>
/// <param name="evaluateInterval">The period of time between state evaluation.</param>
public TravelingState(CombatActor actor,
float repathInterval, float evaluateInterval)
: base(actor, evaluateInterval)
{
this.actor = actor;
RepathInterval = repathInterval;
}
public CombatActor(INameable name, IStats stats, IDamageable damageable, IDamageDealer dealer)
{
Name = name;
Target = null;
Stats = stats;
Damageable = damageable;
DamageDealer = dealer;
}
public override void ApplyToActor(CombatActor aTargetActor)
{
int defense = aTargetActor.GetAttributeValue(AttributeType.Defense);
int finalDamages = (int)Mathf.Ceil(myDamageAmount - defense / 2);
// TODO: damage type
aTargetActor.TakeDamage(mySourceActor, finalDamages, myDamageType);
}
// Token: 0x0600378A RID: 14218 RVA: 0x000F9D90 File Offset: 0x000F7F90
private void SetupTeam(int teamNumber, BattleActor battleActor, ConfigDataSkillInfo heroSkillInfo)
{
if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_SetupTeamInt32BattleActorConfigDataSkillInfo_hotfix != null)
{
this.m_SetupTeamInt32BattleActorConfigDataSkillInfo_hotfix.call(new object[]
{
this,
teamNumber,
battleActor,
heroSkillInfo
});
return;
}
BJLuaObjHelper.IsSkipLuaHotfix = false;
if (battleActor == null)
{
return;
}
CombatTeam combatTeam = this.m_teams[teamNumber];
combatTeam.Initialize(this, teamNumber, battleActor, heroSkillInfo);
int num = this.ConfigDataLoader.Const_CombatHeroDistance / -2;
int num2 = -20;
int num3 = 1;
if (this.GetCombatGridDistance() > 1)
{
num -= this.ConfigDataLoader.Const_CombatSplitScreenDistance / 2;
}
if (teamNumber != 0)
{
num = -num;
num3 = -1;
}
if (battleActor.HeroInfo != null)
{
CombatActor combatActor = combatTeam.CreateActor(true);
combatActor.SetPosition(num, num2);
combatActor.SetDirection(num3);
combatActor.SetFormationLine(9);
}
if (battleActor.SoldierInfo != null)
{
int soldierCount = battleActor.GetSoldierCount();
for (int i = 0; i < soldierCount; i++)
{
CombatActor combatActor2 = combatTeam.CreateActor(false);
Position2i formationPosition = combatTeam.GetFormationPosition(i);
combatActor2.SetPosition(num + formationPosition.x * num3, num2 + formationPosition.y);
combatActor2.SetDirection(num3);
combatActor2.SetFormationLine(combatTeam.GetFormationLine(i));
if (i == soldierCount - 1)
{
combatActor2.SetHealthPoint(battleActor.SoldierTotalHealthPoint - combatActor2.HealthPointMax * (soldierCount - 1));
}
}
}
}
public override List <CombatEffect> GenerateCombatEffects(CombatActor aSourceCombatActor, Vector2Int aTargetPosition)
{
int attack = aSourceCombatActor.GetAttributeValue(AttributeType.Attack);
DamageCombatEffect damageEffect = new DamageCombatEffect(attack, DamageType.PHYSICAL);
damageEffect.myAffectedCells = GetAffectedCellsPattern();
return(new List <CombatEffect>()
{
damageEffect
});
}
// Token: 0x060038A6 RID: 14502 RVA: 0x00101EBC File Offset: 0x001000BC
private void AddSkillDelayHits(CombatSkillState ss, Fix64 x0, Fix64 x1)
{
if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_AddSkillDelayHitsCombatSkillStateFix64Fix64_hotfix != null)
{
this.m_AddSkillDelayHitsCombatSkillStateFix64Fix64_hotfix.call(new object[]
{
this,
ss,
x0,
x1
});
return;
}
BJLuaObjHelper.IsSkipLuaHotfix = false;
int num = 0;
int num2 = 0;
int num3 = this.GetDelayHitFrameMax() - this.m_frameCount;
if (num3 >= 0 && ss.m_skillInfo.Time_MultiHit.Count > 0)
{
num = Combat.FrameToMillisecond(num3) + ss.m_skillInfo.Time_MultiHit[0];
num2 = 1;
}
while (ss.m_preAttackHitCount < ss.m_skillInfo.HitCountMax)
{
CombatActor combatActor = this.SearchHitTarget(x0, x1, this.m_hitId);
if (combatActor != null)
{
bool isCritical = ss.IsCritical(combatActor.IsHero());
do
{
this.AddDelayHit(combatActor, num);
this.m_sourceActor.PreAttack(combatActor, ss.m_skillInfo, isCritical);
if (ss.m_skillInfo.Time_MultiHit.Count > 0)
{
num += ss.m_skillInfo.Time_MultiHit[num2 % ss.m_skillInfo.Time_MultiHit.Count];
num2++;
}
ss.m_preAttackHitCount++;
if (combatActor.GetPreAttackHealthPoint() <= 0 && !combatActor.IsHero())
{
break;
}
}while (ss.m_preAttackHitCount < ss.m_skillInfo.HitCountMax);
IL_190:
combatActor.AddBeHitId(this.m_hitId);
continue;
goto IL_190;
}
break;
}
}
// Token: 0x060038A3 RID: 14499 RVA: 0x001019E0 File Offset: 0x000FFBE0
private static int ComputeTargetScore(Fix64 x, CombatActor target)
{
int num = 0;
if (target.GetPreAttackHealthPoint() <= 0)
{
num = 1000000;
}
num += target.FormationLine * 100000;
int num2 = (int)((long)(x - target.Position.x));
return(num + num2 * num2 / 100);
}
private void OnTriggerEnter(Collider collider)
{
CombatActor actor = collider.gameObject.GetComponent <CombatActor>();
if (actor)
{
// Damage the actor
actor.TakeDamage(Damage);
// Destroy this object on collision
Destroy(gameObject);
}
}
public override List <CombatEffect> GenerateCombatEffects(CombatActor aSourceCombatActor, Vector2Int aTargetPosition)
{
int magic = aSourceCombatActor.GetAttributeValue(AttributeType.MagicPower);
float magicModifier = 1.0f + magic / 10.0f;
int damages = (int)Mathf.Floor(10 * magicModifier);
DamageCombatEffect damageEffect = new DamageCombatEffect(damages, DamageType.AIR);
PushActorCombatEffect pushEffect = new PushActorCombatEffect(new Vector2Int(2, 0));
return(new List <CombatEffect>()
{
damageEffect, pushEffect
});
}
private void Awake()
{
// Convert the inspector materials into dictionary form.
materials = new Dictionary <CombatActor.State, Material>();
foreach (StateMaterialEntry entry in stateMaterials)
{
materials.Add(entry.state, entry.material);
}
// Get the combat actor instance.
instance = combatActor.Unwrap();
// Subscribe to the state changed event and set initial visual state.
instance.StateChanged += OnStateChanged;
OnStateChanged(instance, instance.CurrentState);
}
// Reinitialize variables, should be used if repurposing a hitbox.
public virtual void reinitialize(GameObject u, float dam, float lifetime, bool hurtSelf, bool reuse)
{
user = u;
damage = dam;
lifetimeSeconds = lifetime;
friendlyFire = hurtSelf;
reusable = reuse;
CombatActor userActor = u.GetComponent <CombatActor>();
faction = userActor != null ? userActor.faction: Faction.None;
convertLifetime();
reset();
}
// Token: 0x060038A5 RID: 14501 RVA: 0x00101C34 File Offset: 0x000FFE34
public override void Tick()
{
if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_Tick_hotfix != null)
{
this.m_Tick_hotfix.call(new object[]
{
this
});
return;
}
BJLuaObjHelper.IsSkipLuaHotfix = false;
this.m_life++;
this.m_frameCount++;
if (this.m_life <= this.m_lifeMax)
{
if (this.m_configDataFlyObjectInfo.TrackType == TrackType.TrackType_Parabolic)
{
CombatActor targetActor = this.m_targetActor;
Fix64 value = MathUtility.Lerp(this.m_startPosition.x, this.m_endPosition.x, (Fix64)((long)this.m_life) / (Fix64)((long)this.m_lifeMax));
int num = this.m_configDataFlyObjectInfo.CollisionRadius + targetActor.Radius;
if (((this.m_endPosition.x >= this.m_startPosition.x && (int)((long)value) >= (int)((long)targetActor.Position.x) - num) || (this.m_endPosition.x < this.m_startPosition.x && (int)((long)value) <= (int)((long)targetActor.Position.x) + num)) && targetActor.CanBeTarget())
{
this.Attack(this.m_targetActor);
this.m_targetActor.AddBeHitId(this.m_hitId);
this.m_sourceSkillState.m_hitCount++;
base.DeleteMe();
}
}
else
{
Fix64 x = MathUtility.Lerp(this.m_startPosition.x, this.m_endPosition.x, (Fix64)((long)(this.m_life - 1)) / (Fix64)((long)this.m_lifeMax));
Fix64 x2 = MathUtility.Lerp(this.m_startPosition.x, this.m_endPosition.x, (Fix64)((long)this.m_life) / (Fix64)((long)this.m_lifeMax));
this.AddSkillDelayHits(this.m_sourceSkillState, x, x2);
this.TickDelayHits();
}
}
else if (this.HasDelayHit())
{
this.TickDelayHits();
if (this.m_fx != null)
{
this.m_fx.FxStop(true);
this.m_fx = null;
}
}
else
{
base.DeleteMe();
}
}
public CombatActorViewModel(CombatActorPairStats pairStats, string mainActorName)
{
if (pairStats == null)
{
throw new ArgumentNullException("pairStats");
}
if (mainActorName == null)
{
throw new ArgumentNullException("mainActorName");
}
PairStats = pairStats;
AttackerActor = pairStats.GetActorByName(mainActorName);
DefenderActor = pairStats.ActorOne == AttackerActor ? pairStats.ActorTwo : pairStats.ActorOne;
}
// Token: 0x060038A4 RID: 14500 RVA: 0x00101A38 File Offset: 0x000FFC38
private CombatActor SearchHitTarget(Fix64 x0, Fix64 x1, ushort hitId)
{
if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_SearchHitTargetFix64Fix64UInt16_hotfix != null)
{
return((CombatActor)this.m_SearchHitTargetFix64Fix64UInt16_hotfix.call(new object[]
{
this,
x0,
x1,
hitId
}));
}
BJLuaObjHelper.IsSkipLuaHotfix = false;
CombatTeam team = this.Combat.GetTeam(this.m_targetTeamNumber);
int num = int.MaxValue;
CombatActor result = null;
int num2 = (int)((long)(x0 + x1)) / 2;
int num3 = Math.Abs((int)((long)(x0 - x1)) / 2) + this.m_configDataFlyObjectInfo.CollisionRadius;
if (!this.m_team.IsAttackHeroOnly())
{
foreach (CombatActor combatActor in team.GetActors())
{
if (combatActor.CanBeTarget())
{
if (Math.Abs((int)((long)combatActor.Position.x) - num2) <= num3 + combatActor.Radius)
{
if (!combatActor.HasBeHitId(hitId))
{
int num4 = CombatFlyObject.ComputeTargetScore(x1, combatActor);
if (num4 < num)
{
num = num4;
result = combatActor;
}
}
}
}
}
return(result);
}
CombatActor hero = team.GetHero();
if (hero != null && hero.CanBeTarget() && Math.Abs((int)((long)hero.Position.x) - num2) <= num3 + hero.Radius)
{
return(hero);
}
return(null);
}
protected override void attackAction()
{
for (int i = 0; i < hitboxObjs.Length; i++)
{
hitboxObjs[i].SetActive(true);
}
CombatActor selfDmg = GetComponentInParent <CombatActor>();
if (selfDmg != null)
{
selfDmg.Health -= Mathf.FloorToInt(selfDamage);
// for debugging
print(selfDmg.Health);
}
}
public override List <CombatEffect> GenerateCombatEffects(CombatActor aSourceCombatActor, Vector2Int aTargetPosition)
{
int magic = aSourceCombatActor.GetAttributeValue(AttributeType.MagicPower);
float magicModifier = 1.0f + magic / 10.0f;
int damages = (int)Mathf.Floor(10 * magicModifier);
DamageCombatEffect damageCombatEffect = new DamageCombatEffect(damages, DamageType.FIRE);
BuffCombatEffect burningEffect = new BuffCombatEffect(); // TODO: burning as buff
return(new List <CombatEffect>()
{
damageCombatEffect,
burningEffect
});
}
// Token: 0x06003790 RID: 14224 RVA: 0x000FA21C File Offset: 0x000F841C
public void OnActorCastSkill(CombatActor a, ConfigDataSkillInfo skillInfo)
{
if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_OnActorCastSkillCombatActorConfigDataSkillInfo_hotfix != null)
{
this.m_OnActorCastSkillCombatActorConfigDataSkillInfo_hotfix.call(new object[]
{
this,
a,
skillInfo
});
return;
}
BJLuaObjHelper.IsSkipLuaHotfix = false;
if (a == null || skillInfo == null)
{
return;
}
if (skillInfo.CutsceneType != 0)
{
ConfigDataCutsceneInfo configDataCutsceneInfo = null;
if (skillInfo.CutsceneType == 1)
{
ConfigDataHeroInfo heroInfo = a.Team.HeroInfo;
if (heroInfo != null)
{
ConfigDataCharImageInfo charImageInfo = heroInfo.GetCharImageInfo(a.Team.HeroStar);
if (charImageInfo != null)
{
configDataCutsceneInfo = charImageInfo.m_skillCutsceneInfo;
}
}
}
this.Pause(true);
this.m_teams[a.TeamNumber].SetGraphicSkillFade(true);
if (configDataCutsceneInfo != null)
{
this.m_cutscenePauseCountdown = Combat.MillisecondToFrame1(configDataCutsceneInfo.Time);
}
else
{
this.m_cutscenePauseCountdown = Combat.MillisecondToFrame1(this.ConfigDataLoader.Const_SkillPauseTime);
}
this.m_battle.Listener.OnStartSkillCutscene(skillInfo, configDataCutsceneInfo, a.TeamNumber);
}
}
string BuildSpellAttacks(CombatActor actor)
{
string result = string.Empty;
if (actor.AffectingHits > 0)
{
result += "Affecting: " + actor.AffectingHits + Environment.NewLine;
}
if (actor.FreezingHits > 0)
{
result += "Freezing: " + actor.FreezingHits + Environment.NewLine;
}
if (actor.FlamingHits > 0)
{
result += "Burning: " + actor.FlamingHits + Environment.NewLine;
}
return(result);
}
// Token: 0x06003792 RID: 14226 RVA: 0x000FA42C File Offset: 0x000F862C
public void OnActorDie(CombatActor a)
{
if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_OnActorDieCombatActor_hotfix != null)
{
this.m_OnActorDieCombatActor_hotfix.call(new object[]
{
this,
a
});
return;
}
BJLuaObjHelper.IsSkipLuaHotfix = false;
if (!this.IsPlay())
{
return;
}
this.m_battle.Listener.OnCombatActorDie(a);
}
// Token: 0x060038A7 RID: 14503 RVA: 0x00102088 File Offset: 0x00100288
private bool Attack(CombatActor target)
{
if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_AttackCombatActor_hotfix != null)
{
return(Convert.ToBoolean(this.m_AttackCombatActor_hotfix.call(new object[]
{
this,
target
})));
}
BJLuaObjHelper.IsSkipLuaHotfix = false;
if (target == null)
{
return(false);
}
bool isCritical = this.m_sourceSkillState.IsCritical(target.IsHero());
target.AttackBy(this.m_sourceActor, this.m_sourceSkillState.m_skillInfo, isCritical);
return(true);
}
private void TravelFight(Location location)
{
var opponent = World.Creatures
.OrderBy(c => Math.Abs(c.Stats.Level - Player.Stats.Level))
.Take(3)
.ToList()
.Random()
.Clone();
CombatActor combatOpponent = new CombatActor(opponent, opponent.Stats, opponent, opponent);
Combat combat = new Combat(Player, new[] { combatOpponent });
SetView(new ViewCombat(this, Renderer, combat, () =>
{
TravelTo(location, false);
if (combat.EnemiesDead)
{
RewardPlayerForCombat(combat);
}
}));
}
// Token: 0x06003791 RID: 14225 RVA: 0x000FA358 File Offset: 0x000F8558
public void OnActorCastPassiveSkill(CombatActor a, BuffState sourceBuffState)
{
if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_OnActorCastPassiveSkillCombatActorBuffState_hotfix != null)
{
this.m_OnActorCastPassiveSkillCombatActorBuffState_hotfix.call(new object[]
{
this,
a,
sourceBuffState
});
return;
}
BJLuaObjHelper.IsSkipLuaHotfix = false;
if (a == null || sourceBuffState == null)
{
return;
}
this.Pause(true);
this.m_teams[a.TeamNumber].SetGraphicSkillFade(true);
this.m_cutscenePauseCountdown = Combat.MillisecondToFrame1(this.ConfigDataLoader.Const_SkillPauseTime);
this.m_battle.Listener.OnStartPassiveSkillCutscene(sourceBuffState, a.TeamNumber);
}
// Token: 0x060038A8 RID: 14504 RVA: 0x00102138 File Offset: 0x00100338
private void AddDelayHit(CombatActor target, int delay)
{
if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_AddDelayHitCombatActorInt32_hotfix != null)
{
this.m_AddDelayHitCombatActorInt32_hotfix.call(new object[]
{
this,
target,
delay
});
return;
}
BJLuaObjHelper.IsSkipLuaHotfix = false;
if (target == null)
{
return;
}
if (this.m_delayHits == null)
{
this.m_delayHits = new List <DelayHit>();
}
int num = this.m_frameCount + Combat.MillisecondToFrame(delay);
int index = 0;
for (int i = this.m_delayHits.Count - 1; i >= 0; i--)
{
if (this.m_delayHits[i].m_frame <= num)
{
index = i + 1;
break;
}
}
DelayHit item = default(DelayHit);
item.m_frame = num;
item.m_targetActor = target;
this.m_delayHits.Insert(index, item);
this.m_sourceActor.SetCanStopFrame(delay + this.Combat.ConfigDataLoader.Const_DamagePostDelay);
}
// Use this for initialization
void Start()
{
CombatActor mainChar = new CombatActor();
mainChar.myName = "MainChar";
mainChar.myPosition = new Vector2Int(1, 1);
mainChar.SetAttributeValue(AttributeType.MaxHealth, 100);
mainChar.SetAttributeValue(AttributeType.CurrentHealth, 100);
CombatActor enemy1Char = new CombatActor();
enemy1Char.myName = "Enemy1";
enemy1Char.myPosition = new Vector2Int(7, 1);
enemy1Char.SetAttributeValue(AttributeType.MaxHealth, 100);
enemy1Char.SetAttributeValue(AttributeType.CurrentHealth, 100);
CombatActor enemy2Char = new CombatActor();
enemy2Char.myName = "Enemy2";
enemy2Char.myPosition = new Vector2Int(6, 2);
enemy2Char.SetAttributeValue(AttributeType.MaxHealth, 100);
enemy2Char.SetAttributeValue(AttributeType.CurrentHealth, 100);
}
public void TakeDamage(CombatActor aSource, int aDamageAmount, DamageType aDamageType)
{
GetAttributeState(AttributeType.CurrentHealth).myBaseValue -= aDamageAmount;
Debug.Log("Actor " + myName + " took " + aDamageAmount + " " + aDamageType + " damages from " + aSource.myName);
}
// Use this for initialization
void Start()
{
player_ca = player.GetComponent <CombatActor>();
player_data = player.GetComponent <PlayerData>();
}
/// <summary>
/// Creates the disabled state for the given actor.
/// </summary>
/// <param name="actor">The actor to effect.</param>
public DisabledState(CombatActor actor)
{
this.actor = actor;
}
// Use this for initialization
void Start()
{
player_ca = player.GetComponent <CombatActor>();
bar = gameObject.GetComponent <Slider>();
}
