Robot Arena 2 - What goes on behind the GUI

[apanx]

Long post with lots of text. It is not guaranteed to be all comprehensive or correct.
 
When the Robot Arena 2 executable is loaded. The first thing it does that is related to Python is to load the Main.py found in the Scripts folder. The Main.py starts by importing all the C++ commands that is avaliable in Python form, the plus library. It also reroutes all console output from Python scripts to the Debug box, which makes this an excellent place to add a file output to.

Code: [Select]

class giScript_stdout:
    def write(self, s):
        giScript.debug_stdout(s)
        output = file("debug.txt", "a")
        output.write(str(s))
   
class giScript_stderr:
    def __init__(self):
        self.count = 0
    def write(self, s):
        self.count += 1
        output = file("debug.txt", "a")
        output.write(str(s))
        giScript.debug_stderr(s)
    def flush(self):
        pass
It then initiates the loading of Arenas followed by AI. The Arena and AI folder is interpreted by Python, which starts by reading __init__.py. The Practice arena is the first to be loaded. After that, the loading of all avaliable AI begins which continues by creating a list containing all bindings, which is what bindings.py does. In order to draw up all the GUI portions, the game queries the gib files found under the UI folder. These contain instructions on how to draw up all the elements on the screen.
In order to populate the Player and the AI teams, the game queries the Teams.txt and fills up the slots accordingly. Unfortunately it does not create the folders (Team1, Team2... and so on) if they are missing, leading to problems with creating new teams in-game since the data cannot be saved in a nonexisting path. All components and textures are also loaded at this stage.
 
When a match is started, the Arena chosen is created by the game. Which gets its basic properties from the SuperArena in __init__.py. The resulting Arena is a combination of the python code for the Arena and the SuperArena takes care of the sections that are not defined in the current Arenas own python code.
 
This is followed by a cleaning up of the AI stack which disables all running AI by emptying the running_ai global variable. The game then reads the name of the AI bot and queries the Binding list created earlier for the AI script to be loaded.
 
Every AI gets the Invert and Unstuck tactics assigned to themselves by the __init__.py, or SuperAI. All AIs are additions to the SuperAI, which provides basic functionality to the AI. The code in the SuperAI can be overridden by adding the same section in your own AI.
 
The Arena and AI are activated and the code under the Activate section is run. During the match the code under the Tick section for both the Arena and the AI is run. Usually the time between each tick is 250ms for an Arena and 125ms for an AI. This continues until Winners are declared, or the game quit by user.

[DuckRA2]

I got kinda lost, but seems interesting

[Reier]

*Brain short circuts*

[System32]

I think He's saying the scource is already open.

[Serge]

Seems quite logical.

@people wanting raw capture of keys

The RA2 WinAPI window already captures them, and translates the messages concerning them however it wants, probably not minding Python. There is no way we can intercept that, unless we make it capture form a different window. Or use some sort of keylogger mechanism. Maybe a kernel driver connecting to a python module via IPC? It may be a bit overkill, but it will surely work. It will also probably be laggy.
One could also intercept DirectInput, but I never studied DirectX API's, so I know nothing about it.

[apanx]

Well, I tried pyHook, which hooks the keyboard input, but that only works in the GUI parts and not in the game part. It seems like the game uses DirectInput for the actual game part with all 3D stuff. Which cannot be hooked using pyHook. Only by hooking DirectInput, or doing some other esoteric stuff will it be possible to get raw input in-game

[Madiaba]

Well, thanks guys. I put in too many hours reading up on py commands and recipes to no avail, and then just gave up a few months ago.
I'm not an expert by any means with DirectX, so the ball's in your court to assess if it will work, or even if it's worth the effort...(though I have a couple cool tweeks raw input could facilitate).
.

[philetbabe]

Well, I tried pyHook, which hooks the keyboard input, but that only works in the GUI parts and not in the game part. It seems like the game uses DirectInput for the actual game part with all 3D stuff. Which cannot be hooked using pyHook. Only by hooking DirectInput, or doing some other esoteric stuff will it be possible to get raw input in-game

how do you do to use pyHook ?
Does just installing the library and then 'import pyhook' inside one of the file.py (arena or ai) is enough to let you use the pyHook function ?

first post : clear and concise -as long as one get a little understanding about pyhon. Thank's.