Scripting in Python Laborations and projects

Transcription

1 Scripting in Python Laborations and projects 1 Introduction There are two possibilities for the scripting labs in the compiler course, either implementing a self-selected project or implementing the proposed lab project specified here. In both cases, the goal is to get a basic understanding of Python and to understand how Python can be integrated with C or C Common Requirements These are the requirements and guidelines common to both the predefined labs and the projects. You should implement the boids algorithm which simulates flocking behavior (see Section 4) The implementation should be written in mixed Python/C/C++ You should implement the project individually or two by two The game must run on hardware available at the university Examination You should present your lab- or project implementation on the third lab. If you are not ready by then, you should book a time with me (ska@bth.se), but you should really try to be finished soon after the third lab. You should also write a post mortem page about the lab on the BTH game programming wiki (spel.bth.se). 2 Project 2.1 Requirements for the Project Those that want to make their own project need to supply a project proposal which has to be accepted. The requirements and guidelines are: A written proposal (sent in as a PDF) describing what you plan to do needs to be submitted and accepted You are allowed to reuse your own existing code from older projects and are allowed to reuse code from the lab project You do not need to implement menus, high score etc. 1

2 2.2 Example Project: Commando/SDL As an example of a project, you could implement a more modern version of the old vertically scrolling shoot-em-up Commando game. The story in Commando is As the crack shot Commando, your mission is to move forward into enemy territory. You must destroy the enemy and their base by passing through the Iron Walls. (taken from the Wikipedia article on the Commando game 1 ). version of the commando game can be seen below. A screenshot from the C64 One of the problems with the original commando game was that it was quite easy to walk through since the enemies behave stupidly. In a new version, the enemies could at least try to look more intelligent, through a boid-style flocking algorithm. 3 Lab Project The goal of the lab project is to implement boids-style flocking behavior for a number of s (non-player characters) in a small game. The boids should be implemented in Python and use functions implemented in C. 3.1 Requirements for the Lab Project You should implement boids-style flocking behavior. The code handed out to you is based on the A* laboration got before. You should therefore also add follow the leader behavior with the flock following a leader that in turn walks a path to somewhere. You can use either your own A* implementation or the dummy path finder implementation provided. A suggestion is to define the HostAPI using Swig. You are allowed to start the game either from C (the supplied main.c file) or from Python. 3.2 Suggested Schedule Lab 1: Good understanding of Python, initializing Python support from C 1 2

3 Lab 2: Calling Python code from C and C code from Python, started with the game implementation Lab 3: Finished the game implementation 3.3 API The handed out source code has an API to talk to game objects, i.e., non-player characters etc, which is defined in objs.h. An example (in C) of an object can be found in scripts/obj_c.c. More thorough documentation is in the html directory. int obj_allocate(surface_img_dir): Allocate a new object with sprites in surface img dir. Look in gfx/sprites/bruce for an example of a sprite directory. This function returns an object identifier which are used for the other functions. obj_free(obj_id): Free object obj id again. obj_set_callback(obj_id, run_frame): Set the function to call for each frame of the game play. The function run frame is passed an object pointer and a double value which represents the number of seconds since last frame (e.g., 0.10 means that 100ms has passed since last frame). obj_draw(obj_id, anim_frame, x, y): Draw the object at (x, y). anim frame specifies the sprite frame to draw. The idea with this structure is that the object is called on each frame of game play and then itself updates the position and draws itself. See the example written in C in scripts/obj_c.c. Also see game_init in game.c for an example on how to add an object to the game. Since C code cannot directly call Python functions, a tip for the Python implementation is to write a small C wrapper function to pass to the obj set callback function which simply forwards the call to a Python function that knows the mapping from obj id to Python objects. 3.4 Suggested HostAPI The suggested HostAPI for the lab is to wrap the API for objs, i.e., allow objects to be created, updated and drawn from Python code. It is probably a good idea to start with this interface, which allows you to get going with the implementation. In order to support a leader following a path, it is also advisable to include a call that gets a path to follow (e.g., something like get_path(sx, sy, dx, dy) which returns a path). If you want to start the game from a Python script, you can also export the start game function. If you are using Swig, you can define the interface in a host_api.i-file. 4 Boids A good description of behavior (and boids) is the book Programming Game AI by example by Mat Buckland, which forms the basis of the behavior patterns described here. The traditional boid behavior is the Separation, Alignment and Cohesion described below. 3

4 Forces 4.1 Steering forces We will work with vectors describing the heading and velocity of an (boid). To avoid writing code outside of the course scope, there is a Python vector class in scripts/lib/vector.py in the environment source code. Note that both the position and the heading can be represented as vectors, an example of vector use is given in the 06.classes/classes.py example, which also shows how to update the position of the boid. For all these steering forces, the output is a vector. To get the final steering force, e.g., the boid-behavior, just add these vectors together. You can also weigh the different vectors if you want, e.g., separation to be more important than cohesion (generally a good idea) Seek Seek behavior causes an to steer towards target. In the figure below, the vector a shows the current velocity of the, vector b shows the wanted heading and velocity to get to the target and vector c shows the direction to add to the current velocity to turn towards the target. target a b c The formula to calculate vector c is then c = Normalize(target pos pos ) MaxSpeed a In the discussion below, N refers to the neighbors of an, i.e., all boids within a certain distance of the, but not including the itself Separation Separation tries to keep an at a certain distance from its neighbors. Separation sums the normalized distance between the and its neighbors, i.e., the sum Normalize( pos n pos ) n N 4

5 4.1.3 Alignment Alignment tries to keep an aligned with it s neighbors, i.e., facing the same direction as the others. The alignment is then the sum of the heading of all neighbors, i.e., the sum for each neighbor Normalize(n vel ) n N Cohesion Cohesion tries to keep the flock together. Therefore, each tries to head towards the average position of the flock. Therefore, cohesion is a vector from the directed towards the average position of the flock. I.e, sum the position of all neighbors and then divide the position by the number of neighbors. Finally, use the seek steering behavior to move the towards the center, or n N n pos N 5