PascalGamerMagazine_Issue03

TABLE OF CONTENTS

TABLE OF CONTENTS

Community

Feature

The Coder's Block

Project Highlights

.................................................................... pg. 4

........................ pg. 8

What's New

Supercool Summer Screenshot Contest

Magic Storm.................................................................. pg. 10

Special Reports

Managing Your Classes

FPC Compiler Directives

Basic Cipher Algorithms

Templates Made Easy

............................................... pg. 14

............................................ pg. 20

............................................. pg. 22

.................................................. pg. 26

Asphyre Sphinx........................................................... pg. 28

From PGD Annual to IGF: Tuberunner

Ludem Dare 17

Aesthetics of Music in Video Games

My Experience of PGD Annual 2009

Game Reviews

....................... pg. 32

............................................................. pg. 36

.......................... pg. 40

.......................... pg. 42

............................................................. pg. 44Page 1

Pascal Gamer Magazine

October 2010Issue 3

H ello again! This is now our third issue of Pascal Gamer Magazine. It has been a long time putting this last one together as my plate has been super full lately. As many may know, I recently took back up, the

mantle of running the Pascal Game Development community website as well. There has been a lot of changes there and I hope that everyone interested in game development with the Pascal or Object Pascal language will register and enjoy all that the newly redone site has to offer.

I would also like to mention again that if it were not for those who graciously offered their time and effort writing these wonderful articles that there would be no magazine at all. So thank you to our volunteering writers for your submissions to this issue. Thanks to your collective works, this is the biggest one to date. I hope that developers continue to offer such support in the future of these fun and exciting projects that make our community worth partaking in.

I wanted to get back to focusing on those teams and individuals who made and continue to make an impact on our community with their own contributions, such as game releases and all the cool tools that we love to use. This issue's feature takes a look at a team who has been around for a long time and has such a great amount of creative energy. They have managed to put at least as many as five game releases and is soon to have two separate franchises in the shareware market. Not too many people can say that they have done the same. Magic Storm is an inspirational group of game developers who I hope inspire others to try their own hands at what they have done.

On top of there being more pages than before, there is also more game reviews than before. It meant more work to do as many, but I'm sure you'll all agree it was well worth it. Go check out these games and see how they stack up for yourselves.

Finally, we managed to get an article on Asphyre Sphinx. I've been trying to fit something in on the amazing project and finally I've managed to do so. I also am happy to be able to bring back the Project Highlights section for this issue. It's important to look at some of the great resources we have available to us to use. Without them we wouldn't have the great and vibrant development community we have today.

With that said, I'd like to thank everyone for reading one of the best game development magazines on the internet. Have fun and keep coding!

- Jason "WILL" McMillenEditor, Pascal Gamer Magazine

Page 2

EditorJason "WILL" McMillen

Contributing WritersPatryk "Brainer" NusbaumJason "WILL" McMillenJohannes "Stoney" SteinNathan "cronozphere" SchagenMatt "Daz" ShafferEric "firlefans" BehmDanielo "Ulf" MattickOliver "Buffolli" MüllerIwicki "Super Vegeta" ArturMichal "mobilus" BugalaPaul Nicholls

Cover DesignJason "WILL" McMillen


Copyright

All images depicted within this publication are the property of their owners and are subject to their local copyrights and laws applied to them. Neither Pascal Gamer nor any of it's contributing authors claim any rights to these works. All articles that are publish are of the opinions of their respective authors and does not reflect the opinions of other authors or Pascal Gamer magazine it's self.

Page Layout

Jason "WILL" McMillen

Editor's Message

Page 4

COMM

UNIT

Y


D age, the 3D adventure game engine and it's website both

have gotten quite the large update recently. The engine's author Pauli Suuraho has put a lot of effort into the new features of this game engine lately so much in fact he couldn't list them all from memory. Guess it wouldn't hurt to

write things down as you go along huh?Either way he has given us a few highlights such as unicode for

text and fonts, Newton Game Dynamics physics, a new TAnimation class for all 3D scene actions and a new set of tools called Coira to help design your Dage based games.

You can check out the new Dage 0.5.0 at www.dageport.com.

N oeska, who is known for his OpenAL header translations and even his own OpenGL

headers, has come up with a new set of headers for OpenGL ES for all of you Pascal-on-mobile pioneers out there. Though he doesn't officially have a page for this set of headers yet, you can find them at PGD in the Forums. So far these headers support dynamic and static linking, Delphi and Free Pascal compilers, Windows and Linux and the OpenGL ES 1.0 API. He is planning on including other versions as his work becomes finished.

OpenGL ES, for those who are not aware of it yet, are a stripped down slim version of the OpenGL library that supports 3D hardware on portable devices that use 3D graphics. This is a growing trend for mobiles and could be a part of the future of mobile gaming.

For those of you who can't be bothered to dig through the PGD Forums we have provided them to you as bonus content for this issue on our website.T eemu Valo also known as

User127 within the Object Pascal development community has started his own game engine project called Next3D. The game engine started with a real-time strategy project where a user interface was required. The engine includes features such as OpenGL graphics, UI editor and renderer, math functions for 3D, a high level Synapse network wrappings enabling simple classes for TCP and UDP server and client communication. 3D model formats such as W3D, MS3D and OBJ is implimented, but is still in development with missing things like bones. Some vertex animation has been done however. Direct3D support may be planned in the future.

There are other funcitons, but much is still in development as of this time, but the project does look very exciting to see come together.

Engine source and demos are available on the project's website at next3d.webs.com.

J arrod Davis has a new brand for his

game framework engine. His new company is known as

'Hadron Games' and it's feature product is the

Hadron Game Engine. Inheriting much of the functionality

of it's predecessor, HGE currently at version 0.1.0 boasts it's 2D based, Direct3D enhanced graphics. The intuitive procedural API's other features include multiple programming language support, sprite and texture support, audio streaming, archive formats, configuration files, swap chains and database support.

Pascal bindings for Delphi, Free Pascal and Lazarus come standard along with support for C++. All you have to do is add the HGE.pas file to your uses clause and include the HGE.dll file with your program to dynamically load it's available functions.

There is also a thin object oriented layer for fast and efficient object management. It's features include Actor and Actor Lists, Actor Scene, AI, Entities and Game Management.

You can get HGE at www.hadrongames.com.

2D physics has been a keen interest with Objectif Studio for the last

little while. Vincent Gsell has done some work on a translation of the Actionscript Physics Engine by Alec Cove, or APE for short, which has been converted to Object Pascal for use with Delphi. Another one of his most recent finds is another Object Pascal translation of the 2DBox open source physics engine originally written by Erin Catto and translated by Qianyuan Wang.

If you are interested in open source 2D physics engines and want one written on Object Pascal then you should check them out at

www.objectifstudio.com. Should you want to check out the original APE go to www.cove.org/ape or for 2DBox you can go to www.box2d.org.

What's New

C ubageddon is the name of XProger's entry into the Russian IGDC contest

"Cubassacre". The IGDC is one of the Russian game development community's large events which holds other such themes often. You'll find many known Object Pascal developers such as XProger, Darthman and various other known names in these wonderful events. It's just too bad it's not in English for us as well.

Check out all the Cubageddon entries posted at www.tinyurl.com/33qmxxf.

K ambi VRML game engine has

received a lot of development attention lately. Michalis Kamburelis' game engine is written in clean Object Pascal code and has excellent support for VRML and X3D data specs. There is also a scripting engine called KambiScript which will serve as the main tool for editing your 3D scenes and scheduled in-game tasks. The engine was originally built as a infrastructure for Michalis' entry into the 2006 PGD Annual Game Developer's Competition, The Castle. You'll find that most 3D modelling software will export to the VRML and X3D format including Blender and Kambi even has it's own customized tool.

You can take a look at the open source engine or get a copy yourself at vrmlengine.sourceforge.net.

K otai, the one who brought us previous faithful remakes of Bubble Bobble Online and Nemesis Online is now enthusiastic to bring us

Castlevania Online. Look out Castlevania fans, it looks like we might be getting our most wished for feature yet; multiplayer! Yes from the few screenshots already posted on the Kotai remakes site it would appear that our Konami and Taito remake artist is developing a multiplayer version of this loved game with up to eight players online at a time.

This will be a wonderful piece of news for those who loved all those early arcade and 8 to 16 bit console versions, but never got to do what they really wanted after finishing each. Grab a buddy to go out with yoyur whips, swords, stakes and daggers and beat down some nasty vampire minions. Well now you can!

The current version is v0.3 beta and you can go get it at www.remakesonline.com/castlevania.

Page 5Pascal Gamer Magazine

D achinko will be a new casual game from Gamecask coming out soon. It is inspired by

the culture of ancient Asia and Pachinko machines from 1970s and earlier. It will have three game modes, one of them being 'Classic mode' which will have fifty-five unique machines. Each machine you must place up to a maximum of one hundred small balls into a green pot, which as it may ssound simple, will be quite the challenge.

Be sure to keep an eye out for it soon at www.gamecask.com.

Y oYo Games has finally released their popular Game Maker, easy game creation design tool, for the Mac OS X platform. A version of Game Maker 7 to be ported over had been

in development for a couple of years now. However you can finally get a working copy of it for your Apple system. Most existing GM7 games should work for the Mac version as it supports most features of GM7.

For many of you who like making games, but sometimes wish that you could just take a break and didn't have to code everything, this could be a nice alternative to play with for a while. It's actually developed using Delphi and now with this port obviously has moved over to Free Pascal.

Check out Game Maker 7 for Mac OS X at store.yoyogames.com/games/2-game-maker-for-mac or if you would rather have Game Maker 8 for your Windows machine go to www.yoyogames.com/gamemaker.


What's New

Embarcadero's just had a new set of development tools come out recently. The new 'Delphi XE' and 'Delphi Prism EX' feature an innovative built-in software revisioning

system, enhanced code organizing and the ability to visualize your code in a new and nifty diagram mode, showing off your code in relation to all your program's in-application objects. David I., Chris Bensen and the whole host of others are out there promoting them now with events like Code Rage 5 which just passed and other various live events.

Nothing new yet on their exciting Project X mission to port over Delphi to both Linux and Mac OS X, but evidence that work has been progressing sporadically has shown up on Eli Boling's company blog. He seems to be the front man for the endeavour. Lets wish him luck in something that Delphi fans have been begging for for years.

In the mean time, you can get Delphi XE and Delphi Prism XE at www.embarcadero.com.

F or those RemObjects Software or Oxygene compiler fans out there, the company has not too

long ago started up a Podcast and Video streaming section on their website called RemObjects Radio and RemObjects TV respectively. Though their podcast has been around for a bit longer, their video service is relatively new and both feature their own products features and topics that relate to them and programming concepts in general.

Their last Radio episode was about their Winder 2010 Roadmap and their last video released was an introduction by Jim McKeith to their .NET assembly obfuscator that integrates in Visual Studio IDE for use with Delphi Prism's Oxygene compiler.

You can check out the RemObjects Radio podcast at www.remobjects.com/radio or RemObjects TV at www.remobjects.com/tv.

GLScene is finally back in the swing of things it seems. Not only have they managed to get their site back up and working with support forums at SourceForge, but they have

also released version 1.1 this past summer. Best of all it now fully supports Lazarus!You can get all the latest and up to date news at their new website at

glscene.sourceforge.net.

Pascal Gamer MagazinePage 8

Supercool Summer Screenshot Contest

H ey PGM fans! A couple of months ago we announced on our website and on several community forums that we would be having our first ever screenshot contest. Well here it is the results. The winner was chosen by the editor based on a balance of

technical prowess and visual like-ability. In other words, he thought it was really cool.Picking the best ones out of these screenshots was really tuff as there were some really

good of screenshots submitted, but unfortunately not everyone could be on top. We have however listed the top ten for your viewing pleasure and give thanks to their hard work in making and emailing them to us, along with everyone else who sent in a screenshot. Here they are, enjoy!

O ne of the things that made me pick this one was not only the clean and polished quality of the scene graphics, but

also the small attention to details in the interface. Looking at this game I get a sense that I'm actually watching a sporting event on TV. You get that a lot with most large budget productions from big companies, but not usually from small independent game projects, so this spoke volumes to me.

Other than this the scene is highly detailed and none of the sprites or scene objects seem to stick out like a sore thumb. It's also rich in color and looks interesting with what's going on on-screen. Good overall in-game gameplay action shot! The statistics and leader board is also a very nice touch to the game's interface as well.

You've earned a copy of this issue for sure!

5th

8th

2nd 3rd

9th

6th

4th

10th

7th

1st

