Getting Started

ARC works by sending broadcasts to tell engines to move, who then read the state, think, and report back a move. Of course, ARC does a lot of heavy lifting for state handling and delievery along with various UI tools, so this eases the load on the engine itself.

Basic Setup

First, create the following broadcasts in your engine sprite. Your chosen engine sprite should be the one that does the "thinking" for a move.

$[engine_name]

$[engine_name] draw?

$[engine_name] stop

You should set "engine_name" to something not too long or complicated, and that doesn't collide with others. Good examples include:

white_dove gok_classic delta 4.1

This broadcast (remember to include the $ at the start!) will be what ARC calls your engine by when it wants your engine to think and report back it's move. The one with "draw?" means that the other engine has offered a draw, and it is valid to simply return accept (we will get into more detail about this later) and the one with "stop" means that the engine should stop all other scripts in sprite (important to not stop all sprites as this will stop ARC too).

Next, create the following for all sprites variables:

_dci fen

_dci think time

_dci black time

_dci black time inc

_dci white time

_dci white time inc

_dci move overhead

And finally create these for all sprites lists:

_dci

Integration

Now that we've created all of the basic setup stuff, let's actually integrate this! To better explain this, let's walk through what the engine should do when $[engine_name] is broadcasted.

1. $[engine_name] (or other versions of this) gets broadcasted
2. Engine sets it's own internal board state with _dci fen
3. Engine sets it's "side to move" (or stm for short) to the current stm that _dci fen is
4. Engine notes how much time it has to think in seconds (the default is to use the dci [white or black] time and dci [white or black] time inc, unless if both engines dci [white or black] time is exactly 0, where it should then rely on _dci think time)
5. Engine thinks