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.

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.

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;

One key factor of pong is that the ball will and should reflect off the top and bottom of the screen and pass through the left or right sides of the screen. The top and bottom edges can be considered walls while the left and right can be considered goals.

It may be wise to consider setting a few variables such as wallWidth and paddleY. Using said variables in conjunction with screen_height you'll be able to prevent your paddles from phasing through both top and bottom walls.

The same can be said for the ball, with a variable aptly named ballY you could prevent the ball from phasing through the walls.

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.