import com.badlogic.gdx.ai.fsm.State; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public boolean handleMessage(Telegram msg) {
	if (msg.message == MessageType.YOU_ARE_DISMANTLED.ordinal()) {
		kill();
		Vector3 p = Game.instance.activeIsland.pos;
		ItemDrop i = new ItemDrop(Island.SIZE / 2 - 5, Island.SIZE / 4 * 3 + p.y + 1, Island.SIZE / 2, Item.get("YELLOW_CRYSTAL"), 1);
		island.addEntity(i, false, false);
		return true;
	}
	
	if (msg.message == MessageType.STRUCTURE_BROADCAST_HANDLED.ordinal()) {
		requestedHumanStates.removeValue((State<Human>) msg.extraInfo, true);
	}
	
	return false;
}
 

import com.badlogic.gdx.ai.fsm.State; //导入依赖的package包/类
public <T extends State> GameEntity changeState(T state){
    if(fsmC == null) fsmC = Mappers.fsm.get(this.entity);
    if(fsmC != null && fsmC.stateMachine.getCurrentState() != state){
        fsmC.stateMachine.changeState(state);
    }
    return this;
}
 

import com.badlogic.gdx.ai.fsm.State; //导入依赖的package包/类
public Structure(float x, float y, float z, String model) {
	super(Math.round(x), Math.round(y), Math.round(z), model);
	
	nodes = new Array<StructureNode>();
	workers = new Array<Human>();
	
	int width = (int) Math.ceil(boundingBox.getDimensions().x);
	int depth = (int) Math.ceil(boundingBox.getDimensions().z);
	
	nodes.add(new StructureNode(NodeType.target, -1, 0, Math.round(depth / 2)));
	nodes.add(new StructureNode(NodeType.target, width, 0, Math.round(depth / 2)));
	nodes.add(new StructureNode(NodeType.target, Math.round(width / 2), 0, -1));
	nodes.add(new StructureNode(NodeType.target, Math.round(width / 2), 0, depth));
	
	nodes.add(new StructureNode(NodeType.build, 0, 0, Math.round(depth / 2)));
	nodes.add(new StructureNode(NodeType.build, width - 1, 0, Math.round(depth / 2)));
	nodes.add(new StructureNode(NodeType.build, Math.round(width / 2), 0, 0));
	nodes.add(new StructureNode(NodeType.build, Math.round(width / 2), 0, depth - 1));
	
	inventory = new Inventory();
	buildInventory = new NonStackingInventory(256 /* That should be enough... */);
	costs = new ResourceList();
	requestedHumanStates = new Array<State<Human>>();
	handledHumanStates = new Array<State<Human>>();
	tasks = new Array<Task>();
	taskQueue = new Array<Task>();
	working = true;
	
	dimensions.x++;
	dimensions.z++;
	
	setBuilt(false);
}
 

import com.badlogic.gdx.ai.fsm.State; //导入依赖的package包/类
public void broadcast(float delay, State<Human> requestedState, Object... params) {
	Array<Object> array = new Array<Object>(params);
	array.insert(0, this);
	
	if (!requestedHumanStates.contains(requestedState, true)) requestedHumanStates.add(requestedState);
	
	MessageDispatcher.getInstance().dispatchMessage(delay, this, null, MessageType.STRUCTURE_BROADCAST.ordinal(), new BroadcastPayload(requestedState, array.items));
}
 

import com.badlogic.gdx.ai.fsm.State; //导入依赖的package包/类
public void changeState(State<Human> newState, Object... params) {
	previousStateParams.clear();
	previousStateParams.addAll(stateParams);
	stateParams.clear();
	stateParams.addAll(params);
	stateMachine.changeState(newState);
}
 

import com.badlogic.gdx.ai.fsm.State; //导入依赖的package包/类
public Entity(final GraphicsProcessor graphics, final PhysicsProcessor physics, final AudioProcessor audio,
		final State<Entity> initialState) {
	this.graphics = graphics;
	this.physics = physics;
	this.audio = audio;
	stateMachine = new DefaultStateMachine<Entity>(this, initialState);
}
 

import com.badlogic.gdx.ai.fsm.State; //导入依赖的package包/类
public State getCurrentState(){
    if(fsmC == null) fsmC = Mappers.fsm.get(this.entity);
    return fsmC == null? null : fsmC.stateMachine.getCurrentState();
}
 

import com.badlogic.gdx.ai.fsm.State; //导入依赖的package包/类
public void changeState (State<GameEntity> state) {
	stateMachine.changeState(state);
}
 

import com.badlogic.gdx.ai.fsm.State; //导入依赖的package包/类
private Tatics(State<Entity> entryState){
	this.entryState = entryState;
}
 

import com.badlogic.gdx.ai.fsm.State; //导入依赖的package包/类
public void changeState (State<Entity> state) {
	stateMachine.changeState(state);
}
 

import com.badlogic.gdx.ai.fsm.State; //导入依赖的package包/类
public State<Human> getWorkerState() {
	return workerState;
}
 

import com.badlogic.gdx.ai.fsm.State; //导入依赖的package包/类
public State<Human> getState() {
	return stateMachine.getCurrentState();
}
 

import com.badlogic.gdx.ai.fsm.State; //导入依赖的package包/类
public SyncedStateMachine(E owner, State<E> initialState) {
	super(owner, initialState);
}
 

import com.badlogic.gdx.ai.fsm.State; //导入依赖的package包/类
@Override
public void changeState(State<E> newState) {
	newStateEntered = false;
	super.changeState(newState);
	newStateEntered = true;
}
 

import com.badlogic.gdx.ai.fsm.State; //导入依赖的package包/类
public BroadcastPayload(State<Human> state, Object... params) {
	this.state = state;
	this.params = params;
}
 

import com.badlogic.gdx.ai.fsm.State; //导入依赖的package包/类
/**
 * Sets a new {@link State} for this {@link Entity} to be performed in the next execution step
 * for this character.
 *
 * @see StateMachine#changeState(State)
 *
 * @param newState
 *            The state to make the transition to. Each {@link Entity} may define its own.
 *
 */
public void changeState(final State<Entity> newState) {
	stateMachine.changeState(newState);
}
 

import com.badlogic.gdx.ai.fsm.State; //导入依赖的package包/类
/**
 * Whether this entity is performing the given state or not.
 *
 * @see StateMachine#isInState(State)
 * @param state
 *            The state to test against the current actions of the entity.
 * @return true if this entity is executing the state; false, otherwise.
 */
public boolean isInState(final State<Entity> state) {
	return state != null && stateMachine.isInState(state);
}
 

import com.badlogic.gdx.ai.fsm.State; //导入依赖的package包/类
/**
 * Returns the current state of this {@link Entity}.
 *
 * @see StateMachine#getCurrentState()
 * @return The {@link State} this entity is currently in.
 */
public State<Entity> getCurrentState() {
	return stateMachine.getCurrentState();
}