SkyRoads by Marco

A 3D Grayscale Racing Game

The very first Turbo Pascal game for the AFX also takes first place in our competition, our judges especially like the included on-calc level editor and its 3D grayscale. SkyRoads scored very well in terms of replay value so you won't play it once and forget about it, I'm sure we'll be seeing quite a few user created levels in the future as well... :)

2072

Graphics (4/5):

+ Very efficient 3D engine with an average frame rate (~12fps) and smooth drawing.
+ Wise use of Grayscale.
+ Possibility to adjust the contrast and the quality level of graphics.
+ Game menus are simple and well designed; there is even a screen saver :)

- Low sprite use, only the ship is precisely designed.
- When the calc is shut down and turned on again, the screen is messed up; a special key would have been useful to reset the screen mode.

Speed (4/5):

+ Fast enough, the speed depends on your piloting skills only :)
+ The controls answer instantaneously.
- Frame rate is only 12 Fps

Game Play (6/9):

+ Informative pause screen.
+ Dexterity is required, the more you play the more you can learn how to control the ship effectively.
+ Per level high score system with time, this incite the player to overtake his own limits.
+ Multiple interactivities with the environment (variable gravity, different surface types).
+ Game menus are handy and transitions can be skipped.

- Strange behavior of the ship when moving sideways and jumping at the same time.
- The help doesn't contain the control keys that cannot be chosen by the player.
- We would have liked an explosion sequence of the ship when it hit a wall _too fast_ (different ways of dying).
-- Hitting a wall at low speed shouldn't crash the ship but make it bounced back or something.
-- "Save points" could have been pleasant so we don't start from scratch each time, because it becomes irritating, maybe the use of a life system coupled with save points would have been handy.

Replay value (7/10):

+ This isn't an easy game, some level are very difficult.
+ Levels are complex with different ways to solve them.
+ We can select the level we want to play.
+ An on calc editor allows the player to create his own levels.

-- To start from scratch when crashing becomes quickly irritating.

Quality (3/3):

+ The game is very stable.
+ Clear HTML documentation in the package.
+ The game is complete.
+ Very original type of game.

Programming skill (5/8):

+ First program in Turbo Pascal ever made on the AFX.
+ Original and effective graphic and 3D engine.
+ Use of best techniques known (multiple key press, grayscales).
+ Use of original libraries created for the game.
+ Use of external files.

- Unable to create its score file (must be created manually).

About the source code:

+ Use of lot of functions.
+ Most variables have a meaning name.

-- Very badly commented; some comments are not in English (in some libraries).
- No indication on how to compile the sources (and no makefile).
- A lot of 'magic' numbers (reinforced by the lake of comments).
- Use of GOTO :-/
- The game is contained in a single source file (3500 lines).
- Source code contains data such as sprites and menus; those should be in external files.

Originality (5/6):

+ Very original concept.
+ Original programming language used (support for this language was non-existent).
- But it's still a car/ship game though.

Huhn

Graphics: 5/5

+ Great 3D Engine
+ Good frame rates
+ Details adjustable
+ Contrast adjustable
+ Grayscale
+ own graphics engine

Speed: 3/5

+ Really fast ("adjustable")
- slowed down by difficult included levels 2,3,...
+ increased by replay value

Game play: 7/9

+ Graphics bring a lot of fun
+ Great idea and realization
-/+ easy controls but non-adjustable
+ Different ways to solve levels
+ Fun through different blocks
- More blocks would have been great
- Strange damage model (instant death on hit, scraping on walls could cause smaller Damage and would increase the fun a lot!!)
+ Time measurement

Replay Value: 9/10

+ Level editor (On Calc!!!)
+ Different ways to solve levels
+ High-score makes you want to beat your own records
+ Different gravity values
- No difficulty settings
- No multiplayer
+ Really fun concept
+ Never ending (through editor)
+ Level select => easy replay

Quality: 3/3

+ Stable
+ Fast
- can not create own save file
+ help on calc

Programming skill: 7/8

