@Override
public boolean handleMessage(Telegram telegram) {
	switch (telegram.message) {
		case Constants.MSG_GUI_SET_DOG_BUTTON_TO_WHISTLE:
			setDogButton(whistleButton, (HumanCharacter) telegram.extraInfo);
			return true;
		case Constants.MSG_GUI_SET_DOG_BUTTON_TO_THROW:
			setDogButton(throwButton, (HumanCharacter) telegram.extraInfo);
			return true;
		case Constants.MSG_GUI_CLEAR_DOG_BUTTON:
			clearDogButton((HumanCharacter) telegram.extraInfo);
			return true;
		case Constants.MSG_GUI_UPDATE_DOG_BUTTON:
			updateDogButton((HumanCharacter) telegram.extraInfo);
			return true;
	}
	return false;
}
 

@Override
public boolean handleMessage (Telegram telegram) {
	switch (telegram.message) {
	case PF_RESPONSE: // PathFinderQueue will call us directly, no need to register for this message
		MyPathFinderRequest pfr = (MyPathFinderRequest)telegram.extraInfo;
		if (PathFinderRequestControl.DEBUG) {
			@SuppressWarnings("unchecked")
			PathFinderQueue<FlatTiledNode> pfQueue = (PathFinderQueue<FlatTiledNode>)telegram.sender;
			System.out.println("pfQueue.size = " + pfQueue.size() + " executionFrames = " + pfr.executionFrames);
		}

		// Swap double buffer
		workPath = activePath;
		activePath = (TiledSmoothableGraphPath<FlatTiledNode>)pfr.resultPath;

		isActivePathSmoothed = pfr.smoothEnabled;

		// Release the request
		requestPool.free(pfr);
		break;
	}
	return true;
}
 

/** Handles received telegrams. The telegram is first routed to the current state. If the current state does not deal with the
 * message, it's routed to the global state's message handler.
 * 
 * @param telegram the received telegram
 * @return true if telegram has been successfully handled; false otherwise. */
@Override
public boolean handleMessage (Telegram telegram) {

	// First see if the current state is valid and that it can handle the message
	if (currentState != null && currentState.onMessage(owner, telegram)) {
		return true;
	}

	// If not, and if a global state has been implemented, send
	// the message to the global state
	if (globalState != null && globalState.onMessage(owner, telegram)) {
		return true;
	}

	return false;
}
 

@Override
public boolean handleMessage(Telegram telegram) {
	switch (telegram.message) {
		case Constants.MSG_DOG_LETS_PLAY:
			humanWantToPlay = true;
			stickThrown = false;
			break;
		case Constants.MSG_DOG_LETS_STOP_PLAYING:
			humanWantToPlay = false;
			break;
		case Constants.MSG_DOG_HUMAN_IS_DEAD:
			humanIsDead = true;
			humanWantToPlay = false;
			alreadyCriedForHumanDeath = false;
			break;
		case Constants.MSG_DOG_HUMAN_IS_RESURRECTED:
			humanIsDead = false;
			alreadyCriedForHumanDeath = false;
			break;
		case Constants.MSG_DOG_STICK_THROWN:
			stickThrown = true;
			break;
	}
	// Update GUI buttons if the dog's owner is selected
	if (this.human != null && this.human.selected) {
		MessageManager.getInstance().dispatchMessage(Constants.MSG_GUI_UPDATE_DOG_BUTTON, this.human);
	}
	return true;
}
 

@Override
public boolean handleMessage(final Telegram msg) {
	Entity character = (Entity) msg.extraInfo;
	character.getBody().setTransform(RESPAWN_POSITION, character.getBody().getAngle());
	character.changeState(NinjaRabbitState.IDLE);
	character.setDirection(Direction.RIGHT);
	return true;
}
 

@Override
public boolean handleMessage(final Telegram msg) {
	getStatus().setLevel((byte) (getStatus().getLevel() + 1));
	getStatus().setTime(PlayerStatus.DEFAULT_TIME);
	MessageManager.getInstance().dispatchMessage(this, MessageType.BEGIN_LEVEL.code());
	return true;
}
 

@Override
public boolean handleMessage(final Telegram msg) {
	if (msg.message == MessageType.COLLECTED.code()) {
		getStatus().setCollectibles((short) (getStatus().getCollectibles() + 1));
		getStatus().setScore(getStatus().getScore() + COLLECTIBLE_POINTS);
	} else if (msg.message == MessageType.DEAD.code()) {
		if (getStatus().getLives() > 0) {
			getStatus().setLives((short) (getStatus().getLives() - 1));
		}
		System.out.println("Dead received!");
	}
	return true;
}
 

@Override
public boolean handleMessage(final Telegram msg) {
	if (msg.message == MessageType.RESET.code()) {
		reset();
	} else if (msg.message == MessageType.DEAD.code()) {
		restartCurrentLevel();
	} else if (msg.message == MessageType.BEGIN_LEVEL.code()) {
		beginNextLevel();
	}
	return false;
}
 

@Override
public boolean handleMessage(final Telegram msg) {
	if (msg.message == MessageType.GAME_OVER.code()) {
		theme.stop();
		gameOverMusic.play();
	} else if (msg.message == MessageType.EXIT.code()) {
		theme.stop();
		exitMusic.play();
	}
	return true;
}
 