M agic Storm brought us a few great games in the past, among them were Tomb Climber, Bouldermouse and of course the Xenidis series; Xenidis and Commando Xenidis. Now they are back

with their latest instalment in the Xenidis universe which will be a direct sequel to the first one, Xenidis 2.

The next big development project for the team is TombClimber II. In this new title they will be taking the 2D platformer 3D. The team is excited about moving on to a new project, but unfortunately they will miss on of their teammates as he moves on to do other things. Please read on about this fun team of people and their projects.

Magic StormFE

ATUR

E


Who is Magic Storm?

The team comprises of the following people...

Danielo "Ulf" Mattick

Graphics. He has not been with the team for very long, he joined the team to work on Xenidis 2, but he enjoys working with everyone so far

and is making his mark on their latest game and plans to continue with more work on their next and hopefully other future game titles under the Magic Storm label.

Juergen Oppermann

Musician. He has been with the team composing music tracks for approximately the past seven years over the production of three

different games. His responsibilities were both sound effects and other music tracks throughout the game titles. He unfortunately had to leave the team shortly after the completion of Xenidis 2 due to his busy schedule. He is sad to leave and will be sorely missed by the whole team.

Oliver "Buffolli" Müller

3D model artist and founder. He is Eric's best friend and partner in gaming crime. They have been playing and making games since they were kids. He does a lot of the

graphics and much of the musical details in all their games. Nothing makes him happier then when he can see his creations being put to good use by Eric's very handy coding.

Eric Behme

The leader of the team, founder and programmer. He is the guy who puts everything together in software form. He relies heavily on his other team mates for their various artistic

skills in the making of their games. He is involved in almost every creative aspect of the games they make and enjoys the fellowship of a team behind his and Oliver's creative vision.

Page 10


We wanted to hear a little bit about these guys and how they did business, so we wrote a short list of questions and let them send us back their responses. Here is what they had to say to us.

PGM: When did you first join or start working with Magic Storm?

Eric Behme: I was the founder together with Oliver Muller who lives in my own town. We have always been best friends. We started back in the old DOS times. I don’t remember exactly when, but I'm sure it was around the year 2000 or so.

Oliver "Buffolli" Müller: Together with Eric. I was a founder of Magic Storm, which was named originally as 'Magic Wings' but this goes back to 1996 when we finished our, I guess third game called 'Bouldermouse'. I have been in this team for oh, lets say for about twenty years now.

Danielo Mattick: Ever since September of 2008 if I remember right.

PGM: How do you enjoy working with the team?

Eric: A lot, of course. Making games is our Hobby. In the beginning of course we dreamed of earning lots of money and fame with our own games, but it never worked out that way and turned out not to be quite as much. We are very happy to be doing this for fun.

Oliver: I always wanted to develop computer games on my own and tell these little sprites what to do up until I was twelve and then I finally got my first computer. It was a Schneider/Amstrad CPC464 with a data-tape. A floppy disc drive was added a year later as Eric gets his own Amstrad CPC with an enormous capacity of 128 kilobytes of RAM! This was huge back then. Anyway, it is very much a pleasure to see a project growing by adding a lot of little items from each of all the members of the team which all form the final game. You can provide your full creativity because in a computer game there is nothing that is impossible, no limitations as in real life need to be considered.

Danielo: Yes, very much so.

PGM: What game development skills do you have?

Oliver: I figure, that I am best at artwork such as 2D sprite design, painting backgrounds, 3D modelling and animating. Also I develop some of the soundtracks for the games too.

Danielo: I think I have staying power and the wish to create new and better worlds where the player has a chance to change everything.

Eric: I have worked on all the Magic Storm titles. Before 2002 all our games were created with Turbo Pascal 6, the DOS compiler. After that time I moved on to using Delphi 5, Borland Developer Studio 2006 and now I have Delphi 2010.

PGM: What are your favourite creative tools?

Danielo: I like Photoshop and I love Inkscape. I also use Hexagon and Carrara for 3D modeling but for creative ideas I'm using Alchemy have been using it for a very long time.

Oliver: Hmm... I usually use Hexagon 2 for modelling, Ultimate Unwrap 3D Pro for UV mapping, Shader Map Pro for shader mapping, and quite often Corel PhotoPaint 10 for some of the texturing issues I encounter. As for gathering and animating and exporting all the objects, I use trueSpace 7, it has the most exact .X exporter I know of. All music is composed on Korg M1 and recorded with Audacity with a little help of some other instruments I use.

Magic Storm's Bouldermouse remake

Magic Storm

Eric: Delphi 2010 for developing code. Right now we are using “Gen2” components from Dan for graphics which uses DirectX. Before that we used DanJetX also from Dan. We are also using Squallsound for playback of OGG music files and other sound effects. Sometimes we work a little bit with sound effects or record them using Audacity and if I need a 3D texture or a picture I use Gimp.

PGM: What was your contribution in the making of Xenidis 2?

Eric: Me and Oliver have always liked Spaceshooters. We used to play on the Commadore 64 and Amstrad CPC with games like 'Nemesis' or later on 'Xenon.' This is also how the name Xendis came to be I guess, it's a combination of the two. This is our third space shooter but I think it will be our last.

Oliver: I was there and had the time to work on it, so I just did what I could to help. I would help to improve our skills in 3D modelling, UV mapping and working together with the other guys in the team. I have created the main background music track that you can hear in the menu and I did the modeling of the bigger ships like the carrier and the medic ship as well as the player's ship. Besides that, I was responsible for the buildings in space and the brown coloured objects and other spacecraft in game as well. I also did the animated pictures of the players, the interface, main menu design, loading screens, and the list goes on...

Danielo: I have done some of the 3D models for the enemies, two faces of enemy aliens for the communication screen and some additional textures here and there.

PGM: What is your favourite moment while making the game?

Eric: Getting the 3D cinematics working like they should I guess. To be honest there were plenty of "little favourite moments." I really can't list them all.

Danielo: It made me happy every time I finished a new texutre for a model.

Oliver: There are a lot. I liked seeing that my objects were making a part of the game or a specific sequence more interesing than it was before as they were added.

PGM: What was your last project before starting X2?

Oliver: We finished a 3D version of our old game 'Bouldermouse,' which is quite an amusing game based on a really old game called 'Boulder Dash.'

Eric: It was 'Bouldermouse.' This one was and still is one of my favourites. My daughter is only six years old. The games she likes most are 'Horseland' and 'Bouldermouse.' She really loves playing it and even creates levels for herself to play.

Danielo: Playing with a MMO PRG game called 'Planeshift' and some of my own concepts and other game ideas.

Magic Storm's first TombClimber


Eric, Juergen and Oliver (from left to right)

Page 12


PGM: What is your next project now that this one is done?

Eric: We have already begun to work on TombClimber 2 and it is already playable in 3D. The release will be sometime next year. After that we've got a pretty new game idea that we are currently working the kinks out of.

Oliver: We are working right now on TombClimber II which will be much like the original 'TombClimber' but all in 3D.

PGM: Is there any project or site of yours that you would like to share?

Eric: I would like to inform you that Dan is making a new set of components for both 2D and 3D game development. They currently have a place on the old DanJetX website located at www.ericbehme.de/phpBB2DAN. I am already using them for 'TombClimber 2' and they are really really nice.

I would of course like to invite everyone to our own homepage www.magicstorm.de. There you will find playable shareware versions of all our games, the old ones and new ones. Except for all the DOS games we first did in the beginning. Those are not availible.

Oliver: Yes, visit our webside www.magicstorm.de and check out our games.

Danielo: Yes, please come visit my personal site, www.dum-planet.com. It has some of my older art work and my own portfolio. It is all in German though.

PGM: Thank you for participating. Is there anything that you'd like to say to our readers?

Eric: I like developing games, and I like doing that using Delphi/Pascal. It is very good and sometimes very helpful to have others around with the same interest and a place to meet them at like the Pascal Game Development community or Dan's or my websites. Thank you everyone for your interest!

Danielo: I hope I did all right because I have never done an interview in English before.

Oliver: If you feel the artist inside of you and have a few skills in developing, sketching, 3D modelling, animating, recording noises or music, having good ideas for new projects, just contact us in our site's forums.

I hope you enjoyed a small look at the Magic Storm team, be sure to look out for their new title TombClimber 2 and this other new secret project they are working on in silence.

- Jason McMillenPascal Gamer Magazine

W ant to use the same development tools that Magic Storm does? Here is a list of some of the tools

they told us about and where to get them...

Gen2 - www.ericbehme.de/phpBB2DANNew DirectX graphics components for Delphi by the creator of DanJetX.

GIMP - www.gimp.orgGraphics editing tools with importable filter effects.

Inkscape - www.inkscape.orgOpen source vector graphics editor. Supports SVG format.

Hexagon - www.daz3d.com/i/software/hexagon3D modeling, texturing, mapping and rendering tools.

Carrara - www.daz3d.com/i/software/carrara83D figure posing, modeling, landscape design and animation tools.

Alchemy - al.chemy.orgCreative tool for sketching and drawing new ideas.

Ultimate Unwap 3D - www.unwrap3d.comSpecialty Windows UV mapping tool for 3D models.

Audacity - audacity.sourceforge.netOpen source recording and editing sound tool.

Squalsound - www.afterwarp.net/resources/soundlibFree playback library for MP3, OGG and WAV audio formats.

Tools of the Trade

Page 13

THE

CODE

R'S

BLOC

KManaging Your Classes

Introduction

H ello there! Do you happen to be in the middle of building a complex application, where you want to write several classes, and wonder how to manage

them in a convenient way? If so, this article is just perfect for you! On these few pages I'm going to show you how easy it is to build a class hierarchy and manage multiple instances of them in one place.

The code presented here can be compiled only in the latest versions of Delphi - I suppose Delphi 2009 is the needed minimum. Of course you don't have to compile it - you can simply take these snippets as an inspiration and adapt them to your very own needs. I used the new language syntax just to emphasize that your classes can be really complex and still managing them is an easy task.

During the tests of the code I used the great memory manager unit - FastMM - to ensure that there are no memory leaks. The ideas written here were tested thoroughly. I can easily say these are ones you can fully rely on.

Ok, let's get started!

Implementation

Let's say we have the following classes:• TBaseClass - the origin of all evil• TChildClass - the very first descendant, contains its own field• TFinalClass - the last descendant, also has its own field

TBaseClass derives from TInterfacedObject, which means there are interfaces likely to be involved in the overall structure. That's right - there are even two of them:• IStreamableObject - introduces two methods for saving and loading a class to stream• IPersistentObject - consists of only one method which allows for assigning the object to another one of the same type

The second interface is a generic interface, which means the assignment routine can be adapted to any (class) type we can think of. Let's take a look at their declarations:

Page 14

T his article is about class management techniques in complex application development. Many games these days can end up with some very complicated and elaborate code structures depending on the size and depth of the

development. Hopefully Patrick can provide you some assistance with his method of organizing your classes into a class hierarchy for large Object Pascal applications.

This lesson is broken down into parts with code to explain different aspects of the class management method being explained. If you have further questions about the topics discussed here, Patrick offers his email at the end. So feel free to write.

{ .: IStreamableObject :. } IStreamableObject = interface(IInterface) procedure SaveToStream(const S: TStream); procedure LoadFromStream(const S: TStream); end;

{ .: IPersistentObject :. } IPersistentObject<T> = interface(IInterface) procedure Assign(const Source: TStream); end;

Nothing complicated, right? The fundamental assumption was that every class we use in our design derives from some base class. It's a very common practice in many applications I've seen before. For an example, you can think of a game engine. Let's say there's a class called TEntity which is the foundation of every object displayed

on screen. It contains some fields, properties, and methods which are essential to define an object in space. (i.e. position, rotation, etc.)

In our case, the one in charge of this is TBaseClass. Let's have a deeper look at its design:

Snippet I – Declarations of interfaces



Whoa, this one surely looks more complex! First of all, it derives from two interfaces we declared before.

You may wonder why those interfaces weren't implemented. Basically, interfaces are just abstract classes, so they only play the containers part. We need to have a class which implements methods of an interface, thus the need of the TBaseClass class.

The base class has one field - SL. It's a string list which holds

text lines. Then there're the two well-known methods - a constructor and a destructor. Their role is straight-forward, isn’t it? At last, OutputStrings is in charge of displaying the string list's content in a console window.

Let's consider the Assign method (derived from IPersistentObject):

{ .: TBaseClass :. } TBaseClass = class(TInterfacedObject, IStreamableObject, IPersistentObject<TBaseClass>) SL: TStringList;

constructor Create(); destructor Destroy(); override;

procedure OutputStrings(); virtual;

