Spring - User contributions [en]

Lua Beginners FAQ

2016-01-18T22:51:16Z

Paulomorfeo: Case problem in the paths, ruining Linux paths

[[Engine_Development|Development]] < [[Lua_Scripting|Lua Scripting]] < {{FULLPAGENAME}}

This page is an introduction to using Lua in Spring - it only tries to answer general questions, for more specific Questions please ask in the forum.

==Where should I start?==

You can start by reading general Lua tutorials [http://lua-users.org/wiki/LuaTutorial here].

After that, you could look at the example widget [[Lua:Tutorial_GettingStarted|here]], and try to add some functionality of your own!

Once you're a pro, have a look at the game repos [https://springrts.com/wiki/Gamedev:PublicRepos here], especially their /luaui/Widgets and /luarules/gadgets dirs.

==Where can I find help?==

You can find documentation of Springs Lua API on the [[Lua_Scripting|Lua_Scripting]] page. Discussion of lua coding takes place on the [https://springrts.com/wiki/Read_Me_First lobby] in #moddev and #lua, and there is also a [https://springrts.com/phpbb/viewforum.php?f=23 Lua sub-forum].

==How do I open ".lua" files?==

Any text editor is enough. On Windows i.e. use [http://notepad-plus.sourceforge.net/uk/site.htm Notepad++]. There are also IDEs able to work with Lua, such as Eclipse, if you look for them.

==What is a call-in? And a call-out?==

Call-ins are functions defined in your script that Spring calls when a determined event takes place. For example, the widget:Initialize() call-in is run by Spring when the widget is loaded.
Call-outs are functions defined in Spring you can run at whichever moment you desire. For example, when you call Spring.GetUnitTeam(unitID), the engine returns the teamID of the unit identified by "unitID".

==What is the difference between unsynced and synced lua code?==

Synced code is code that runs, identically and at the same time, on every connected client. In practice, this means code which controls the game state. Unsynced code is code that will run differently (or maybe not at all) on each connected client. Typically, this means the user interface.

For example, lua code to make units explode if they fell down a cliff would need to be synced. But, code that warned a player when one of their own units was getting near a cliff edge, would need to be unsynced.

==What is the difference between LuaUI, LuaRules, widgets and gadgets?==

Spring allows various [[:Category:Lua|Lua States]], each with differing functionality. Inside each Lua state, developers can write addons, which are self-contained pieces of code. There is:
* LuaUI: Used for unsynced GUI related code. Addons in here are often called widgets. Clients can (if the game permits it) control which widgets are running. Widgets contain only unsynced code. They can be bundled inside the game, or loaded from the users "Spring/LuaUI/Wigets" directory.
* LuaRules: Addons in here are often called gadgets. Clients cannot choose which gadgets run. Gadgets can include both synced and unsynced code, and must be bundled inside the game.

Intended for mappers, there is also LuaGaia, which behaves like LuaRules but is seperated from it. To see which of the lua states has access to which data/functionality, see [[:Category:Lua|Lua States]] and [[Lua:Callins]].

==What can't Lua do in the current version of Spring?==

Springs Lua interface is very powerful. To work out if some idea is possible you need to ask
* When do I need the engine to tell me something has happened? Check against [[Lua:Callins|Callins]].
* What information will I need to know about the game state? Check against [[Lua_SyncedRead]] (synced) and [[Lua_UnsyncedRead]] (unsynced).
* What do I then need to do about it? Check against [[Lua_SyncedCtrl]] (synced) and[[Lua_UnsyncedCtrl]] (unsynced).
Sometimes you need special functionality, like disk access or OpenGL calls, in which case check against [[Lua_Scripting#Interfaces|Interfaces]].

For completeness, some examples of things you (currently) can't do:
*control the ground LOS - but you can set the los status of units!
*add custom parameters to CEG definitions.

==Where can I find/edit examples?==

You can find some easy example widgets [[Lua:Tutorial_GettingStarted|here]]. The best source of more complicated examples is inside games themselves, in the LuaUI/Widgets and Luarules/gadgets directories. See [[Gamedev:PublicRepos]] for a list of repositories.

To make your own widgets, simply place individual .lua files into your Spring/LuaUI/Widgets dir (create the dir if it is not present. Case-sensitive!!!). Game repositories can be checked out into a folder named "SomeAwesomeGame.sdd", placed in your "/Spring/games" dir; this shoudl give a local copy of the game, recognized by Spring, where you can edit files. Make sure to check the licenses before doing this!

==Can I reload a script without restarting Spring?==

Yes, you can type "/luaui reload" to reload widgets, and if you have "cheats" enabled you can also "/luarules reload" to reload gadgets.

==Why does the print function seem to do nothing?==

Its output is displayed in stdout. If you have no easy way to see it, you can Spring.Echo("some text") which prints to the ingame chat and infolog.txt.

[[Category: Lua]]

AI:Development:Lang:Java

2015-11-03T18:45:39Z

Paulomorfeo: Update about serious quirk

[[Engine_Development|Development]] < [[AI:Development|AI Development]] < Java AI Development

== Getting Started on your own Java AI ==

''Note:'' This tutorial assumes you have Spring working on your machine. The Spring directory will be referred to as 'Spring' from here on.

You will also need to make sure that Java AI's run properly on your machine. This is most easily done by running a Spring game with the ''NullOOJavaAI'' that comes with the engine. You will need the JRE 1.5 or greater, and to set the ''JAVA_HOME'' environment variable on your system to point to the correct location.

''Note:'' If you're using a ''64 bit'' version of ''Windows'', you will need a 32 bit Java Runtime Environment/Java Development Kit anyway, because Spring is (as of May 2014) not yet available as a 64bit version for Windows.

=== Setting up a Java Project ===

To start working on your own Java AI, you should first set up a project in your favorite Java IDE. You need to import the Spring Java AI Interface libraries, and then create an AI class and an AI Factory.

'''OUTDATED''' If you are using '''Netbeans IDE''', you can find a detailed tutorial [http://springrts.com/phpbb/download/file.php?id=4970 here] (from [http://springrts.com/phpbb/viewtopic.php?p=448743#p448743 this forum thread]). Otherwise, please continue reading this page.

==== Importing the interface libraries ====

In order to use the Java Interface, you will need to import the Java Interface libraries (optionally, you can attach the sources for JavaDoc support in your editor)

* <code>Spring/AI/Interfaces/Java/[version]/AIInterface.jar</code> (sources: jlib/AIInterface-src.jar</code>)
* <code>Spring/AI/Skirmish/NullOOJavaAI/0.1/jlib/vecmath.jar</code> (sources: vecmath-src.jar)
* <code>JavaOO-AIWrapper.jar</code> (sources: TODO)

==== Creating the main class ====

Now that you have the libraries, the next step is to create your AI's main class. Firstly, you may want to create a package to put your classes in, for example, ''myjavaai''. Create a new class, named MyJavaAI (or whatever you would like your AI to be called). MyJavaAI should extend com.springrts.ai.oo.AbstractOOAI.

=== Adding your AI to Spring ===

Your AI needs to have its own folder, and the engine will need to know your AI's attributes.

==== Creating an AI folder ====

Every Spring AI is stored in ''Spring/AI/Skirmish''. You will have to create a folder for your AI as well. It is easiest to go to the directory ''Spring/AI/Skirmish'', make a copy of the folder ''NullOOJavaAI'', and rename the copy to ''MyJavaAI''.

==== Telling the Engine about your AI ====

The ''MyJavaAI'' folder you created contains the different versions of your AI. As of this writing, the ''NullOOJavaAI'' only has a version ''0.1'', so there should be a folder ''0.1'' inside the ''MyJavaAI'' folder. Inside you will find a number of files.
These files are:
* ''SkirmishAI.jar'': the jar file that contains the AI code.
* ''AIInfo.lua'': contains information about the AI.
* ''AIOptions.lua'': you can specify your AI's options in here.
* Possibly some text files: these are log files generated by the ''NullOOJavaAI''. If you don't plan on using the same files, you may as well delete these.

Additionally, there is a folder named ''jlib''. This is where you should place any additional libraries you use in your AI.

In order to let Spring recognize your AI, you will have to edit ''AIInfo.lua''. You can do this with any regular text editor.
When you open it, the file will look something like this:

<code><pre>
local infos = {
{
key = 'shortName',
value = 'NullOOJavaAI',
desc = 'machine conform name.',
},
{
key = 'version',
value = '0.1', -- AI version - !This comment is used for parsing!
},
{
key = 'className',
value = 'nulloojavaai.NullOOJavaAI',
desc = 'fully qualified name of a class that implements interface com.springrts.ai.AI',
},
{
key = 'name',
value = 'high-level Java stub Skirmish AI',
desc = 'human readable name.',
},
{
key = 'loadSupported',
value = 'no',
desc = 'whether this AI supports loading or not',
},
{
key = 'interfaceShortName',
value = 'Java', -- AI Interface name - !This comment is used for parsing!
desc = 'the shortName of the AI interface this AI needs',
},
{
key = 'interfaceVersion',
value = '0.1', -- AI Interface version - !This comment is used for parsing!
desc = 'the minimum version of the AI interface required by this AI',
},
}

return infos
</pre></code>

The file describes a number of attributes. Each attribute has a key, a value and a desc(ription). The key is the name of the attribute, the description tells you what the attribute is used for, and the value is what you will want to edit.

The shortName attribute is the name used for your AI internally. It's most logical to change this into to the same name you gave your AI class. (MyJavaAI.) The shortName needs to agree with the folder name (see below) and cannot contain the char '_'.

'version' tells the engine which version of your AI this is. If you're in the 0.1 folder, make this 0.1. Your AI should be located at AI/Skirmish/''shortName''/''version''/.

'classname' tells the interface which class is your AIFactory class. Take care that you use the fully qualified class name, or it won't work. In this example, this should be myjavaai.MyJavaAIFactory.

'name' describes your AI to the user. In this example, you might put 'A simple Java AI to learn about AI programming in Spring.'

'loadSupported' is rather self-explanatory. Since you have just started working on your AI, you may not get around to implementing loading support for some time, so it's best to put 'no,' for now.

'interfaceShortName' and 'interfaceversion' tell the engine about the interface your AI uses. Since MyJavaAI uses the same interface as the NullOOJavaAI, leave these as they are.

Finally, the last thing you should do is exporting your AI to SkirmishAI.jar. The way to do this varies depending on your Java editor.

=== Test your AI ===

After following all the above steps, you should be able to run your AI. Either use SpringLobby to start a new game and see if you can add your AI as a bot, or run ''spring.exe'' to see if you can start the script MyJavaAI Test.
Of course, since you haven't told the AI what to do, your starting unit(s) will sit there doing nothing.

== Getting your AI to Do Something ==

After getting your AI running, you will want to make it do something. Traditionally, the first thing to get your AI to is to build a solar plant, assuming you want it to play BA. If not, it is quite straightforward to build other units once you have the general idea.
You will need four things to get your AI to build a solar plant:
* A reference to the callback
* A reference to the commander (your starting unit in BA)
* A reference to the solar plant definition object
* To tell the commander to build the solar plant

However, before we go about building solar plants, first you should know about events. We will use these to get the required object references.

=== Events ===

Nearly everything that happens in the game is an event. When a unit is created, this is an event. Enemy spotted? Also an event. A player sends your AI a message? You got it, this is an event as well.

Every event is made known to your AI. Have a look at the <code>MyJavaAI</code> class again. <code>MyJavaAI</code> extends <code>AbstractOOA</code>. <code>AbstractOOAI</code> implements a number of methods like <code>unitCreated()</code>, <code>enemyEnterRadar()</code> and <code>message()</code>.
Sound familiar? The method <code>unitCreated(Unit unit, Unit builder)</code> is called every time a unit is created, and tells you the unit that was created and the unit that built it. Similarly, enemyEnterRadar(Unit enemy) and message(int player, String message) tell you about an enemy unit entering radar range and receiving a message from another player respectively.
There are many other events that all have corresponding methods. To have your AI respond to these events, simply override the method in your <code>MyJavaAI</code> class.
The return type of these methods is an integer. The return value can be used for debugging. 0 means that no errors occurred, while any other value is threated as an error. This system can be used for debugging, but is it much easier to implement proper logging.

In the sections below you will see an example of the use of these events.

=== Getting a reference to the callback ===

The callback is the object through which the AI communicates with the engine. All information that does not change the state of the engine can be retrieved through individual methods in the callback, and state changing commands (eg to units) will go through a single, specialized method, which is in the callback as well.
Getting a reference to the callback is easy.
First create a class field <code>OOAICallback callback</code> to put the reference in, then overwrite the method <code>init(int teamId, OOAICallback callback)</code>. The init method is called at the start of every game (right at the end of the countdown).
As you can see, all that you need to do is set the parameter value callback to the field callback:

<code><pre>
@Override
public int init(int teamId, OOAICallback callback)
{
this.callback = callback;
return 0;
}
</pre></code>

=== Getting a reference to the commander ===

Whenever a unit has been built, the engine sends a unitFinished event. At the start of the game, the engine will send a UnitFinished event for every starting unit. When playing BA, this means you will get a UnitFinished event for the commander. Therefore, the most straightforward way of finding the reference to the commander is overriding the <code>unitFinished()</code> method:

<code><pre>
@Override
public int unitFinished(Unit unit) {
if (unit.getDef().getName().equals("armcom")) {
commander = unit;
}

return 0;
}
</pre></code>

=== Getting a reference to the solar plant definition ===

Every unit in Spring has a UnitDef (a 'unit defintion'). This object tells you all there is to know about the properties of the unit type, such as maximum speed, turn rate and what weapons it carries.
One way to get the reference to the definition of a solar plant is to use <code>callback.getUnitDefs()</code>. This will give you a list of all the available unit types in the game that is currently being played.
The name of the unit def we are looking for is 'armsolar', so we can just iterate through the list and find the one named armsolar, like this:

<code><pre>
List<UnitDef> unitDefs = this.callback.getUnitDefs();
UnitDef solarPlant = null;
for (UnitDef def : unitDefs)
if (def.getName().equals("armsolar"))
{
solarPlant = def;
break;
}
</pre></code>

=== Telling the commander to build the solar plant ===

Now, the only thing left to do is to tell the commander that we want it to build the solar plant, and where to place it. In short, we need to give the commander a build command.

We want to give this command only once at the first frame of the game. For this we can use the <code>update()</code> method, which is called at every frame of the game. All we need to do is overwrite the <code>update(int frame)</code> method and give the command if the frame is 1. This results in the following code:

<code><pre>
@Override
public int update(int frame)
{
if (frame == 0)
{
// give command here
}

return 0;
}
</pre></code>

Commands are issued by invoking the respective method on the <code>Unit</code> (or <code>Group</code>). In our case, that's the <code>build</code> method, which takes the following arguments:

* <code>UnitDef toBuildUnitDef</code>: the kind of unit to build
* <code>AIFLoat3 buildPos</code>: the location the unit should be built at (in our case, we use the commander's current position)
* <code>int facing</code>: the direction the new unit will be facing (mostly matters for buildings, which can not turn after being constructed)
* <code>short options</code>: a set of UnitCommandOptions. 0 means no option.
* <code>int timeout</code>: the number of frames after which the command times out. We don't want a timeout, and therefore specify a suitably high number :-)

Therefore, our command looks like this:

<code>
commander.build(solarDef, commander.getPos(), 0, (short) 0, Integer.MAX_VALUE);
</code>

At this point you will want to see if your AI actually works. Export your code to ''Spring/AI/Skirmish/MyJavaAI/SkirmishAI.jar'' and start up a game. Your AI should now build a solar plant at its start position.

===Building a metal extractor===
Building a metal extractor is slightly more complicated. Assuming you're not on a metal map, you will need to find a suitable site to place the extractor. Generally, it's preferable to select a site closest to wherever your construction unit (commander) is located.

Modify your code that got a reference to the solar plant by making the following changes:

<code><pre>
List<UnitDef> unitDefs = this.callback.getUnitDefs(); UnitDef solarPlant = null; for (UnitDef def : unitDefs)

if (def.getName().equals("armsolar"))
{
solarPlant = def;
}
else if (def.getName().equals("armmex"))
{
metalExtractor=def;
}
</pre></code>

Again, you will need to create a Unitdef metalExtractor field by where you declared your solarPlant field.

Next, you need a method for determining the distance between two 3D coordinates (since Spring locations are three dimensional). A slightly modified version of a distance function is found below.

<code><pre>
public float calculateDistance(AIFloat3 a, AIFloat3 b)
{
float xDistance = a.x - b.x;
float yDistance = a.y - b.y;
float zDistance = a.z - b.z;
float totalDistanceSquared = xDistance*xDistance + yDistance*yDistance + zDistance*zDistance;
return totalDistanceSquared;
}
</pre></code>

The above code actually returns the distance squared, but it will work for our purposes. In your init function, you will want to add the following code above the return statement but below the line defining the callback:

<code><pre>
checkForMetal();
</pre></code>

This will call the following function you need to place in your code:

<code><pre>
public void checkForMetal()
{
Resource metal=Resource.getInstance(clb, 0);
availablemetalspots=clb.getMap().getResourceMapSpotsPositions(metal);
if(availablemetalspots.isEmpty())
{
sendTextMsg("This is a map with no metal spots");
metalmap=false;
}
else
{metalmap=true;
sendTextMsg("This is a map with metal spots. Listing Values...");
for (AIFloat3 metalspot : availablemetalspots) {
sendTextMsg("Metal Spot at X: "+metalspot.x + ", Y: "+metalspot.y +", Z: "+metalspot.z);
}
}
}
</pre></code>

For the above code to function properly, you will need to create a Boolean named metalmap and a List<AIFloat3> availablemetalspots. You will now have a function set up for calculating distance between two points, and a data structure holding a list of positions of metal spots. The next step is to tie these two together:

<code><pre>
public AIFloat3 closestMetalSpot(AIFloat3 unitposition)
{
AIFloat3 closestspot=null;
for (AIFloat3 metalspot : availablemetalspots) {
if (closestspot==null)
{
closestspot=metalspot;
}
else if(calculateDistance(metalspot, unitposition) < calculateDistance(closestspot, unitposition) && metalspot.hashCode()!=unitposition.hashCode())
{
closestspot=metalspot;
}
}
availablemetalspots.remove(closestspot);
return closestspot;

}
</pre></code>

The above function accepts an AIFloat3 containing the location of your construction unit (commander). It will then find the closest metal spot and return that location. The next step is to have your commander make use of this.

<code><pre>
if (frame == 600)
{
if(metalmap){ sendTextMsg("About to build mex at frame " + frame);
AIFloat3 closestspot=closestMetalSpot(commander.getPos());
commander.build(metalExtractor, closestspot, 0, (short) 0, Integer.MAX_VALUE);
}
</pre></code>

Place the above code in your update() method. When the frame count reaches 600, your commander will start to build a metal extractor at the closest metal spot. The extractor may not be right on top of where the metal spot appears to be, but you can mouse over the extractor to make sure it's drawing the metal properly.

== Frequently Asked Questions ==

'''Q:''' What is the difference between <code>unitCreated()</code> and <code>unitFinished()</code>?

'''A:''' The difference is that <code>unitCreated()</code> is called when construction of a unit starts, while <code>unitFinished()</code> when construction on the unit has been completed. Any number of things may happen in-between, including the unit under construction being destroyed, so it is important to remember this distinction.

'''Q:''' Do I have to copy and paste my jar file to the directory in Spring/AI/Skirmish/MyAI/0.1 each time I want to test my AI out?

'''A:''' Yes, but it is much easier if you automate the process. In Windows, a simple batch file can be created to move the files over for you. For example

<code><pre>
copy C:\Users\msm8bball\Documents\NetBeansProjects\MyAI\dist\MyAI.jar "C:\Program Files (x86)\Spring\AI\Skirmish\MyAI\0.1"

del "C:\Program Files (x86)\Spring\AI\Skirmish\MyAI\0.1\SkirmishAI.jar"
rename "C:\Program Files (x86)\Spring\AI\Skirmish\MyAI\0.1\MyAI.jar" SkirmishAI.jar
</pre></code>

Modify the above code to match your computer's directories. Place it in a text file and save it as MoveAI.bat. This will create a batch file that you can double click and it will automatically move your AI to the proper location and rename it. You might wish to put a shortcut to this in your Start menu or taskbar.

'''Q:''' I have problems with the class-loader in my AI, any idea?

'''A:''' Each Java AI implementation is loaded by a separate class loader. This is used to load all the AI's class files and dependency libraries (in the ''jlib'' dir). Some libraries though, use the Thread contexts class loader, instead of the one of the current class. Therefore, if you want to load something from the AI's own class-path, make sure to let these libraries use the class-path of your AI classes, eg:
<code><pre>
ClassLoader myClassLoader = AIFactory.class.getClassLoader();
MySpecialUtil msp = new MySpecialUtil();
msp.setClassLoader(myClassLoader);
</pre></code>
Please do not set this class-loader on the thread with <code>Thread.currentThread().setContextClassLoader(myClassLoader)</code>, because all AI's are run in the same Java thread, and therefore this will cause problems.

== Links ==
* [[AIInterface:Java|Java AI Interface]]
* [https://springrts.com/dl/buildbot/doc/100.0.1-225-ga4855e7/JavaOO/ Javadoc of the Java AI OO Wrapper]
* '''OUTDATED''' [http://springrts.com/phpbb/download/file.php?id=4970 Netbeans Java Skirmish AI Tutorial] (from [http://springrts.com/phpbb/viewtopic.php?p=448743#p448743 this forum thread])

[[Category: AI Dev]]

AI:Development

2014-10-22T23:45:09Z

Paulomorfeo:

[[Engine_Development|Development]] < AI Development

=How to write a Skirmish AI for Spring=
This section gives help on how to create Artificial Intelligence agents that control teams (as if a player) - "Skirmish AI".

The SpringRTS engine interacts with the Skirmish AIs through an "Interface". There are stable (10-2014, Spring v98) interfaces for the languages C/C++ and Java (not currently sure about the others but I think Lua too).

==Quick Start==
See these pages for tutorials on how to setup a development environment, connect to the appropriate "Interface" and how to build your first example Skirmish AI:

* '''[[AI:Development:Lang:Cpp|C++]]''' 
* '''[[AI:Development:Lang:C|C]]''' 
* '''[[AI:Development:Lang:Java|Java]]''' ''(up-to-date as of 10-2014, SpringRTS v98)'' 
* '''[[AI:Development:Lang:Lua|Lua]]''' 
* '''[[AI:Development:Lang:Python|Python]]''' 
* '''[[AI:Development:Lang:CSharp|C#]]''' 
* '''[[AI:Development:Lang:Groovy|Groovy]]''' 

==I have setup my development environment. What now?==

* '''[[AI:Development:System|SpringRTS <-> AIs architecture]]''' - architecture of SpringRTS and how it interacts with the AIs.
* '''[[AI:Development:TheMaps|The mappings provided by the AI Interface]]''' - how the engine maps the game area and how the interface exposes those maps.
* '''[[AI:Development:MonitorAndDebug|How to monitor and debug your Skirmish AI]]''' - How to monitor and debug your Skirmish AI.
* '''[[AI:Skirmish:List|AIs for Spring]]''' - list of some of the Skirmish AIs that have already been developed for SpringRTS.

==Overall AI ideas, practical examples, useful resources==

* '''[[AI:Links|AI related links]]''' - ranging from how to conceptualize AI agents all the way down to how to tackle very specific problems like pathfinding.
* '''[[AI:GameInferences|Useful inferences]]''' - how to infer where the opponents might have started, where on the maps can your units go, etc..
* '''[http://springrts.com/phpbb/viewforum.php?f=15 Springs AI dev forum]''' - comunity's forum dedicated to AI development.
* '''[[AI:Development:Interface|AI Interfaces & Wrappers]]''' - semi-technical description of the Interfaces that expose the SpringRTS engine to the AI agents.

== Other hints, tips and interesting infos ==

*''' AI "frame skipping"'''
http://springrts.com/phpbb/viewtopic.php?p=463953#p463953 
As in: if a Java/C/C++ SkirmishAI gets delayed responding back to the Interface, the SpringRTS engine will wait on the AI. Thus delaying the game, thus not having the AI "skip" frames.

*''' Engine commands to control the AIs'''
In spring you have some control over AIs with these commands:
<code><pre>
/aireload
/ailist
/aikill
/aicontrol
</pre></code>

*''' Lua<-->AI communications [in Spring 0.83+]'''
http://springrts.com/phpbb/viewtopic.php?f=15&t=26298
He shall say that only it once!

*''' Link to source code of the Interface, engine-side'''
Chances are you'll have doubts about what exactly the commands abc(), qwe() or xyz() do. Asking in the AI forum is a good way to clarify. The most reliable is probably to look at the source code (if you're able to navigate the maze of C++ code in all its glory, that is): 
https://github.com/spring/spring/blob/develop/rts/ExternalAI/AICallback.h 
https://github.com/spring/spring/blob/develop/rts/ExternalAI/AICallback.cpp 

[[Category: AI Dev]]

2014-10-19T15:10:54Z

Paulomorfeo: /* I have setup my AI dev environment, what now? */

[[Engine_Development|Development]] < AI Development

=How to write a Skirmish AI for Spring=

==Quick Start==
Please choose your preferred programming language:

* '''[[AI:Development:Lang:Lua|Lua]]''' 
* '''[[AI:Development:Lang:C|C]]''' 
* '''[[AI:Development:Lang:Cpp|C++]]''' 
* '''[[AI:Development:Lang:CSharp|C#]]''' 
* '''[[AI:Development:Lang:Java|Java]]''' 
* '''[[AI:Development:Lang:Groovy|Groovy]]''' 
* '''[[AI:Development:Lang:Python|Python]]''' 
* other -> have a look at '''[[AI:Development:Interface|AI Interfaces & Wrappers]]''' 

For a general explanation about Springs AI API, see [[AI:Development:System|the introduction to Springs AI interface system]]. Though, an AI dev does not have to know about this, and should just follow the link to his preffered language from the list above.

==I have setup my AI dev environment, what now?==

* Look at some of the other [[AI:Skirmish:List|AIs for Spring]] 
* Check out the [[AI:Links|AI related links]] page for ideas on how to conceptualize AI agents or how to tackle specific problems 
* Visit the [http://springrts.com/phpbb/viewforum.php?f=15 Springs AI dev forum] 

==Lua<-->AI communications [in Spring 0.83+]==
http://springrts.com/phpbb/viewtopic.php?f=15&t=26298
He shall only say it once!

==AI "frame skipping"==
http://springrts.com/phpbb/viewtopic.php?f=15&t=24838&start=9

==Hints==
In spring you have some control over AIs with these commands:
<code><pre>
/aireload
/ailist
/aikill
/aicontrol
</pre></code>

[[Category: AI Dev]]

AI:Links

2014-10-19T15:06:19Z

Paulomorfeo: /* Development/Research */

=AI Links=

===Development/Research===

;'''[http://www.darkstars.co.uk Darkstars]''': AF's main site, has a lot of theory on it, including details of his NTai project 

;'''[http://taspring.clan-sy.com/phpbb/viewtopic.php?t=539 5 Matrix AI 1,2,3]''': A thread discussing Triaxx' theory and plans for his AI 5 matrix AI/Wormhole AI 

;'''[http://taspring.clan-sy.com/phpbb/viewtopic.php?t=2752&highlight= "Research about Pathfinding, AI and Voronoi diagrams"]''': A forum post by Gabba. 

;'''[http://taspring.clan-sy.com/phpbb/viewtopic.php?t=4326 Academic research papers on AI in RTS games]''': A forum post by NeuronExMachina. 

;'''[[AIResearch | AI research Material]]''': Research links to articles and documents about AI 

;'''[http://www.topcoder.com/tc?module=Static&d1=tutorials&d2=greedyAlg Greedy is good]''': Greedy is good tutorial at topcoder.com 

;'''[http://www.topcoder.com/tc?module=Static&d1=tutorials&d2=graphsDataStrucs1 Graph and data structures]''': Graph and data structures tutorial at topcoder.com. This includes path-finding using bfs 

;'''[[AI:HughsUnitGroupingHeuristic|Unit grouping heuristic]]''': Unit grouping and reorg heuristic by Hugh Perkins 

;'''[http://christophermpark.blogspot.co.uk/2009/06/optimizing-30000-ships-in-realtime-in-c.html Optimizing 30,000+ Ships In Realtime In C#]''': Lead developer of game AI Wars discusses performance considerations for his RTS handling 30K+ units. Mostly good ideas on how to build a performance RTS engine but also some ideas applicable on how to make a performant AI agent, like working with fixed-ints rather than floats (especially for sync issues between different computers) or imperfect range checks. 

;'''[http://christophermpark.blogspot.co.uk/2009/07/range-checks-approximation-vs-accurate.html Range Checks - Approximation vs Accurate]''': Lead developer of game AI Wars discusses how to improve performance of range checks at the cost of accuracy, which also raises the question of whether we really need 100% accurate range checks always/most times/ever in an AI agent. He states (other post) that range checks was the largest consumer of CPU in the alpha version of the game. He describes how he used an alternative that doesn't use the expensive SquareRoot math calculation. 

;'''[http://christophermpark.blogspot.co.uk/2009/06/designing-emergent-ai-part-1.html Designing Emergent AI, Part 1: An Introduction]''': Lead developer of game AI Wars explains how the game's AI works - essentially an overview of how to conceptually construct an AI agent for RTSs. A good resource on how to start going at building an AI agent for an RTS. 

''' [[Main_Page|<- Back to Main page page]]'''

[[Category: AI]]