private void Start()
{
_collider = GetComponentInChildren <Collider2D>();
_boss = GameObject.FindGameObjectWithTag(Tags.Boss).GetComponent <BossActor>();
_contactFilter2D = new ContactFilter2D();
_contactFilter2D.SetLayerMask(1 << LayerMask.NameToLayer(Layers.Harmfull));
}
private IEnumerable ChargeResolver(BossActor actor)
{
BossBehaviour.Log(actor + " charges", actor);
foreach (var unused in ChargeAndWaitForCompletion(actor))
{
yield return(null);
}
}
void SpawnEffect(BossActor target)
{
if (EffectPrefab == null)
{
return;
}
Instantiate(EffectPrefab, target.handler.transform.position + EffectOffset, Quaternion.identity);
}
public void Init(BossActor boss)
{
//Debug.Log("Start init of boss: " + boss.Name);
this.boss = boss;
boss.onHealthChanged += UpdateHealth;
boss.onStatusChanged += UpdateStatus;
hpBar = hpBarObj.GetComponent <RectTransform>();
hpBar.DOScaleX(1f, 0f);
hpBarText.text = "100% HP";
}
/// <summary>
/// Tally up the amount of damage the stage has taken. Only affects shared health stages
/// </summary>
/// <param name="stageIndex">The stage to take damage</param>
/// <param name="damage">The amount of damage taken</param>
public void ApplyDamageToCurrentStage(float damage, BossActor parentBoss)
{
GetCurrentStage().damageTaken += damage;
//Check if the shared damage is enugh to complte the stage
if (IsCurrentStageComplete())
{
parentBoss.StageCompleted();
}
}
private IEnumerable WaitResolver(BossActor actor, float duration)
{
BossBehaviour.Log(actor + " waits for " + duration + " seconds", actor);
while (duration > 0)
{
yield return(null);
duration -= Time.deltaTime;
}
}
private IEnumerable MoveResolver(BossActor actor, BossBehaviour.TargetType type)
{
BossBehaviour.Log(actor + " moves to " + type, actor);
var mob = actor.Mobile;
var targetPositionX = GetTargetPositionX(type, mob);
var toTarget = targetPositionX - mob.BodyPosition.x;
if (Mathf.Abs(toTarget) < _settings.CloseRangeThreshold)
{
foreach (var unused in WalkResolver(actor, targetPositionX))
{
yield return(null);
}
}
else if (Mathf.Abs(toTarget) < _settings.MidRangeThreshold)
{
BossBehaviour.Log(Time.frameCount + " actor will jump to targetX", actor);
foreach (var unused in JumpAndWaitForCompletion(actor, toTarget))
{
DebugExtension.DebugArrow(mob.BodyPosition.WithX(targetPositionX), Vector3.down);
yield return(null);
}
}
else
{
const float LongRangeWalkDistance = 2;
var movementDirection = Mathf.Sign(toTarget);
var walkTargetX = ClampPositionX(mob.BodyPosition.x + movementDirection * LongRangeWalkDistance);
BossBehaviour.Log(Time.frameCount + " actor will first walk to walkTargetX", actor);
foreach (var unused in WalkResolver(actor, walkTargetX))
{
yield return(null);
}
BossBehaviour.Log(Time.frameCount + " then actor will jump to targetX", actor);
foreach (var unused in JumpAndWaitForCompletion(actor, targetPositionX - mob.BodyPosition.x))
{
DebugExtension.DebugArrow(mob.BodyPosition.WithX(targetPositionX), Vector3.down);
yield return(null);
}
}
}
private IEnumerable ChargeAndWaitForCompletion(BossActor actor)
{
foreach (var unused in _controller.WaitForStateEnter <ChargeAttackState>(actor))
{
BossBehaviour.Log(Time.frameCount + " wait for charge state enter", actor);
actor.DesiredCharge = true;
yield return(null);
}
BossBehaviour.Log(Time.frameCount + " charge state entered", actor);
foreach (var unused in _controller.WaitForStateExit <ChargeAttackState>(actor))
{
BossBehaviour.Log(Time.frameCount + " wait for charge state exit", actor);
yield return(null);
}
BossBehaviour.Log(Time.frameCount + " charge state exited", actor);
}
private IEnumerable JumpAttackAndWaitForCompletion(BossActor actor, float toTarget)
{
foreach (var unused in _controller.WaitForStateEnter <JumpAttackState>(actor))
{
BossBehaviour.Log(Time.frameCount + " wait for jumpattack state enter", actor);
actor.DesiredJumpAttack = true;
actor.DesiredJumpMovement = toTarget;
yield return(null);
}
BossBehaviour.Log(Time.frameCount + " jumpattack state entered", actor);
foreach (var unused in _controller.WaitForStateExit <StrikeGroundState>(actor))
{
BossBehaviour.Log(Time.frameCount + " wait for strike ground state exit", actor);
yield return(null);
}
BossBehaviour.Log(Time.frameCount + " strike ground state exited", actor);
}
public AttackState(BossActor actor, int comboCount = 0) : base(actor)
{
ComboCount = comboCount;
switch (ComboCount)
{
case 0:
_setting = Settings.Attack1;
break;
case 1:
_setting = Settings.Attack2;
break;
default:
_setting = Settings.Attack3;
break;
}
}
private IEnumerable JumpAttackResolver(BossActor actor, BossBehaviour.TargetType type)
{
BossBehaviour.Log(actor + " jump attacks", actor);
var mob = actor.Mobile;
var targetPositionX = GetTargetPositionX(type, mob);
// var targetPositionX = Mathf.Clamp( Player.BodyPosition.x, GetHotSpotPosition( TargetType.LeftCorner ).x,
// GetHotSpotPosition( TargetType.RightCorner ).x );
var delta = targetPositionX - actor.Mobile.BodyPosition.x;
foreach (var unused in JumpAttackAndWaitForCompletion(actor, delta))
{
DebugExtension.DebugArrow(mob.BodyPosition.WithX(targetPositionX - delta), Vector3.up);
DebugExtension.DebugArrow(mob.BodyPosition.WithX(targetPositionX), Vector3.down);
yield return(null);
}
}
// Load the bosses and retrun their speed
float LoadBoss()
{
float totalSpeed = 0f;
int index = 0;
MonsterHandler handler;
print(" - boss count: " + data.Zone.BossFight.monsters.Count);
foreach (BossData boss in data.Zone.BossFight.monsters)
{
//Debug.Log(" - Loading Boss: " + boss.Name);
string bossSpritePath = "Monster/" + boss.Sprite;
GameObject prefab = Resources.Load <GameObject>(bossSpritePath);
if (prefab == null)
{
Tracer.traceError("Could not Instantiate Monster: " + bossSpritePath);
continue;
}
GameObject bossObj = (GameObject)Instantiate(prefab);
bossObj.transform.SetParent(battleRoot.MonsterPositions[index]);
// set sprite order render as well here
bossObj.transform.localPosition = Vector3.zero;
/*Vector3 tempscale = Vector3.one;
* tempscale.x *= prefab.transform.localScale.x;
* bossObj.transform.localScale = tempscale;*/
bossObj.name = boss.Name;
handler = bossObj.AddComponent <MonsterHandler>();
BossActor enemy = new BossActor(boss, handler, FCTInterface, this);
battleRoot.HealthBars[index].gameObject.SetActive(true);
battleRoot.HealthBars[index].Init(enemy);
TurnOrder.Add(enemy);
totalSpeed += boss.Speed;
index++;
//Debug.Log("Finished Spawning " + boss.Name);
}
return(totalSpeed);
}
private IEnumerable AttackResolver(BossActor actor, int count)
{
BossBehaviour.Log(Time.frameCount + " " + actor + " attacks " + count + " times", actor);
for (var i = count; i > 0; i--)
{
foreach (var unused in _controller.WaitForStateEnter <AttackState>(actor))
{
BossBehaviour.Log(Time.frameCount + " waiting attack state enter", actor);
actor.DesiredAttack = true;
yield return(null);
}
}
BossBehaviour.Log(Time.frameCount + " attack state entered", actor);
foreach (var unused in _controller.WaitForStateExit <AttackState>(actor))
{
BossBehaviour.Log(Time.frameCount + " waiting attack state exit", actor);
yield return(null);
}
}
private static IEnumerable WalkResolver(BossActor actor, float targetPositionX)
{
var mob = actor.Mobile;
const float MovementEpsilon = 0.1f;
// set a timeout to prevent player from using properly timed attacks in order to block movement
var walkSpeed = Boss1Settings.Instance.GroundedMovementSpeed;
var distance = Mathf.Abs(mob.BodyPosition.x - targetPositionX);
var duration = distance / walkSpeed;
BossBehaviour.Log(Time.frameCount + " actor will walk to targetX", actor);
while (Mathf.Abs(targetPositionX - mob.BodyPosition.x) > MovementEpsilon && duration > 0)
{
DebugExtension.DebugArrow(mob.BodyPosition.WithX(targetPositionX), Vector3.down);
BossBehaviour.Log(Time.frameCount + " wait for actor to reach targetX", actor);
duration -= Time.deltaTime;
actor.DesiredMovement = Mathf.Sign(targetPositionX - mob.BodyPosition.x);
yield return(null);
}
}
private IEnumerable ActionResolver(BossActor actor, BossBehaviour.Action action)
{
switch (action.Type)
{
case BossBehaviour.ActionType.Wait:
return(WaitResolver(actor, action.DurationParameter));
case BossBehaviour.ActionType.Move:
return(MoveResolver(actor, action.TargetTypeParameter));
case BossBehaviour.ActionType.JumpAttack:
return(JumpAttackResolver(actor, action.TargetTypeParameter));
case BossBehaviour.ActionType.Charge:
return(ChargeResolver(actor));
case BossBehaviour.ActionType.Attack:
return(AttackResolver(actor, action.CountParameter));
case BossBehaviour.ActionType.Count:
default:
throw new ArgumentOutOfRangeException();
}
}
public DeathState(BossActor actor) : base(actor)
{
}
public GroundedState(BossActor actor) : base(actor)
{
}
public ChargeAttackState(BossActor actor) : base(actor)
{
}
public CriticalHurtState(BossActor actor, float direction) : base(actor, direction)
{
}
public HurtState(BossActor actor, float direction) : base(actor)
{
_hurtDirection = direction;
}
public BossFixedHorizontalMovementBase(BossActor actor) : base(actor.Mobile)
{
Actor = actor;
Settings = Boss1Settings.Instance;
}
public JumpState(BossActor actor, float height, float distance) : base(actor)
{
_jumpHeight = height;
_horizontalDistance = distance;
}
protected BossFixedTimeStateBase(BossActor actor)
{
Actor = actor;
Settings = Boss1Settings.Instance;
}
public FallState(BossActor actor) : base(actor)
{
}
public JumpAttackState(BossActor actor, float height, float distance) : base(actor, height, distance)
{
}
public StrikeGroundState(BossActor actor) : base(actor)
{
}
public BossFixedVerticalMovementStateBase(BossActor actor) : base(actor.Mobile)
{
Actor = actor;
Settings = Boss1Settings.Instance;
}
public PrepareJumpState(BossActor actor, bool transitionToJumpAttack) : base(actor)
{
_mobile = actor.Mobile;
_transitionToJumpAttack = transitionToJumpAttack;
}
public DiveState(BossActor actor) : base(actor)
{
}
