// ====================================================
private IEnumerator SwapCoroutine(SwappableEntity swappableEntity)
{
SoundManager.instance.PlaySound(SoundManager.SoundType.Swap);
Vector2 previousPos = transform.position;
Vector2 previousSpeed = currentSpeed;
transform.position = VectorUtils.GetPosition3D(swappableEntity.GetPosition());
bool wasSwappableEntityGrounded = swappableEntity.physicsController.isGrounded;
swappableEntity.SetPosition(previousPos);
swappableEntity.SetVelocity(previousSpeed);
PatrollingEnemy patroller = swappableEntity as PatrollingEnemy;
if (patroller != null)
{
patroller.SetDirectionAsForward();
}
swappableEntity.OnSwap();
isSwapping = true;
deathVfxAnimator.SetTrigger("deathTrigger");
animator.gameObject.SetActive(false);
yield return(new WaitForSeconds(0.2f));
isSwapping = false;
animator.gameObject.SetActive(true);
currentSpeed = previousSpeed;
Vector2 direction = joystickController.GetDirection();
if (direction.x > 0.4f)
{
currentSpeed.x = maxHorizontalSpeed;
}
else if (direction.x < -0.4f)
{
currentSpeed.x = -maxHorizontalSpeed;
}
else
{
currentSpeed.x = 0f;
}
if (wasSwappableEntityGrounded)
{
currentSpeed.y = 0f;
}
else
{
currentSpeed.y = currentSpeed.y < 0f ? 0f : currentSpeed.y;
}
canDoubleJumped = true;
prevPos = VectorUtils.GetPosition2D(transform.position);
}
public void KeepPatrolling()
{
if (gameOverEnemy != null)
{
PatrollingEnemy patrolEnemy = gameOverEnemy.GetComponent <PatrollingEnemy>();
patrolEnemy.BackToPatrolling();
gameOverEnemy = null;
}
}
public override bool check(Controller c)
{
PatrollingEnemy p = State.cast <PatrollingEnemy> (c);
PatrolNode n = p.getPatrolTarget();
float dist = Vector2.Distance(c.transform.position, n.transform.position);
float moveDist = c.getSelf().getMovespeed() * Time.deltaTime;
return(dist < moveDist);
}
public override void perform(Controller c)
{
PatrollingEnemy pe = State.cast <PatrollingEnemy> (c);
//move to origin
if (Vector3.Distance(pe.transform.position, pe.getOrigin()) > originDistTolerance)
{
Vector3 navPos;
if (c.getMap() != null)
{
// if (Vector2.Distance (pe.transform.position, pe.getOrigin ()) < pe.getMap ().cellDimension)
// navPos = pe.getOrigin ();
if (!c.currentPosition(out navPos))
{
c.setPath(pe.getOrigin());
//throw out the first node in the path
Vector3 trash;
c.nextPosition(out trash);
}
}
else
{
navPos = pe.getOrigin();
}
//turn to face move direction; wait until turning is done
pe.facePoint(navPos, pe.getTurnSpeed() * Time.deltaTime);
if (Vector3.Angle(pe.transform.position - navPos, -pe.transform.up) < turnTolerance)
{
float dist = Vector2.Distance(c.transform.position, navPos);
float moveDist = c.getSelf().getMovespeed() * Time.deltaTime;
if (moveDist > dist)
{
moveDist = dist;
}
//move
c.transform.Translate(
(navPos - c.transform.position).normalized *
moveDist, Space.World);
}
}
//reorienting idle behavior
else
{
if (Quaternion.Angle(pe.transform.rotation, pe.getStartRotation()) > turnTolerance)
{
pe.facePoint(pe.getStartRotation() * Vector2.up, pe.getTurnSpeed());
}
}
}
private Tile LoadFlameTile(int x, int y, char enemyType)
{
GameObjectList enemies = this.Find("enemies") as GameObjectList;
TileField tiles = this.Find("tiles") as TileField;
GameObject enemy = null;
switch (enemyType)
{
case 'A': enemy = new UnpredictableEnemy(); break;
case 'B': enemy = new PlayerFollowingEnemy(); break;
case 'C':
default: enemy = new PatrollingEnemy(); break;
}
enemy.Position = new Vector2(((float)x + 0.5f) * tiles.CellWidth, (y + 1) * tiles.CellHeight);
enemies.Add(enemy);
return new Tile();
}
//======================================================
private void OnTriggerEnter2D(Collider2D other)
{
if (player == null || player.isDead)
{
return;
}
SwappableEntityHitboxReference swappableEntityReference = other.GetComponent <SwappableEntityHitboxReference>();
if (swappableEntityReference != null && swappableEntityReference.swappableEntity != null)
{
PatrollingEnemy patrollingEnemy = swappableEntityReference.swappableEntity as PatrollingEnemy;
if (patrollingEnemy != null)
{
player.InstaDeath();
}
}
}
// ====================================================
void Squash(PhysicsController other)
{
PlayerController player = other.GetComponent <PlayerController>();
if (player != null)
{
player.InstaDeath();
return;
}
PatrollingEnemy patroller = other.GetComponent <PatrollingEnemy>();
if (patroller != null)
{
patroller.InstaDeath();
return;
}
Destroy(other.gameObject);
}
private Tile LoadFlameTile(int x, int y, char enemyType)
{
GameObjectList enemies = this.Find("enemies") as GameObjectList;
TileField tiles = this.Find("tiles") as TileField;
GameObject enemy = null;
switch (enemyType)
{
case 'A': enemy = new UnpredictableEnemy(); break;
case 'B': enemy = new PlayerFollowingEnemy(); break;
case 'C':
default: enemy = new PatrollingEnemy(); break;
}
enemy.Position = new Vector2(((float)x + 0.5f) * tiles.CellWidth, (y + 1) * tiles.CellHeight);
enemies.Add(enemy);
return(new Tile());
}
//======================================================
void OnTriggerEnter2D(Collider2D other)
{
PlayerHitboxReference playerReference = other.GetComponent <PlayerHitboxReference>();
if (playerReference != null && playerReference.player != null)
{
playerReference.player.InstaDeath();
}
SwappableEntityHitboxReference swappableEntityReference = other.GetComponent <SwappableEntityHitboxReference>();
if (swappableEntityReference != null && swappableEntityReference.swappableEntity != null)
{
PatrollingEnemy patrollingEnemy = swappableEntityReference.swappableEntity as PatrollingEnemy;
if (patrollingEnemy != null)
{
patrollingEnemy.InstaDeath();
}
}
}
void LoadFlameEnemy(int x, int y, char symbol)
{
Vector2 pos = GetCellBottomCenter(x, y);
PatrollingEnemy enemy;
if (symbol == 'A')
{
enemy = new PatrollingEnemy(this, pos);
}
else if (symbol == 'B')
{
enemy = new PlayerFollowingEnemy(this, pos);
}
else
{
enemy = new UnpredictableEnemy(this, pos);
}
AddChild(enemy);
}
//======================================================
protected override void OnTriggerEnter2D(Collider2D other)
{
PlayerHitboxReference playerReference = other.GetComponent <PlayerHitboxReference>();
if (playerReference != null && playerReference.player != null)
{
playerReference.player.InstaDeath();
}
SwappableEntityHitboxReference swappableEntityReference = other.GetComponent <SwappableEntityHitboxReference>();
if (swappableEntityReference != null && swappableEntityReference.swappableEntity != null)
{
PatrollingEnemy patrollingEnemy = swappableEntityReference.swappableEntity as PatrollingEnemy;
if (patrollingEnemy != null)
{
patrollingEnemy.InstaDeath();
}
}
//Do something
Destroy(gameObject);
}
// =====================================
private void OnTriggerStay2D(Collider2D other)
{
PlayerHitboxReference playerReference = other.GetComponent <PlayerHitboxReference>();
if (playerReference != null && playerReference.player != null && !playerReference.player.isDead)
{
PlayerController player = playerReference.player;
Vector2 direction = transform.TransformDirection(localSpikeDirection).normalized;
if (Vector2.Dot(direction, player.currentSpeed - currentSpeed) >= -0.1f)
{
return;
}
SoundManager.instance.PlaySound(SoundManager.SoundType.Spikes);
player.InstaDeath();
return;
}
SwappableEntityHitboxReference swappableEntityReference = other.GetComponent <SwappableEntityHitboxReference>();
if (swappableEntityReference != null && swappableEntityReference.swappableEntity != null)
{
PatrollingEnemy enemy = swappableEntityReference.swappableEntity as PatrollingEnemy;
if (enemy != null)
{
Vector2 direction = transform.TransformDirection(localSpikeDirection).normalized;
if (Vector2.Dot(direction, enemy.currentSpeed - currentSpeed) >= -0.1f)
{
return;
}
SoundManager.instance.PlaySound(SoundManager.SoundType.Spikes);
enemy.InstaDeath();
return;
}
}
}
public override bool check(Controller c)
{
PatrollingEnemy pe = State.cast <PatrollingEnemy> (c);
return(pe.getPatrolTarget() == null && pe.getPrevNode() == null);
}
public override void perform(Controller c)
{
PatrollingEnemy patroller = State.cast <PatrollingEnemy> (c);
PatrolNode n = patroller.getPatrolTarget();
//can't do anything without a patrol target
if (n == null)
{
return;
}
Vector3 navPos;
if (c.getMap() != null)
{
if (Vector2.Distance(patroller.transform.position, n.transform.position) <= c.getMap().cellDimension)
{
navPos = n.transform.position;
}
else if (!c.currentPosition(out navPos))
{
c.setPath(n.transform.position);
//throw out the first node in the path
Vector3 trash;
c.nextPosition(out trash);
}
}
else
{
navPos = n.transform.position;
}
//turn to face move direction; wait until turning is done
patroller.facePoint(navPos, patroller.getTurnSpeed() * Time.deltaTime);
if (Vector3.Angle(patroller.transform.position - navPos, -patroller.transform.up) < turnTolerance)
{
float dist = Vector2.Distance(c.transform.position, navPos);
float moveDist = c.getSelf().getMovespeed() * Time.deltaTime;
if (moveDist > dist)
{
moveDist = dist;
}
//move
Vector2 dir = navPos - c.transform.position;
RaycastHit2D hit = Physics2D.Raycast(c.transform.position, dir, moveDist * 20, ~0);
Door d = null;
if (hit.collider != null)
{
d = hit.collider.GetComponent <Door> ();
if (d == null || d.isOpen())
{
c.transform.Translate(
dir.normalized *
moveDist, Space.World);
}
}
//if near the next point in the path, look ahead
if (c.getMap() != null && dist < c.getMap().cellDimension / 2f)
{
c.nextPosition(out navPos);
}
// float patrolTolerance = c.getMap () != null ? c.getMap ().cellDimension : moveTolerance;
//if near the target patrol node, look to the next one
if (Vector2.Distance(patroller.transform.position, n.transform.position) < moveTolerance)
{
patroller.nextPatrolNode();
if (c.getMap() != null && patroller.getPatrolTarget() != null)
{
c.setPath(patroller.getPatrolTarget().transform.position);
//throw out the first node in the path
Vector3 trash;
c.nextPosition(out trash);
}
}
}
}
private void OnEnable()
{
targetObject = target as PatrollingEnemy;
}