@Override
public boolean handleMessage (Telegram msg) {
	// build a new house
	if (houses.size <= 10) {
		houses.add(new House(this));
	}
	return false;
}
 

@Override
public boolean handleMessage (Telegram msg) {
	if (citizens.size < 3) {
		// new child
		Gdx.app.log(toString(), "We're having a baby!");
		citizens.add(new Citizen(this));
	}
	return false;
}
 

@Override
public boolean handleMessage (Telegram msg) {
	Citizen citizen = (Citizen)msg.extraInfo;
	// greet only if not in the same house
	if (this.house.id != citizen.house.id) {
		Gdx.app.log(toString(), "Hi " + citizen + ", I'm your new neighbour");
	}
	return false;
}
 

@Override
public boolean handleMessage (Telegram msg) {
	this.msgCounter = (Integer)msg.extraInfo;
	this.msgTimestamp = msg.getTimestamp();
	if (timerEnabledButton.isChecked()) {
		float lag = GdxAI.getTimepiece().getTime() - msg.getTimestamp();
		lag -= (int)lag; // take the decimal part only (in case the lag is > 1)
		float delay = 1f - lag;
		sendMessage(delay, msgCounter + 1);
	}
	return true;
}
 

@Override
public boolean handleMessage (Telegram telegram) {
	switch (telegram.message) {
	case PF_RESPONSE: // PathFinderQueue will call us directly, no need to register for this message
		if (PathFinderRequestControl.DEBUG) {
			@SuppressWarnings("unchecked")
			PathFinderQueue<HierarchicalTiledNode> pfQueue = (PathFinderQueue<HierarchicalTiledNode>)telegram.sender;
			System.out.println("pfQueue.size = " + pfQueue.size());
		}
		MyPathFinderRequest pfr = (MyPathFinderRequest)telegram.extraInfo;
		TiledSmoothableGraphPath<HierarchicalTiledNode> path = paths[pfr.pathIndex];
		int n = path.getCount();
		if (n > 0 && pfr.pathFound && pfr.endNode != path.get(n - 1)) {
			pfr.startNode = path.get(n - 1);
			if(pfr.pathIndex + 1 < paths.length) {
				pfr.pathIndex++;
			}
			pfr.resultPath = paths[pfr.pathIndex];
			pfr.changeStatus(PathFinderRequest.SEARCH_NEW);
			numPaths = pfr.pathIndex;
		} else {
			requestPool.free(pfr);
			numPaths = pfr.pathIndex + 1;
		}
		break;
	}
	return true;
}
 

@Override
public boolean handleMessage (Telegram telegram) {
	@SuppressWarnings("unchecked")
	PathFinderRequest<N> pfr = (PathFinderRequest<N>)telegram.extraInfo;
	pfr.client = telegram.sender; // set the client to be notified once the request has completed
	pfr.status = PathFinderRequest.SEARCH_NEW; // Reset status
	pfr.statusChanged = true; // Status has just changed
	pfr.executionFrames = 0; // Reset execution frames counter
	requestQueue.store(pfr);
	return true;
}
 

@Override
public boolean handleMessage(Telegram msg) {
    return stateMachine.handleMessage(msg);
}
 

@Override
public boolean handleMessage(Telegram msg) {
    return stateMachine.handleMessage(msg);
}
 

@Override
public boolean onMessage(Integer entity, Telegram telegram) {
  return false;
}
 

@Override public boolean onMessage(Integer entityId, Telegram telegram) {
  return false;
}
 

@Override public boolean onMessage(Integer entityId, Telegram telegram) {
  return false;
}
 

@Override
public boolean onMessage(HumanCharacter entity, Telegram telegram) {
	return false;
}
 

@Override
public boolean handleMessage(final Telegram msg) {
	Collectible collectible = (Collectible) msg.extraInfo;
	removed.add(collectible);
	return true;
}
 

@Override
public boolean handleMessage(final Telegram msg) {
	renderGameOver = msg.message == MessageType.GAME_OVER.code();
	return true;
}
 

@Override
public boolean handleMessage(final Telegram msg) {
	Gdx.input.setInputProcessor(null);
	return true;
}
 

@Override
public boolean handleMessage(final Telegram msg) {
	assets.get(Assets.LIFE_LOST_FX).play();
	return true;
}
 

@Override
public boolean handleMessage (Telegram msg) {
	return stateMachine.handleMessage(msg);
}
 

@Override
public boolean handleMessage (Telegram msg) {
	return stateMachine.handleMessage(msg);
}
 

/** Handles received telegrams.
 * <p>
 * Implementation classes should first route the telegram to the current state. If the current state does not deal with the
 * message, it should be routed to the global state.
 * </p>
 * @param telegram the received telegram
 * @return true if telegram has been successfully handled; false otherwise. */
public boolean handleMessage (Telegram telegram);
 

/** This method executes if the {@code entity} receives a {@code telegram} from the message dispatcher while it is in this
 * state.
 * 
 * @param entity the entity that received the message
 * @param telegram the message sent to the entity
 * @return true if the message has been successfully handled; false otherwise. */
public boolean onMessage (E entity, Telegram telegram);