procedure Assign(const Source: TBaseClass); virtual; procedure SaveToStream(const S: TStream); virtual; procedure LoadFromStream(const S: TStream); virtual; end;

Snippet II – The TBaseClass declaration

procedure TBaseClass.Assign(const Source: TBaseClass); begin if not Assigned(Source) then exit;

SL.AddStrings(Source.SL); end;

Snippet III – An example implementation of the Assign method

Like I said earlier, this method "synchronizes" our local field with the one taken from Source. Before we do the assignment though, we need to ensure that the object we want to synchronize our class with was created, so that we can avoid the popular "Access Violation" exception. (whose

message is always obscure)Ok, let's move further. We're in need of creating

another class which will have its own unique features, but also will have the same ones our base class has. An example may be the TChildClass class, declared as follows:

{ .: TChildClass :. } TChildClass = class(TBaseClass) TimeEntries: TList<TTestRecord>;

constructor Create(); destructor Destroy(); override;

procedure OutputStrings(); override;

procedure Assign(const Source: TBaseClass); override; procedure SaveToStream(const S: TStream); override; procedure LoadFromStream(const S: TStream); override; end;

Snippet IV – The TChildClass declaration

Managing Your Classes


It looks familiar, doesn't it? In fact it's almost identical to our base class, the only difference is that it overrides its methods (i.e. introduces new functionality) and adds another field to the overall structure. The field is a generic

list (declared in Generics.Collections) which takes the TTestRecord type as its fields. What is the record like? Nothing fancy:

{ .: TTestRecord :. } TTestRecord = packed record CurrentDate: TDate; CurrentTime: TTime; class operator Add(A: TTestRecord; B: Integer): TTestRecord; end;

Snippet V – The TTestRecord type introduced

The only “hard thing” is that it overrides an operator. Too bad that only records are capable of doing so in Delphi. As you can see, the new syntax allows for adding methods to records. I wonder why objects were marked as deprecated

then. It seems a little illogical to me, but it's because the Delphi compiler was made to be compatible with .NET.

To some readers overriding an operator might be a new task, so here's how it's implemented:

class operator TTestRecord.Add(A: TTestRecord; B: Integer): TTestRecord; begin A.CurrentTime := IncHour(A.CurrentTime, B); Result := A; end;

Snippet VI – Overriding an operator

Let's get back to describing TChildClass. As I mentioned before, all of the base class' methods are overriden inside the TChildClass. What does that mean? Well, we don't want to leave out the code we have in our base class - we

just want to expand it. So for instance, the OutputStrings method now, except displaying the contents of the SL field, may also display the records of TimeEntries:

procedure TChildClass.OutputStrings; var i: Integer; begin inherited OutputStrings();

for i := 0 to TimeEntries.Count - 1 do Writeln(' ', Format('Current date: %s, Current time: %s', [DateToStr(TimeEntries[i].CurrentDate), TimeToStr(TimeEntries[i].CurrentTime)])); end;

Snippet VII – Overriding a method

The key thing is to keep the first line - we can't forget about it if we want to maintain the functionality of our base class!

The last class in our design - TFinalClass - shows that there may even be different constructors (its constructor takes one parameter) and it's still okay.


{ .: TFinalClass :. } TFinalClass = class sealed(TChildClass) SomeString: String;

constructor Create(const S: String); procedure OutputStrings(); override; end;

Snippet VIII – The TFinalClass design

What is that mysterious word sealed? It means that no class can derive from this class (hence the class name). Because the whole class isn't big, here's its full implementation:

constructor TFinalClass.Create(const S: String); begin inherited Create();

SomeString := S; end;

procedure TFinalClass.OutputStrings; begin inherited OutputStrings();

Writeln(' ', 'Some string: ', SomeString); end;

Snippet IX – Full implementation of TFinalClass

Important note: as you can see, there are no Assign, LoadFromStream, and SaveToStream methods. How is that possible? When a class derives from an interface, it has to implement all of its methods, so why are they missing here? The answer is simple - TBaseObject does the work of implementing all of them. Because of the fact that they're marked as "virtual methods", they may be overridden in another class (of course, in a descending one), but it's not a

necessity.We have our design done. Now how do we manage

those classes without the need to create many instances and playing with lots of variables? We can use a class which will hold them all, let us to read/write to their fields, and assign methods! What's more, it'll even take care of freeing the memory they allocated! Sounds impossible? Well, you probably couldn't imagine anything simpler than that:

var ClassContainer: TObjectList<TBaseClass>;

Snippet X – Declaration of a container class

Is that all? Basically, yes! We just need to create it now:

begin ClassContainer := TObjectList<TBaseClass>.Create(True);

Snippet XI – Creation of the container class


Managing Your ClassesThe parameter it takes in its constructor tells the class whether it should be responsible for cleaning up the memory. Of course it should!

Now, how do we add a class? This snippet explains it:

with ClassContainer do begin Add(TBaseClass.Create()); Items[0].SL.Add('test string'); Items[0].OutputStrings(); { ... }

Snippet XII – Adding a class to the container

Because by default all items are of TBaseClass type, we don't need to use typecasting. But what if we wanted to add a TChildClass instance? Nothing simpler:

Add(TChildClass.Create()); TChildClass(Items[1]).TimeEntries.Add(TimeEntry()); TChildClass(Items[1]).OutputStrings();

Snippet XIII – Adding a descending class to the container

Summary

And finally here we are at the end of this article on how to manage your classes. I hope you can adapt this technique to some of your projects and successfully use the ideas presented here. If there's anything further on the topic that

you wish to discuss with me, don't hesitate and write me an email at [email protected].

- Patrick Nusbaum

B elow I have provided you with some suggested sites that you might want to consider for further reading:

• Generics with Delphi 2009 Win32 http://sjrd.developpez.com/delphi/tutoriel/generics/

• New Delphi language features since Delphi 7 http://edn.embarcadero.com/article/34324

• DN4DP#5: Redefining the operators http://hallvards.blogspot.com/2007/03/dn4dp5-redefining-operators.html

Further Reading

Page 18

Page 20

Pascal Compiler Directives


C ompiler directives are a very powerful tool. These little things come in handy when you want to suppress annoying errors that you are aware of and that do not need fixing. When you want to make cross-platform code, compiler directives are extremely

important. Curious? Just read on.

What are compiler directives?

Compiler directives are special “words” in your code that can be used to control the compiling process. They are always in the {$SOMETHING} form. They can be used to achieve the following:

• Conditional compilation• Enabling/Disabling compiler options• Including new sourcecode into your unit• Setting the compatibility modes *• Pushing/Popping compiler options from the stack *

* Freepascal only

Generally, there are two kinds of compiler directives: Local directives and Global directives. Local directives are effective anywhere in your source, while global directives should only be defined once at the top of the unit, before the interface-section. If you fail to place them there, freepascal will give you a warning. Keep an eye on these warnings, because the can lead you to ineffective compiler directives, which may cause problems.

Allthough most of the mentioned techniques will work in Delphi, some of them are FPC-only. I must admit that I have limited experience with compiler directives so I can't tell exactly which one work on which compiler.

Conditional compilation

With conditional compilation, you can make the compiler skip entire chunks of code. This can be handy when your project contains code that is only used when you want to debug. Also, code that can only be used on one platform can be conditionally compiled. It works as follows:

//This symbol will cause the code to be compiled{$DEFINE LETS_MAKE_NOISE}

//Here we check if some symbol was defined{$IFDEF LETS_MAKE_NOISE}beep;{$ENDIF}

People often add a period right before the dollar sign, to un-define the symbol.

//The period will make sure that the compiler doesn't define this symbol{.$DEFINE LETS_MAKE_NOISE}

As you see, it works the same as an if-statement. That means you can also do this.

//Here we check if some symbol was defined{$IFDEF LETS_MAKE_NOISE}beep;{$ELSE}//be quietsleep(1000);{$ENDIF}

You can put IFDEF and ENDIF around big chunks of code. It doesn't matter where you put them. For example, you don't need to put them inside a function or method.

Finally, you can use IFNDEF to compile code when a symbol has not been defined.

Compiler options

There is a whole range of options that can be switched on or off. These are called switches. Switches used like this:

{$OPTION+} //enables the option{$OPTION-} //disable the option

To name a few:

{$H+} or {$LONGSTRINGS+}: This will enable the use of AnsiStrings in FreePascal. Delphi uses AnsiStrings by default, so you might need this switch now and then. Do note that if you are in delphi-mode, AnsiStrings are automaticly enabled.

{$B+} or {$BOOLEVAL+}: Enabling this will make sure that all part of a boolean expression will be evaluated, even though the outcome may be allready known.


{$C+} or {$ASSERTIONS+}: This will enable assertions. These can be used to check if the state of the program is still valid. Assertions are only used in the development-version of a program. Quickly disabling them for release can be done by using this switch.

{$Q+} or {$OVERFLOWCHECKS+}: Like the name says, this switch will enable checking of overflows. This means that extra code is inserted to check if a variable overflows.

{$R+} or {$RANGECHECKS+}: This adds range-checking code for array indices, enumerations and subrange types. The compiler doesn't do this by default.

These are just a few commonly used switches. More can be found in the Freepascal documentation.

Including new source into your unit

This option is very handy when you have a whole load of compiler directives that you need to include in every unit of your project. It can also be used to add new source into your unit, but this isn't very usefull, because sourcecode isn't ment to be included. It should just be there.

Here's how you do it:

{$I yourfile.inc}

Easy isn't it? It's a good habbit to give these files the *.inc extension, because everyone does that.

The compatibility mode

The compatibility mode is crucial if you want to make Delphi-code work in FPC. I've mentioned it explicitly here because it's one of the first and most important directives that you will learn.

It can have different modes. The most important ones are shown below:

{$MODE DELPHI}: Ensures that the code is compiled in the way Delphi does it. Very usefull if you quickly want to port Delphi code to other platforms. This switch also enables {H} (for AnsiStrings, which are used in delphi by default).

{$MODE FPC}: The FreePascal-dialect is used to read the code.

Do note that this is a global directive. It should be defined at the top of the unit, before the interface-section.

Pushing and popping states

I have recently discovered this option, but I never have used it myself. It seems handy in some cases and I just wanted to point out that it exists.

//Set some compiler directives here{$PUSH} //Will save all compiler settings

//More code and directives{$POP} //restore the old settings again

The stack can hold up to 20 sets of compiler-settings. Do note that the pushed settings will be remembered across different units.

Conclusion

I hope that you found this tutorial usefull. Some knowledge of this subject is very usefull when you are working on big projects. One bit of advice I can give you; Make sure you keep the number of compiler directives at a minimum. Code that is soaked with compiler directives is not pleasant to work with. If you really need a lot of compiler directives you should put them into an include file (*.inc) and include that at the start of your unit. or program source.

- Nathan "chronozphere" Schagen

Page 21


T he problem of keeping one’s data safe dates back to ancient times. Keeping your data in a safe place which only you can access can work, provided it’s only you who needs to access the data or you can meet the addressee face-to-face. The issue gets complicated when you need to somehow deliver the

message – there is a risk the data might fall into the wrong hands – or worse, you have to keep it in a publicly accessible place. This is where ciphers come in. In this article I’ll try to introduce some basic ciphers. They may not be able to stop the most determined, but consider it a start, secondly – they’ll probably be enough to prevent just anyone someone trying to ‘hack’ their save-game in your new PascalAssKicker 2.0.


Glossary of Terms Used

• Plaintext – the text we want to cipher.

• Ciphertext – the same text, after it has been enciphered.

• Key – a value that affects the ciphering algo. Using a different key with the same plaintext will produce different ciphertext.

• Substitution cipher – an algo which creates ciphertext by replacing parts of the plaintext with some other data.(Caesar, Gaderypoluki, Vigenere)

• Transposition cipher – an algo which does not affect the data itself, but only changes its order.(Scytale)

Notice that substitution ciphers can be used “on-the-fly”, ciphering every character individually, while transposition ciphers need the whole message to operate. This can be both a disadvantage - because you need to wait for the message transmission to end; and an advantage, because if someone intercepts only part of the data, it will be of no use to him – while using a substitution cipher, he can decipher every possessed fragment.

Caesar cipher

One of the simplest ciphers, this one has been in use since the Roman times. Basically, take every letter in the plaintext and replace with the key-th letter to the right in the alphabet. As such, when key=1, A becomes B, B becomes C, C becomes D et cetera.

Implementation

function caesar(plain: string; key: shortint): string;var pos: byte; calc: smallint; ret: string;begin ret := ''; for pos := 1 to length(plain) do begin calc := (ord(plain[pos]) + key) mod 256; if (calc < 0) then calc := 256 + calc; ret := ret + chr(calc); end; caesar := ret;end;

