GameObject FindClosestUnkissed()
{
GameObject nearestTarget = null;
float closestDistance = Mathf.Infinity;
Vector3 currentPosition = transform.position;
//add switch statement that checks which room ghost is in then changes furniture options
foreach(GameObject potentialTarget in rg.currentFurniture)
{
if (potentialTarget.GetComponent<KissableFurniture>())
{
Vector3 directionToTarget = potentialTarget.transform.position - currentPosition;
float dSqrToTarget = directionToTarget.sqrMagnitude;
if (dSqrToTarget < closestDistance && potentialTarget.GetComponent<KissableFurniture>().isKissed == false)
{
closestDistance = dSqrToTarget;
nearestTarget = potentialTarget;
}
if (directionToTarget == Vector3.zero)
{
currentState = GhostState.Kiss;
}
}
}
return nearestTarget;
}
void Start () {
audioSource = GetComponentInParent<AudioSource>();
audioSource.volume = lowVolume;
state = GhostState.Wander;
agent = transform.parent.GetComponent<NavMeshAgent>();
agent.obstacleAvoidanceType = ObstacleAvoidanceType.NoObstacleAvoidance;
SetNewDestination();
}
private void ChangeState(GhostState newState)
{
if(newState == GhostState.Pursue)
{
state = GhostState.Pursue;
agent.destination = controller.mainCharacter.transform.position;
audioSource.volume = highVolume;
} else if(newState == GhostState.Wander)
{
state = GhostState.Wander;
SetNewDestination();
audioSource.volume = lowVolume;
}
}
public Human(Model m, Vector3 Position, Tank tank, int speed)
: base(m)
{
ghostState = GhostState.IDLE;
this.position = Position;
this.targetTank = tank;
this.maxSpeed = speed;
currentVelocity = Vector3.Normalize(new Vector3(0, 0, 1));
//RandomPatrolPoint();
translation = Matrix.CreateTranslation(position);
//behavious[0] = Flee;
behavious = new Behavious[2];
}
void NextTarget()
{
if (state != GhostState.eyes)
{
xz xz = passable[Random.Range(0, passable.Count)];
targetObj.transform.position = controller.Xz2Coord(xz.x, xz.z);
}
else
{
if (transform.position.x > 0)
{
targetObj.transform.position = new Vector3(0.5f, 0, 4);
}
else
{
targetObj.transform.position = new Vector3(-0.5f, 0, 4);
}
trials = 0;
if (Vector3.Distance(transform.position, targetObj.transform.position) < 2)
{
state = GhostState.gohome;
}
else
{
switch (trials)
{
case 0:
targetObj.transform.position = new Vector3(1, 0, 4);
break;
default:
targetObj.transform.position = new Vector3(0, 0, 4);
break;
}
trials++;
}
}
ChaseTarget();
}
public Ghost(Texture2D spritesheet, GhostName name, int xPos, int yPos, GhostState startState) : base(spritesheet, 8, 8, xPos, yPos)
{
_name = name;
_scatterElapsed = 0.0f;
_chaseElapsed = 0.0f;
_frightenedElapsed = 0.0f;
_cagedLength = 1.5f;
_cagedElapsed = 0.0f;
_blinkLength = 0.4f;
_numBlinks = 4;
_homeXPixel = -1;
_homeYPixel = -1;
_startPosX = xPos;
_startPosY = yPos;
_startState = startState;
State = startState;
}
/// <summary>
/// Animation that moves the Ghost outside of the spawn
/// </summary>
private void LeaveSpawn()
{
timer++;
if (x > 51 && timer < 40)
{
return;
}
if (x < 51 || x > 51)
{
x = x > 51 ? x - 1 : x + 1;
}
else if (y > 17)
{
y--;
}
else
{
state = GhostState.SearchPacMan;
timer = ghostNumber > 2 ? 0 : timer;
}
}
private void Move()
{
if (currentState == GhostState.Waiting)
{
return;
}
var speed = (currentState == GhostState.Consumed) ? modeManager.consumedStateSpeed :
(hasBeenEaten && !modeManager.WaitingForConsumption)? modeManager.normalSpeed : modeManager.movSpeed;
Vector3 newPosition = gameManager.GetNewEntityPosition(speed, transform.position, currentDirection);
if (levelManager.ReachedTargetTile(entityId, newPosition, currentDirection))
{
if ((currentState == GhostState.LeavingBox || currentState == GhostState.Consumed) && levelManager.ReachedBoxDoorEntrance(entityId))
{
isInBox = (currentState == GhostState.Consumed);
}
if (currentState == GhostState.Consumed && levelManager.ReachedTile(entityId, consumedBoxTile))
{
_animator.SetBool(_animatorEatenId, false);
if (modeManager.currentMode == ModeManager.Mode.Frightened)
{
gameManager.PlayFrightenedModeMelody();
}
currentState = GhostState.LeavingBox;
hasBeenEaten = true;
}
levelManager.UpdateTargetTile(entityId, currentDirection);
var chosenDirection = ChooseNewDirection();
transform.position = gameManager.GetValidatedPosition(entityId, newPosition, currentDirection, chosenDirection);
currentDirection = chosenDirection;
_animator.SetInteger(_animatorDirectionId, (int)currentDirection);
}
else
{
transform.position = newPosition;
}
}
/// <summary>
/// Changes the state of a ghost
/// </summary>
/// <param name="state">The state in which the ghost is changed to</param>
public void ChangeState(GhostState state)
{
this.CurrentState = state;
switch (state)
{
case GhostState.Scared:
currentState = new Scared(this, this.maze);
break;
case GhostState.Chase:
switch (Name)
{
case GhostName.Blinky:
this.currentState = new Chase(this, maze, pacman);
break;
case GhostName.Speedy:
this.currentState = new Ambush(this, maze, pacman);
break;
case GhostName.Inky:
this.currentState = new Predict(this, GhostAssistant, maze, pacman);
break;
case GhostName.Clyde:
this.currentState = new Proximity(this, maze, pacman);
break;
}
break;
case GhostState.Released:
position = ReleasePosition;
ChangeState(GhostState.Chase);
break;
case GhostState.Zombie:
currentState = new Zombie(this, this.maze, pen.Entrance);
break;
}
}
/// <summary>
/// Check for collisions againts PacMan
/// </summary>
private void CheckCollision()
{
if ((x >= pacman.X && x <= pacman.X + 4 && y == pacman.Y) ||
(x + 4 >= pacman.X && x + 4 <= pacman.X + 4 && y == pacman.Y) ||
(x == pacman.X && y <= pacman.Y && y >= pacman.Y + 2) ||
(x == pacman.X && y + 2 >= pacman.Y && y <= pacman.Y + 2))
{
if (isVulnerable)
{
timer = 0;
isVulnerable = false;
pacman.Points += 1500;
IsDead = true;
state = GhostState.ReturnToSpawn;
}
else
{
pacman.IsDead = true;
pacman.Respawn();
}
}
}
public List <Vector3> GetAllowedDirs(GhostState state, Vector3 direction)
{
List <Vector3> res = new List <Vector3>();
if (up && (Vector3.forward != -direction))
{
res.Add(Vector3.forward);
}
if (left && (Vector3.left != -direction))
{
res.Add(Vector3.left);
}
if (down && (Vector3.back != -direction))
{
res.Add(Vector3.back);
}
if (right && (Vector3.right != -direction))
{
res.Add(Vector3.right);
}
if (isHouseNode)
{
if (state != GhostState.Dead && !pacman.Dead)
{
res.Remove(Vector3.back);
}
}
if (isSpecialNode)
{
if (state == GhostState.Dead || state == GhostState.Frightened)
{
res.Add(Vector3.forward);
}
}
return(res);
}
/// <summary>
/// Returns the Ghost to spawn
/// </summary>
private void ReturnToSpawn()
{
if (IsDead)
{
BackToNormal();
IsDead = false;
x = 51;
y = 21;
}
else if (!IsDead)
{
timer++;
// Animate the Ghosts currently trapped in the spawn to move from side to side
Move();
if (timer > 140)
{
state = GhostState.LeavingSpawn;
timer = 0;
}
}
}
public void ObserverUpdate(Object sender, Object message)
{
if (message is PacManState)
{
PacManState p = (PacManState)message;
gameConsole.GameConsoleWrite(this + " notified " + p + " from " + sender);
if (p == PacManState.Dying)
{
this.State = GhostState.Roving;
}
}
if (message is string)
{
string strMessage = (string)message;
switch (strMessage)
{
case "PowerUP":
this.Evade();
break;
case "PowerUP Elapsed":
this.ghostState = GhostState.Roving;
break;
case "Alive":
if (this.Intersects(pacMan))
{
while (this.Intersects(pacMan))
{
gameConsole.GameConsoleWrite(this + " relocated ");
this.Location = this.GetRandLocation();
this.SetTranformAndRect();
}
}
break;
}
}
}
private void Update()
{
if (isDead)
{
if (timeToDie > 0f)
{
timeToDie -= Time.deltaTime;
}
else
{
Destroy(gameObject);
}
return;
}
// Reduce amount of expensive calls
if (Random.value > 0.9f)
{
state = GetCurrentState();
}
switch (state)
{
case GhostState.Idle:
Idle();
break;
case GhostState.Attack:
Attack();
break;
case GhostState.Flee:
Flee();
break;
default:
throw new ArgumentOutOfRangeException();
}
}
//From IObservable messages from PacMan
public void ObserverUpdate(object sender, object message)
{
if (sender is PacMan)
{
if (message is string)
{
//TODO should be subclassed to avoid using Debug.Log in non unity specific class
this.Log(string.Format("{0} recieved message from {1} : {2}", this, sender, message));
switch (message.ToString())
{
case "SuperPacMan":
this.state = GhostState.Evading;
break;
case "SuperPacMan End":
this.state = GhostState.Roving;
break;
}
}
if (message is PacManState)
{
switch ((PacManState)message)
{
case PacManState.SuperPacMan:
break;
case PacManState.Spawning:
break;
case PacManState.Chomping:
break;
case PacManState.Still:
break;
}
}
}
}
private void RestartLevel()
{
_pacman.Initialize();
for (int i = 0; i < _ghosts.Length; i++)
{
_ghosts[i].Initialize();
_ghostTiles[i] = _board.GetTile(_ghosts[i].transform.position);
}
_permaChase = false;
_ongoingFright = false;
_currentAlternance = 0;
CurrentGhostState = GhostState.Scatter;
_textMessage.gameObject.SetActive(true);
_textMessage.text = _LEVEL_START;
_levelStartTime = Time.time;
_levelStarted = false;
_timesinceLastBonus = 0;
_board.BonusTile.Collectable.gameObject.SetActive(false);
}
public void Reset()
{
state = GhostState.ready;
switch (tag)
{
case "Blinky":
transform.position = new Vector3(0, 0, 4);
break;
case "Inky":
transform.position = new Vector3(-1.5f, 0, 1);
break;
case "Pinky":
transform.position = new Vector3(0, 0, 1);
break;
case "Clyde":
transform.position = new Vector3(1.5f, 0, 1);
break;
}
}
public void _on_AnimatedSprite_animation_finished()
{
if (_movement == Vector2.Zero && IsOnFloor())
{
_state = GhostState.Walking;
}
else if (IsOnFloor())
{
_state = GhostState.Walking;
}
if (_state == GhostState.Attacking)
{
_state = GhostState.Walking;
}
if (_state == GhostState.Dead || _animationState == GhostAnimationState.Death)
{
EmitSignal(nameof(GhostKilled));
QueueFree();
}
}
/// <summary>
/// The method ChangeState take an Enum type GhostState and change
/// the state of our current ghost depending the state given.
/// Also, if we switch to scare mode a timer is activated and the ghosts are feared
/// for 9 seconds.
/// </summary>
/// <param name="state">state is an Enum that represent the new state that we gonna give to our ghost</param>
public void ChangeState(GhostState state)
{
switch (state)
{
case GhostState.Chase:
this.state = GhostState.Chase;
currentState = new Chase(this, maze, pacman, pacman.Position);
break;
case GhostState.Scared:
this.state = GhostState.Scared;
currentState = new Scared(this, maze);
scared.Interval = 7000;
scared.Enabled = true;
scared.Elapsed += UpdateState;
break;
case GhostState.Released:
this.state = GhostState.Chase;
currentState = new Chase(this, maze, pacman, pacman.Position);
this.Position = ReleasedPos;
break;
}
}
/// <summary>
/// Changes the state of the ghost to scared/released/chase, depending on the parameter.
/// </summary>
/// <param name="stateParam">The state we want to set the ghost into</param>
public void ChangeState(GhostState stateParam)
{
if (stateParam == GhostState.Scared)
{
currentState = new Scared(this, maze);
colour = Color.White;
scaredTime.Enabled = false;
scaredTime.Enabled = true;
}
else if (stateParam == GhostState.Chase)
{
currentState = new Chase(this, maze, pacman, target);
colour = originalClr;
}
else if (stateParam == GhostState.Released)
{
currentState = new Chase(this, maze, pacman, target);
this.Position = Ghost.releasedPosition;
colour = originalClr;
stateParam = GhostState.Chase;
}
CurrentState = stateParam;
}
/// <summary>
/// Constructor of the class Ghost
/// </summary>
/// <param name="x"> The wanted X position </param>
/// <param name="y"> the wanted Y position </param>
/// <param name="allMapPieces"> The List of all Physics Objects</param>
public Ghost(int x, int y, List <Object> allMapPieces, int cX, int cY,
char visual, int value = 0)
{
// Creates a new Position vector and assigns it the x and y value
Pos = new Position(x, y);
// Creates a new Position and assigns it the x value -1 and y value
OldPos = new Position(x - 1, y);
// Assigns a character to be displayed while rendering
Visuals = visual;
// Creates the collider bounding box
BoxCollider = new int[4] {
x, y, x + 1, y + 1
};
// Assigns this Object list the one passed as argument
allPieces = allMapPieces;
// Assigns the ghost state to chase mode
state = GhostState.chase;
// Assigns the ghost it's respective corner
corner = new DefaultObject(cX, cY, ' ', ObjectType.target);
// Assigns the type to Ghost
ObjType = ObjectType.ghost;
// Sets the score it should give
ScoreVal = value;
}
void Kiss()
{
if (kissCooldown > 0)
{
furnToKiss.GetComponent<KissableFurniture>().KissFurniture();
int chanceToWander = Random.Range(1, 4);
if (chanceToWander != 3)
{
currentState = GhostState.Find;
}
else
{
currentState = GhostState.Wander;
rand = Random.Range(1, 3);
waypoint = Random.insideUnitCircle * 25;
}
kissCooldown--;
}
else
{
currentState = GhostState.Wander;
rand = Random.Range(1, 3);
}
}
private void SetState(GhostState state)
{
_state = state;
TargetSpeed = 4;
switch (state)
{
case GhostState.Scatter: _stateCountDown.Start(_scatterTime); break;
case GhostState.Chase: _stateCountDown.Start(_chaseTime); break;
case GhostState.Frightened:
_stateCountDown.Start(_frightendTime);
if (Maze.IsCellOpen(this, GetOppositeDirection()))
{
CurrentDirection = GetOppositeDirection();
}
TargetSpeed = 2;
break;
case GhostState.Recovering:
_stateCountDown.Start(_warnTime);
TargetSpeed = 2;
break;
case GhostState.Dead:
if (Maze.IsCellOpen(this, GetOppositeDirection()))
{
CurrentDirection = GetOppositeDirection();
}
break;
}
SetCharacterAnimation();
}
public void SetGhostState(GhostState gs)
{
ghostState = gs;
onGhostStateChange.Invoke(ghostState);
}
private void StateEval()
{
GhostState initialState = State;
scheduleStateEval_ = false;
switch (State)
{
case GhostState.Home:
// Ghost exit the home state for the scatter state when they get to the row
// above the home
if (position_.Tile.Y == 11 && position_.DeltaPixel.Y == 0)
{
// Select inital direction based on scatter tiles
if (Constants.scatterTiles(identity_)[0].X < 13)
{
direction_ = Direction.Left;
}
else
{
direction_ = Direction.Right;
}
if (scatterModesLeft_ > 0)
{
State = GhostState.Scatter;
}
else
{
State = GhostState.Attack;
}
return;
}
// Ghosts move up when they are aligned with the entrance
else if (position_.Tile.X == 13 && position_.DeltaPixel.X == 8)
{
direction_ = Direction.Up;
}
// When on one side, move towards middle when on the bottom and time's up
// If time's not up, keep bouncing up and down
else if ((position_.DeltaPixel.Y == 8) &&
((position_.Tile.X == 11 && position_.DeltaPixel.X == 8) ||
(position_.Tile.X == 15 && position_.DeltaPixel.X == 8)))
{
if (position_.Tile.Y == 14)
{
initialJumps_--;
if (initialJumps_ == 0)
{
if (position_.Tile.X == 11)
{
direction_ = Direction.Right;
}
else
{
direction_ = Direction.Left;
}
}
else
{
direction_ = Direction.Up;
}
}
else if (position_.Tile.Y == 13)
{
direction_ = Direction.Down;
}
}
break;
case GhostState.Scatter:
// Attempt to reverse direction upon entering this state
if (previousState_ == GhostState.Attack)
{
scatterModesLeft_--;
if (NextTile(OppositeDirection(direction_)).IsOpen)
{
direction_ = OppositeDirection(direction_);
}
}
AIScatter();
int timeInScatterMode = scatterModesLeft_ <= 2 ? 5 : 7;
if ((DateTime.Now - timeInCurrentState) > TimeSpan.FromSeconds(timeInScatterMode))
{
State = GhostState.Attack;
}
break;
case GhostState.Dead:
// Attempt to reverse direction upon entering this state
if (previousState_ != GhostState.Dead && previousState_ != GhostState.Blue)
{
if (NextTile(OppositeDirection(direction_)).IsOpen)
{
direction_ = OppositeDirection(direction_);
}
}
else
{
AIDead();
}
if (position_.DeltaPixel.X == 8 && position_.DeltaPixel.Y == 8)
{
if (position_.Tile.Y == 14)
{
State = GhostState.Home;
}
}
break;
case GhostState.Attack:
// Attempt to reverse direction upon entering this state
if (previousState_ != GhostState.Attack && previousState_ != GhostState.Blue)
{
if (NextTile(OppositeDirection(direction_)).IsOpen)
{
direction_ = OppositeDirection(direction_);
}
}
else
{
AIAttack();
}
if ((DateTime.Now - timeInCurrentState) > TimeSpan.FromSeconds(20))
{
State = GhostState.Scatter;
}
break;
case GhostState.Blue:
// Attempt to reverse direction upon entering this state
if (previousState_ != GhostState.Blue)
{
if (NextTile(OppositeDirection(direction_)).IsOpen)
{
direction_ = OppositeDirection(direction_);
}
}
else
{
// TODO : make special blue AI
AIAttack();
}
// When blue time is over, revert to attack mode.
if ((DateTime.Now - timeInCurrentState) > TimeSpan.FromSeconds(Constants.BlueTime()))
{
State = GhostState.Attack;
}
break;
}
// TODO : move all these magic numbers to the Constants class.
// We select a new sound only upon some state change, or when
// the number of crumps goes below certain thresholds.
if ((initialState != previousState_) ||
(Grid.NumCrumps == 199 && previousNumCrumps_ == 200) ||
(Grid.NumCrumps == 19 && previousNumCrumps_ == 20))
{
PlaySound();
}
previousState_ = initialState;
}
private void FixedUpdate()
{
timer += Time.deltaTime;
switch (m_GhostState)
{
case GhostState.Chase:
animator.Play("ghost-Idle", 0); //we can set an animation
targetPosition.x = player.transform.position.x;
targetPosition.y = player.transform.position.y;
break;
case GhostState.Attack:
animator.Play("ghost-Attack", 0); //we can set an animation
targetPosition.x = player.transform.position.x;
targetPosition.y = player.transform.position.y;
break;
case GhostState.Spawning:
animator.Play("ghost-Spawn", 0); //we can set an animation
if (timer > animationTimeDelay)
{
timer = 0f;
//batAudio.clip = batFlyingClip;
//batAudio.Play();
m_GhostState = GhostState.Chase;
GetComponent <Enemy>().active = true;
}
break;
case GhostState.Despawning:
animator.Play("ghost-despawn", 0); //we can set an animation
if (timer > animationTimeDelay)
{
m_GhostState = GhostState.Inactive;
GetComponent <Enemy>().active = false;
timer = 0f;
}
break;
case GhostState.Inactive:
transform.position = new Vector3(transform.position.x, transform.position.y, -100);
if (timer > 8f)
{
transform.position = new Vector3(transform.position.x, transform.position.y, 1);
m_GhostState = GhostState.Spawning;
timer = 0f;
}
break;
}//end switch
playerLocation = player.transform.position;
direction = rigBody.velocity;
if (targetPosition.x > transform.position.x + 0.1)
{
direction.x = 1 * speed;
}
else if (targetPosition.x < transform.position.x - 0.1)
{
direction.x = -1 * speed;
}
else
{
direction.x = 0;
}
if (targetPosition.y > transform.position.y + 0.1)
{
direction.y = 1 * speed;
}
else if (targetPosition.y < transform.position.y - 0.1)
{
direction.y = -1 * speed;
}
else
{
direction.y = 0;
}
rigBody.velocity = direction;
}
void Wander()
{
timer -= Time.deltaTime;
if(timer <= 0)
{
kissCooldown = 3;
currentState = GhostState.Find;
timer = 3;
}
switch(rand)
{
case 1:
transform.position = Vector3.MoveTowards(transform.position, RandomVector(), ghostSpeed * Time.deltaTime);
break;
case 2:
transform.position = Vector3.MoveTowards(transform.position, closestPlayer.transform.position, ghostSpeed * Time.deltaTime);
break;
case 3:
transform.position = Vector3.MoveTowards(transform.position, furnToKiss.transform.position, ghostSpeed * Time.deltaTime);
break;
}
if(this.transform.position == randomVec)
{
randomVec = Vector3.zero;
}
}
public void Evade()
{
this.ghostState = GhostState.Evading;
}
public void TakeDamage(Vector2 pos)
{
FSoundManager.PlaySound("enemyHurt");
Go.killAllTweensWithTarget(this);
this.health--;
if (health > 0)
State = GhostState.INVULNERABLE;
else
State = GhostState.DYING;
Vector2 dist = (this.GetPosition() - pos).normalized * 4;
maxVel = 50;
xVel = dist.x;
yVel = dist.y;
xAcc = 0;
yAcc = 0;
}
public virtual void Hit()
{
this.ghoststate = GhostState.Dead;
}
public Ghost()
{
this.State = GhostState.Roving;
//pac.Attach(this);
}
//Ghost class is dependant on the PacMan class
public Ghost(PacMan pac)
{
this.State = GhostState.Roving;
}
public override void OnFixedUpdate()
{
if (C.isTransitioning)
return;
if (State == GhostState.MOVING)
{
if (RXRandom.Float() < .2f)
SpawnParticles();
}
else
{
if (RXRandom.Float() < .01f)
SpawnParticles();
}
switch (State)
{
case GhostState.IDLE:
case GhostState.MOVING:
if (stateCount > minState)
{
if (RXRandom.Float() < .03f)
{
switch (State)
{
case GhostState.IDLE:
float randAngle = RXRandom.Float() * Mathf.PI * 2.0f;
if (RXRandom.Float() < .5f)
randAngle = Mathf.Atan2(this.y - world.player.y, this.x - world.player.x);
xAcc = Mathf.Cos(randAngle) * -moveSpeed;
yAcc = Mathf.Sin(randAngle) * -moveSpeed;
State = GhostState.MOVING;
break;
case GhostState.MOVING:
if (RXRandom.Float() < .3f)
{
//stop
State = GhostState.IDLE;
PlayAnim(true);
xAcc = 0;
yAcc = 0;
}
else
{
}
break;
}
}
}
if (State == GhostState.MOVING)
{
if (hitUp)
yAcc = -Mathf.Abs(yAcc);
else if (hitDown)
yAcc = Mathf.Abs(yAcc);
if (hitLeft)
xAcc = Mathf.Abs(xAcc);
else if (hitRight)
xAcc = -Mathf.Abs(xAcc);
}
if (xAcc == 0)
xVel *= .8f;
if (yAcc == 0)
yVel *= .8f;
break;
case GhostState.INVULNERABLE:
if (RXRandom.Float() < .2f)
SpawnParticles(1);
this.isVisible = stateCount * 100 % 10 < 5;
if (stateCount > invulnerableCount)
{
State = GhostState.IDLE;
resetMax();
this.isVisible = true;
}
this.xVel *= .9f;
this.yVel *= .9f;
break;
case GhostState.DYING:
if (RXRandom.Float() < .4f + .4f * stateCount)
SpawnParticles(1 + (int)stateCount);
this.isVisible = stateCount * 100 % 10 < 5;
if (stateCount > invulnerableCount)
{
if (!String.IsNullOrEmpty(name))
C.Save.requiredEnemyKills.Add(this.name);
FSoundManager.PlaySound("enemyDie");
if (RXRandom.Float() < Knight.HEART_DROP_CHANCE)
world.addObject(new Heart(world, this.GetPosition()));
SpawnParticles(25);
world.removeObject(this);
}
this.xVel *= .9f;
this.yVel *= .9f;
break;
}
base.OnFixedUpdate();
PlayAnim();
}
public override void Update(GameTime gameTime)
{
float distance = (targetTank.CurrentPosition - this.position).Length();
if (distance < fleeDistance)
{
ghostCondition = GhostConditions.PLAYERNEAR;
}
else if (distance > 160&& distance < 700)
{
ghostCondition = GhostConditions.PLAYERFAR;
}
else
{
ghostCondition = GhostConditions.PLAYERTOOFAR;
}
foreach (XElement state in states.Elements())
{
foreach (XElement changestate in state.Elements())
{
if(state.Attribute("fromState").Value == ghostState.ToString())
{
if (changestate.Attribute("condition").Value==ghostCondition.ToString())
{
string toState = changestate.Attribute("toState").Value;
if(toState== GhostState.IDLE.ToString())
{
ghostState = GhostState.IDLE;
}
else if (toState == GhostState.PURSUE.ToString())
{
ghostState = GhostState.PURSUE;
}
else if (toState == GhostState.FLEE.ToString())
{
ghostState = GhostState.FLEE;
}
}
}
}
}
if (ghostState == GhostState.IDLE)
{
IDLE(gameTime);
}
if (ghostState == GhostState.PURSUE)
{
Pursue(gameTime);
}
if (ghostState == GhostState.FLEE)
{
Flee(gameTime);
}
//tankPosition = tank1.CurrentPosition;
//direction = tankPosition - world.Translation;
//direction.Normalize();
//if (this.CollidesWith(tank1.model, tank1.world))
//{
//}
//else
//{
// Vector3 path = direction * speed;
// world *= Matrix.CreateTranslation(path);
//}
base.Update(gameTime);
}
public void ResetTurning()
{
isPlaying = false;
ghostModelState = GhostState.Ridable;
}
public void setState(GhostState newState)
{
if (newState.isEye())
{
// état demandé : yeux avec déplacement yeux
State = GhostState.EYE;
strategy = Strategy.EYE;
}
else if (newState.isFlee())
{
// état demandé : fuite
if (!State.isEye())
{
// fuit seulement si pas en état yeux
fleeTime = Constants.TIME_FLEE;
blink = false;
if (!strategy.isHouse())
{
strategy = Strategy.FLEE;
_DesiredDirection = CurrentDirection;
CurrentDirection = CurrentDirection.Opposite;
}
State = GhostState.FLEE;
}
}
else if (newState.isRest())
{
fleeTime = Constants.TIME_REST;
strategy = Strategy.FLEE;
_DesiredDirection = CurrentDirection;
CurrentDirection = CurrentDirection.Opposite;
State = GhostState.REST;
}
else if (newState.isHouse())
{
// état demandé : chasse avec déplacement maison
strategy = Strategy.HOUSE;
houseTime = color * Constants.TIME_HOUSE;
State = GhostState.HOUSE;
}
else if (newState.isHunt())
{
// état demandé : chasse avec déplacement chasse
strategy = Strategy.HUNT;
State = GhostState.HUNT;
}
else if (newState.isRandom())
{
// état demandé : chasse avec déplacement aléatoire
strategy = Strategy.RANDOM;
randomTime = Constants.TIME_RANDOM_OFFSET + color * Constants.TIME_RANDOM_K;
State = GhostState.HUNT;
}
}
void Start()
{
noDamage_script = gameObject.GetComponent <Invincibility>();
ghostStateScript = gameObject.GetComponent <GhostState>();
}
/// <summary>
/// Updates the ghost, applying movement and physics
/// </summary>
/// <param name="gameTime">The GameTime object</param>
public void Update(GameTime gameTime)
{
if (animationState == GhostState.WalkingLeft)
{
Position.X -= speed;
if (Position.X - 16 < 0)
{
Position.X = 16;
animationState = GhostState.WalkingRight;
}
}
else if (animationState == GhostState.WalkingRight)
{
Position.X += speed;
origin = new Vector2(10, 20);
if (Position.X + 20 > 2100)
{
Position.X = 2080;
animationState = GhostState.WalkingLeft;
}
}
/*
* if (Bounds.CollidesWith(player.Bounds)) // check for collisions with the player
* {
* player.gameState = 2;
* /*
* if (player.Bounds.Y + player.Bounds.Height <= Bounds.Y)
* {
* //logic player bouncing off head, but ghost wont be dying, can bounce off ghost heads
* player.Position.Y -= 1;
* player.playerBounce = 1;
* }
* else if (player.Bounds.X >= Bounds.X + Bounds.Width) //&& player.Bounds.Y > Bounds.Y
* {
* //logic for player death
* player.gameState = 2;
* }
* else if (player.Bounds.X + player.Bounds.Width <= Bounds.X) //&& player.Bounds.Y > Bounds.Y - 18
* {
* //logic for player death
* player.gameState = 2;
* }
*
* }
*/
switch (animationState)
{
case GhostState.WalkingLeft:
animationTimer += gameTime.ElapsedGameTime;
spriteEffects = SpriteEffects.None;
// Walking frames are 0 & 1
if (animationTimer.TotalMilliseconds > (FRAME_RATE * 2 - (FRAME_RATE * 0.05))) //this slight adjustment fixes the issue of seeing a small blip of frame 11 pop up
{
animationTimer = new TimeSpan(0);
}
currentFrame = (int)animationTimer.TotalMilliseconds / FRAME_RATE;
break;
case GhostState.WalkingRight:
animationTimer += gameTime.ElapsedGameTime;
spriteEffects = SpriteEffects.FlipHorizontally;
// Walking frames are 0 & 1
if (animationTimer.TotalMilliseconds > (FRAME_RATE * 2 - (FRAME_RATE * 0.05))) //this slight adjustment fixes the issue of seeing a small blip of frame 11 pop up
{
animationTimer = new TimeSpan(0);
}
currentFrame = (int)animationTimer.TotalMilliseconds / FRAME_RATE;
break;
}
}
public virtual void Chase()
{
this.ghoststate = GhostState.Chasing;
}
/// <summary>
/// Allows the game component to update itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
float turnAmount = .04f;
switch (this.ghostState)
{
case GhostState.Dead:
//TODO Dead moving and dead animation.
//Until then
this.ghostState = GhostState.Roving;
//Pick random direction
Random r = new Random();
Vector2 v = new Vector2((float)r.NextDouble() - 0.5f, (float)r.NextDouble() - 0.5f);
Vector2.Normalize(ref v, out v); //Normalize
this.Direction = v; //Assign random direction
break;
case GhostState.Chasing:
//Change texture if Chasing
if (!(this.spriteTexture == this.ghost))
{
//gameConsole.GameConsoleWrite(this.ToString() + " Chasing changed texture to spriteTexture");
this.spriteTexture = this.ghost;
}
if (pacMan.Location.Y > this.Location.Y)
{
//this.Direction.Y = 1;
this.Direction.Y = MathHelper.Clamp(this.Direction.Y += turnAmount, -1, 1);
}
else
{
//this.Direction.Y = -1;
this.Direction.Y = MathHelper.Clamp(this.Direction.Y -= turnAmount, -1, 1);
}
if (pacMan.Location.X > this.Location.X)
{
//this.Direction.X = 1;
this.Direction.X = MathHelper.Clamp(this.Direction.X += turnAmount, -1, 1);
}
else
{
//this.Direction.X = -1;
this.Direction.X = MathHelper.Clamp(this.Direction.X -= turnAmount, -1, 1);
}
break;
case GhostState.Evading:
//Change texture if evading
if (this.spriteTexture != this.ghostHit)
{
//gameConsole.GameConsoleWrite(this.ToString() + " Evading changed texture to ghostHit");
this.spriteTexture = this.ghostHit;
}
if (pacMan.Location.Y > this.Location.Y)
{
this.Direction.Y = -1;
}
else
{
this.Direction.Y = 1;
}
if (pacMan.Location.X > this.Location.X)
{
this.Direction.X = -1;
}
else
{
this.Direction.X = -1;
}
break;
case GhostState.Roving:
//Change texture if Chasing
if (!(this.spriteTexture == this.ghost))
{
//gameConsole.GameConsoleWrite(this.ToString() + " Roving changed texture to spriteTexture");
this.spriteTexture = this.ghost;
}
//check if ghost can see pacman
Vector2 normD = Vector2.Normalize(this.Direction);
Vector2 p = new Vector2(this.Location.X, this.Location.Y);
while (p.X < graphics.GraphicsDevice.Viewport.Width &&
p.X > 0 &&
p.Y < graphics.GraphicsDevice.Viewport.Height &&
p.Y > 0)
{
if (pacMan.LocationRect.Contains(new Point((int)p.X, (int)p.Y)))
{
this.ghostState = GhostState.Chasing;
gameConsole.GameConsoleWrite(this.ToString() + " saw pacman");
break;
}
p += this.Direction;
}
break;
}
//Borders
if ((this.Location.Y + this.spriteTexture.Height / 2 > graphics.GraphicsDevice.Viewport.Height)
||
(this.Location.Y - this.spriteTexture.Height / 2 < 0)
)
{
this.Direction.Y *= -1;
//this.ghostState = GhostState.Roving;
}
if ((this.Location.X + this.spriteTexture.Width / 2 > graphics.GraphicsDevice.Viewport.Width)
||
(this.Location.X - this.spriteTexture.Width / 2 < 0)
)
{
this.Direction.X *= -1;
//this.ghostState = GhostState.Roving;
}
Location += ((this.Direction * (lastUpdateTime / 1000)) * Speed); //Simple Move
//Collision
if (this.Intersects(pacMan))
{
//PerPixel Collision
if (this.PerPixelCollision(pacMan))
{
if (this.ghostState == GhostState.Evading)
{
this.Visible = false;
this.Enabled = false;
}
else
{
if (pacMan.PacManState != PacManState.Dying)
{
pacMan.Die();
this.Location = new Vector2(100, 100);
this.ghostState = GhostState.Roving;
}
}
}
}
base.Update(gameTime);
}
void Start()
{
ghostState = GhostState.CHASING_PLAYER;
}
void Start()
{
gm = GameObject.Find("GameManager").GetComponent<GameManager>();
rg = GameObject.Find("GameManager").GetComponent<RoomGenerator>();
currentState = GhostState.Find;
currentRoom = rg.MainBaseRoomPiece;
}
