src/com/replica/replicaisland/NPCComponent.java - platform/external/replicaisland - Git at Google

 /*
  * Copyright (C) 2010 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.replica.replicaisland;

 import com.replica.replicaisland.CollisionParameters.HitType;
 import com.replica.replicaisland.GameObject.ActionType;

 public class NPCComponent extends GameComponent {
     private float mPauseTime;
     private float mTargetXVelocity;
     private int mLastHitTileX;
     private int mLastHitTileY;

     private int mDialogEvent;
     private int mDialogIndex;

     private HitReactionComponent mHitReactComponent;

     private int[] mQueuedCommands;
     private int mQueueTop;
     private int mQueueBottom;
     private boolean mExecutingQueue;

     private Vector2 mPreviousPosition;

     private float mUpImpulse;
     private float mDownImpulse;
     private float mHorizontalImpulse;
     private float mSlowHorizontalImpulse;
     private float mAcceleration;

     private int mGameEvent;
     private int mGameEventIndex;
     private boolean mSpawnGameEventOnDeath;

     private boolean mReactToHits;
     private boolean mFlying;
     private boolean mPauseOnAttack;

     private float mDeathTime;
 	private float mDeathFadeDelay;

     private static final float UP_IMPULSE = 400.0f;
     private static final float DOWN_IMPULSE = -10.0f;
     private static final float HORIZONTAL_IMPULSE = 200.0f;
     private static final float SLOW_HORIZONTAL_IMPULSE = 50.0f;
     private static final float ACCELERATION = 300.0f;
     private static final float HIT_IMPULSE = 300.0f;
     private static final float HIT_ACCELERATION = 700.0f;

     private static final float DEATH_FADE_DELAY = 4.0f;

     private static final float PAUSE_TIME_SHORT = 1.0f;
     private static final float PAUSE_TIME_MEDIUM = 4.0f;
     private static final float PAUSE_TIME_LONG = 8.0f;
     private static final float PAUSE_TIME_ATTACK = 1.0f;
     private static final float PAUSE_TIME_HIT_REACT = 1.0f;

     private static final int COMMAND_QUEUE_SIZE = 16;

     public NPCComponent() {
         super();
         setPhase(ComponentPhases.THINK.ordinal());
         mQueuedCommands = new int[COMMAND_QUEUE_SIZE];
         mPreviousPosition = new Vector2();
         reset();
     }

     @Override
     public void reset() {
         mPauseTime = 0.0f;
         mTargetXVelocity = 0.0f;
         mLastHitTileX = 0;
         mLastHitTileY = 0;
         mDialogEvent = GameFlowEvent.EVENT_SHOW_DIALOG_CHARACTER1;
         mDialogIndex = 0;
         mHitReactComponent = null;
         mQueueTop = 0;
         mQueueBottom = 0;
         mPreviousPosition.zero();
         mExecutingQueue = false;
         mUpImpulse = UP_IMPULSE;
         mDownImpulse = DOWN_IMPULSE;
         mHorizontalImpulse = HORIZONTAL_IMPULSE;
         mSlowHorizontalImpulse = SLOW_HORIZONTAL_IMPULSE;
         mAcceleration = ACCELERATION;
         mGameEvent = -1;
         mGameEventIndex = -1;
         mSpawnGameEventOnDeath = false;
         mReactToHits = false;
         mFlying = false;
         mDeathTime = 0.0f;
         mDeathFadeDelay = DEATH_FADE_DELAY;
         mPauseOnAttack = true;
     }

     @Override
     public void update(float timeDelta, BaseObject parent) {

         GameObject parentObject = (GameObject)parent;

         if (mReactToHits &&
         		mPauseTime <= 0.0f &&
         		parentObject.getCurrentAction() == ActionType.HIT_REACT) {
         	mPauseTime = PAUSE_TIME_HIT_REACT;
             pauseMovement(parentObject);
         	parentObject.getVelocity().x = -parentObject.facingDirection.x * HIT_IMPULSE;
         	parentObject.getAcceleration().x = HIT_ACCELERATION;

         } else if (parentObject.getCurrentAction() == ActionType.DEATH) {
         	if (mSpawnGameEventOnDeath && mGameEvent != -1) {
         		if (Utils.close(parentObject.getVelocity().x, 0.0f)
         				&& parentObject.touchingGround()) {

         			if (mDeathTime < mDeathFadeDelay && mDeathTime + timeDelta >= mDeathFadeDelay) {
         				HudSystem hud = sSystemRegistry.hudSystem;

         	        	if (hud != null) {
         	        		hud.startFade(false, 1.5f);
         	        		hud.sendGameEventOnFadeComplete(mGameEvent, mGameEventIndex);
         	        		mGameEvent = -1;
         	        	}
         			}
         			mDeathTime += timeDelta;

         		}
         	}
         	// nothing else to do.
         	return;
         } else if (parentObject.life <= 0) {
         	parentObject.setCurrentAction(ActionType.DEATH);
         	parentObject.getTargetVelocity().x = 0;
         	return;
         } else if (parentObject.getCurrentAction() == ActionType.INVALID ||
         		(!mReactToHits && parentObject.getCurrentAction() == ActionType.HIT_REACT)) {
         	parentObject.setCurrentAction(ActionType.MOVE);
         }

         if (mPauseTime <= 0.0f) {

             HotSpotSystem hotSpotSystem = sSystemRegistry.hotSpotSystem;

             if (hotSpotSystem != null) {
             	final float centerX = parentObject.getCenteredPositionX();
                 final int hitTileX = hotSpotSystem.getHitTileX(centerX);
                 final int hitTileY = hotSpotSystem.getHitTileY(parentObject.getPosition().y + 10.0f);
                 boolean accepted = true;

                 if (hitTileX != mLastHitTileX || hitTileY != mLastHitTileY) {

             	    final int hotSpot = hotSpotSystem.getHotSpotByTile(hitTileX, hitTileY);

                     if (hotSpot >= HotSpotSystem.HotSpotType.NPC_GO_RIGHT && hotSpot <= HotSpotSystem.HotSpotType.NPC_SLOW) {
                     	// movement-related commands are immediate
                         parentObject.setCurrentAction(ActionType.MOVE);
                     	accepted = executeCommand(hotSpot, parentObject, timeDelta);
                     } else if (hotSpot == HotSpotSystem.HotSpotType.ATTACK && !mPauseOnAttack) {
                     	// when mPauseOnAttack is false, attacks are also immediate.
                     	accepted = executeCommand(hotSpot, parentObject, timeDelta);
                     } else if (hotSpot == HotSpotSystem.HotSpotType.NPC_RUN_QUEUED_COMMANDS) {
                     	if (!mExecutingQueue && mQueueTop != mQueueBottom) {
                     		mExecutingQueue = true;
                         }
                     } else if (hotSpot > HotSpotSystem.HotSpotType.NONE) {
                     	queueCommand(hotSpot);
                     }
                 }

                 if (mExecutingQueue) {
                 	if (mQueueTop != mQueueBottom) {
                 		accepted = executeCommand(nextCommand(), parentObject, timeDelta);
                 		if (accepted) {
                 			advanceQueue();
                 		}
                 	} else {
                 		mExecutingQueue = false;
                 	}
                 }

                 if (accepted) {
                 	mLastHitTileX = hitTileX;
                 	mLastHitTileY = hitTileY;
                 }

             }
         } else {
             mPauseTime -= timeDelta;
             if (mPauseTime < 0.0f) {
                 resumeMovement(parentObject);
                 mPauseTime = 0.0f;
                 parentObject.setCurrentAction(ActionType.MOVE);
             }
         }

         mPreviousPosition.set(parentObject.getPosition());
     }

     private boolean executeCommand(int hotSpot, GameObject parentObject, float timeDelta) {
     	boolean hitAccepted = true;
     	final CameraSystem camera = sSystemRegistry.cameraSystem;

     	switch(hotSpot) {
         case HotSpotSystem.HotSpotType.WAIT_SHORT:
             if (mPauseTime == 0.0f) {
                 mPauseTime = PAUSE_TIME_SHORT;
                 pauseMovement(parentObject);
             }
             break;
         case HotSpotSystem.HotSpotType.WAIT_MEDIUM:
             if (mPauseTime == 0.0f) {
                 mPauseTime = PAUSE_TIME_MEDIUM;
                 pauseMovement(parentObject);
             }
             break;
         case HotSpotSystem.HotSpotType.WAIT_LONG:
             if (mPauseTime == 0.0f) {
                 mPauseTime = PAUSE_TIME_LONG;
                 pauseMovement(parentObject);
             }
             break;
         case HotSpotSystem.HotSpotType.ATTACK:
         	if (mPauseOnAttack) {
 	            if (mPauseTime == 0.0f) {
 	                mPauseTime = PAUSE_TIME_ATTACK;
 	                pauseMovement(parentObject);

 	            }
         	}
             parentObject.setCurrentAction(ActionType.ATTACK);

             break;

         case HotSpotSystem.HotSpotType.TALK:
         	if (mHitReactComponent != null) {
             	if (parentObject.lastReceivedHitType != HitType.COLLECT) {
             		mHitReactComponent.setSpawnGameEventOnHit(
             				HitType.COLLECT, mDialogEvent, mDialogIndex);
             		if (parentObject.getVelocity().x != 0.0f) {
             			pauseMovement(parentObject);
             		}
             		hitAccepted = false;
             	} else {
                     parentObject.setCurrentAction(ActionType.MOVE);

             		resumeMovement(parentObject);
             		mHitReactComponent.setSpawnGameEventOnHit(HitType.INVALID, 0, 0);
             		parentObject.lastReceivedHitType = HitType.INVALID;
             	}
         	}
         	break;

         case HotSpotSystem.HotSpotType.WALK_AND_TALK:
         	if (mDialogEvent != GameFlowEvent.EVENT_INVALID) {
         		LevelSystem level = sSystemRegistry.levelSystem;
         		level.sendGameEvent(mDialogEvent, mDialogIndex, true);
         		mDialogEvent = GameFlowEvent.EVENT_INVALID;
         	}
         	break;

         case HotSpotSystem.HotSpotType.TAKE_CAMERA_FOCUS:
         	if (camera != null) {
         		camera.setTarget(parentObject);
         	}
         	break;

         case HotSpotSystem.HotSpotType.RELEASE_CAMERA_FOCUS:

         	if (camera != null) {
         		GameObjectManager gameObjectManager = sSystemRegistry.gameObjectManager;
         		camera.setTarget(gameObjectManager.getPlayer());
         	}
         	break;

         case HotSpotSystem.HotSpotType.END_LEVEL:
         	HudSystem hud = sSystemRegistry.hudSystem;

         	if (hud != null) {
         		hud.startFade(false, 1.5f);
         		hud.sendGameEventOnFadeComplete(GameFlowEvent.EVENT_GO_TO_NEXT_LEVEL, 0);
         	}
         	break;
         case HotSpotSystem.HotSpotType.GAME_EVENT:
         	if (mGameEvent != -1) {
     			LevelSystem level = sSystemRegistry.levelSystem;
     			if (level != null) {
     				level.sendGameEvent(mGameEvent, mGameEventIndex, true);
     				mGameEvent = -1;
     			}
     		}
         	break;

         case HotSpotSystem.HotSpotType.NPC_GO_UP_FROM_GROUND:
             if (!parentObject.touchingGround()) {
                 hitAccepted = false;
                 break;
             }
             // fall through
         case HotSpotSystem.HotSpotType.NPC_GO_UP:
         	parentObject.getVelocity().y = mUpImpulse;
         	parentObject.getTargetVelocity().y = 0.0f;
             mTargetXVelocity = 0.0f;

             break;
         case HotSpotSystem.HotSpotType.NPC_GO_DOWN_FROM_CEILING:
             if (!parentObject.touchingCeiling()) {
                 hitAccepted = false;
                 break;
             }
             // fall through
         case HotSpotSystem.HotSpotType.NPC_GO_DOWN:
         	parentObject.getVelocity().y = mDownImpulse;
         	parentObject.getTargetVelocity().y = 0.0f;
         	if (mFlying) {
         		mTargetXVelocity = 0.0f;
         	}
             break;
         case HotSpotSystem.HotSpotType.NPC_GO_LEFT:
         	parentObject.getTargetVelocity().x = -mHorizontalImpulse;
         	parentObject.getAcceleration().x = mAcceleration;
         	if (mFlying) {
         		parentObject.getVelocity().y = 0.0f;
         		parentObject.getTargetVelocity().y = 0.0f;
         	}
             break;
         case HotSpotSystem.HotSpotType.NPC_GO_RIGHT:
         	parentObject.getTargetVelocity().x = mHorizontalImpulse;
         	parentObject.getAcceleration().x = mAcceleration;
         	if (mFlying) {
         		parentObject.getVelocity().y = 0.0f;
         		parentObject.getTargetVelocity().y = 0.0f;
         	}

             break;
         case HotSpotSystem.HotSpotType.NPC_GO_UP_RIGHT:
         	parentObject.getVelocity().y = mUpImpulse;
         	parentObject.getTargetVelocity().x = mHorizontalImpulse;
         	parentObject.getAcceleration().x = mAcceleration;


             break;
         case HotSpotSystem.HotSpotType.NPC_GO_UP_LEFT:
         	parentObject.getVelocity().y = mUpImpulse;
         	parentObject.getTargetVelocity().x = -mHorizontalImpulse;
         	parentObject.getAcceleration().x = mAcceleration;


             break;
         case HotSpotSystem.HotSpotType.NPC_GO_DOWN_RIGHT:
         	parentObject.getVelocity().y = mDownImpulse;
         	parentObject.getTargetVelocity().x = mHorizontalImpulse;
         	parentObject.getAcceleration().x = mAcceleration;


             break;
         case HotSpotSystem.HotSpotType.NPC_GO_DOWN_LEFT:
         	parentObject.getVelocity().y = mDownImpulse;
         	parentObject.getTargetVelocity().x = -mHorizontalImpulse;
         	parentObject.getAcceleration().x = mAcceleration;


             break;
         case HotSpotSystem.HotSpotType.NPC_GO_TOWARDS_PLAYER:
             int direction = 1;
             GameObjectManager manager = sSystemRegistry.gameObjectManager;
             if (manager != null) {
                 GameObject player = manager.getPlayer();
                 if (player != null) {
                     direction = Utils.sign(
                             player.getCenteredPositionX() -
                             parentObject.getCenteredPositionX());
                 }
             }
             parentObject.getTargetVelocity().x = mHorizontalImpulse * direction;
             if (mFlying) {
             	parentObject.getVelocity().y = 0.0f;
         		parentObject.getTargetVelocity().y = 0.0f;
         	}
             break;
         case HotSpotSystem.HotSpotType.NPC_GO_RANDOM:
         	parentObject.getTargetVelocity().x = mHorizontalImpulse * (Math.random() > 0.5f ? -1.0f : 1.0f);
         	if (mFlying) {
         		parentObject.getVelocity().y = 0.0f;
         		parentObject.getTargetVelocity().y = 0.0f;
         	}
             break;

         case HotSpotSystem.HotSpotType.NPC_STOP:
         	parentObject.getTargetVelocity().x = 0.0f;
         	parentObject.getVelocity().x = 0.0f;
             break;

         case HotSpotSystem.HotSpotType.NPC_SLOW:
         	parentObject.getTargetVelocity().x = mSlowHorizontalImpulse * Utils.sign(parentObject.getTargetVelocity().x);
             break;

         case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_1_1:
         case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_1_2:
         case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_1_3:
         case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_1_4:
         case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_1_5:
         case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_2_1:
         case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_2_2:
         case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_2_3:
         case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_2_4:
         case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_2_5:
         	selectDialog(hotSpot);
         	break;
         case HotSpotSystem.HotSpotType.NONE:
             if (parentObject.touchingGround() && parentObject.getVelocity().y <= 0.0f) {
                 //resumeMovement(parentObject);
             }
             break;
     	}

     	return hitAccepted;
     }

     private void pauseMovement(GameObject parentObject) {
     	mTargetXVelocity = parentObject.getTargetVelocity().x;
     	parentObject.getTargetVelocity().x = 0.0f;
     	parentObject.getVelocity().x = 0.0f;
     }

     private void resumeMovement(GameObject parentObject) {
     	parentObject.getTargetVelocity().x = mTargetXVelocity;
     	parentObject.getAcceleration().x = mAcceleration;
     }

     private void selectDialog(int hitSpot) {
 		mDialogEvent = GameFlowEvent.EVENT_SHOW_DIALOG_CHARACTER1;
     	mDialogIndex = hitSpot - HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_1_1;

     	if (hitSpot >= HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_2_1) {
     		mDialogEvent = GameFlowEvent.EVENT_SHOW_DIALOG_CHARACTER2;
     		mDialogIndex = hitSpot - HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_2_1;
     	}
     }

     private int nextCommand() {
     	int result = HotSpotSystem.HotSpotType.NONE;
     	if (mQueueTop != mQueueBottom) {
     		result = mQueuedCommands[mQueueTop];
     	}
     	return result;
     }

     private int advanceQueue() {
     	int result = HotSpotSystem.HotSpotType.NONE;
     	if (mQueueTop != mQueueBottom) {
     		result = mQueuedCommands[mQueueTop];
     		mQueueTop = (mQueueTop + 1) % COMMAND_QUEUE_SIZE;
     	}
     	return result;
     }

     private void queueCommand(int hotspot) {
     	int nextSlot = (mQueueBottom + 1) % COMMAND_QUEUE_SIZE;
     	if (nextSlot != mQueueTop) { // only comply if there is space left in the buffer
     		mQueuedCommands[mQueueBottom] = hotspot;
     		mQueueBottom = nextSlot;
     	}
     }

     public void setHitReactionComponent(HitReactionComponent hitReact) {
     	mHitReactComponent = hitReact;
     }

     public void setSpeeds(float horizontalImpulse, float slowHorizontalImpulse, float upImpulse, float downImpulse, float acceleration) {
     	mHorizontalImpulse = horizontalImpulse;
     	mSlowHorizontalImpulse = slowHorizontalImpulse;
     	mUpImpulse = upImpulse;
     	mDownImpulse = downImpulse;
     	mAcceleration = acceleration;
     }

     public void setGameEvent(int event, int index, boolean spawnOnDeath) {
     	mGameEvent = event;
     	mGameEventIndex = index;
     	mSpawnGameEventOnDeath = spawnOnDeath;
     }

     public void setReactToHits(boolean react) {
     	mReactToHits = react;
     }

     public void setFlying(boolean flying) {
     	mFlying = flying;
     }

     public void setPauseOnAttack(boolean pauseOnAttack) {
     	mPauseOnAttack = pauseOnAttack;
     }
 }
	/*
	* Copyright (C) 2010 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.replica.replicaisland;

	import com.replica.replicaisland.CollisionParameters.HitType;
	import com.replica.replicaisland.GameObject.ActionType;

	public class NPCComponent extends GameComponent {
	private float mPauseTime;
	private float mTargetXVelocity;
	private int mLastHitTileX;
	private int mLastHitTileY;

	private int mDialogEvent;
	private int mDialogIndex;

	private HitReactionComponent mHitReactComponent;

	private int[] mQueuedCommands;
	private int mQueueTop;
	private int mQueueBottom;
	private boolean mExecutingQueue;

	private Vector2 mPreviousPosition;

	private float mUpImpulse;
	private float mDownImpulse;
	private float mHorizontalImpulse;
	private float mSlowHorizontalImpulse;
	private float mAcceleration;

	private int mGameEvent;
	private int mGameEventIndex;
	private boolean mSpawnGameEventOnDeath;

	private boolean mReactToHits;
	private boolean mFlying;
	private boolean mPauseOnAttack;

	private float mDeathTime;
	private float mDeathFadeDelay;

	private static final float UP_IMPULSE = 400.0f;
	private static final float DOWN_IMPULSE = -10.0f;
	private static final float HORIZONTAL_IMPULSE = 200.0f;
	private static final float SLOW_HORIZONTAL_IMPULSE = 50.0f;
	private static final float ACCELERATION = 300.0f;
	private static final float HIT_IMPULSE = 300.0f;
	private static final float HIT_ACCELERATION = 700.0f;

	private static final float DEATH_FADE_DELAY = 4.0f;

	private static final float PAUSE_TIME_SHORT = 1.0f;
	private static final float PAUSE_TIME_MEDIUM = 4.0f;
	private static final float PAUSE_TIME_LONG = 8.0f;
	private static final float PAUSE_TIME_ATTACK = 1.0f;
	private static final float PAUSE_TIME_HIT_REACT = 1.0f;

	private static final int COMMAND_QUEUE_SIZE = 16;

	public NPCComponent() {
	super();
	setPhase(ComponentPhases.THINK.ordinal());
	mQueuedCommands = new int[COMMAND_QUEUE_SIZE];
	mPreviousPosition = new Vector2();
	reset();
	}

	@Override
	public void reset() {
	mPauseTime = 0.0f;
	mTargetXVelocity = 0.0f;
	mLastHitTileX = 0;
	mLastHitTileY = 0;
	mDialogEvent = GameFlowEvent.EVENT_SHOW_DIALOG_CHARACTER1;
	mDialogIndex = 0;
	mHitReactComponent = null;
	mQueueTop = 0;
	mQueueBottom = 0;
	mPreviousPosition.zero();
	mExecutingQueue = false;
	mUpImpulse = UP_IMPULSE;
	mDownImpulse = DOWN_IMPULSE;
	mHorizontalImpulse = HORIZONTAL_IMPULSE;
	mSlowHorizontalImpulse = SLOW_HORIZONTAL_IMPULSE;
	mAcceleration = ACCELERATION;
	mGameEvent = -1;
	mGameEventIndex = -1;
	mSpawnGameEventOnDeath = false;
	mReactToHits = false;
	mFlying = false;
	mDeathTime = 0.0f;
	mDeathFadeDelay = DEATH_FADE_DELAY;
	mPauseOnAttack = true;
	}

	@Override
	public void update(float timeDelta, BaseObject parent) {

	GameObject parentObject = (GameObject)parent;

	if (mReactToHits &&
	mPauseTime <= 0.0f &&
	parentObject.getCurrentAction() == ActionType.HIT_REACT) {
	mPauseTime = PAUSE_TIME_HIT_REACT;
	pauseMovement(parentObject);
	parentObject.getVelocity().x = -parentObject.facingDirection.x * HIT_IMPULSE;
	parentObject.getAcceleration().x = HIT_ACCELERATION;

	} else if (parentObject.getCurrentAction() == ActionType.DEATH) {
	if (mSpawnGameEventOnDeath && mGameEvent != -1) {
	if (Utils.close(parentObject.getVelocity().x, 0.0f)
	&& parentObject.touchingGround()) {

	if (mDeathTime < mDeathFadeDelay && mDeathTime + timeDelta >= mDeathFadeDelay) {
	HudSystem hud = sSystemRegistry.hudSystem;

	if (hud != null) {
	hud.startFade(false, 1.5f);
	hud.sendGameEventOnFadeComplete(mGameEvent, mGameEventIndex);
	mGameEvent = -1;
	}
	}
	mDeathTime += timeDelta;

	}
	}
	// nothing else to do.
	return;
	} else if (parentObject.life <= 0) {
	parentObject.setCurrentAction(ActionType.DEATH);
	parentObject.getTargetVelocity().x = 0;
	return;
	} else if (parentObject.getCurrentAction() == ActionType.INVALID \|\|
	(!mReactToHits && parentObject.getCurrentAction() == ActionType.HIT_REACT)) {
	parentObject.setCurrentAction(ActionType.MOVE);
	}

	if (mPauseTime <= 0.0f) {

	HotSpotSystem hotSpotSystem = sSystemRegistry.hotSpotSystem;

	if (hotSpotSystem != null) {
	final float centerX = parentObject.getCenteredPositionX();
	final int hitTileX = hotSpotSystem.getHitTileX(centerX);
	final int hitTileY = hotSpotSystem.getHitTileY(parentObject.getPosition().y + 10.0f);
	boolean accepted = true;

	if (hitTileX != mLastHitTileX \|\| hitTileY != mLastHitTileY) {

	final int hotSpot = hotSpotSystem.getHotSpotByTile(hitTileX, hitTileY);

	if (hotSpot >= HotSpotSystem.HotSpotType.NPC_GO_RIGHT && hotSpot <= HotSpotSystem.HotSpotType.NPC_SLOW) {
	// movement-related commands are immediate
	parentObject.setCurrentAction(ActionType.MOVE);
	accepted = executeCommand(hotSpot, parentObject, timeDelta);
	} else if (hotSpot == HotSpotSystem.HotSpotType.ATTACK && !mPauseOnAttack) {
	// when mPauseOnAttack is false, attacks are also immediate.
	accepted = executeCommand(hotSpot, parentObject, timeDelta);
	} else if (hotSpot == HotSpotSystem.HotSpotType.NPC_RUN_QUEUED_COMMANDS) {
	if (!mExecutingQueue && mQueueTop != mQueueBottom) {
	mExecutingQueue = true;
	}
	} else if (hotSpot > HotSpotSystem.HotSpotType.NONE) {
	queueCommand(hotSpot);
	}
	}

	if (mExecutingQueue) {
	if (mQueueTop != mQueueBottom) {
	accepted = executeCommand(nextCommand(), parentObject, timeDelta);
	if (accepted) {
	advanceQueue();
	}
	} else {
	mExecutingQueue = false;
	}
	}

	if (accepted) {
	mLastHitTileX = hitTileX;
	mLastHitTileY = hitTileY;
	}

	}
	} else {
	mPauseTime -= timeDelta;
	if (mPauseTime < 0.0f) {
	resumeMovement(parentObject);
	mPauseTime = 0.0f;
	parentObject.setCurrentAction(ActionType.MOVE);
	}
	}

	mPreviousPosition.set(parentObject.getPosition());
	}

	private boolean executeCommand(int hotSpot, GameObject parentObject, float timeDelta) {
	boolean hitAccepted = true;
	final CameraSystem camera = sSystemRegistry.cameraSystem;

	switch(hotSpot) {
	case HotSpotSystem.HotSpotType.WAIT_SHORT:
	if (mPauseTime == 0.0f) {
	mPauseTime = PAUSE_TIME_SHORT;
	pauseMovement(parentObject);
	}
	break;
	case HotSpotSystem.HotSpotType.WAIT_MEDIUM:
	if (mPauseTime == 0.0f) {
	mPauseTime = PAUSE_TIME_MEDIUM;
	pauseMovement(parentObject);
	}
	break;
	case HotSpotSystem.HotSpotType.WAIT_LONG:
	if (mPauseTime == 0.0f) {
	mPauseTime = PAUSE_TIME_LONG;
	pauseMovement(parentObject);
	}
	break;
	case HotSpotSystem.HotSpotType.ATTACK:
	if (mPauseOnAttack) {
	if (mPauseTime == 0.0f) {
	mPauseTime = PAUSE_TIME_ATTACK;
	pauseMovement(parentObject);

	}
	}
	parentObject.setCurrentAction(ActionType.ATTACK);

	break;

	case HotSpotSystem.HotSpotType.TALK:
	if (mHitReactComponent != null) {
	if (parentObject.lastReceivedHitType != HitType.COLLECT) {
	mHitReactComponent.setSpawnGameEventOnHit(
	HitType.COLLECT, mDialogEvent, mDialogIndex);
	if (parentObject.getVelocity().x != 0.0f) {
	pauseMovement(parentObject);
	}
	hitAccepted = false;
	} else {
	parentObject.setCurrentAction(ActionType.MOVE);

	resumeMovement(parentObject);
	mHitReactComponent.setSpawnGameEventOnHit(HitType.INVALID, 0, 0);
	parentObject.lastReceivedHitType = HitType.INVALID;
	}
	}
	break;

	case HotSpotSystem.HotSpotType.WALK_AND_TALK:
	if (mDialogEvent != GameFlowEvent.EVENT_INVALID) {
	LevelSystem level = sSystemRegistry.levelSystem;
	level.sendGameEvent(mDialogEvent, mDialogIndex, true);
	mDialogEvent = GameFlowEvent.EVENT_INVALID;
	}
	break;

	case HotSpotSystem.HotSpotType.TAKE_CAMERA_FOCUS:
	if (camera != null) {
	camera.setTarget(parentObject);
	}
	break;

	case HotSpotSystem.HotSpotType.RELEASE_CAMERA_FOCUS:

	if (camera != null) {
	GameObjectManager gameObjectManager = sSystemRegistry.gameObjectManager;
	camera.setTarget(gameObjectManager.getPlayer());
	}
	break;

	case HotSpotSystem.HotSpotType.END_LEVEL:
	HudSystem hud = sSystemRegistry.hudSystem;

	if (hud != null) {
	hud.startFade(false, 1.5f);
	hud.sendGameEventOnFadeComplete(GameFlowEvent.EVENT_GO_TO_NEXT_LEVEL, 0);
	}
	break;
	case HotSpotSystem.HotSpotType.GAME_EVENT:
	if (mGameEvent != -1) {
	LevelSystem level = sSystemRegistry.levelSystem;
	if (level != null) {
	level.sendGameEvent(mGameEvent, mGameEventIndex, true);
	mGameEvent = -1;
	}
	}
	break;

	case HotSpotSystem.HotSpotType.NPC_GO_UP_FROM_GROUND:
	if (!parentObject.touchingGround()) {
	hitAccepted = false;
	break;
	}
	// fall through
	case HotSpotSystem.HotSpotType.NPC_GO_UP:
	parentObject.getVelocity().y = mUpImpulse;
	parentObject.getTargetVelocity().y = 0.0f;
	mTargetXVelocity = 0.0f;

	break;
	case HotSpotSystem.HotSpotType.NPC_GO_DOWN_FROM_CEILING:
	if (!parentObject.touchingCeiling()) {
	hitAccepted = false;
	break;
	}
	// fall through
	case HotSpotSystem.HotSpotType.NPC_GO_DOWN:
	parentObject.getVelocity().y = mDownImpulse;
	parentObject.getTargetVelocity().y = 0.0f;
	if (mFlying) {
	mTargetXVelocity = 0.0f;
	}
	break;
	case HotSpotSystem.HotSpotType.NPC_GO_LEFT:
	parentObject.getTargetVelocity().x = -mHorizontalImpulse;
	parentObject.getAcceleration().x = mAcceleration;
	if (mFlying) {
	parentObject.getVelocity().y = 0.0f;
	parentObject.getTargetVelocity().y = 0.0f;
	}
	break;
	case HotSpotSystem.HotSpotType.NPC_GO_RIGHT:
	parentObject.getTargetVelocity().x = mHorizontalImpulse;
	parentObject.getAcceleration().x = mAcceleration;
	if (mFlying) {
	parentObject.getVelocity().y = 0.0f;
	parentObject.getTargetVelocity().y = 0.0f;
	}

	break;
	case HotSpotSystem.HotSpotType.NPC_GO_UP_RIGHT:
	parentObject.getVelocity().y = mUpImpulse;
	parentObject.getTargetVelocity().x = mHorizontalImpulse;
	parentObject.getAcceleration().x = mAcceleration;


	break;
	case HotSpotSystem.HotSpotType.NPC_GO_UP_LEFT:
	parentObject.getVelocity().y = mUpImpulse;
	parentObject.getTargetVelocity().x = -mHorizontalImpulse;
	parentObject.getAcceleration().x = mAcceleration;


	break;
	case HotSpotSystem.HotSpotType.NPC_GO_DOWN_RIGHT:
	parentObject.getVelocity().y = mDownImpulse;
	parentObject.getTargetVelocity().x = mHorizontalImpulse;
	parentObject.getAcceleration().x = mAcceleration;


	break;
	case HotSpotSystem.HotSpotType.NPC_GO_DOWN_LEFT:
	parentObject.getVelocity().y = mDownImpulse;
	parentObject.getTargetVelocity().x = -mHorizontalImpulse;
	parentObject.getAcceleration().x = mAcceleration;


	break;
	case HotSpotSystem.HotSpotType.NPC_GO_TOWARDS_PLAYER:
	int direction = 1;
	GameObjectManager manager = sSystemRegistry.gameObjectManager;
	if (manager != null) {
	GameObject player = manager.getPlayer();
	if (player != null) {
	direction = Utils.sign(
	player.getCenteredPositionX() -
	parentObject.getCenteredPositionX());
	}
	}
	parentObject.getTargetVelocity().x = mHorizontalImpulse * direction;
	if (mFlying) {
	parentObject.getVelocity().y = 0.0f;
	parentObject.getTargetVelocity().y = 0.0f;
	}
	break;
	case HotSpotSystem.HotSpotType.NPC_GO_RANDOM:
	parentObject.getTargetVelocity().x = mHorizontalImpulse * (Math.random() > 0.5f ? -1.0f : 1.0f);
	if (mFlying) {
	parentObject.getVelocity().y = 0.0f;
	parentObject.getTargetVelocity().y = 0.0f;
	}
	break;

	case HotSpotSystem.HotSpotType.NPC_STOP:
	parentObject.getTargetVelocity().x = 0.0f;
	parentObject.getVelocity().x = 0.0f;
	break;

	case HotSpotSystem.HotSpotType.NPC_SLOW:
	parentObject.getTargetVelocity().x = mSlowHorizontalImpulse * Utils.sign(parentObject.getTargetVelocity().x);
	break;

	case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_1_1:
	case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_1_2:
	case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_1_3:
	case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_1_4:
	case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_1_5:
	case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_2_1:
	case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_2_2:
	case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_2_3:
	case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_2_4:
	case HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_2_5:
	selectDialog(hotSpot);
	break;
	case HotSpotSystem.HotSpotType.NONE:
	if (parentObject.touchingGround() && parentObject.getVelocity().y <= 0.0f) {
	//resumeMovement(parentObject);
	}
	break;
	}

	return hitAccepted;
	}

	private void pauseMovement(GameObject parentObject) {
	mTargetXVelocity = parentObject.getTargetVelocity().x;
	parentObject.getTargetVelocity().x = 0.0f;
	parentObject.getVelocity().x = 0.0f;
	}

	private void resumeMovement(GameObject parentObject) {
	parentObject.getTargetVelocity().x = mTargetXVelocity;
	parentObject.getAcceleration().x = mAcceleration;
	}

	private void selectDialog(int hitSpot) {
	mDialogEvent = GameFlowEvent.EVENT_SHOW_DIALOG_CHARACTER1;
	mDialogIndex = hitSpot - HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_1_1;

	if (hitSpot >= HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_2_1) {
	mDialogEvent = GameFlowEvent.EVENT_SHOW_DIALOG_CHARACTER2;
	mDialogIndex = hitSpot - HotSpotSystem.HotSpotType.NPC_SELECT_DIALOG_2_1;
	}
	}

	private int nextCommand() {
	int result = HotSpotSystem.HotSpotType.NONE;
	if (mQueueTop != mQueueBottom) {
	result = mQueuedCommands[mQueueTop];
	}
	return result;
	}

	private int advanceQueue() {
	int result = HotSpotSystem.HotSpotType.NONE;
	if (mQueueTop != mQueueBottom) {
	result = mQueuedCommands[mQueueTop];
	mQueueTop = (mQueueTop + 1) % COMMAND_QUEUE_SIZE;
	}
	return result;
	}

	private void queueCommand(int hotspot) {
	int nextSlot = (mQueueBottom + 1) % COMMAND_QUEUE_SIZE;
	if (nextSlot != mQueueTop) { // only comply if there is space left in the buffer
	mQueuedCommands[mQueueBottom] = hotspot;
	mQueueBottom = nextSlot;
	}
	}

	public void setHitReactionComponent(HitReactionComponent hitReact) {
	mHitReactComponent = hitReact;
	}

	public void setSpeeds(float horizontalImpulse, float slowHorizontalImpulse, float upImpulse, float downImpulse, float acceleration) {
	mHorizontalImpulse = horizontalImpulse;
	mSlowHorizontalImpulse = slowHorizontalImpulse;
	mUpImpulse = upImpulse;
	mDownImpulse = downImpulse;
	mAcceleration = acceleration;
	}

	public void setGameEvent(int event, int index, boolean spawnOnDeath) {
	mGameEvent = event;
	mGameEventIndex = index;
	mSpawnGameEventOnDeath = spawnOnDeath;
	}

	public void setReactToHits(boolean react) {
	mReactToHits = react;
	}

	public void setFlying(boolean flying) {
	mFlying = flying;
	}

	public void setPauseOnAttack(boolean pauseOnAttack) {
	mPauseOnAttack = pauseOnAttack;
	}
	}