By AndyMtThis is a Breakout/Blockout/Arkanoid inspired game. 😀. It is my very first try on the X16.
You have to use a mouse or a joystick (cursor keys + enter on the emulator)
It's only tested it on the emulator (R37, R38), so if anyone of the few with real hardware can give it a go, I'm eager to know the result.
Available power ups (no keycodes, you have to catch the dropping badges):
[L]: adds one live to player [M]: paddle is magnetic for 30 seconds. Can only hold one ball at a time. [C]: twin laser cannon for 15 seconds, 16 rounds in a row (if you are quick). [D]: Duplicates ball, so now you can have fun with 2... Keyboard commands:
's': sound on/off. 'q': quit game. How to use with the local emulator:
Unpack ZIP file into the same directory as the emulator. Start the emulator, then enter LOAD"BRIXX.PRG" RUN Or use the "Try now" button.
Let me know what you think...
By JimmyDansboA game where you have to visit all fields in a maze with your "block".
For the latest version and to see the source, go to https://github.com/JimmyDansbo/cx16-maze
By SlithyMattChase Vault: a game for the Commander X16 by Matt Heffernan
You are a pith-helmeted adventurer trying to collect artifacts from an ancient Caribbean crypt, haunted by the ghosts that want to keep their secrets. Collect all the artifacts in each room and try to make it to the end. There are many locked doors, so make sure to pick up any keys you find! If you collect each kind of native fruit, you will have more lives, so be on the lookout for them in each room. Also, the ghosts are vulnerable for a short amount of time after you collect each voodoo talisman, so you can chase them for a change.
To play, load CHASVALT.PRG and run. You can use joystick 1 or the keyboard (cursor keys to move) if no joystick/controller is connected.
Keep up to date with future releases on GitHub: https://github.com/SlithyMatt/x16-chasevault
Enjoy and good luck!
By AndyMtThis is a space invaders inspired game. Use the mouse to control the player ship. The shield segments can take 2 hits each.
Now with 7 playable levels, only basic sound.
Requires emulator R38!
more diverse enemy formations enemy attack raids over the sides power ups (shields, double cannon, disruptors etc.) boss enemy joystick control music Different enemy sprites. done Sprite animations. done for player sprite and enemies fade in/out of palettes and backgrounds. done more levels with more backgrounds (all planets of the solar system), done sound effects basics done title screen How to use with the local emulator:
Unpack ZIP file into the same directory as the emulator. Start the emulator, then enter LOAD"INVADERZ.PRG" RUN
Ziggurat is a Z-machine interpreter written from scratch to take advantage of the power of the Commander X-16. Relive the nostalgia of playing your old Infocom adventures or new Inform stories.
(Note: This is a pre-alpha release. Almost nothing works correctly yet. Please be patient. Development is on GitHub if you want to help out!)
By DusanStraklSimple snake game in Basic. Just testing the forum but game should still work in last few versions of Emulator. Have fun 😃
More details about the game and full walkthrough the source code can be found at:
By Elektron72This is a minesweeper clone for the Commander X16. It allows custom minefield sizes up to 38x24, with almost any amount of mines.
To start, load and run MINEX16.PRG.
Main Game Left click to reveal a tile Right click to flag a tile Click on the face to reset Press space to open the configuration screen (will reset the minefield) To exit, reset the machine (Ctrl-R on the emulator) Configuration Space to open and close Use the + and - buttons next to each digit to change the width, height, and number of mines Numbers are capped to a specific range; attempting to select an invalid value will set the number to its maximum or minimum value Click any of the presets to set all of the numbers at once Note: The game uses kernal functions to handle the mouse, so any weirdness is most likely caused by the emulator.
By kcowolfRemake of Sega's classic game Columns. Currently plays a basic game. Source code is available at https://github.com/kcowolf/x16-columns.
By Johan KårlinThis is a topdown racing game. If you ever played Rally Speedway for Commodore 64 or Atari, it will feel familiar. I consider it a late sequel, somewhat improved actually and hopefully still fun.
Starting the game:
All game files should be in the same directory. Depending of how many game controllers you have, this is how you start the X16 emulator:
No controllers: Just start the emulator and use the following keys: Ctrl - Button A, Alt - Button B, Enter - START, Cursor Keys - UP, DOWN, LEFT, RIGHT. Naturally, you can just play in one-player-mode. One controller: Start the emulator with -joy2 SNES (or "NES", depending on you controller type). Player 1 will use the keyboard and player 2 the game controller. Two controllers: Start the emulator with -joy1 SNES/NES -joy2 SNES/NES. For example if you have two SNES controllers and want to load and run the game immediately: "x16emu -joy1 SNES -joy2 SNES -prg rallyspeedway.prg -run"
Up - Start the race when cars are in position A Button - Brake (the cars will accelerate to maximum speed automatically) B Button - Return to menu when race is finished Start Button - Pause game Further instructions
This is an open world racing game. For every track there is a certain distance you have to drive. When you have driven the given distance, you are ready to cross any finish line you happen to find. Remaining distance is displayed in the bottom corner of the screen.
Most of the time you will probably just drive the default route by following the road and continue straight ahead in every crossing if there isn't an arrow to point you in a certain direction. But you can also find your own way. Just remember that every time you crash or get too far away from the other car, the race will pause and you will be brought back to the default route.
For every crash a penalty of one second is added to your time. This is also the case if you are outdistanced by the other player. You can only be outdistanced as long as the other player is on the road and driving the standard route.
By GetafixThis is a Commander X16 remake of the ZX Spectrum game "Penetrator" by Phillip Mitchell and published by Beam Software in 1982. This, version 1, does not have any audio.
By rjeThis is a work in progress, which means there's lots of missing functionality, the UI is rough, there are unfinished bits, and there's no "win" or "lose" condition, yet.
The map is revealed as you explore. There are two kinds of treasures -- weapons and armor -- and one special treasure: the Amulet of Yendor. The goal of the game *will* be to find the Amulet of Yendor and exit the forest with it.
There are 31 monsters in the forest. They (currently) are not differentiated, except by name.
Movement is via the cursor keys. Trees are impassable. "Bump" a monster to attack it.
There are no special commands, yet.
I will add some sound effects before promoting it to 1.0
By Fnord42This is a simple Tetris clone, originally written in BASIC, then reimplemented in assembly.
By SlithyMattAlpha demo of Cavy's Quest - a point-and-click adventure game created using the XCI game engine. The current graphics are placeholders while the final graphics are created for the first beta release of the demo.
Simply load and run XCI.PRG from BASIC, and all controls are done through the mouse.
Premise: You are a guinea pig named Penelope who yearns for something more than a life in a cage. Explore your environment and solve puzzles to make your dreams of freedom come true.
By GetafixWritten in "C", in 2014 for the Commodore 64 and ported to CX16 in 2020. I wanted to know how hard it would be to make a chess AI. I am not a great chess player, nor did I research chess engines, so I made things up as I went. The end result is this chess which by any standards of chess, is not a good AI opponent. However, it's there and it's playable. Use and keys
The user controls an on-screen cursor. The cursor changes color to indicate
a state. The colors for selection are:
Green - the piece can be selected
Red - The piece cannot be selected as it doesn't have valid moves
Purple - Empty tile or piece on the other side
Blue - The currently selected piece
Cyan - A valid destination for the currently selected piece
To move the cursor, use the cursor keys. To select a piece, press the RETURN
key while the piece is selected. To deselect the piece, press RETURN on the
same piece again, or press ESC.
To bring up the menu, press the M key, or the ESC key when no piece is
selected. Pressing ESC in a menu backs out of the menu, to the previous
menu or back to the game. Press RETURN to select a menu item and use the up
and down cursor keys to change the selection.
While a side is under human control, there are a few more options. Press B to
toggle on/off a state showing on every tile how many of both black and white's
pieces can attack that tile. Pressing A will toggle a highlight of all of the
pieces on the opposing side that attack the selected tile. Pressing D will
toggle a highlight of all the pieces on the side currently playing's side that
can defend the selected tile. All three of these options basically give a
visual representation of the Game Database. The colors are: For attackers Cyan
and for defenders Red.
Lastly, the game has an Undo/Redo stack that tracks the last 254 moves. Pressing
U will undo the last move and R will redo the last move. In an AI/Human game,
the undo will undo the last AI and human player move, so the human player can
make a different move.
By JimmyDansboIn this game you need to crush ghosts between walls before the ghosts catch (touch) you.
Red walls can not be moved, but green walls can be pushed around.
Be careful as ghosts can walk diagonally.
At the moment there are only 4 levels.
In level 4 you will encounter a poltergeist. Poltergeists can only be killed against a static (red) wall.
Let me know what you think about the difficulty level. For each level I can control:
Number of walls and static walls Number of ghosts and their speed Number of poltergeists and their speed Number of portals and how long it takes before they let a dimensional ghost through.
By jjBlissThis is an early build of my engine for side-scrolling shooters in the style of the original Mega Man games.
Running the game:
Load the file SSE.PRG into the commander X16 emulator.
On windows, the easiest way to run it is the copy the emulator files into the game's directory and run the rungame_controller.bat or rungame_keyboard.bat files
It currently contains only three levels and placeholder graphics. There is some basic sound support, but it is not used much.
The game is played with Joystick 1 or the keyboard. If using an SNES controller, the L/R buttons may be used to quick switch between sections of the first level and the A-button may be used as a secondary attack. There is an experimental 2-player mode, that can be activated by pressing start on joystick 2 at the title screen, but it does not handle screen transitions so is not really usable at the moment.
I have been keeping track of progress of the game on youtube. Here is the latest video showing gameplay.
The json files in the tilemaps directory can be opened in the Tiled Map editor (https://www.mapeditor.org/) levels.cfg can also be changed to add or remove levels and change the overworld navigation data.
After changes are made, run buildlevel.exe or buildlevel.py to rebuild the binary files from the json files.
Player sprite by: sylvius fischer https://opengameart.org/content/fumiko-complete-charset
By DusanStraklTetris Clone written in BASIC.
Source code tutorial available at:
By SlithyMattThis is the example game for the exTremely Compact Interpreter, or XCI, an adventure game engine for the Commander X16 inspired by earlier game engines like SCI and SCUMM. This game is only intended to show a potential developer how to create their own game, so it is extremely short and simple.
To learn more about the XCI game engine and how you can develop your own game: https://github.com/SlithyMatt/x16-xci
To play, load XCI.PRG and run. Then, when the menu appears, select "New Game".
Note that this is based on an intermediate build after release 0.4b, from commit 33b29de, which will eventually be release 0.5b.
See the latest demo on YouTube:
By ChrisLROM r37 support Splash screen with support for selecting world (Classic, Championship Lode Runner, Professional, Revenge of Lode Runner, Lode Runner Fanbook, or custom), game speed (slow/medium/fast), sound (on/off) and starting level This is still a beta release; please open issues on the github repo: https://github.com/CJLove/x16-LodeRunner and specify the world, and level on which you encountered the issue.
By DusanStraklBoulder Dash style game written in Commander X16 BASIC for learning purposes.
Link to detailed description and access to source code on my blog:
By mobluseAritm is a game that trains you in mental calculation. It only teaches what is necessary to know in order to calculate manually using pen and paper. It adapts and asks more about what you answered wrong before.
Aritm is written in pure BASIC v2 and uses X16 control codes for text and screen colors, and has sound effects.
Future versions will probably support larger text in game.
Aritm is available for many platforms including graphing calculators, Java phones, spread sheets, and common retro computers.
By Gaz MarshallWari is an old game with roots that are much older. Its origins go back thousands of years to variety of other similar games, all classified as being members of the Mancala family. Other variations are Awari, Oware, Pallanguli, Kalah, and countless other offshots. The program matches you against the computer. You are probably going to lose few games before you win one the computer plays pretty good game. This may hurt your ego little bit, since Wari is purely skill game (like chess or checkers). There is no element of luck involved, as would be the case with backgammon, for example. When you lose, it's because you were outplayed. How to use it When you start the program, the first thing it does is display the Wari board and ask you if you want to go first. The board is made up of twelve squares in two rows of six. Your side is the bottom side, numbered one through six from left to right. The computer's side is on the top, numbered seven through twelve from right to left. At the start of the game, each square has four "stones" in it. There is no way to differentiate between your stones and the computer's. They all look alike and will move from one side to the other during the course of play. The first player "picks up" all the stones in one of the squares on his side of the board and drops them, one to square, starting with the next highest numbered square. The stones continue to be dropped consecutively in each square, continuing over onto the opponent's side if necessary (after square number 12 comes square number again). If the last stone is dropped onto the opponent's side and leaves total of either two or three stones in that square, these stones are captured by the player who moved, and removed from the board. Also, if the next-to-last square in which stone was dropped meets the same conditions (on the opponent's side and now with two or three stones), its stones are also captured. This continues backwards until the string of consecutive squares of two or three on the opponent's side is broken. Regardless of whether any captures are made, play alternates back and forth between the two players. The object of the game is to be the first player to capture twenty-four or more stones. That's half of the forty-eight stones that are on the board at the beginning of the game. There are few special rules to cover some situations that can come up in the game. It is not legal to capture all the stones on the opponent's side of the board, since this would leave the opponent with no moves on his next turn. By the same token, when your opponent has no stones on his side (because he had to move his last one to your side on his turn), you have to make move that gives him at least one stone to move on his next turn, if possible. If you cannot make such move, the game is over and counted as draw. During the course of the game, it's possible for square to accumulate twelve or more stones in it. Moving from such square causes stones to be distributed all the way around the board. When this happens, the square from which the move was made is skipped over. So, the square moved from is always left empty. It takes the computer anywhere from five seconds to about forty seconds to make move, depending on the complexity of the board position. The word THINKING is displayed during this time, and period is added to it as each possible move is evaluated in sequence (seven through twelve).
By StephenHornA little gameplay-ish and graphics demo of a car on a road. You can control the car with the D-pad on your controller. There's parallax! And a glitchy road, demonstrating why you shouldn't naively depend on sprites to create additional layers of parallax... you'll need to be more clever.
The source code for this can be found in the following github repo:
Sea Battle is a variation on the classical game "Battleship". Sea Battle is a cc65 application currently compatible with revision R38 of the Commander X16 emulator. The graphics and computer targeting could both stand some improvement, but the game is fairly playable in it's current state. I believe computer targeting is strongest when "HIT NOTIFICATION" is configured as "IMMEDIATE" and "SHIP NOTIFICATION" is configured as "SHIP" which are the default settings. I'm at the point where I've had to optimize the code several times to squeeze in more functionality, and adding any significant additional functionality will likely require an investigation into the possibility of taking advantage of memory bank switching.
The "P" key is used to toggle the player-mode between single-player, two-player, and computer-vs-computer modes. The entity names on the bottom of the left and right grids illustrate the currently selected player-mode. The "S" key is used to toggle the fleet size between 5 and 6 ships. Player-mode and fleet size can only be changed before player-1 accepts configuration of their ships after which the "Q" key must be used to quit the game in order to change player-mode or fleet size. The "F1" key is used to select the number of "TURN GUESSES" which consists of an initial number of guesses for the first turn and also the number of guesses for each subsequent turn. In "1/1" mode each player is allowed one guess per turn including the initial turn. In "n/SHIPS LEFT" mode the entity (player or computer) taking the first turn is allowed "n" guesses, and the number of guesses allowed on each subsequent turn is based on the number of ships left in the attacking entity's fleet. The ability to configure the number of guesses for the entity taking the first turn is intended to be a way to offset the advantage of taking the first turn. The "F2" key is used to toggle the "HIT NOTIFICATION" between "IMMEDIATE" and "END OF TURN". This configuration is only relevant when "TURN GUESSES" is set to the "n/SHIPS LEFT" mode described above (since both "HIT NOTIFICATION" options are equivalent when "TURN GUESSES" is set to the "1/1" mode described above). The "F3" key is used to control the "SHIP NOTIFICATION" related to the sinking of ships. When the "NONE" option is selected there is no notification of sunken ships. The "NONE" option only applies when "TURN GUESSES" is set to "1/1" as described above. When the "COUNT" option is selected the notification is limited to the sinking of a ship. When the "SHIP" option is selected a hidden ship is displayed on the grid when sunk. Fleet Setup:
Two-Player Mode: In two-player mode player-1 selects their ships using the "1-6" keys, moves their ships using the cursor keys, and rotates their ships using the "L" and "R" keys. Ships of odd length are rotated about their center, and ships of even length are rotated about the the first segment behind their center. The currently selected ship is indicated by the cursor. Movements and rotations that result in part of the ship being off-grid are disallowed.The space bar may also be used to generate a random ship configuration. When player-1 presses the "ENTER" key the display of player-1's ships is turned off (assuming a valid ship configuration with no overlap of ships) and then player-2 configures the location of their ships in a likewise manner. When player-2 presses the "ENTER" key the display of player-2's ships is turned off and player-1 then takes the first turn. It is assumed each player looks the other way when their opponent configures the location of their ships. Single-Player Mode: In single-player mode player-1 configures the location of their ships as described in the preceding paragraph. When player-1 presses the "ENTER" key the locations of the computer's ships are randomly generated and hidden. The location of player-1's ships remains visible to player-1 and the referee part of the application but are hidden from the computer opponent part of the application. Game play begins after player-1 chooses whether to take the initial turn or let the computer take the initial turn. Computer-vs-Computer Mode: In computer-vs-computer mode the player configures the location of the ships for both computer opponents. Both ship configurations remain visible to the player and the referee part of the application for the entire game, but each computer's ships remain hidden to the opponent computer part of the application. After accepting both configurations with the "ENTER" key, the left computer takes the first turn. Computer-vs-computer mode is intended as an aid to explore the strengths and weaknesses of the computer targeting system and the effects of "n" on the game outcome when "TURN GUESSES" is configured to "n/SHIPS LEFT". Game-Play:
Player: The cursor may be moved on the opponent's grid using the cursor keys. The "0-9" and "A-J" keys may also be used to select any column or row respectively. The space bar may be used to select a random untested coordinate, and the "T" key may be used to select a coordinate preferred by the computer targeting system. This last option is intended as an aid to explore the strengths and weaknesses of the computer targeting system. When the user presses the enter key the selected coordinate is fired upon. Hits are indicated by red, misses are indicated by white, the last hit that sinks a ship is indicated by orange (assuming "SHIP NOTIFICATION" is not configured to "NONE"), and yellow is used to temporarily indicate selected targets when "TURN GUESSES" is configured to "n/SHIPS LEFT" and "HIT NOTIFICATION" is configured to "END OF TURN". Computer: When the computer takes it's turn the player is prompted to press a key to acknowledge each of the computer's guesses. Support:
If you encounter a problem that you think is related to a bug in the source code please take and submit a screen shot in a problem report illustrating the configuration where you're having a problem to aid in diagnosis of the problem.
Future Strategic Mode:
My ultimate goal is to develop a game mode with a much deeper strategy than the classical "Battleship" game. The basic concept is to allow each player to see the position of their opponents ships at all times, and also to allow movement of each of a player's ships on their turn. Each ship may be moved one position backward, starboard or port on a single turn, or it may be moved multiple positions forward on a single turn. The number of positions forward is based on the length of the ship (smaller ships which are presumably faster can move further than larger ships). Alternatively a ship can be rotated 90-degrees clockwise or counterclockwise. Movements and rotations that result in part of the ship being off-grid are disallowed.
At the beginning of the game player-1 (who takes the first turn) configures the position of their ships, and then player-2 configures the position of their ships. This is intended to partially offset the advantage of player-1 taking the first turn. This player-1 advantage can be further offset by configuring the number of shells that can be fired on player-1's first turn to be less than the fleet size (which is the maximum number of shells that can be fired on each player's subsequent turn until their first ship is sunk).
Each ship segment is initially loaded with a shell, and each ship with a remaining shell can fire each turn. Shells are only fired horizontally along the same row and limited to a range of 10, so a only a shell fired from the closest column adjacent to the enemy's grid can reach the furthest column of the enemies grid. The probability of a hit can be adjusted such that it decreases with range, and also can be adjusted such that it decreases when a shell is fired after a ship moves (instead of before it moves) on a player's turn.
A ship's shells can be reloaded when part or all of the ship is on the column furthest from the enemy's grid which is considered home base (which is column-0 for player-1 and column-9 for player-2). When a ship segment is damaged that segment can no longer be reloaded, and when all segments are damaged a ship is considered sunk. A player's ship shells are reloaded at the beginning of their turn assuming one or more of the ship segments is on the home-base column. When only a single segment of the ship is on the home-base column a single shell is reloaded to the first undamaged and empty segment of the ship closest to the home-base column. When the entire ship is on the home-base column all undamaged and empty segments of the ship are reloaded in parallel at the beginning of a player's turn.
I was originally thinking of integrating the future strategic mode into the current Sea Battle application, but due to memory constraints mentioned above I'll probably end up making it a separate application.
I'm planning on implementing two-player mode first since the computer targeting strategy required for single-player mode is much more complicated for the future planned strategic mode than it is for the currently implemented mode which is only a slight variation of the classical "Battleship" game.
I'm defining an API for the computer targeting function which I'm separating out from the rest of the current Sea Battle application, and I'm planning on taking a similar approach with the future strategic mode application. The intent is to support collaboration on enhancing the computer targeting function of the current Sea Battle application as well as collaboration on the development of the computer targeting and ship movement functions of the future strategic mode application (which I consider to be the most difficult part), so let me know if anyone is interested in collaboration on the computer functions of either of these two applications.
By SlithyMattAn implementation of Tic Tac Toe using the XCI game engine.
Follow the development on GitHub: https://github.com/SlithyMatt/xci-tictactoe
To learn more about the XCI game engine and how you can develop your own game: https://github.com/SlithyMatt/x16-xci
To play, load XCI.PRG and run. Then, when the menu appears, select "New Game".
See a demo with a little explanation on YouTube: