Difference between revisions of "BotProgramming Basics"

From Gladiabots Wiki
Jump to: navigation, search
Line 101: Line 101:
  
 
One needs to recall that an AI always uses values of the past. It uses actions from the last tick and the health and shield values as well as the range distances are evaluated at the beginning of the current tick for determining the current action. (for details see [[Game mechanics]])
 
One needs to recall that an AI always uses values of the past. It uses actions from the last tick and the health and shield values as well as the range distances are evaluated at the beginning of the current tick for determining the current action. (for details see [[Game mechanics]])
 +
 +
[[File:Debugging AI Ritter Runkel in action.jpg|800px]]
  
 
To avoid confusion about this delay when analyzing an AI, one can create a debugging sub-AI showing each value the AI used for its decision in the current tick:
 
To avoid confusion about this delay when analyzing an AI, one can create a debugging sub-AI showing each value the AI used for its decision in the current tick:
 +
 +
 +
 +
<!--
 +
 +
[[File:Debugging AI Ritter Runkel in action.jpg]]
 +
[[File:Debugging AI Ritter Runkel.jpg]]
 +
 +
Chat:
 +
Left side is enemy I'm attacking, middle is own Shields and health and on the right side are all the enemies attacking me with a counter for the Assaults.
 +
On the bottom I have pointers to my standard subtrees
 +
But how do you know how to react on which situations. Especially due to the fact that there is one tick delay between actions and filters?
 +
You can't know then what your bot is sensing?
 +
The healthbars, lines, and range circles tells me enough
 +
But you see these things one tick before your bot sees it
 +
In this case, two assaults and one mg are attacking the sniper from long range
 +
 +
 +
-->
 +
 +
  
 
{{Warning|The rest of the page is a work in progress.}}
 
{{Warning|The rest of the page is a work in progress.}}
Line 178: Line 201:
 
|There is no Sniper nor a Machine gun.||{{I}}||{{I}}||{{I}}||{{X}}||{{I}}||{{X}}||{{I}}||{{X}}
 
|There is no Sniper nor a Machine gun.||{{I}}||{{I}}||{{I}}||{{X}}||{{I}}||{{X}}||{{I}}||{{X}}
 
|}
 
|}
−
 
−
<!--
 
−
 
−
== Debugging AIs ==
 
−
 
−
 
−
 
−
[[File:Debugging AI Ritter Runkel in action.jpg]]
 
−
[[File:Debugging AI Ritter Runkel.jpg]]
 
−
 
−
Chat:
 
−
Left side is enemy I'm attacking, middle is own Shields and health and on the right side are all the enemies attacking me with a counter for the Assaults.
 
−
On the bottom I have pointers to my standard subtrees
 
−
But how do you know how to react on which situations. Especially due to the fact that there is one tick delay between actions and filters?
 
−
You can't know then what your bot is sensing?
 
−
The healthbars, lines, and range circles tells me enough
 
−
But you see these things one tick before your bot sees it
 
−
In this case, two assaults and one mg are attacking the sniper from long range
 
−
 
−
-->
 

Revision as of 21:27, 24 October 2017

Information.png This page needs improvement, you are welcome to contribute.

Basics

The robots in Gladiabots are autonomous and obey their Artificial Intelligence (AI). Bots can only execute one of the possible actions at a time. The AIs task is to determine what action to use in the current situation. Each bot checks its AI counterclockwise, searching for the first valid branch leading to an action.

Example AI.png

The AI of a bot is shaped like an upside down tree. It can be composed of the following elements:

Element Description
Root node Each AI contains exactly one root node that defines the starting point of the AI check. Nodes linked from the bottom of the root node are evaluated counterclockwise. The root node indicates the name of the AI.
Action node If a rectangular-shaped action node is evaluated valid during AI check, the described action is executed for the current tick. An action node is considered invalid if the bot cannot perform it.
Condition node If an oval-shaped condition node is evaluated valid during AI check, the nodes linked from the bottom of the condition node are evaluated counterclockwise. A condition node is considered invalid if the current situation doesn't fit it.
Connector node The diamond-shaped connector node is always evaluated valid during AI check. It connects every node linked to the top of the connector node with every node linked from the bottom of the connector node. A connector node can be used to simplify the layout of the AI.
Sub-AI node One can reuse an AI inside another one, by using a Sub-AI node. When evaluating this node the whole sub-AI is checked for a valid action. A sub-AI can again contain its own sub-AIs. Dividing the AI in sub-AIs also improves performance when viewing or editing the AI.
Link Nodes can be connected with a link. A link is a directed connection from the bottom of one node to the top of another node.