Mod can return below-zero values, that’s because the ASCII code is written to a variable and then passed though ‘if’, instead of putting everything straight into ret+=. In order to decipher the message, we simply need to pass the cipher text through the algo once again, only changing the key’s sign – e.g. +2 instead of -2.

Scytale

Scytale was a cipher used by the ancient Greeks – most notably, the Spartans. The idea was to use a strip of paper (or leather, so it can be stealth-ed as, say, a belt), wrap it around a rod of certain diameter, and then write the message horizontally. Unwrapped, the letters appeared in vertical sequence.


Scytale can be easily represented using a table – consider this one as a rod which circumference allows to write four characters, and is six characters long. Take the plaintext and put it into the board row-by-row. If there are empty spaces left, fill them in with, let’s say, dots. Now all you need to do is to read the text from the board column-by-column. As such, our ciphertext is: “P**iaGMnsaaecmg.aea.lrz.”.

Implementation

function scytale(plain: string; rows: byte): string;var arr: array of char; cols, pos, x, y: byte;begin cols := 1; while (rows * cols < length(plain)) do cols := cols + 1; setlength(arr, cols, rows); pos := 1; for y := 0 to rows - 1 do begin for x := 0 to cols - 1 do begin if (pos <= length(plain)) then begin arr[x][y] := plain[pos]; pos := pos + 1; end else arr[x][y] := '.'; end; end; plain := ''; for x := 0 to cols - 1 do begin for y := 0 to rows - 1 do begin plain := plain + arr[x][y]; end; end; scytale := plain;end;

You might wonder why there aren’t separate functions for ciphering and deciphering. When we cipher, we insert plaintext row-by-row and read it column-by-column. Deciphering would mean inserting the ciphertext column-by-column and reading it row-by-row – we can achieve the same effect by “rotating” the table; for the example above, that would mean using a 4x6 table, instead of 6x4.

Gaderypoluki

Another simple cipher, this one is mostly used by scouts to cipher short messages. Its name comes from the fact that “gaderypoluki” is the most often used key for this algorithm.

The key must be even-length and no letter can appear more than once. The key is easy to remember if it consists of consonant-vowel syllables – that would be why “gaderypoluki” is the most often used one. Take the key and break it into bigrams. Using “gaderypoluki”, we will get: GA-DE-RY-PO-LU-KI. In order to cipher the message, replace every paired letter with its partner – G becomes A, while A becomes G; P becomes O, while O becomes P, et cetera. Letters that are not paired remain unchanged.

Implementation

function gaderypoluki_validkey(key: string): boolean;var present: array[0 .. 255] of boolean; pos: byte;begin if (length(key) mod 2 = 1) then exit(false); for pos := 0 to 255 do present[pos] := false; for pos := 0 to length(key) do begin if (present[ord(key[pos])]) then exit(false) else present[ord(key[pos])] := true; end; exit(true);end;


function gaderypoluki(plain, key: string): string;var replace: array[0 .. 255] of char; pos: byte;begin if (not gaderypoluki_validkey(key)) then exit(plain); for pos := 0 to 255 do replace[pos] := chr(pos); pos := 1; while (pos < length(key)) do begin replace[ord(key[pos])] := key[pos + 1]; replace[ord(key[pos + 1])] := key[pos]; pos := pos + 2; end; for pos := 1 to length(plain) do plain[pos] := replace[ord(plain[pos])]; gaderypoluki := plain;end;

To decipher the message, pass the ciphertext though the algo, using the same key.

Vigenère cipher

This one is actually a transformation of the Caesar cipher and, put as short as possible, operates on the idea of using multiple Caesar ciphers (that is, ciphers with different key values).

To the left is a stump of the table of alphabets used for this cipher. We start with an alphabet with no shift, and then shift every next alphabet +1. Possessing a hand-made table, this one can be done by hand – but since we can use computers now, let’s put a little innovation into this one – and apart from using a keyword, we’ll add the option to define the beginning shift and the row shift.

To cipher the message, take the key – if it’s shorter than the message, simply repeat it. Then, look at the row in the table with the label of the keyword’s first letter. The letter in the column which label is the plaintext’s first letter becomes the ciphertext. This probably sounds confusing, so a simple example: if the first letter of the keyword is C, and the first letter of the plaintext is B, our ciphered letter is located in row C, column B – in this case, “D”.

Of course, instead of letters, we will be using ordinal values corresponding to ASCII lettercodes.

Implementation

type chrarr: array[0 .. 255, 0 .. 255] of char;

procedure vigenere_maketable(var alph: chrarr; sshi, rshi: shortint);var x, y: byte; let: smallint;begin for y := 0 to 255 do begin for x := 0 to 255 do begin let := (sshi + y * rshi + x) mod 256; if (let < 0) then let := 256 + let; alph[x][y] := chr(let); end; end;end;

procedure vigenere_checkkey(var plain, key: string);var temp: string;begin if (length(key) >= length(plain)) then exit; temp := key; while (length(key) < length(plain)) do key := key + temp;end;



function vigenere_cipher(plain, key: string; sshi, rshi: shortint): string;var alph: chrarr; pos: byte; res: string;begin res := ''; vigenere_maketable(alph, sshi, rshi); vigenere_checkkey(plain, key); for pos := 1 to length(plain) do res := res + alph[ord(plain[pos])][ord(key[pos])]; vigenere_cipher := res;end;

function vigenere_decipher(ciph, key: string; sshi, rshi: shortint): string;var alph: chrarr; pos, x: byte; let: smallint; res: string;begin res := ''; vigenere_maketable(alph, sshi, rshi); vigenere_checkkey(ciph, key); for pos := 1 to length(ciph) do begin for x := 0 to 255 do if (alph[x][ord(key[pos])] = ciph[pos]) then break; res := res + chr(x); end; vigenere_decipher := res;end;

As you can see, this time we got separate functions for ciphering and deciphering.

Summing up

All of the ciphers presented above are, first: the most known; second: pretty easy to do by hand – and as such, they shouldn’t be treated as anywhere around secure. Scytale can be recognized by the fact that text length must be a result of multiplication; also, if the text does not fill the table completely, you can notice that the additional dots appear in a repetitive manner, hinting not only that Scytale was used, but also the “rod size”. Caesar cipher can be broken by frequency analysis – if the most common letter in a language is, say, ‘A’, and the most common letter in the ciphertext is ‘E’ – then most probably the shift is +4. Gaderypoluki can be broken by this method too – this time, instead of shifting the whole frequency diagram left or right, particular bars will be swapped. Vigenère is the most secure one, but it should be noted that due to the repeating nature of the key, longer keywords provide more security.

Still, I think these few algorithms presented above can serve as a nice start for those of you who’d like to learn something about encryption algorithms on their own. Besides – as long as you want only to protect the save files in your games, basically any cipher will do – mainly due to security by obscurity (that is, the attacker does not know which cipher was used).

- Iwicki "Super Vegeta" Artur


Templates Made Easy

R ecently, I discovered a technique that allows you to make templates in pascal. Templates are useful if you want a class to work with multiple datatypes. This technique makes use of compiler directives, so if you don't know what they are, please read my article about them. Read on to see what this is all about.

Templates: Why You Need Them

Often, while programming, you imaging that it would be neat if your class would be able to handle multiple data-types. Good examples are lists, maps, sets and other kinds of generic data structures. People often use TList or similar classes to manage their data. The downside of this, is that every time you get a pointer from the list, you have to cast it to get the actual type that was stored there. Like this:

TSomeCoolObject( MyList[3] ).DoSomethingSweet();

PInteger( MyList[2] )^ := 10;

All these typecasts clutter your code. To solve this, you need to write a list-class for every kind of data that you want to store in a list. This is just too much work and many programmers just accept that their code looks ugly with typecasts all over the place. Templates (a.k.a Generics) solve this problem. They allow you to write your code once, and reuse it for all the data-types that you want to support.

How about real templates?

Templates are supported by the newer versions of Delphi, such as Delphi 2006 and up. Free Pascal also supports them. However, I think this technique is the best one to use because:

• It works in both Delphi and Free Pascal.• It works in old versions of Delphi, including 7.• It's fairly easy to use.

There are also downsides:

• Code completion does not work for the template classes.• It's a hack, so the real templates probably look nicer in code.

I think that keeping code portable is more important than code-aesthetics. Also, code-completion is a sacrifice I'm willing to make.

How does it work?

Lets start off with a class that we want to turn into a template. I have made a basic list class for this article:

TSomeList = classprivate FList: array of TSomeType;

function GetItem(aIndex: Integer): TSomeType; procedure SetItem(aIndex: Integer; Item: TSomeType); function GetCount(): Integer; procedure SetCount(aCount: Integer);public constructor Create(aInitialCount: Integer);

property Items[I: Integer]: TSomeType read GetItem write SetItem; property Count: Integer read GetCount write SetCount;end;

Implementation

constructor TSomeList.Create(aInitialCount: Integer);begin //..end;

//etc etc...

This is nothing too special. Just a very simple list class that stores objects or records of type TSomeType. First of all, we need to make sure that this code is put in a separate file. The file must only contain the class and the implementation. The other keywords like unit, interface, uses and implementation are left out. We can use any file-extension we like. A *.tpl extension is good for templates. You can also use *.pas to get nice syntax highlighting. I saved it as “list.pas”.

So list.pas consists of two parts. The interface part and the implementation part. The next step is to turn it into this format:

// If TEMPLATE_IMPLEMENTATION is not defined,// include the interface{$IFNDEF TEMPLATE_IMPLEMENTATION}

TList_Template = class //Same stuff here as in TSomeList... //However, replace TSomeType by TEMPLATE_TYPE;end;

// Make sure that the next time the file is // included, the implementation part is included {$DEFINE TEMPLATE_IMPLEMENTATION}

{$ELSE} // Apparently, TEMPLATE_IMPLEMENTATION was // defined, so we should include the // implementation

constructor TList_Template.Create(aInitialCount: Integer);begin //..end;

//All the other methods here...{$ENDIF}

As you see, the interface part is placed inside the IF-block and the implementation part is placed inside the ELSE-block.

Okay, It's time explain what we did. “List.pas” contains a base class that describes how our list works. We will derive multiple classes from this base class. Each of these will offer support for a specific type. We make a new unit for every class. In every unit, the base class will be re-defined for a specific type. The descendant class is just a way to rename the base class and to make sure that delphi “sees” it. I will show you how to make a TBooleanList. :

unit booleanlist;

interface

// Include units that are needed by the code in// “list.pas”uses SysUtils;

type // We set the constant TEMPLATE_TYPE to the // type we want. TEMPLATE_TYPE = Boolean;

// Include base class now. TEMPLATE_TYPE will // be replaced by the type we selected // previously {$INCLUDE 'list.pas' }

// Define descendant class with a proper name TBooleanList = class(TList_Template) private public end;

implementation

// Include implementation now{$INCLUDE 'list.pas' }

end.

First of all, we include the units that we need, because list.pas has no uses-clause (it is not a real pascal-unit). Next, we set the datatype we want to work with. Now it's time to include “list.pas”.

When it's first included, it will check whether TEMPLATE_IMPLEMENTATION is not defined. It is not, so the interface part of the class is included. Then, TEMPLATE_IMPLEMENTATION is defined, so that the next time we include the unit, the implementation part will be included.

Make sure that you make a new unit for every type you want to support. Multiple templates in a single unit does not work. We're finished. You can now use the TbooleanList class, like you would normally.

I have to say thanks to Luuk van Venrooij, who gave me the idea to use this technique. He used a slightly more complex technique in his sources. When I looked into it, I figured that it could be simplified and that I could write this article about it.

So that's it. Hope you have found this article useful. If you need a full source example. Please contact me. I may post it on the PGD forums.

- Nathan Schagan


Page 28

Asphyre SphinxPR

OJEC

T HI

GHLI

GHTS


A sphyre has a long running history dating all the way back to the days when the DelphiX components for Delphi were the primary way to use third party libraries to make games. Starting out as a simple add-on library for DelphiX, using the name PowerDraw, it has then since been renamed to 'Asphyre'

which has come a long long way since then.Having been used by commercial games and other indie developers the library has made a name for it's

self among many Pascal game developers. Asphyre Sphinx is the latest version of this powerhouse game library and we are going to have a look at what it can do.

2D Graphics Features