+ frame rate measurement
- can't create own save file
+ New, great, fast & reliable 3D engine
+ written in new language (TPascal)
+ Great menu & intro screen
-/+ a little big but might be caused by Pascal compiler
+ New own libraries
+ Grayscale
+ Adjustable details
+ Good & fast texturing

Roeoender

* Graphics: 8 F:15

Very nice graphics, unique dithered-grayscale pseudo-3D technique for presenting track.
Game has nice 2D pictures.
Did I mention wonderful dithered pseudo-3D engine?

* Speed: 4 F:17

Sorry to say but this game definitely works too slowly!!! Don't believe this built-in FPS-meter As it probably assumes that BIOS call for getting time on Casio AFX clock works right which is wrong (it counts about 3 times faster). I did "manual" calculation of fps -
I just counted all the frames for one jump animation and checked time for 5 jumps (5 x 13 frames) - took 14 sec which gives about 4.64 fps while fps-meter said it was 12.73!
Reducing length of sight doesn't help much; moreover some levels won't be playable with reduced LOS.
One quite common thing - games uses quite nice looking fades between screens, but they took bloody long time!!!
For example: getting to the race from shell: 8 seconds (minimum), getting from the game to the shell: 19 seconds! Arghh!
Please make a version of the game *without* any of those fades, I don't even want to be forced to press 3x [EXE] to go to the main screen put this demo stuff in a separate menu item.
(Note that I didn't cut score for those fades as this is rather just an "unwanted feature").

* Game play: 7 F:18

Quite playable, just try it yourself ;').
Sadly this game is very difficult! Ship is big and hitting wall with even a single pixel ends race. Please make game a bit easier, ideas:
1. Ship smaller and more maneuverable 2. Time penalty when colliding or HP reduced

* Replay Value: 7 F:15

Game keeps high score for each track saved which is very useful.
Game is distributed with on-calc level editor that is really easy to use - once again good feature too.

* Quality: 8 F:15

Very well done, game never crashed or behaved incorrectly.
Game physics done correctly - ship bounces very realistically.
There are only few unimportant graphics bugs:
Ship and terrain aren't displayed correctly at the rightmost edge of view.
Probably this is a bug too: with normal gravity it is possible to actually fly out of the screen instead of making a huge jump.

Some suggestions:
The ship could be better visible on the track (sometimes can't be distinguished from the background).
Note: should be "Road Completed" instead "Road completed".

* Programming Skill: 8 F:13

Definitely lots of work - as this is the first game for AFX written in Pascal (and author's debut) Marco had to put lots of work to write all graphics functions and the game itself from scratch.


* Originality: 6 F:7

Faithful port of the PC version moreover we have 1 racing game for AFX.

Comment:

Best mix of playability and quality.

Hearts by Bija

The Classic Card Game Hearts (Aka, we're board with Solitaire)

Personally I've never had a great deal of love for Hearts, but if you're like me your ready for ANY other card game but Solitaire...

2072

Graphics (2.5/5):

+ Everything is clear and useful, no wasted resources.
- Graphics are very simplistic, fully designed cards would have been great at some point of the game.
- The use of grayscales in some area of the games would have been nice.

Speed (4/5):

+ No wasted time in game.
+ The IA thinks instantly.
- The use of the [EXE] key costs time.
- We cannot return to main menu, have to quit and restart the game.

Game Play (5/9):

+ Rules are simple and easy to remember.
+ Everything is clear and easy to read (except the number seven).
+ A nice thing happen when one of the player do a special trick.
- The [EXE] key should have been replaced by a key near the PAD such as [F6].
- No guide during the game.
- We don't know or can't check which player started the trick, so we cannot always know who will take it.
- At the hand of a trick it would be good to know which players have the hearts and the Queen of spades.

Replay value (7/10):

+ It's a strategy game, each party is unique.
+ Multiplayer possibility.
+ You can save the game at each end of hand.
- A better graphic engine could add interest to the game, with special animations when the player wins a hand.
- Completely designed cards could have been used in some point of the game (such as in the possible special animation).

Quality (2/3):

+ Very good overall quality, the game is completely playable.
- No integrated help about rules and keys to use.
- No help about what to do (useful for beginners) such as: "Hearts haven't been broken, choose another card."...

Programming skill (4.5/8):

+ This is a rather simple game, no astonishing graphics but it works very well, I couldn't find any bug.
+/- No external files for graphics but since there is not much graphics, including them in the EXE saves space because the EXE can be compressed with UPX.
+ Save feature using Memzones.
+ Multiplayer possibility (I couldn't test it because I only have one AFX).
+ Good IA, it's not easy to win against the calculator :).
- No use of grayscales, that makes everything clear but it could have been used in pictures.
- There is no detection of a key being pressed continuously so some actions loop (such as card selection).

About the source code:

+/- The beginning of the sources are rather well commented but the rest isn't.

- No indication on how to compile the sources.
- "#Include" of .C files
- Weird indentation, the source code is difficult to read.
The code is often a real mess... (Looks like a Casio basic file :lol: )
Some lines are very long.
- Use of a lot of 'magic' numbers macros should have been used.
- The "main" function makes 333 lines long :(.


Originality (3/6):

+ Card games are rare on calculators.
- This card games is an adaptation of Windows' Hearts so, this isn't very original.

Roeoender

"And you thought card games are boring?"

* Graphics: 6 F:12

This game is done in BW mode with cards presented as sprites.
Cards move when put on the table (animation).
Graphics is OK; B&W mode makes everything well visible.
Animation doesn't annoy after seeing it 100th time and puts some life to the game.
When one of the players does a special "trick" a full screen picture is presented (nice addition).


* Speed: 9 F:5

Very good, there is no thing that unnecessary slows down game play,
but it isn't too hard to achieve in card games isn't it?


* Game play: 6 F:18

Believe me I am not a fan of card games and I thought that making card games on a calc doesn't make sense as you can always take cards with you (and they're smaller than calc), but I found this game quite interesting as it simulates other 1-3 players and does it quite well (I had to play 3 times before I didn't loose).
Computer players can even do the "Shooting The Moon" trick!
Really I didn't have to force myself to spend some time with this game.


* Replay Value: 6 F:20

Quite high replay value is built-in the game idea, but author didn't do anything to make it even greater.
For example I know a Hearts variant (called "Kierki" here in Poland) of this game in which rules (scoring for what you take) change after each round.
Making a set of rules from which player could choose would greatly increase replay value (probably it wouldn't complicate AI too much at those rules were quite simple).


* Quality: 8 F:19

Everything is done correctly, no game-logic bugs found.

Some suggestions:
1. Keyboard layout not ergonomic, why using when it is so far from other keys used in game.

2. There could be an option that would allow seeing how much points player gets after each hand.

3. The player which took hand and thus starts next hand should be marked
(As I often forget who took the last one and thus began current hand)

4. Selecting cards could be improved by allowing cyclic selection
(While being at first card pressing left would move selection to the last one, and vice-versa).

5. Readme could be better as describing rules in more detail would attract more players.

* Programming skill: 5 F:13

Definitely making AI players adds to this score greatly.
Linking two calcs (I wasn't able to test it) add a bit too, but I don't feel it as useful for a card game.


* Originality: 4 F:13

First implementation of "hearts" on Casio AFX calc.
AFAIR second card game for this calc.

Comment:

Surprisingly I found this the most playable game in the competition.

Starscape by C@siomax

The First FPS for the AFX

Ti calc's have had Wolfenstein for a while now, but now we have Starscape! Err... almost... While this game seems to have great potential its not quite done :( . None the less we're sure you'll enjoy this "preview" version of yet another gaming masterpiece (in the works) brought to you by C@asioMax.

2072

Graphics (4/5):

+ First FPS 3D engine
+ Good frame rate (~13 FPS)
+ Use of grayscales
+ Well designed weapons and enemies.
+ We can choose the level of detail.
- Annoying display bug when the player comes near walls, this bug is the most important to correct.
- Textures of the walls are not really good looking.

Speed (4/5):

+ Average good frame rate.
- When enemies are close, the frame rate can decrease a lot.

Game Play (4/9):

+ Smooth drawing and movements.
+ Possibility to save the game at any moment.
+ Different types of weapons available.
+ Targeting is rather easy.
+ Simple and good looking menus.

- The use of the multidirectional PAD isn't a good idea since it's difficult to use diagonals.
- No indication when you're hit by an enemy (a flashing screen or something similar...)
- Weapon graphics are good but the projectiles are all the same.
- Only one sprite for each enemy.
- you can't configure the keys nor see which key do what in the game, you have to read the Readme.txt.
- No death sequence for the enemies, they just disappear when killed.

Replay value (5/10):

- No story line (a little in-game story is needed in a FPS - that gives a reason to kill).
- The first level is rather empty.
- You cannot die (no real challenge).
- Enemies and weapon graphics are good but we cannot say the same for the rest of the décor.
+ Multiple levels.

Quality (1.5/3):

- This game is incomplete; there is a lot to be done to make it a real game.
- There are some really annoying graphic bugs
+ Despite of these graphic bugs, the engine is still a real breakthrough for this type of calculator...

Programming skill (6/8):

++ First FPS ever made on AFX, a lot of original work and coding needed to be done.
+ Use of external files for graphics.
+ Use of best techniques available (grayscales, multi-key press, APO, contrast, Memzones)
+ Use of external libraries for part of graphics and Memzones (--> improve compatibility and reliability)
-- Rather long to load, the loading procedure uses a 1 byte long buffer with no logical reason; a 1Kb buffer could have been used without any problem... This would have divided the load time by at least 50!
- Moreover the loading of the file in memory isn't really needed since the file content could have been accessed by mapping the flash drive into memory...
- No compression for graphic files.

About the source code:
+ Many small source files with intuitive names.
+ Many small functions.
- Most of source files are badly commented, sometimes not in English
- "#Include" of .C files
- No indication on how to compile the sources.

Originality (3/6):

+ This type of game isn't original but it's the first ever made for this calculator.

Huhn

Graphics: 3/5

+ New 3D Engine / FPS
+ Good texturing
- VERRY annoying misplacement of walls on certain angles
+ Good frame rates (I think)
+ Details adjustable
+ Grayscale
+ own graphics engine
+ Nice enemies & guns

Speed: 4/5

+ Good levels, gets more difficult and bigger
+ number of enemies increases with level
- Quite slow start (no enemies)

Game play: 8/9

+ Great realization
- Controls quite difficult and non-adjustable
+/- Difficult to adjust settings BUT in game
- No scoring system
+ Huge amount of levels
+ Nice enemies but sometimes strange (random) behavior (disappear)

Replay value: 6/10

+ Moldable
+ Level editor
+ Weapons
- Not really unique concept but nice
+ Saving
--- Bad graphics once again

Quality: 1/3

-- Strange graphics on certain angles
+ Stable
+ Fast
- No on-calc help

Programming skill: 5/8

- Problems in engine
+ Creates own save files
+ New engine, unique, moldable
+ Free 360° rotation
- Probably inexact calculations leading to erroneous display (small sin tables?)
- Waste of memory (dat & level files could be heavily compressed) very important for calc
- Long load / startup times

Originality: 3/6
A well known concept new on the calc but not too good realization

Roeoender

"It may rock"

* Graphics: 7 F:16

On the game website's screenshots wall textures are rendered quite well while on my calc they were rendered obviously incorrectly due to bug in algorithm.
When turning textures off I see strange horizontal lines - another bug.
At low angles and/or distances walls look completely messed up.

Besides that, game 2D art (walls, guns, and monsters) look exceptionally well and there's plenty of them.
Grayscale presents nicely and adds to the score - I especially like the transparent gun crosshair.


* Speed: 8 F:15

Good! Ray casting algorithm is quite computation-consuming and C@siomax did good job keeping frame rate on the proper level.
Game slows down only when enemy sprite is displayed near.
Sadly this is achieved by some "cheating" that destroy graphics when walls are at high angles - it seems that game's engine cast rays only on every 5th screen pixel column, other 4 pixel columns (walls) have the same height.
It would be better to allow user to control this behavior.


* Gameplay: 5 F:18

I am really sorry, but game programmers should not forget that game o be good must be playable. Programming challenge is interesting for programmers, but ordinary player wants just to play and even may not be aware of the overall complexity of the program.
This is not programming skill competition. We just want to encourage creation of playable games for gamers (of course as a programmer I know how difficult this is to achieve).

* Replay value: 6 F:16

Project's web page describes how to "mod" the game which may lengthen game's life when it will be at playable stage.

* Quality: 4 F:13

Sadly many bugs lower quality of the game. Game unfinished status lowers it even more.

* Programming skill: 9 F:13

This game was definitely hard to make - it needs fast graphics, graphics need complex algorithms, algorithms need fixed point math etc. Drawing sprites is not as easy too - you must handle sprites that are partially hidden by the wall and scaled. Making everything flexible enough to add new graphics, maps, weapons etc. is hard task too.
This game even uses compression for graphics.
Definitely one of the most complex games available for Casio calculator.
A bit of bitter: C@siomax used help from the TI community, which is nothing wrong, but I saw better implementation of wolf-engine there.

Originality: 5 F:9

First published version of Wolfenstein-clone on Casio AFX, lack some features (getting health, ammo, weapons from the floor), but tries (will try) to have original plot.

Comment:

Very ambitious project, but it needs to be developed further to be playable.

XOX by Madjar

A "Funny Little Logic Game"

Alas, not all games can win in this competition, especially with some of what we've seen here up to this point, yet XOX pulls big points for originality... we only wish that there were better graphics and a bit more to the game.

2072

Graphics (1/5):

- Only text, some simple graphics could have greatly improved the game...

Speed (4/5):

- The use of the [EXE] key costs time.

Game Play (4/9):

+ Rules are simple.
- The [EXE] key isn't very handful, the [F6] key could have been an alternate key...
- Some parts could have been added to the interface such as the time elapsing and score.
- Too monotonous, no surprise or special things happen during the game.
- Better graphics could have improved the game play.

Replay value (4.5/10):

+ The principle of the game is original and interesting.
- Too simple, there is not enough variation in the game, it's too monotonous.

Quality (1/3):

+ The game is working correctly.
- The interface is very poor.

Programming skill (2/8):

- This is only a 100% text based program, there were no real challenge.
+ High Score system.

About the source code:
+ Many small functions.
+ Small organized source files.

- "#Include" of .C files
- Functional code in .H files
- Weird indentation in some source file, the source code is difficult to read.
- Not enough comments and not in English.
- Name of functions not in English
- Use of magic numbers (key numbers for example)
- No indication on how to compile the sources (and no makefile).

Originality (5/6):

+ A simple logical game but very original.

Roeoender

"A little funny logical game"

This game is quite similar to common task done by compilers:
Given a set of rules (productions) check whether input text is a valid (according to grammar) program by applying selected productions and reducing it to the start rule.
I don't know if Madjar thought about his game this way, but don't be afraid game is really simple to play.


* Graphics: 1 F:10

Well it is only text mode with some text animations.
A good graphics in logic games isn't hard to achieve (no real-time constraints) so it is a pity that here we have almost none.

* Speed: 9 F:5

The only thing that slows game play down is location of the accept button as you are not able to play using only one hand.

* Game play: 3 F:18

The idea of this game needs some improvement to be more playable.
Maybe after every 10 seconds a new symbol should be added - this would add some "dramaturgy" to the game (just like falling blocks in Tetris).
Making more complicated scoring system would make game more difficult and "brain twisting" too.
Score and time should be presented during the game.

BTW My top score was 1288 in 32sec (max input length, 5 productions).


* Replay Value: 2 F:18

Although game is quite original and each session is randomly generated overall simplicity kills replay value.

* Quality: 6 F:16

OK everything is here done correctly, but once again because of simplicity this isn't hard to achieve.
It would be better if keys could be reconfigured, or at least player could choose from some predefined key sets.


* Programming skill: 2 F:13

No cutting-edge technologies were used.

* Originality: 8 F:20

Well this game is the most original in this competition.


Comment:

The idea of this game is quite interesting, but it definitely needs to be expanded to be playable.