AI checking process

Nodes are evaluated counterclockwise
Branches are explored with depth-first search

To determine the action a bot should use in the current situation, the valid nodes are traversed by a depth-first search algorithm beginning with the root node:

Depth-First-Search.gif

Information.png
[Expand]Details of the AI checking process 

Use the root node as reference node and start at step (1):

  • 1) Get a list of all subnodes linked from the bottom of the reference node. Traverse this list of subnodes ordered counterclockwise:
    • 1a) If the current subnode is an action node and evaluated valid, then the AI checking is discontinued as a valid action is found.
    • 1b) If the current subnode is a sub-AI, then this sub-AI is evaluated. If a valid action is found in it the AI checking is discontinued.
    • 1c) If the current subnode is a condition or connector node and evaluated as valid, then use this subnode as reference node and start a recursive evaluation at step (1). If no valid action is found there, continue at step (1d) afterwards.
    • 1d) If there are further subnodes in step (1) continue with the next subnode at step (1a).
  • 2) If there are no further subnodes in step (1), try to backtrack to the previous evaluation in step (1c). If there is no previous evaluation no valid action could be found. The bot idles instead.
Information.png Branches are not executed counterclockwise but checked counterclockwise.
Information.png The evaluation of nodes is instant and is not wasting any time from the current tick.

Best practices for AI design

Some best coding practices from software development also apply to AIs in Gladiabots. The following rules can help improve the quality of AIs, enhancing both the initial development and subsequent maintenance of the AI.

Information.png
[Expand]Divide and conquer. 

Break down a problem into two or more sub-problems and solve each of them separately. Complex sub-problems can again be divided. In Gladiabots this could be done by creating sub-AIs for each sub-problem. The complexity is reduced leading to a better maintainability.

Information.png
[Expand]Readability first. 

AIs are written once, but read many times. Overlapping nodes, links crossing each other and great distances between linked nodes are difficult to read and should be avoided. AIs should have meaningful names revealing their purpose. One should consider to align nodes to the grid.

Information.png
[Expand]Don't repeat yourself. 

Avoid using the exact same set of nodes in several places. Sometimes duplicate nodes can be prevented by using bot specific filters or additional conditions. If its not possible to prevent duplicate nodes in the first place one can try to move them to sub AIs.

Information.png
[Expand]Keep it simple. 

The size of an AI has a significant effect on the error rate. A simple solution should be preferred over a complex one leading to the same or very similar results. One should ask the question: "Has this AI been implemented with the least amount of nodes necessary?". The more complex the AI is the more likely it is to be buggy.

Information.png
[Expand]Test, test, test. 

"If debugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Wybe Dijkstra) As no developer is perfect, new nodes should be tested and debugged right after they were added.

Naming AIs

By adding prefixes like "1 " and "2 " or "A " and "B " in front of the AI name, similar AIs can be shown grouped together for easy selection in the AI list.

Possible AI groups:

  1. Main AIs assigned to bots
  2. Test AIs
  3. Basic sub-AIs used by many AIs
  4. Specific sub-AIs used in some AIs
  5. Sub-AIs used in sub-AIs
  6. Old AIs not in use anymore

Furthermore one of the following elements could be added as prefix, suffix or infix in the AI name:

  • Bot class (for example: "SN", "SG", "AS", "MG")
  • Map name (for example: "7w", "syp", "mp", "...")
  • Game version (for example: "9.1", "10.4")
  • AI version (for example: "1.4", "3.2")
Information.png
[Expand]Chars to use in AI names 