• Image transformation including rotation, skew, mirroring and so on.• Alpha-blending with multiple effects such as add, subtract, multiply, shadow among others.• Buffered drawing calls deliver extremely high rendering performance in real-time.• Many different drawing primitives such as rectangles, ellipses, arcs, ribbons and holes.• Multiple image pixel formats to maximize quality and minimize video memory consumption.• Images can be loaded from compressed ASDb archives, external files and streams.• Patterns (small sub-images) can be distributed among different textures to reduce memory footprint.• Dynamic textures allow fast pixel access for effects such as plasma and destructible terrain.• Rendering targets allow dazzling visual effects such as motion blur, glows and other effects.• Proper handling of lost devices, surviving Alt+Tab, Win+L and other rare events.• Bitmap text drawing with Unicode support, color gradient tags and alignment options.• Integration with Vampyre Imaging Library for loading many different image formats.

3D Graphics Features

• Easy to use 3D mesh drawing even for inexperienced developers.• Mesh instancing for improved performance when many small meshes are drawn.• Optimized 3D pipeline with hidden surface removal and triangle sorting.• Transparent support for DirectX 7, DirectX 9 and OpenGL providers.• Billboard rendering for particle effects, explosions and smoke.• Load meshes from 3D Studio Max using the conversion tool, which can read 3DS and ASE formats.• Mesh generation code for 3D planes, spheres, round boxes, torus, torus knots and super ellipsoids.• Illumination models including Phong, Blinn-Phong, Minneart, Cook-Torrance, Oren-Nayer, Isotropic and Anisotropic Ward.

LLiibbrraarryy FFuunnccttiioonnaalliittyy

A sphyre was originally designed to be a DelphiX alternative that used Direct 3D's hardware acceleration capabilities, eventually it's functionality grew to include other such features as a sprite engine, collision detection, advanced content packaging, advanced math functions and of course 3D graphics. The option of using either Direct Draw or Direct 3D

existed before, but the new Sphinx now boasts added benefit of using OpenGL as an extra option. The implementation of these three options allows for the developer to set a specific one for use or allow the player to choose themselves.

The game library has grown much since it's original creation and comes with many tools and functions. It available with support for both Delphi and Lazarus. Here are some of the main features of Asphyre Sphinx...

Other Features

• Capture the state of all keyboard keys, read multiple joysticks and mouse displacement.• Store all images, sounds and other files using LZ77 compression in a single ASDb archive for easier deployment.• Set password for ASDb archive to encrypt the contents using XTEA 128-bit cipher so nobody else can open your media files.• Complete set of mathematical types with operator overloading for 2D and 3D vectors and matrices.• High-precision timer for independent graphics rendering and object movement.


Asphyre Success Stories

Along with it's many years of development the Asphyre game library has also been quite a success in many past titles. These games have used it in the game engine's core, but mostly for it's versatile graphics capabilities. Past versions of Asphyre have shown up in commercial titles along with gaming competitions, including the winning entry to the 2006 PGD Annual "Big Boss" Game Developer's Competition, 'Tanx' by Dirk Nordhusen. He created his entry using Asphyre Extreme, which allowed him to add some incredible visual effects all done with pre-rendered 2D graphics. You are a tank commander driving around blasting other enemy vehicles and aircraft. The game was later remade into an enhanced version called 'Iron Strike: Stormfront' which was submitted to the Independent Game Festival in 2007. The game featured more special effects, new enemy units and more weapons and special pick-ups. Though it didn't win any awards, is stands as testament to what you could do visually with the older versions of the Asphyre game library.

Another series of successes were the Abra Academy games created by Cezar Wagenheimer and published by Big Fish Games. Though not the only Pascal developers working with Big Fish, they have been very successful with not one, but two releases of the Abra Academy games. In these game you play the character Wanda who is a witch at the Abra Academy and the goal is to find ingredients and put them into your brew. How this is done is by solving puzzles and finding hidden objects in an elaborately drawn and organized scenery. This casual game normally sells for $9.99 US Dollars, but with a Big Fish Games membership "Game Club," it goes for only $6.99 for the more serious gamers. A good solid series of casual games made for Windows.

Probably some of the more exciting game releases are those made by the very same developers of the Asphyre library and tools themselves. The group Ixchel Studios consists of both Afterwarp developers and others and their first release was a game called Wicked Defense in September of 2007. The game is a visually dazzling special effects heavy version of 'Tower Defence,' where you have to purchase new defensive structures to prevent an onslaught of incoming enemy units. For each unit you kill you get points that go toward the purchasing of new defensive structures. The game was released for Windows and was enough of a success and gained enough market attention that the group wen on to make more games, including a sequel of their first game, Wicked Defense 2. Other titles included both the Aztlan Dreams and Aztlan Dreams 2 games.

- Jason McMillenPascal Game Development

Tanx (left) & Iron Strike: Stormfront (right)

Abra Academy (left) & Abra Academy Sequel (right)

Wicked Defense (top) & Aztlan Dreams (bottom)

NOTE: Lazarus, unlike Delphi, is a project-based development tool. This means that compiler-specific settings and library paths will have to be set for each individual project rather than sharing a single configuration for all of your projects. Each new project using Asphyre Shpinx will require you to input the path in it's included libraries which it will use.

1 Start by downloading the installer at www.afterwarp.net. Once the download is complete, uncompress the archive on your local

harddrive. You should ensure that all the folders within the archive are properly extracted or there may be some issues upon installation. License, Source and Tools should all be present along with Examples if you downloaded the complete package. Copy these files to where you want to keep them for use by your Lazarus projects.

2Once everything is properly extracted and copied, you will need to add the Source folder's location to the search

path so that Lazarus can tell Free Pascal where to find it. An easy way to do this is to include the path in the Compiler Options window for each individual project you wish to use it in. Start Lazarus and create or open an existing project and from the main menu select 'Project' then 'Compiler Options.' The Compiler Options window will then popup and you will be able to add the file path to your Source folder to 'Other Unit Files', 'Include Files', 'Other Sources', and 'Libraries' as shown.

3 Provided that you have properly completed the steps above, you should be able to compile the project or open an existing project from the

Examples folder and successfully compile it. Some of the project in the Examples folder may have been written for Delphi and as such may have to be ported over to Lazarus to function properly. Asphyre originally supported only Delphi and Lazarus support is still relatively new. If you wish to write examples for Lazarus feel free to post them on the forums at www.afterwarp.net.

Lazarus Installation

NOTE: Turbo Delphi and Delphi 2006 are the official versions the library supports, however Turbo Delphi is no longer available. Also as of Delphi 2009 and up there are some issues with installation. There is however an unofficial version that installation on Delphi 2010 by a member of the Afterwarp web forums. Look for it in this issue's Bonus Content or at the Afterwarp website. A new version of Sphinx is pending that will fix these issues with Delphi.

1 Start by downloading the installer at www.afterwarp.net or the Delphi 2010 unofficial port from the downloadable Bonus Content

section. Once the download is complete, uncompress the archive on your local harddrive. You should ensure that all the folders within the archive are properly extracted or there may be some issues upon installation. License, Source and Tools should all be present along with Examples if you downloaded the complete package. Copy these files to where you want to keep them.

2Once everything is properly extracted and copied, you will

need to add it's location to the library path for Delphi's compiler to use. Start up Delphi and select the following options from it's main menu. Under 'Tools' choose 'Options' then go into the tree view on the left hand side and look for and expand 'Environment Options' then under it 'Delphi Options' and finally select 'Library - Win32' which should bring up your 'Directories' panel. You will want to add the path of your Asphyre installation's Source folder to the existing 'Library path' value. Don't forget to make sure you use a semi-colon delimiter to prevent errors.

3 Provided that you have followed these steps properly, you should have a ready installation of Ashpyre Sphinx. It's important to note that there

aren't any VCL in this framework and you will not see anything on the component palette in case you want to look for it there. If you installed a version with the Examples folder it's recommended that you try to open the Basic or Basic3D examples and try to recompile them to verify proper installation. If there aren't any errors, you are now ready to start using Asphyre Sphinx.

Delphi Installation

Asphyre Sphinx


Page 32

From PGD Annual to IGF: TuberunnerSP

ECIA

L RE

PORT


2009 PGD Annual:

Tuberunner Post MortemSummary

It's been a while since the competition results were announced. I was very happy to learn that I had won with my entry: “TubeRunner”. Now is a good time to look back on what happened during those preceeding months of hard work. It wasn't all easy and fun. To be honest, a lot of things went wrong. Here I'll share with you my success, failure, fun and the things I learned, during development.

In June, I was very excited to hear that a PGD Annual 2009 competition was being organized. I always wanted to make a race-game so I started making a design document. The game I had in mind was actually a race-game with a bit of combat gameplay in it. Unfortunately I didn't have enough time to add the actual combat part.

The racetrack-concept was something I found essential, so I've put a lot of time in it. I thought that my idea of racing up the walls and ceilings would make it a bit more innovative. Also there should be obsticles to dodge. Actually, making such a race-track would be really hard, so I wrote two DeleD plug-ins that helped me with this. They allowed me to make prefabs and copy/stretch/bend them to form a new track. Bending those prefabs into place was especially mathy. Still, I pulled it off.

Development didn't go as quick as I'd hoped for. This was because I was working on many different things at the same time. There was the engine, the game and then two different DeleD plugins that needed to be programmed. I started working on the engine in July, according to my SVN log. Strangely, the development of the engine went rather quick at first. It took me two weeks to get an OpenGL renderer working. Then I went on a holiday or two and I was suddenly in August. During the holiday, I did a bit of work on the game too because I decided to bring my laptop with me.

In August, I started working on the race track building plug-ins. It took a few weeks to get them working right. This should've gone a bit faster.

Then there was a big gap because I started at university. It took me three weeks to get started and adjusted there. If I had made a schedule with deadlines, this definitely would have knocked it off the table. Believe me, don't go to university when you're in the midst of a game project. Of course I'm just kidding, but it wasn't easy to do.

When I had things up and running in Amsterdam, I shifted my focus towards the game project again. During October, I was still working on technical features like text input and an XML parser. I also had a lot of problems fighting floating-point errors here. These were an absolute pain in the butt and made the game unplayable. However, good things were still happening as well. I had even wrote a neat menu system for the game too.

Suddenly I found myself halfway through November and then the stress of the competition really kicked in. I had made some wonderfull race tracks with power-ups and working collision detection. There was a menu in the game now, but still there was no gameplay yet. I worked really hard to squeeze in some proper gameplay in there before the final deadline. Often, I found myself staring at buggy collision detection code at 4:00 AM, of which I thought would never work properly.

A t the end of 2009 the PGD Annual Game Developer's Competition came to a close with it's winner and their chance to win it big at the Independent Games Festival. We here at Pascal Gamer decided to keep an eye on

Nathan Schagan as he takes his game on a journey from the PGD Annual to the IGF. Read from Nathan's own words how it has been going so far!


What went wrong.

First of all, I put way too much time in the racetrack code. I figured that I could do the collision detection myself, so I defined a few complex coordinate systems to do the math in. A lot of code depended on this math. I foud out that floating-point errors were ruining my plans. It was neccesary to rewrite this code a couple of times to make it more reliable. In the end, I managed fix most problems, but the time that went into this was forever lost.At first, I didn't properly define the conventions for my track format. It's important that you think about this because otherwise the different parts of your program will interpret your data in different ways. It wasn't that hard to fix though.I decided to program the game-engine by myself. This was challenging and fun. The only downside was that it distracted me during the development of the actual game. For example: In August I was still working on loading TGA Images, lightmaps and rendering particle systems.I used DeleD's XML-based format to load the tracks into the game. This caused a lot of overhead because the file of an average track was huge and it took a lot of time to parse all the XML when loading it. From now on, I will be using simple binary model formats because they load a lot quicker.Halfway the project, I realized that DeleD didn't have local-coordinate systems for their objects. Everything was defined in world-space. This turned out to be a real problem. It appeared that I really needed this feature, to make sure that the track pieces are properly aligned. I kinda solved it with a dirty and unreliable hack. This had some implications on how I should model the track pieces. It made designing good race tracks a lot harder.Finally, I didn't properly use the design document I wrote before starting the competition. I feel a developer should often read his design documents to keep an eye on his progress. I occupied myself with a bunch of technical challenges while neglecting my goals in the document.

What went right.

One thing I was really satisfied with, was my menu system. I wrote a game-state class that described a state of my application (gameplay, loading, main menu etc..). After adding a few derived classes and a lot of menu-controls like buttons, selectors, edit-fields and such, I had a really flexible system. With a few lines of code, I could set up a new menu and attach a few event-handlers to it's controls.Making the content (aside from the racetracks) didn't cost me much time. I have a whole collection of sound effects and I picked a few of them for my game. Also, I did the voice-over sounds in Goldwave. Those required some extra attention, but the result was quite nice.I've also put quite some effort in the appearance of the powerups. Making the models was easy, but rendering them in the right way was not. Fortunately, I ended up with some very arcade-ish semi-transparent powerups on my track.I used DeleD for this project. Allthough I was having problems here and there, DeleD proved to be quite usefull. It allowed me to customize the appearance of the racetrack. I did this with the “Pipe of pipes” track and it looked awesome. Also the built-in lightmapper was great. The lightmaps with the coloured lights really added atmosphere to my game.

