Gdx-ai提供了常见的AI算法，当然也包括寻路算法，比如常用的A*。

Gdx-ai自身的API抽象也很易懂，也方便自定义寻路。

首先由Graph和Connection提供图中的连通性和对应连接的开销。 简单一点直接用DefaultConnection，它提供的默认开销为1。

而PathFinder就是具体执行寻路的类，而返回的结果是GraphPath，它包含了路的结果，对应的连接还有其他一些数据。

这是Meritxell Calvo Palanques画的示意图

 

另外就是Heuristic，它并不是必须的，但是一个有效的Heuristic函数可以加快搜索，不过不方便提供，或者不想提供，最坏的结果无非就是退化为Dijkstra。（我提供的例子会直接返回一个错误的启发函数，不过依然可以获得结果）。

例子就简单一点吧，一般地图的数据是从Tiled地图或者其他格式的文件中获得的，这里我直接用硬编码来。

这个图只有四个点，其中点1,2,3相互连接，点3连接点4，我们要寻找从点1到点4的路径。

首先表示这个图

IndexedGraph<Node> graph = new IndexedGraph<Node>() {
            @Override
            public Array<Connection<Node>> getConnections(Node fromNode) {
                Array<Connection<Node>> connections = new Array<Connection<Node>>();
                switch (fromNode.getId()) {
                    case 1:
                        connections.add(new DefaultConnection<Node>(n1, n2));
                        connections.add(new DefaultConnection<Node>(n1, n3));
                        break;
                    case 2:
                        connections.add(new DefaultConnection<Node>(n2, n1));
                        connections.add(new DefaultConnection<Node>(n2, n3));
                        break;
                    case 3:
                        connections.add(new DefaultConnection<Node>(n3, n4));
                        connections.add(new DefaultConnection<Node>(n3, n1));
                        break;
                    default:
                        connections.add(new DefaultConnection<Node>(n4, n3));
                }
                return connections;
            }

            @Override
            public int getIndex(Node node) {
                return node.getId() - 1;
            }

            @Override
            public int getNodeCount() {
                return 4;
            }
        };

然后使用A*寻路并提供一个随机的启发函数

IndexedAStarPathFinder<Node> pathFinder = new IndexedAStarPathFinder<Node>(graph);
        GraphPath<Connection<Node>> out = new DefaultGraphPath<Connection<Node>>();
        final RandomXS128 randomXS128 = new RandomXS128();
        pathFinder.searchConnectionPath(n1, n4, new Heuristic<Node>() {
            @Override
            public float estimate(Node node, Node endNode) {
                return randomXS128.nextFloat();
            }
        }, out);

最后从GraphPath<Connection<Node>> out获取数据即可

LIbgdx旗下的gdx-ai库提供了大量使用的AI算法，其中包括了最常见的有限状态机FSM。

gdx-ai是一个普通的java库，并不存在平台相关依赖，所以直接在core中引入就可。

dependencies {
        compile "com.badlogicgames.gdx:gdx-ai:1.7.0"
    }

StateMachine是有限状态机的接口，对应的实现目前有两个DefaultStateMachine和StackStateMachine。

StackStateMachine以栈的形式保存状态，所以可以提供了方法获取上一个状态，一般使用DefaultStateMachine就行了。

FSM的例子很多，我们直接来一个简单的。

首先主体对象是人，而人只有两个状态，一个走路，一个打伞。

状态切换的条件是时间，也就是假定下雨的时间符合一定的条件。

首先创建一个Person类

public class Person extends Image {
    private TextureRegion walk;
    private TextureRegion rain;
    private StateMachine<Person, PersonState> stateMachine;
    private float time;

    public Person(final TextureRegion walk, final TextureRegion rain) {
        super(walk);
        this.walk = walk;
        this.rain = rain;
        stateMachine = new DefaultStateMachine<Person, PersonState>(this, PersonState.WALK);
    }

