The Vircon32 website and Github has lots of great references that will help you complete this project and familiarize yourself more with the Vircon32 system and it's tools.

- The Github repository “Vircon32Documents” guides for the C compiler, The C language, how the console works, and how to make games for Vircon32.

- The Github repository “ConsoleSoftware” includes tutorials and test programs that you can walk through and inspect. Doing so will reveal how some different aspects are made with their example functions and assets.

- The Vircon32 website itself has a “C API reference” tab under Documents that is a complete reference for all functions included in the C compiler used for Vircon32. This will show you what is included in each file of the standard library, and how the functions behave.

The game loop will consist of everything in the main while loop. This will iterate 60 times per second

Sprites are two-dimensional graphic objects used in computer graphics, particularly video games. You can use something like a sprite editor to make the objects needed for this project.

After creating your sprites, you will need to move them onto lab46 and possibly onto your PI. One way of doing this is using the scp command. To use the scp command use to following format:

  scp FILENAME DESTINATION:PATH

Here is an example:

  scp sprites.png username@lab46.g7n.org:~/src/fall2023/discrete/mpg0

If necessary, this is how you would get the desired file onto your PI:

  scp sprites.png username@raspberrypi:~/src/fall2023/discrete/mpg0

To include a sprite in the game cartridge you have to change the make.sh file to include the png. It should look something like this.

  echo
  echo Convert the PNG textures
  echo --------------------------
  png2vircon Texture.png -o obj/Texture.vtex || abort_build

There is no limit to the amount of pngs you can convert, however you also need to include the texture in the pong.xml file to have the texture show up in the cartridge.

    <textures>
        <texture path="obj\Texture1.vtex" />
        <texture path="obj\Texture2.vtex" />
    </textures>

after finishing this, you should be good to use the pngs in your code, Rom texture numbers begin with 0, so selecting texture 0 would result in Texture1.vtex

  select_texture( 0 ); //selects the Texture1 set in the .xml file

  select_region( 0 );  // Sets the selected texture region to the given texture ID

  define_region( int min_x, int min_y, int max_x, int max_y, int hotspot_x, int hotspot_y );

These x and y values correspond to the pixel coordinates in the selected texture. Once the region is defined it can then be drawn to the screen.

The game controls can be modified in the Config-Controls.xml file in the emulator file. To get game input in we must store the X and Y direction of the controls even if you do not intend to use them.

  #include "input.h"
  int directionX, directionY;
 
  gamepad_direction( &directionX, &directionY );
  paddle += directionY;

The bounds of the Vircon32 emulator are 640×360. will 0,0 being at the top left and 640, 360 being at the bottom right. you can use these maximum width and height values to see if something comes in contact with them.

To do this you will need a max and min X , and a max and min Y. These will tell your object where they can and cannot go.

 int MaxX = 30
       if (objectX > MaxX)
         objectX = MaxX;

Motion from the player will be used from controller input. You have to be able to check if the player is holding/pressing the keys that relate to up and down on the y axis. If the key is pressed, then you will move the sprite up or down on the y axis at a speed you set through a variable that gets added to the sprites location each loop.

Motion not from the player can be activated on your own set conditions. such as using bool to activate or deactivate the ball and if functions to run through a set of code if the ball is active or not.

To display a score, you'll need to declare a couple integers first to mathematically keep track of each player's points.

#int [name of variable for paddle 1];
int [name of variable for paddle 2];

While here, you're also going to need to declare a couple arrays (we'll need them for later). The arrays don't need to be too long, for our purposes 10 is large enough, just that we'll need 2 arrays (one per paddle). Keep in mind Vircon32 has a different format for arrays compared to other C code:

type[array size] name

Drawing the score on the display is simple, the process used in btt0's “Hello World” project mostly works here. However, you'll first need to convert the integer to a string, as Vircon32's print function can only print strings.

We'll need to make use of itoa() used from the string.h library. In order to convert the score integer to the score string, do:

#include "string.h"

itoa( [name of integer score], [name of array], [numerical base] ); 

In order to print out the score for this specific paddle, use the name of the array in the print function. To keep track of score, increment either paddle's score integer in your code that resets the arena upon each score.