Despite the fact that I've won the competition, I feel that I made a lot of mistakes during the project. Most importantly, I was focusing too much on the racetrack instead of the gameplay. Also, I wanted to re-invent the wheel all over the place. I should have used a physics engine and I should have aimed for simpler racetracks. These things soaked up a lot of my time. I didn't manage to add the combat part of my gameplay.Also, there were some unavoidable things that delayed my development, like university and a holiday. They consumed at least one month from the five months I had for this project.Still, I'm very pleased with the overall result. People said nice things about the graphical detail, the clear menus and the sound effects I used. Also, the IGF offers me a second chance. I really hope that development of the new TubeRunner will go smoother. So far, I'm quite confident that I will get there.

- Nathan Schagan1st Place, 2009 PGD Annual


28 May 2010

May is almost over now. I should have started this journal earlier, but I real life distracted me.

I started working on the new TubeRunner in April. The new engine was first on my list. My aim was to make the engine cross-platform, using SDL and OpenGL. I allready had a working OpenAL module, that just needed to be refactored a bit. Also, Input wouldn't be too difficult with SDL.

I made a plan for my engine-project and then I started.The first thing on my list was input. This wasn't a

problem at all, and it was done within a week. I also made a small test project for the input part. It seemed like a good way to test my functionality and see if my own API works and looks nice in code. I decided to make a test project for every part of the engine.

Next, I started working on the graphics part. Progress slowed down considerably, because I had some exams coming up. Fortunately Luuk van Venrooi helped me a lot by sharing the sourcecode of his shader-driven. I took a close look at his code and used the things I liked in my own engine. Somehow it felt awkward because there wasn't a lot of room for improvement. I could aswell just use his engine for my game. The thing that kept me from doing this, was my learning goal. From my perspective, reinventing the wheel can be justified when you're goal is to learn how something works.

Thanks to his help, I quickly got GLSL shaders working. The game will be totally shader driven, so this is definitely a relief.

I have some doubts about how to look at this project. First of all, I want it to be finished on time, but secondly, I want to learn some things that I feel are important. For example: Learning how those matrices work and learning how to program shaders.

The best way to learn matrices is by reading articles and taking a close look at the matrix routines that you use. I found this to be very interesting, but also very time consuming. That last part worries me because time is my main enemy in this project.

That said, I'm not really happy with the development speed. Right now, I'm two weeks behind on schedule. I feel that I was being too optimistic when I first made my planning for the project. The final deadline for my engine is 20 june. I do have time during June, but I'm not sure if it's enough to actually finish. If I throw alot of juice at it, I may be able to pull it off.

Also, I started working together with Paul Nicholls on Path-functionality in DeleD. At the moment of writing this, we are well under way. Still, there are very important things that need to be done, and I forsee that there will be a number of bugs waiting for me when I'm done.

9 July 2010

During the passed month, I have made quite some progress, but still not as much as I had hoped for. I'll give you a quick summary of what happened:

First of all, I was unable to finish the engine before 20 June. Infact, it's still not finished. I was too busy with a JAVA program I had to write for a homework assignment. It seems that my planning was not realistic. However, I still finished some important features.

I've managed to load wavefront OBJ models into my engine. This was a big breakthrough and it made me more confident that I could pull it off. Also, I've got texture support up and running.

First of all, I wanted to use my own TGA code (actually I stole it from sulaco.co.za haha). But I realized that it contained a piece of assembly which could not be compiled by FreePascal. So, I decided to use the vampyre imaging library instead. Luuk van venrooij pointed out that it was easy to configure an *.inc file, to cut down the number of Vampyre units that were needed. I ended up only needing 9 units. Given the great quality of the code and the documentation of the library, I was confident that this was a good choice.

From PGD Annual to IGF: Tuberunner


Before June ended, I managed to squeeze in Fonts as well.

I noticed that one feature to the engine usually takes me an afternoon to implement. After that, I still need time to test and improve things. Knowing this, It's quite clear that my initial planning schedule was unrealistic. I planned about three features a week, while I was still doing school work and other projects as well.

Implementing paths into DeleD came to a grinding halt. Paul was very busy with real life, and I was not motivated enough to take the next step. Still, we are both determined to finish the things we started.

This week, I solved some major problems on linux that were preventing me from running my engine demo's. First of all, there was the “Invalid launching application” error. This was caused by the fact that I stored my code on an NTFS drive that was shared between windows and linux. Because of an error in a configuration file, the files on the drive were owned by the root-user and could not be executed by Lazarus.

After fixing that, I ran into an “X11 driver was not configured with OpenGL” error. This was because I during the compile-process of SDL, it could not find an openGL header file, thus skipping all OpenGL related code. Making the file available and rebuilding SDL solved the problem. I feel that making the game run on linux is possible now.

Finally, I'm working on a rendertarget-support. This is essential if you want some good visual effects in your games. Luuk van Venrooij also helped me here by sharing his sources and by giving valueable advice. I don't have it working yet, but it won't take long.

It's time to reassess the whole project. Hopefully I can finish the engine quickly and move on to the actual game. My hope is that the last three months were well spent and that I will have a reliable engine that doesn't distract me from working on my game.

9 October 2010

A lot of time has passed since I wrote my last journal. Unfortunatly I didn't make a lot of progress. The main reason was that I had other projects to work on, which are progressing nicely now.

During the last three months, I started to realize that it would be impossible to finish the game before November 2010, which was the deadline for the IGF competition. To cut myself some slack, I have decided to aim for IGF 2012, giving me an extra year. Also, to make sure that I won't make the same mistake again, I have made a little schedule for this project.

Each month I will try to implement some features in my engine or game. At the end of each month, I will look back and see what worked and what did not (and possibly write a journal about that, to keep you guys updated). I will also discuss things with Christina a.k.a AthenaOfDelphi, to make sure I don't focus on the wrong things.

So, what's in store for October? I'll mainly work on my engine this month. First of all, I

want to move the whole project to the GIT version system. I've learned how to work with that during the last months and I can use it in both windows and linux, which makes it perfect if I ever want to go cross-platform, which is quite likely.

Also, I will make a scene graph. This will be a really simple thing, which only contains the stuff I need.

Finally, I need to do some refactoring, as I have discovered that I'm using the wrong approach here and there in my code.

No spectacular goals for this month, but they ARE realistic!

- Nathan Schagan

Nathan Schagan's Tuberunner development journal will continue in the next issue of Pascal Gamer!


Ludum Dare 17

A Practical Survival Guide for RobotsPost-Mortem by Johannes Stein

Personally I didn’t like the theme that much. First of all, because I used islands in my LD #16 game, in several other prototypes and couldn’t really find an idea that would be different from them. I had several ideas in my head, such as “You are the island”, some kind of Project Nomads game in which you have a floating island, build towers on your island and battle other islands, a RPG-like game where you go from island to island solving different quests and finally the survivor idea.

I went with the latter because I thought I can pull that off in 48 hours. The plan was to make kind of parody game, I don’t know if you can already tell in the status the game is now in. I planned a nice little intro, where you definitely get the idea that the game doesn’t take itself too seriously, but it got cut due to lack of time.

I nearly spent the complete first day on graphics and I could have been more productive. The most productive time for me was the last nine hours before the deadline. The actual gameplay got finished the hour before the deadline, so there wasn’t a a lot of time left for playtesting.

Still, this is the most finished LD game I made yet, you actually have around 20 minutes of gameplay. Well, allright, that depends if you are exploring the world, building stuff or just focusing on the goal.

The Good• Graphics & Music: Of course it could be better and the graphics are not 3D, but for the time invested it’s fairly good• Luck: I had so much luck during development. I had to modify some core parts of my framework and was getting a lot of Access Violations and cryptic messages. If I hadn’t found the error in time, the game probably wouldn’t have been submitted• Technical design: I designed classes and the gameplay elements very early in the developmen process, so it was more or less loading an displaying the graphics accordingly and seeing if it really works like expected

The Bad• Motivation: I don’t know why but I was not that motivated this time, only in the last couple of hours the motivation to finish the game was back• Humor: I was planning to add more humoristic elements, but the time wasn’t enough• Scripting: I was planning to script an intro, instructions and credits screen, but again not enough time; so there isn’t actually any scripting in the game

What I’m planning to do for next time?• Extend my base code/framework: I especially need a camera class and something to manages maps that are bigger than just one screen• Integrate a level editor into the base code or write one myself

All in all, it was fun as always :) and I can’t wait to play all those games.

T he Ludum Dare #17 competition was held from April 23rd to April 25th, 2010 and having 204 total entries submitted by the deadline. The theme of the 17th competition was Islands. A total of three Pascal entries were submitted before the deadline. The competitions are plot-based challenges to make a game that fits the chosen theme. Development timeframe

usually takes place over a weekend, giving entries only a couple of days, 48-hours to be exact, to create and submit their games. Entries can be submitted only by individuals, no teams or group development is permitted as per the Ludum Dare rules.

The Ludum Dare community was founded by Geoff Howland, and held it's first competition in April of 2002.


Isolated EmpirePost-Mortem by Matt Shaffer

Joining a Ludum Dare is always an exhilarating experience that will drive any sane man to his breaking point. Creating a game from scratch in 48 hours is more than daunting. It all begins with the theme and an idea for a game.

Ludum Dare #17's theme was islands. While I did initially vote for this theme, when it was chosen I had no idea what I was going to create for a game. First things first: start doodling or writing out ideas. There is no need to write a fully-fledged design document for a game with such a limited time frame. After I had a few ideas down on paper, I decided on a game concept based on an old game I had played as a child. In this game (which I sadly cannot recall the name of), you are stranded on an island and must collect resources to build a raft and escape.

Now I had a basic idea, but I wanted to expand upon it a bit more than what I could recall of the original game. In the original game, everything was turn based. The player was just one man, collecting everything by himself. Here's one of the key points I used in twisting the gameplay every so slightly. Instead of just one man, I incorporated elements seen in other real time strategy games, including villagers, housing, and cities.

What's important to note is how added a slight bit of management to the villagers. Every villager will consume a small bit of water and food after a certain period of time, and it is up to the player to make sure the supplies are high enough to support the population. As the islands (they are procedurally generated) contain no natural food sources, the player must quickly create farms and send off villagers to harvest them.

The end goal of the game is to gather enough resources to afford building a raft to leave the island with your villagers. Unfortunately, here's where one flaw with the

current version of the game lies: it is a hard task to achieve within the short time frame. Currently, I have the time capped to maximum of 1 hour, after which the game will end. This is not enough time to complete the goal.

But unfortunately, giving the player more time to complete the task won't help much. What I need to do in the future is create different difficulty modes, preferably lowering the costs of the raft as well as lengthening the time.

Does all of this gameplay sound complex yet? The villagers are the main driving force behind the gameplay. Without villagers, you cannot collect any more resources, and will lose the game over time (because villagers are constantly consuming, even when not working).

I now want to tie in this complexity with a reminder of the competition: one man, 48 hours, creating everything from scratch. On Saturday I spent most of my time creating the actual drawing and procedural island generation engines. I made it extensible (thankfully), but it took way too much time for this competition.

When developing in such a short amount of time, it's a better idea to create at least some kind of placeholder art while the core gameplay mechanics are fleshed out. I skipped this and went directly to final art (which is still nowhere near “good”), which ate up even more of my time.

But we can't just leave this at programming and creating art. Entrants still have to create all of their own sound effects and music to go along with the game. Luckily, DrPetter (from Ludum Dare) has created a simple program to generate simple sound effects. Yet even with a handful of sound effects, it can be hard to tie them all into the game – something noticeable in the current iteration of Isolated Empire.

Creating music can be even more challenging. Luckily for me, I can pick out tunes, chords, and notes that I think sound good together. The downside is that it takes me a very long time to get a finished product I am satisfied with. For my entry, Isolated Empire, I created a single track that was 24 seconds long and looped rather seamlessly, as well as utilizing only 2 instruments. This in itself took an hour to an hour and a half of my time. It's OK to prioritize and decide music should go in last. I used Anvil Studio to create the base MIDI music, but it didn't seem too fitting. I proceeded to run the output through another program named GXSCC which converted the MIDI into an 8bit wonderland.


Ludum Dare 17