    public void showRain() {
        setDrawable(new TextureRegionDrawable(rain));
        setSize(getPrefWidth(), getPrefHeight());
    }

    public void showWalk() {
        setDrawable(new TextureRegionDrawable(walk));
        setSize(getPrefWidth(), getPrefHeight());
    }

    public void update(float delta) {
        time += delta;
        stateMachine.update();
    }
}

当初始化时默认状态是没有下雨了，而界面的表现就是显示不同的图片

而time就是总共经历的时间

在最关键状态处理逻辑，包括进入，更新，退出，接受消息，是放在对应的State中的。这里我们不考虑接受消息的情况，所以永远返回false。

public enum PersonState implements State<Person> {
    WALK {
        @Override
        public void enter(Person entity) {
            entity.showWalk();
        }

        @Override
        public void update(Person entity) {
            float v = entity.getTime() % 10;
            if (v >= 6 || v <= 4) {
                entity.getStateMachine().changeState(PersonState.RUN);
            }
        }

        @Override
        public void exit(Person entity) {
        }

        @Override
        public boolean onMessage(Person entity, Telegram telegram) {
            return false;
        }
    },
    RUN {
        @Override
        public void enter(Person entity) {
            entity.showRain();
        }

        @Override
        public void update(Person entity) {
            float v = entity.getTime() % 10;
            if (v < 6 && v > 4) {
                entity.getStateMachine().changeState(PersonState.WALK);
            }
        }

        @Override
        public void exit(Person entity) {
        }

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

当在update中切换状态时，会自动触发对应的进入（enter）事件，所以也不需要额外的处理。

切换状态时的对应代码实现

@Override
	public void changeState (S newState) {
		// Keep a record of the previous state
		previousState = currentState;

		// Call the exit method of the existing state
		if (currentState != null) currentState.exit(owner);

		// Change state to the new state
		currentState = newState;

		// Call the entry method of the new state
		if (currentState != null) currentState.enter(owner);
	}

参考资料：

https://github.com/libgdx/gdx-ai/wiki/State-Machine

Libgdx对于资源管理提供了AssetManager来做资源的管理，如果你需要使用它那么你就不得不使用这样的代码

manager.load("data/mytexture.png", Texture.class);
manager.load("data/myfont.fnt", BitmapFont.class);
manager.load("data/mymusic.ogg", Music.class);

其中的文件路径是字符串。然后在你使用的地方

Texture tex = manager.get("data/mytexture.png", Texture.class);
BitmapFont font = manager.get("data/myfont.fnt", BitmapFont.class);

这样使用其实蛮不方便的，如果你把文件路径作为一个全局变量的话，其实很多代码是重复的。

而AnnotationAssetManager提供了反射的方法来完成这个工作

package com.huangyunkun.hundred;

import com.badlogic.gdx.graphics.Texture;
import net.dermetfan.gdx.assets.AnnotationAssetManager;

public class Assets {
    @AnnotationAssetManager.Asset(Texture.class)
    public static final String ball = "ball.png";
}

比如有一个球的图片，那么只需要声明一个字符串。然后加载的时候直接传入这个类本身，由加载器自己去寻找所有需要加载的资源即可。

public class QuickStartScreen extends ScreenAdapter {
    private Stage stage;
    private AnnotationAssetManager annotationAssetManager;

    public QuickStartScreen() {
        this.annotationAssetManager = new AnnotationAssetManager();
        this.stage = new Stage(new StretchViewport(960, 480));
        this.annotationAssetManager.load(Assets.class);
        this.annotationAssetManager.finishLoading();
        this.stage.addActor(new Image(this.annotationAssetManager.get(Assets.ball, Texture.class)));
    }

    @Override
    public void render(float delta) {
        GdxUtilities.clearScreen();
        stage.draw();
    }
}

Asset类本身还可以根据需要拆成不同的小类。

而@Asset注解还支持参数，比如

@Asset(value = Texture.class, params = "textureParams")
public static final String grass = "img/grass.png";