Simple simulator in Python

Let’s make a simple RTI-enabled simulator (a 2D game) in Python, using the Pygame library.

All you need, besides Python and a text editor, is the RTI installed on your computer. It’ll also be more fun if you have the Viewer installed so you can see the result of your work.

TL;DR final version simplesim.py

Let’s get started. First, create a virtual environment and installed the necessary libraries:

python -m venv .venv
.venv/bin/activate
pip install pygame inhumate_rti

Create the game

Let’s create a file, simplesim.py and start hacking away.

First, some imports and typical Pygame setup of a 500x500 pixel window:

import pygame
import math
import random

# Set up the game window
pygame.init()
pygame.display.set_caption("SimpleSim")
screen = pygame.display.set_mode((500, 500))
clock = pygame.time.Clock()

We’ll initialize some global settings and state variables, including a random player start position, that we’re gonna need later, as well as define custom sin and cos functions for the convenience of using degrees rather than radians throughout the code.

# Player settings
player_color = (0, 150, 200)
player_speed = 3
player_rotation_speed = 3

# Player state
player_x = random.randint(10, 490)
player_y = random.randint(10, 490)
player_heading = random.randint(0, 360)

# Let's use degrees instead of radians
def sin(degrees): return math.sin(degrees * math.pi / 180)
def cos(degrees): return math.cos(degrees * math.pi / 180)

Next, let’s add a main loop:

# Main loop
try:
    done = False
    while not done:
        for event in pygame.event.get():
            if event.type == pygame.QUIT: 
                done = True
    
        # Move the player with WASD keys
        keys = pygame.key.get_pressed()
        if keys[pygame.K_a]: # rotate left
            player_heading -= player_rotation_speed
        if keys[pygame.K_d]: # rotate right
            player_heading += player_rotation_speed
        if keys[pygame.K_w]: # move forward
            player_x += sin(player_heading) * player_speed
            player_y -= cos(player_heading) * player_speed
        if keys[pygame.K_s]: # move backward
            player_x -= sin(player_heading) * player_speed
            player_y += cos(player_heading) * player_speed

        # Limit movement
        if player_heading < 0: player_heading += 360
        if player_heading > 360: player_heading -= 360
        if player_x < 10: player_x = 10
        if player_x > 490: player_x = 490
        if player_y < 10: player_y = 10
        if player_y > 490: player_y = 490
    
        # Render the screen
        screen.fill((20, 24, 27))
        pygame.draw.circle(screen, player_color, (player_x, player_y), 10)
        pygame.draw.line(screen, player_color, (player_x, player_y), 
                        (player_x + sin(player_heading) * 15, player_y - cos(player_heading) * 15), 5)
        pygame.display.update()
        clock.tick(30)
finally:
    pygame.quit()

The above code

  • handles events and graceful quit properly
  • lets the player move around with WASD keys
  • limits the movement so the player doesn’t end up outside the screen
  • renders the player as a simple circle and line (to show which way it’s heading) over a dark grey background
  • maintains a frame rate of 30 frames/second

That’s it for now! Run it with

python simplesim.py

and you should see something like this:

Result 1

Try moving around with the WASD keys.

Add an RTI connection

We’re now going to add some code for connecting to the RTI, publishing an entity representing our player, along with updating its position as we move around.

First, import the RTI client library (right beneath the other imports):

import inhumate_rti as RTI

Then, create an RTI client and establish a connection at the end of the initialization code (right before the main loop):

# Set up the RTI connection
rti = RTI.Client("SimpleSim")
rti.wait_until_connected()

Publish entity

An entity can be described as an object of interest to other applications connected to the RTI. It may be a car, person, or something more abstract, depending on your use case. In our case, it’s the player.

Continuing, right after the connection, we’ll publish our player entity with a random ID:

# Publish player entity
entity = RTI.proto.Entity()
entity.id = "player" + str(random.randint(0, 9999))
entity.type = "player"
rti.publish(RTI.channel.entity, entity)

We also need to respond to update requests, so that if another application connects after we’ve started our game, they’ll get to know about our player as well.

# Publish entity update on request
def on_entity_operation(operation):
    if operation.request_update:
        rti.publish(RTI.channel.entity, entity)
rti.subscribe(RTI.channel.entity_operation, RTI.proto.EntityOperation, on_entity_operation)

And that’s it for publishing our entity. Now our player is known to all other interested RTI clients.

Publish position

Moving on, we’ll publish our player’s position on the RTI. At the end of the main loop, right before the finally: line, add this:

# Publish player position
position = RTI.proto.EntityPosition()
position.id = entity.id
position.local.x = player_x - 250
position.local.z = 250 - player_y
position.euler_rotation.yaw = player_heading
rti.publish(RTI.channel.position, position)

Here we’re projecting our 2D x and y axes to the 3D x and -z axes of the RTI local coordinate system and placing it so that the 3D origo (0,0,0) is in the middle of the screen (250,250).

Now, if you run the Viewer, you can watch your player in the 3D view. It’ll be represented as a sphere, as we have no 3D model or dimensions for it yet.

Result 2

Bonus feature: Geodetic position

Positions can be expressed both in local (3D x/y/z) and/or geodetic (latitude/longitude) coordinates. To add geodetic coordinates, let’s just decide that the middle of our screen is at latitude 59.36°N and longitude 17.96°E, and scale so that one screen pixel is approximately one meter (the length of one latitude is ~111.3 km, and a longitudes is ~57.5 km in our case).

position.geodetic.latitude = 59.36 + (250 - player_y) / 111300
position.geodetic.longitude = 17.96 + (player_x - 250) / 57500

With a geodetic position published, we can now view our player as we move it around in the Viewer map view:

Result 3

If you ran into some trouble or want to compare to our final version, grab it here: simplesim.py

In this tutorial, we’ve learned one of the simplest ways to have something user-controlled and moveable represented by an entity and position over the RTI.

That’s all there is to it! For now.

Copyright © Inhumate AB 2024