To participate in a Ludum Dare, you really must have the right frame of mind. You will undergo massive amounts of stress and frustration with programming alone, which is why many entries are lacking sound effects and music. When I enter a Ludum Dare, the only motivational force I have is the desire to complete the original game I had created in my mind's eye. Whether the game is a simple 2 hour quickie before you leave to go somewhere, or a full 48 hour mess, you must plan accordingly. You certainly can't fit in all of the gampelay elements you would have desired. It's OK to save updates for later. After the competition, it can be refreshing to come back to your project and fix it up to cover all of your extended goals – and this is exactly what I plan to do.

Motivation is key. Without motivation, you have nothing. You'll end up hating your game idea or not being able to work on your game, and you will scarp the project. This is always a saddening experience, and something I hope I will remain avoiding. With only 2 days to create a game, it's in no way a long term commitment. For motivation, I browsed the website at ludumdare.com and idled in the IRC channel. Even though these activities may have ranged from 5-15 minutes in length at a time, it really helped boost my motivation to finish my game. But beware: unless you are careful, this can easily turn into a large timesink. With 48 hours, you will often find all too late that you needed most of that time to create the dream game you had first envisioned, instead of having the luxury of squandering it.

General Ludum Dare Tips:

• Don't let yourself become distracted too much.• Plan breaks of half an hour or more.• Clear the weekend of obligations ahead of time.• Decide how long you expect the game to take, and make that as a goal.

• Read and comment on others' progress, as well as chatting in IRC. It really is a motivator for people.• Don't spend too much time on music, or any one resource.• Focus first on gameplay, and secondly on graphics, music, and sound.• Know your libraries ahead of time, and do not attempt to use any new library.• Playtest like crazy. You don't want a buggy product.• Take time to post screenshots and progress updates, but not actual builds. Creating alpha builds of a game you have to make in 48hrs is too much of a waste of time. Screenshots and some info is good enough. Also, this applies to creating videos of your alpha game. Save your desire to create a video for a final gameplay video or timelapse.• Comment your code. It's hard remembering what that mess of horrendously named variables is supposed to do.• Don't focus on pretty code. You have 48 hours. It doesn't matter how ugly it is, if it compiles.

One final note for entering in Ludum Dare is that your game will NOT work on all systems. You shouldn't expect it to. For instance, some people have trouble with my game not loading or otherwise not starting. I'm fairly sure this is either due to Andorra's collision system or perhaps these people were running a 64 bit OS that didn't like my 32 bit executable. The only other problem people seemed to experience was an access violation when they tried to start the game. To be fair, this was a bug and I have fixed it in my post-competition version of the game... This error occurs when users try to send any input to the game while it is loading.

You can visit the personal website of Matt Shaffer at www.matt-shaffer.com.


To see the full LD#17 results or look at past competitions visit www.ludumdare.com!

A Practical Survival Guide for Robotshttp://tiny.cc/pmlir

Overall: 54th Place (8-way Tie)Audio: 14th PlaceCommunity: 12th Place (Tie)Coolness: 2nd Place (5-way Tie)

Isolated Empirehttp://tiny.cc/kvxv4

Overall: 22nd PlaceCoolness: 3rd Place (19-way Tie)

Ferry Catcherhttp://tiny.cc/8x5fo

Overall: 112th Place

Competition #17's Results

Page 39

Other Stuff from the Competition

Alexander Rosendal aka Traveler made an attempt for an entry into the competition having gotten as far as implementing a river scene with some objects, logs and a speed boat, and some graphical effects. He did not submit what he had done to the competition as he felt it was incomplete, however he did post a couple of screenshots on the PGD website. Here is what he shared.

JSoftware aka Laksen made his entry but it was not the game he originally intended to do. Instead he opted for a simple platformer, however it seems that his plans were made too late as it turned out to lack a true gameplay goal and the overall polish you'd expect from even an indie game.

His original game idea looked to be more of a RTS game where you chose to be on the side of killer robots or powerful lizard men. A much cooler concept if you ask us! It's a shame that time and planning was not on his side, but alas at least he did get an entry in before the deadline. Maybe we still have a chance to see his original idea come to fruition? We can only hope.

There were others that wanted to jump into the Ludum Dare as it seems to be growing in popularity. Paul Nicholls wanted to make this his first dive-in to the Lundum Dare but he just didn't have the time. A few others were in the same boat we can easily assume. These types of twenty-four hours, forty-eight hours and one or two week competitions, if you can make the time for them, are neat and push the gameplay and design more so than content, which is kinda nice because it gives you some innovative ideas. The other nice thing about this one is that it allows a hosting place for your game's source. So if someone liked your game and wanted to tweak it or learn from your code, it's easily down. Just download, gather the libraries and tools needed and you're off!

- Jason "WILL" McMillenPascal Gamer Magazine

M ichal is a programmer, musician and owner for his company, Gamecask. He does his own music for all of his games instead of contracting music from other artists. He finds that it allows him to have greater control over the effect that the music in his

games than if he offered out this job to others. Read what he has to say about the aesthetics of music in games.


Aesthetics of Music in Video Games

M usic is a subject that is rarely discussed in the articles about game development, although is very important. Music is of particular

importance in the case of casual games, because we need to create a pleasant mood and we need to be stick to the theme of the game. I do not want to write, in this article, about the techniques of creating music or software used, but to talk about the aesthetics of music in video games.

Listen... if music is compared to the shape, the more we like this track, which had not previously seen. Our brains want to meet with new musical shapes, new solutions and new impressions.

"The impression is the beginning and the first condition for aesthetic satisfaction. It creates the basis for this feeling." ~Eduard Hanslick

You must be noted that all good movies start with the best soundtrack, and this is the beginning for good feeling. We must do this same in our games!

Programming and music composing are very similar - every mistake has huge implications. If the graphics can commit an error and could no one notice, so in music it is recognizable immediately - the listener understands music in real time and does not need time to think about it, as is the case for example in poetry. What's more, each of us is the best judge in matters of music and can pick up any discordant note from any bad music track. We're all musicians, but not everyone from us knows that. Therefore, I think that good music and well-written program is the most important elements of the game... more important than graphics.

I am not educated in music, but I think nobody will give us an algorithm to compose beautiful music and nobody will teach as the musical sensitivity. However, it's worth talking about music and read about music, because when you sit down and begin create, you will not have a vacuum in the head.

I think that sensibility, life experiences and knowledge are the key to becoming a good composer, and if we talk about knowledge, I highly recommend reading the book by Eduard Hanslick called "On the Beautiful in Music". It's a great read for everyone, not only for music students.

As for music in video games, I am an advocate of minimalism. It is a good solution, especially in dynamic games with a large number of sound effects. For example, in my last game Dachinko, I prepared about 150 sound effects that can be played by the collisions of 10 balls with all elements of the game machine. It really generates a lot of sounds and they could be in conflict with the music with a large group of instruments. Therefore, I try not to use a large number of instruments and I do not compose a complex melodies. What's more, music in the Asian culture have the characteristics of minimalism and this culture has been my inspiration for this game.

I urge all, especially to creative developers to try to start making music for their games. It's great fun and gives great satisfaction. I could write more, but like Bruce Lee said:

"Knowing is not enough, you must apply. Willing is not enough, you must do."

- Michal "mobilus" BugalaCompany Owner, Gamecask

W hen I saw last year’s PGD Annual theme was to write an arcade game, I was thrilled, I love arcade games! Luckily, a few months prior to

the start of the competition, I had come up with a game idea, but as with lots of my ideas, I hadn’t started the project. So I figured this would be a perfect excuse to get off my butt and get into it. The idea was to have the Earth in the center of the screen, with asteroids coming towards it which you had to destroy (and thus “Day Of Destruction!” was born!). When the competition came around, I got stuck into the design document first as stipulated by the stage 1 competition rules. This was quite a new experience for me as I usually don’t do design documents for games, or any programming project, I am one of those “get stuck in and start programming” kind of guys LOL. I’m glad I did though as it did help me stick to my game idea (which was mostly unchanged by the end of the competition), and even stay motivated to an extent.

During stage 2 of the competition (creating the actual game), I did at times find it hard to stay motivated…at one stage, there was a period of almost 2 weeks where I hadn’t done ANY coding for it (bad boy Paul!). Maybe this was because of the long time frame of the competition, but if it wasn’t this long, then I wouldn’t have completed it anyway,

so I think this was a good thing. Seeing the progress of other competitors did help a lot in keeping me motivated though, so yay! There were other times where I was coding furiously without taking many breaks (in what little spare time I had around work + family LOL). Luckily, I had already some helper classes/units like a basic SDL + OpenGL application framework I could use as the base, and some other things like texture loading, and state machine classes (which I hadn’t used for anything up till this point). Sites like http://www.pascalgamedevelopment.com, http://nehe.gamedev.net, http://www.gamedev.net, and a whole bunch of others really helped me figure out how to get different things working with my coding.

I’m not sure what I would do differently next time, but I guess, better time and priority management for one! It was lots of fun, rewarding, and I won some really neat prizes to boot! LOL

- Paul Nicholls2009 PGD Annual Competition Winner

2009 PGD Annual, My Experience


P aul Nicholls wrote us an email at Pascal Gamer Magazine sometime after the completion of the 2009

PGD Annual Game Developer's Competition to let us know how his experience went. After coming in second place in the competition he has gone on to other projects, but anxiously awaits the next competition. Here is what he had to say about his Arcadia entry and what he thought about the competition.

Page 42

W e will be looking at a few new games along with a few hidden gems alike in this issue. You should know that all of these games have been played

through thoroughly, reviewed and scored by randomly selected people and not by all one author. Our goal is to provide a totally unbiased and fair assessment of all games covered in our reviews.

Pascal Gamer Magazine's rating system is used as a criteria to score areas of the game along with the game as a whole. Not all games are equal and so it would not be fair to simply just throw up a single one-to-ten scale score and have an equally

scored game and not highlight it's distinct strengths compaired to the other game.

It is our hope that you enjoy these reviews and find them to be informative, but most of all entertaining. A url is provided for each game where it can be downloaded or more information can be read about it.

If you have your own completed game or wish to submit a url to a released game which you know to be made using either Pascal or Object Pascal, please drop us a line at: [email protected]. We would love to hear about it!

Page 44

Game Reviews


Wicked Defense 2http://www.ixchels.net/

Price: $9.99Genre: Real Time StrategyDeveloper: Ixchel GamesPlatform: Windows

Another trip into the wonderful visual effects latent world of Wicked Defense. The object of the game is to prevent as many monsters from crossing for their entrance to the exit. You have a life meter that goes down when each one makes it to the exit, until it reaches zero and your game is over. Score as high as you can and build up your defence towers to fend off as many of the monsters as you can. You can even cast magic attacks using your mana points

that regenerate slowly. This is one of those games that has a level of complexity that has a lot to learn and makes it hard to master, which is great for those that like strategy games that give you a challenge. The key to winning each scenario is balancing your tower abilities with the monsters that will be passing by next. Graphics and special effects are stunning and the ambient music is nice too. Lots of polish and shine to the interface which drives this title. Controls are pretty good leaving only a few things that I'd like tweaked. There is lots of content that can be unlocked by completing future scenarios which greatly adds to 'come back and play' value. Online highscores are also a

nice feature. There is some on-screen assistance at the beginning of each map, but a small tutorial on the tower types and basic strategy would help newcomers to the game get started easier. Overall a solid release worthy of the 2.0 label. Try the free demo for sure, it's a wonder to see.

7

779

87

Graphics(Visuals & Special Effects)

Sound(Sound Effects & Musical Score)

Fun Factor(Overall Enjoyable Experience)

Game Controls(Easy of Use & Dependability)

Replay Value(Addiction & Varied Gameplay)

Overall Score(Overall Impressions)

Pascal Gamer Rating System

1 - 23 - 4

5 - 6

Bad

PoorFair

7 - 8 Good9 - 10 Great

Page 45

Sultan's Labyrinth: A Royal Sacrificehttp://tinyurl.com/2dbqr7a

Price: $6.99Genre: Hidden Object GameDeveloper: BrutoMemo EntertainmentPlatform: Windows

In this arabian sequel the son of the sultan who has been trapped in a labyrinth by a powerful genie owned by his father. You must now pass his trials to get out alive for offences caused by your father. This game is a mix between a hidden object game and a classic adventure game where you must find

objects and use them in specific scenes to continue on in the story. The graphics are very nicely drawn and details with beautiful special effects that add the right touch to each scene. Music is nicely themed and pleasant to take in. Controls are rather simple, but effective in the gameplay. A very smart feature that takes your cursor away and shakes it when you try the old rapid click cheat to find objects your looking for. Cutscene story panels in between the game stages are great and have a wonderful in-depth story to tell. Being able to switch between a selection of scenes at each stage and use objects between them adds

