Skip to content

Latest commit

 

History

History
52 lines (34 loc) · 3.96 KB

research.md

File metadata and controls

52 lines (34 loc) · 3.96 KB

Understanding the id Tech 3 Engine

  • Quake Live is based on a modified version of the id Tech 3 engine. This engine was open-sourced by id Software, which allows for an in-depth understanding of its structure and inner workings.

  • Game State and Network Protocol: The id Tech 3 engine uses a "snapshot" system to handle game state. The game server keeps a circular buffer of game states for each client. Every frame, the server creates a new game state, compares it with the last one the client acknowledged receiving, and sends the difference (a delta compression). This means if we can interpret this network protocol, we could potentially read game state data and send commands.

  • QuakeC Scripting: The original Quake engines (including id Tech 3) were designed with a scripting language called QuakeC that was used to program game behavior. Mods for the game are often written in this language. Understanding QuakeC could be crucial if we have to create a mod to expose the API.

  • Console Commands: id Tech 3 has a console that can be used to issue a wide variety of commands and change settings. Some of these commands may be useful for controlling the game.

Plan for Quake Live Python Interface

  1. Create a Quake Live Server Wrapper:
  • Build a Python wrapper for setting up and managing a Quake Live server.
  • This server wrapper should be able to start, stop, and restart the server.
  • Also, allow the wrapper to modify server configurations such as game mode, maps, and bot behavior.
  1. Interact with the Game Console:
  • Implement functionality in the Python interface to issue commands to the Quake Live server console.
  • This could include changing game settings, spawning bots, and more.
  1. Interpret Network Data:
  • Write a parser in Python to interpret the network data sent between the Quake Live client and server.
  • The data should be used to construct a game state that the AI can understand.
  1. Send Commands as a Client:
  • Develop the ability for the Python interface to send commands as if it were a Quake Live client.
  • These commands could be movement, shooting, or any other in-game action.
  1. Handle Game State Updates:
  • The interface should handle the state updates from the game and update the local game state representation.
  • This state update should be passed to the AI agent for decision-making.
  1. API for AI Integration:
  • Create an API in the Python interface that allows the AI agent to retrieve the current game state and issue commands.
  • This API should be made in a way that is compatible with OpenAI Gym environments for ease of use with reinforcement learning algorithms.
  1. Demo Replay Parsing:
  • Implement functionality to parse Quake Live demo files.
  • This could be used to build a dataset for training the AI, or for replaying specific game scenarios.

Interpreting Network Data

Interpreting the network data sent between the Quake Live client and server will be a complex task because this data is likely to be binary and not easily human-readable. Here's a basic plan for how to go about it:

  • Capture Network Traffic: Capture the network data packets sent between the Quake Live client and server. This can be done using a packet sniffing library like pcapy for Python.

  • Interpret Packets: Quake Live uses the id Tech 3 engine, which uses its own protocol for networking called the "Quake 3 networking protocol". You will need to understand this protocol in detail in order to interpret the packets. The protocol covers details on how packets are structured, how game states are updated, how client commands are issued, etc.

  • Parse Game State: Once you understand the networking protocol, you can start to parse the game state updates from the captured packets. This will likely involve reading and interpreting binary data.

  • Maintain Local Game State: As you parse the game state updates, you will need to maintain a local copy of the game state for the AI to use. This game state should be updated every time a new packet is received.