The following chars can be used in AI names:

  • !, #, $, %, &, (, ), *, ,, .,
  • /, :, ;, ?, @, [, ], ^, _, `,
  • {, |, }, ~, +, =, 0, 1, 2, 3,
  • 4, 5, 6, 7, 8, 9, -, a, A, b,
  • B, c, C, d, D, e, E, f, F, g,
  • G, h, H, i, I, j, J, k, K, l,
  • L, m, M, n, N, o, O, p, P, q,
  • Q, r, R, s, S, t, T, u, U, v,
  • V, w, W, x, X, y, Y, z, Z,  

The following chars can not be used in AI names:

  • ", ', <, >, \

Debugging AIs

It is important to check if the AIs work like intended or if some bugs have sneaked in. To help understanding the AI there are lines drawn from each bot to the target of its current action upon execution. By selecting an allied bot one can additionally see the state of its AI.

One needs to recall that an AI always uses values of the past. It uses actions from the last tick and the health and shield values as well as the range distances are evaluated at the beginning of the current tick for determining the current action. (for details see Game mechanics)

Debugging AI Ritter Runkel in action.jpg

To avoid confusion about this delay when analyzing an AI, one can create a debugging sub-AI showing each value the AI used for its decision in the current tick:




Warning.png The rest of the page is a work in progress.

Combining condition nodes

It is possible to create logic terms like A and B or A or B by combining several condition nodes. In the following examples Is a Sniper attacking me is used as Condition A and Is a Machine gun attacking me is used as Condition B.

Arrangement Logic term Negated arrangement Negated logic term
Logic A and B.png A and B

Is a Sniper and a Machine gun attacking me?

  • This arrangement is evaluated valid, if both condition nodes are evaluated valid.
  • This arrangement is evaluated invalid, if one or both of the conditions are evaluated invalid.
 Logic not (A and B).png not (A and B)

The opposite of the arrangement "Is a Sniper and a Machine gun attacking me?" is: Is there no Sniper attacking me or is there no Machine gun attacking me.

  • This arrangement is evaluated invalid, if both condition nodes are evaluated valid.
  • This arrangement is evaluated valid, if one or both of the conditions are evaluated invalid.
Logic A or B.png A or B

Is a Sniper or a Machine gun attacking me?

  • This arrangement is evaluated valid, if one or both of the conditions are evaluated valid.
  • This arrangement is evaluated invalid, if both condition nodes are evaluated invalid.
 Logic not (A or B).png not (A or B)

The opposite of the arrangement "Is a Sniper or a Machine gun attacking me?" is: Is there no Sniper attacking me and is there no Machine gun attacking me.

  • This arrangement is evaluated invalid, if one or both of the conditions are evaluated valid.
  • This arrangement is evaluated valid, if both condition nodes are evaluated invalid.
Logic A xor B.png A xor B

Is either a Sniper or a Machine gun but not both of them attacking me?

  • This arrangement is evaluated valid, if exactly one of the conditions is evaluated valid.
  • This arrangement is evaluated invalid, if none or both condition nodes are evaluated valid.
 Logic not (A xor B).png not (A xor B)

The opposite of the arrangement "Is either a Sniper or a Machine gun but not both of them attacking me?" is: Is there a Sniper attacking me and is there a Machine gun attacking me or is there no Sniper attacking me and is there no Machine gun attacking me.

  • This arrangement is evaluated invalid, if exactly one of the conditions is evaluated valid.
  • This arrangement is evaluated valid, if none or both condition nodes are evaluated valid.

Truth table

Description Sniper Machine gun A and B not (A and B) A or B not (A or B) A xor B not (A xor B)
There is a Sniper and a Machine gun. ✔ ✔ ✔ ✖ ✔ ✖ ✖ ✔
There is a Sniper but no Machine gun. ✔ ✖ ✖ ✔ ✔ ✖ ✔ ✖
There is a Machine gun but no Sniper. ✖ ✔ ✖ ✔ ✔ ✖ ✔ ✖
There is no Sniper nor a Machine gun. ✖ ✖ ✖ ✔ ✖ ✔ ✖ ✔
Retrieved from "https://wiki.gladiabots.com/index.php?title=BotProgramming_Basics&oldid=804"