to the gameplay nicely. The hint option with it's slowly replenishing gauge is also a welcomed relief when you are struggling. An overall very nice adventure with a great story and cool gameplay features.

Jawbreakers Return!http://www.fingerspoil.com/

Price: $14.95Genre: MazeDeveloper: Fingerspoil GamesPlatform: Windows

A very polished and feature packed release with a cute theme. Graphics are clean and the special effects are really good. The game is very much like the classic maze games of the 80s. You are one of the Jaw invading the Jawbreaker planet trying to eat everything up. In doing so you must collect all the green dots around the map without running into a jawbreaker. Bigger red dots let

you eat the Jawbreakers too, but if you can't get to one of those you have a selection of attacks that you can use to take them out as well, such as your green chili breath. You try to collect fruits and other special pickups as well to increase your speed, get extra weapons, save a checkpoint, unlock gates and block or slow down the Jawbreakers, but be careful not to run into those trick pickups which will either make you drunk, slow you down or get you stuck on the spot in a nasty oil slick. The Jawbreakers are cute enemies that come in a variety of different shapes and even parachute down into the maze to add more danger to your task at hand. Music is fairly decent, but there is mostly only the one track you hear while playing. Level progression is pretty nice offering new challenges as you go along. There are two modes, Story and Arcade modes which offer varied gameplay for whatever mood your in. In story mode there are some pretty neat bonus games such as catching fruit shot out of a volcano. Controls are responsive and

easy to use, however configurations options are limited to only changing the direction arrows. A fun game overall that could be picked up again and again for it's modernized take on the classic maze genre.

6

867

87

8

788

68


UltraStar Deluxehttp://www.ultrastardeluxe.org/

Price: FreeGenre: PartyDeveloper: UltraStar Deluxe TeamPlatform: Windows, Linux, Mac OS X

Music games can be a hit or miss depending on the execution and the ability to get contracts and the rights to known popular music. However this in mind, this one stands out as a great base for building up to that with a good solid karaoke and voice detection engine inside. Menus and options are very impressive leave only a few minor visual

glitches and some added initial startup options for the microphone would be nice too. The game overall is very polished and has many themes to choose from allowing you to personalize. The voice detection is pretty neat too and it even allows you to see your voice visually displayed with an onscreen

oscillator you can toggle on and off. There are two modes of play Single player sing or Party mode which adds more people to the mix. As you go along and sing it gives you little indications of how well you did on that last portion of the song. When you or you and your friends have finished the song and your singing session, you are greeted with a results screen which shows how well

you have done. Overall a nice well polished and put together game engine which has a potential to become a hit at parties. Graphics and animations are beautiful and suit the atmosphere for a fun time. More music bundled or song downloading options right from the game it's self could be an excellent next feature. Nice job keep up the good work!

Game Reviews

7

888

98


Soldathttp://www.soldat.pl/en/

Price: FreeGenre: AdventureDeveloper: Michał MarcinkowskiPlatform: Windows

This is a game of mass side scrolling slaughter addiction. Made with the same flavour and gameplay style of the first person shooter deathmatch genre, this side scrolling shoot 'em up is all about the deathmatch. You can take on players from all around the world in teams or in a full free-for-all cabal. The graphics and animation take on both an indie charm

while also maintaining a very high quality in environmental effect. Sound effects are fairly accurate to actual weapons fire and are of rather good quality. Network play is smooth and is very stable. Your controls are the mouse to aim and fire and use a jet pack to fly and the 'wasd' keys will let you run, crouch and jump. You can choose from several different default weapons at respawn, but there is other weapons you can pickup and ammo drops you can pickup to restock on the run as well. Plus you can throw grenades, fun! There are quite a few game modes such as Deathmatch, Pointmatch, Teammatch,

Capture the Flag, Infiltration, Hold the flag and Rambomatch each with their own set of rules and winning conditions. Soldat is great online shoot-em-up fun with and recommended for anyone feeling a little trigger happy.

9

878

98

Page 47

LambdaRogue: The Book of Starshttp://www.lambdarogue.net/

Price: FreeGenre: RPG / RoguelikeDeveloper: Mario DonickPlatform: Windows, Linux

This was quite the enchanting RPG engine with an old school gaming feel. The story is rich, well written and quite in depth. Though simpler than most RPG games of today's standards, it keeps the player's interest through it's story telling and verbose interaction options, which is something that not too many RPGs today

do much of anymore. Graphics were not overly spectacular, but they served their purpose and were not all that bad really. Some special effects also helped to tell what was going on when specific reactions took place with the player's own actions. Music was very good and of a professional quality and it helped to keep you in the right frame of mind and mood while playing. Sound effects were also endearing of the classic RPGs years ago. Controls were simple and were without problems. The interface is well designed and has all the vital information needed to let the player know how his character is doing on the

main map screen. The inventory screen is very intuitive and allows you to perform many useful actions. A well structured dungeon crawler for gamers who love old school RPGs and good storytelling.

7

86 6

7

6


Demonic Sagahttp://markuss13.narod.ru/ds/

Price: FreeGenre: PlatformDeveloper: Markus_13Platform: Windows

Sadly this game was not completed and polished up more. Graphics are simple, yet clean and some places small, but they're well themed and quite well done. Music is fantastic and adds a lot of excellent feeling to the game. Special effects are pretty cool too. The goal of the story mode portion of the game is to collect all the gems as far as we can tell,

the game and the instructions are after all in Russian so some English translation wouldn't hurt. Controls aren't documented well and are a little hard to work with. Too much scrunching down on the left half of the keyboard and not configurable at all. Dual mode game play is pretty neat, but the AI lacks in the ability to chase or follow the player and often ends is the same face-off at the bottom of one of the maps. Being able to select different dual maps is also a nice feature. Some story would have been nice to read as I played along. The game unfortunately is only a discontinued beta and lacks much of the gameplay that

would have gone into it should it have been completed. Would that it have been completed, it would have been a pretty neat game with a very cool theme. Perhaps this game engine will spawn a new game project.

5

486

24

Game Reviews


Last Dawnhttp://www.csse.uwa.edu.au/awesome/presentation.php?id=44

Price: FreeGenre: Platform / ShooterDeveloper: Scott KerrPlatform: Windows

This game has a great visual quality to it, though it's very simple by design, thats a part of it's beauty. The goal of this game is to survive until the helicopter comes to rescue you and all the people you find stranded out in the zombie infested city scape. During the day you can explore the city and look for weapons and

ammo, but at night the zombie hordes come to try to take out your base. You start with a hand gun, but are able to find other weapons to help fend off the hoarding attacks at night. You can also find survivors who will help head back to the base to help defend it when attacked. There is unfortunately no music for this game, however the cool zombie moans and weapon sound effects make up for this, especially at night when things start to get exciting in the intense rush of running and jumping zombies coming in waves. Who would have thought stickmen zombies could be so intimidating. Controls are fairly

responsive and accurate, however when a lot is going on on-screen it gets a little choppy on slower systems. A well thought out and designed art piece in the form of a zombie platform shooter. Worth a few play-throughs on all modes.

6

777

67

Alexlandhttp://www.svgames.pl/

Price: FreeGenre: Top Down ShooterDeveloper: Super VegetaPlatform: Windows

A decent top down shooter game using familiar graphics. Interface is attractive, clean and easy to use. The game is fun however due to some difficulties with fullscreen mode on bigger screens, mouse controls and being able to see the characters well enough can be a problem. Some minor glitches on large screen displays, however graphics did

display well regardless, they just really small. Music suited the game and added some excitement to the game. Sound effects were pretty good, but some of them were a bit odd and seemed out of place. There were some neat features in the game such as the different weapons and power-ups you could pickup dropped by dead monsters you shot. A kills counter and ammo until reload display were really helpful to have along with the obvious need for a life meter. Gameplay though really simple has an addictive quality which has been proven by other titles of this genre. It would have been nice however to have different

game modes or some other goal than a high score, which was nice to have though. With bigger game sprites this game would be a great start to a game that could have been picked up and played over and over. Good engine!

5

66 4

5

6


Drawn: Dark Flighthttp://tinyurl.com/238m9k5

Price: $9.99Genre: Hidden Object Game / AdventureDeveloper: Big Fish GamesPlatform: Windows, Mac OS X

A great sequel that continues excellent use of colour and visual effects, all wonderfully well drawn. Use of the concept of drawings that come alive and you can jump into them is really creative and the back story plot is really exciting too. Amazing cinematics in between major sections of the game and great music to set the right mood for the game.

Puzzles are very challenging, but there is a handy hint system that will help you if you get stuck and can't remember what task you have to do next. Also should you get stuck on a puzzle, you can skip it after you spend at least a little bit of time

on it which a little meter above will indicate. Game controls are easy to use, except for the odd occasion when trying to close a popup view of a specific zoomed in spot in the scene. The game takes place after the end of the first game where the tower has collapsed and you now have to go into the town to save the little girl and help her become queen. Gameplay is very addictive and is great

for someone who enjoys a good puzzler and creative fantasy adventure with beautiful visuals. Highly recommended to try the free demo which will give you a basic taste of the full game. Awesome release, great game.

8

899

79

Spelunkyhttp://www.spelunkyworld.com/

Price: FreeGenre: Scrolling PlatformDeveloper: MossmouthPlatform: Windows

This small unassuming game is quite the fun underground adventure. The story is simple, you are an explorer searching caves for treasure and excitement. In this game you get both, plus a whole bunch of monsters and traps. Decent down multiple levels finding treasure and items to help you explore and get out of tricky situations. You can collect bombs,

rope and all kind of other neat items that can come in handy. Lets of course not forget your trusty whip to take out those nasty snakes, bats and large spiders. A neat feature is the shops you can purchase bonus items from, just don't try to attack him or he'll shoot you dead. Now for some odd reason there are women trapped down here too. Save them and get extra points, just the same. Graphics are simple yet charming and the music and sound effects are just as nice with a good. Controls are pretty good and kept simple, you can even customize them as well which is a nice capability. The menu system is really

neat. You sort of play it like you do inside the game. Climb out of the cave to quit or go inside a door to start your game. The tutorial is very handy which teaches you the basic moves and gameplay. A great game for platform lovers. Highly recommended.

9

877

98

D elphiX was the first Object Pascal game library available

for Windows. As history turns out, it wasn't until this set of DirectX-based visual components for Delphi, written by Hiroyuki Hori, was released and posted on the internet that making games with Object Pascal or Delphi specifically became as popular as it is today. In fact the initial move to Windows and away from both DOS and Borland's Turbo Pascal compiler practically killed any form of game development with the Pascal language at the time.

You could say that it was Hori and his innovative components from the years 1998 to 2000 that fathered

the current Pascal game development community that exists today. In true to form, pioneering fashion other motivated developers eventually created their own game libraries to improve upon DelphiX. Many were quite successful and more have been released since, but DelphiX started the ball rolling and helped make what our community is today.

DelphiX's last official release was way back in 2000 and has long since been officially abandoned. The fans of the DelphiX project however, just won't let go as it's been kept alive through various unofficial updates and installation fixes, the UnDelphiX project and the latest of the updates by Jaro Barnes who hosts

the last unofficial site for the components on his page at www.micrel.cz/Dx. The original DelphiX components can still be downloaded from Mr. Hiroyuki's site at www.yks.ne.jp/~hori/.


Knight Lorehttp://retrospec.sgn.net/game/kl/

Price: FreeGenre: Isometric Platform / PuzzleDeveloper: Peter HanrattyPlatform: Windows

This is a remake of the 1984 original which was one of the first isometric games made. This very well polished high-end graphics version is pretty fun, but pretty tricky. You spend time exploring a randomly generated maze of rooms where each has deadly obstacles that if touched will take away a life. Some of the rooms have moving knights

and ghosts or other baddies that glow. The main challenge is your ability to aim your jumps in the isometric perspective and often time then when they place a platform piece on top of the head of one of these moving enemy characters. You can pickup scattered objects placed in specific rooms to use as platforms to help you overcome specific obstacles. The game's controls are fairly responsive and responsive however the skewed perspective of the isometric game space can sometimes make determining the exact location of where a platform sits in relation to the room challenging. Special effects are very nice and add some

atmosphere to the game. If you were a fan of the original this one may be for you, but the game mechanics might be a bit too simple for more hardcore gamers. Lots of polish make this a nice showpiece with potential for more.

6

56 4

6

7

Did You Know?

Page 51

Game Reviews

Hori's Book on DelphiX

Documents

PascalGamerMagazine_Issue03