editorial / december 06

While most of us are probably only just coming to terms with the impending event that is Christmas, it was a sobering thought to realise that this is actually the final issue of 2006. While so much has happened this year it felt strange writing a re-cap of events given we've still several weeks of 2006 left. Rather than dwell on the past, let's look to the future:

Next year will see the consumer launch of Windows Vista, and with it DirectX 10. Make no mistake about it, this is the future of Windows, and we as a company will be embracing this change with much gusto. Infact we've been embracing it for some months now, and DBPro DX10 is already powering the FPS Creator X10 engine, as you'll read about in this issue.

We see Vista as being unique for TGC. Never in the history of the company have our products had a chance to be totally re-invented, from scratch, to operate on a brand new O/S. Vista gives us this chance. It levels the playing field once and for all. Everyone will be starting from the same DX10 base. It does away with so much out-dated technology that DBPro DX10 will be a far sleeker and refined product, shedding stacks of dead-weight in the process. That's not to say we're going to neglect our current range of software. It is still being updated, enhanced and worked on, and we'll have many more new releases for you next year. 2007 is going to be a great year for game makers, regardless of your platform!

Don't forget you can read this newsletter online, which is a much nicer experience if you are stuck within a web mail client. See you next year for issue 48.

Cheers — Rich

contents

(1) Christmas Posting (2) 30% December Special (3) PhysX Hardware Compo Results (4) TGC in 2007 + Video (5) ConvSEO (6) 3D Guru: Modeling a Game character Part 2 (7) NVIDIA Game Dev Compo (8) DBPro Mastery: Invaders Part 3 (9) From the Forums (10) FPS Creator News (11) Lee's Tip of the Month (12) Dark Shader Preview (13) DBPro Tech Tips: Strange Forces (14) EZRotate Tutorial (15) PlayBasic News (16) The Winner (17) Outro

Christmas Last Posting Dates

If you order a boxed item that requires shipping, and you want it delivered in time for Christmas, then it needs placing before the dates below.

Destination	Last Order Date
USA & Canada	11th December 2006
Europe	13th December 2006
UK	17th December 2006

Orders for software sent via download will be dispatched up to the 22nd of December. Please note that we will not be processing any orders from the 23rd to the 26th of December, as we're closed for Christmas break.

December Special Offers

For the month of December we are offering great savings of 30% on four of our top products. Hurry though as this offer expires in 30 days!

DarkBASIC Professional - Buy the fully boxed version of this classic programming language for only $62.99 (€48.99, £34.99). Or if you prefer you can buy DarkBASIC Professional On-line for even less, at only $48.99 (€41.99, £27.99)

Add the power of physics to your games with Dark Physics. The brand new license means you can now use Dark Physics in commercial games for free, and with 30% off it's a bargain at only $41.99 (€31.49, £20.99).

Need to improve the intelligence of your baddies? Then why not try Dark A.I.. With commands to handle all kinds of AI and group interactions you'd be mad to miss-out when it's only $31.49 (€24.49, £16.79).

Finally add some 3D design muscle to your arsenal with Caligari gameSpace. With powerful design and modelling tools, a feature rich animation suite and comprehensive export options you can buy it at the special price of $179.00 (€151.99, £103.99) this month only.

Click here to buy DarkBASIC Professional Boxed at 30% Off
Click here to buy DarkBASIC Professional Online at 30% Off
Click here to buy Dark Physics at 30% Off
Click here to buy Dark A.I. at 30% Off
Click here to buy Caligari gameSpace at 30% Off

PhysX Programming Competition Results

The Hardware part of the Ageia and BFG sponsored Programming Competition ended November 15th and here are the games entered into it:

• Aftershock by Cash Curtis II
• World Demo by David James Westfall
• Paradox by Carlos Wilkes

The battle between first and second place was a well fought one. Here are the winners ...

1st Place - Paradox by Carlos Wilkes

Overview: Your country has been at war for decades, and is nearing defeat, the enemy claims the war was started by an unprovoked attack against their bases and cities, however a recent development in time travel technology has made it possible to even the odds against the enemy attack, it's your job to go back in time and cripple vital enemy positions so that you will succeed in this war.

Judges Verdict: The team behind Paradox have done an exceptional job with their game. Right from the start it has a very good feel about it. The menu system looks very slick and once in the game the action is non stop. You pilot a helicopter and have to navigate over an area that is packed full of tanks and other enemy machinery that are hell bent on causing your destruction. You have to react quickly and move around fast to avoid getting hit while at the same time trying to take down the enemy.

There's a lot of detail in this game from the impressive looking water which splashes when fired at, all the objects on the bridge below you such as barrels which you can use to your advantage as they can be blown up and much more. All of this contributes to a fun, addictive game and so far it's been the best use of Dark Physics that we've seen.

Lee Bambers Review: This game has all the tick boxes checked, a polished game and no mistake. With a little work on the difficulty curve, this could be quite an addictive game. Getting the new players into the action slowly, with fewer, larger, weaker targets would encourage level progression, and a series of warnings when health is low plus the ability to 'collect' health will sustain lastability. A top effort!

This game won the author: USD $1000 cash, BFG 7950GX2 PCIe graphics card, $200 TGC software voucher and a Super Goodie Pack.

Download Paradox - Download the Paradox video (20MB WMV Video)

2nd Place - Aftershock by Cash Curtis II

Overview: At a secret military station a power source was compromised. Domestic terrorists, taking advantage of other stolen technologies, have siezed the base and are preparing to transport the power source elsewhere. You must secure the base and stop the terrorists.

Judges Verdict: As soon as you get into the military base the terrorists start attacking and you have to think and move fast if you're going to stay alive. There's cars driving around, explosions being set off and plenty of terrorists who want to terminate you.

Everything is very well presented and there's a great deal going on in this game. I'd like to tell you more but I struggled to get past the first few terrorists. You can get into vehicles and it looks like there's much more to see but unfortunately I haven't got that far yet. It certainly makes good use of the physics and it looks very promising.

Lee Bambers Review: Great use of explosions and physics based debris, and good use of stock artwork. I would spend some time tweaking the weights of the items in the scene, so the larger items behave themselves, and keep working on the player control system to give the user more manouverability during combat.

This game won the author: 2 x BFG 7900GT SLI or 1 x 7950GX2 PCIe graphics card(s), $100 TGC software voucher and a Goodie Pack

Download Aftershock.

3rd Place - World Demo by David James Westfall

Overview: This game has no objective as such. The basic premise is you find yourself in an area and can wander around and interact with the scenery.

Judges Verdict: The world is quite large there's a good atmosphere with the animated sky, all the buildings, trees and foliage around. But for all the good points about the world it is fairly lacking with regards to the physics. Being able to shoot a stack of crates and see them all tumble down with all kinds of explosions being set off is fun for a while but it can be quite limiting. It's a shame there wasn't more to interact with inside the buildings. Perhaps some simple puzzles would have added a lot to it and also better use of features contained within Dark Physics like fluid and cloth.

While the lack of interaction is disappointing the level itself does look great. It certainly has a lot of potential and had there been more focus on the physics then it would have made for a much better game.

Lee Bambers Review: This demo has potential with its day / night cycles, and a good focus on using physics for things like the particle steam which moves around the player when walked over. I recommend continued development of this engine, incorporating the physics into the actual objectives of the game (i.e. shoot the boxes to discover a passage or way forward).

This game won the author: 2 x BFG 7900GT SLI or 1 x 7950GX2 PCIe graphics card(s), $100 TGC software voucher and a Goodie Pack

Download World Demo.

The Game Creators into 2007

Another year is approaching and the TGC team have plenty of game making ideas that need developing! Our main aims for the year ahead are to build upon the strong product ranges we have in our range.

Starting with FPS Creator, it is already being tweaked and modified and will be converted to work on the new Windows Vista platform which features the awesome Direct X10 graphics engine. New hardware from partner companies like NVIDIA will make real time 3D game development an amazing experience and TGC will be developing affordable tools so that you, the home user, can take advantage of these powerhouse GPUs.

We have prepared a collection of FPS Creator X10 screen shots for you. These are still very early days, and we appreciate we have gone overboard on the effects in some of the shots! but they are all possible to create with the new engine, in real-time. Nothing you see is rendered. Download the zip file (2.8MB) and have a look, we've 7 screen shots for you in high resolution to see.

We were pleased to be invited by NVIDIA to the 8800 Launch event in San Francisco, where we got the chance to promote FPS Creator X10 up on stage infront of the masses, along with the likes of Crytek. We created a video report of the event which you can download and watch. The video shows you a little of what went on at the show, and also interviews Lee about the features and changes that DirectX10 (and DX10 level GPUs) will bring to TGC products.

Download the TGC 8800 Video (62 MB). The video is an MP4 (plays with QuickTime or Windows Media Player)

Once FPS Creator has had a significant spring clean we'll also be working on DarkBASIC Professional. Part of the development of FPS Creator X10 means that we have had to create a whole new 3D pipeline so that the 3D can work on DirectX10. Lee has this working in his labs now, compiling DBPro code to generate the FPS Creator game engine. So a significant part of the engine for DBPro will already be ported to Vista / DX10.

Closer to release is Dark Shader. This exciting new shader tool will soon be complete and allows easy shader creation. Mark my words, shaders are massively important now that Vista will have a base standard of DX10. It might seem that uptake of Vista and DX10 is a long way off but I doubt that this will be the case. The X-Box 360 is only a year old and it feel like it's always been around. On Microsoft's web site they quote these projections: "Industry analysts predict that some 200 million people will be using Windows Vista within the first 24 months of launch."

That's some going and if you remember the uptake of XP. It was very much the O/S to use within two years of release. As developers we are very exciting about the potential of Direct X10 and the power of the new GPUs. It means we can do more in games and we can develop systems that take advantage of all this GPU horse power.

The TGC team thank all our dedicated users for supporting our game making tools. It's your passion for making games that inspires us to develop new tools and add features you request.

Have a wonderful Christmas period and if you're spending the holiday making a game for the NVIDA competition, good luck!

The Google SketchUp Model Importer Plug-In (ConvSEO)

ConvSEO stands for Convert SketchUp-Exported Objects, and that is exactly what this plug-in does. Simply put, ConvSEO combines the incredible ease-of-use of SketchUp with the awesome power of DarkBASIC Professional by allowing you to load SketchUp models directly into your DarkBASIC games with a single command.

To give you an idea of the immensity of the worlds you can create, this sample model measures over 1/2 scale mile across each way... and ConvSEO can load and render it (from a 16 megabyte export generated by SketchUp) in about 6 seconds on a 1.6GHz laptop PC running a mobile CPU.

What can I do with it?

Load and Manage Multiple Models, Using Real-World Units

SketchUp works with dimensions like inches and feet, and these are translated directly to DarkBASIC 3D units by ConvSEO. This means that, if you use the inches scale in SketchUp, then one "unit" in DarkBASIC will equal one inch in your model. ConvSEO can also automatically apply offsets and rotations to models as they are loaded, allowing you to place and orient them as required. Once a model is loaded, you can then hide, show and exclude (on/off) an entire model, or any group within that model, with a single command.

Easily Access Model Information

ConvSEO provides several powerful search commands that let you easily locate SketchUp groups, materials and textures by name. You can then retrieve a wide range of information about any element, and use that information to coordinate your own objects with those in the model. You can even find out exactly which DarkBASIC objects are associated with every part of your model, what their color properties are - including transparency - and which DarkBASIC images are being used to store which textures. The plug-in can also generate a comprehensive report, listing all of this information for any or all models, that you can print out for easy reference.

Conserve Resources and Control DarkBASIC Interactions

ConvSEO allows you to conserve resources by sharing common texture images across multiple models.  When importing from an OBJ file, the plug-in automatically combines geometry that uses the same material, within a group, into as few objects as possible to help maximize your frame rate, and it also automatically splits high-face-count geometry into multiple objects when the number of faces in an object would exceed the DarkBASIC limit of 21844 faces per mesh. Interaction with your own objects, images, memblocks and meshes is also easily controlled.

Enjoy Complete Integration with the DarkBASIC Compiler and RunTime

ConvSEO automatically informs both the DarkBASIC compiler and runtime of its dependencies on DarkBASIC DLLs. This means that you do not have to insert meaningless code into your DarkBASIC applications to ensure that the proper DLLs are loaded. ConvSEO was developed using Microsoft Visual C++ 6.0, and does not require the .NET runtime in order to operate.

Models imported with ConvSEO have also been successfully tested with DarkLIGHTS and DarkPHYSICS. An example application is included that illustrates both.

Here are some useful links:

• Download Google SketchUp
• Access a huge library of models from the SketchUp 3D Warehouse
• Download a wide assortment of SketchUp components
• View a series of SketchUp video tutorials
• Read the SketchUp Users Guide

Model Design Competition

To celebrate the release of ConvSEO we are pleased to announce an on-going mini competition around this product. The competition runs over the period of 4 months with a $100 TGC software voucher up for grabs each month, as well as free copies of ConvSEO. Check out the Competition thread on our forum for details.

ConvSEO is on sale now for $29.99 (€23.99, £16.99) from the ConvSEO web page

3D Guru - Modeling a Game Character - by Mark Blosser

Last month I gave some character modeling and texturing texturing tips for a "peasant girl" character I made for an upcoming fantasy-themed pack for FPS Creator. For this months article I'll be using the male counterpart as an example.

Modeling Tips

In last month's article I showed you how I like to model a human face. To quickly recap, this picture shows the progression of the model.

As I mentioned before, notice how the edges follow the contour of the face. The great thing about modeling this way is because every human face is fundamentally the same, just with different proportions. For this reason, there is no reason to model a face from scratch every time. I was able to use the same basic face model to create the peasant man. It was simply a matter of moving vertices around until I came to the facial proportions I was happy with. In general, the typical male face consists of a wider, more prominent jaw and brow. Men typically have a straighter nose while females have a narrower, upturned "button-nose". In addition, female necklines are tapered in from the jawline, while men have necklines that are straighter and may even taper outward from the jawline, especially for a muscular, hero-type character.

Use smoothing groups to define detail. Smoothing groups are a great way to define sharp creases without adding extra polygons to your model. They can also be used to define facial detail. For these characters, I wanted them to be able to support facial animation. A great way to keep your characters lips looking nice and detailed when animated is to assign each one to a separate smoothing group from the rest of the face.

Take a look at the two models below, they are identical. I purposely made the image fairly small. Which one do you think will look better when your character's lips are moving in-game? Or how about when your character is 2 inches tall on-screen? Keeping them on separate smoothing groups gives the illusion of more detail, and better shading all around. As you can see, this not only applies to the lips, but also the eyelid area as well.

Use can use this for other areas too. In this picture look at how the smoothing groups help define the model. In particular, look how the pants seem to "tuck in" the boots, just by assigning different smoothing groups. This helps with texturing as well. When you bake a lightmap for the purpose of texturing, this shading will carry over.

Texturing Tips

For the male peasant character, I went all out and gave him a 2048 x 2048 texture. When viewed up close, you can clearly see the stubble on his face, the leather in his boots and vest, and even the fine stitching at the seams in his shirt. For this month's tutorial, I'll be covering facial texturing and creating realistic hair in Photoshop.

As I touched on last month, my first step in texturing is to "bake out" a few lightmaps to get my basic shading. All major 3D apps are capable of doing this. First, I'll bake an ambient occlusion map, then I'll assign a specular material to my model and bake out a second lightmap. In photoshop, I'll blend the two together, then use the dodge and burn tools to add some more shading around the eyelids and nose, and arrive at something like the image on the left below:

Next, I'll add a skin texture on top of this on a separate layer, and set the blending mode to multiply. Already it looks pretty darn good, and I haven't even done anything yet! Since the face occupies a space of nearly 1024x1024 on my UV map, I was able to overlay a skin texture with plenty of detail and natural imperfections, as can be seen on the right in the image above.

Now is when the fun really begins, when we start to add the details. Using a very low opacity brush set to overlay mode, I painted in some red blotches around the cheeks and nose. Go EASY here, it's tempting to overdo it. But the slightest amount of color will make a very big difference on your character.

Next, it's time to add some eyebrows and some faint stubble to his face, it is a man after all. You'll want to get yourself some nice hair brushes for Photoshop. I used the excellent and free Nagel hair brushes, which can be found with a Google search. Then, on a separate layer set to overlay mode, simply brush on your facial hair! Using a graphics tablet is useful here, as you can set your brush size to correspond with pen pressure, useful for creating tapered strokes.

Use the same technique to create your stubble. The Nagel brushes have a good selection of brushes suitable for doing short stubble to thick beards. Once you are happy with your facial hair, try applying a drop shadow layer style. When used subtly, it greatly adds to the realism, because even tiny hairs cast a small amount of shadow! Here is a close-up of the finished face texture.

For the hair on top of the head, again I turned to the Nagel brushes, and found one suitable for medium length hair. The great thing about these brushes is that you can control the flow of the hair with your mouse or graphics pen.

The idea is to slowly build up strokes to give depth to the hair, and change brush modes from time to time. For example, I'll usually start brushing in multiply mode, then change to overlay or maybe color dodge mode. Below shows the progression of the hair texture:

Next month I will cover some normal mapping tricks and techniques. Please feel free to email me any questions / comments.

NVIDIA and TGC Game Dev Competition

We are now a few months into the NVIDIA Game Dev Competition - and it's still not too late to enter! Things are looking extremely hot over on our Forum, with stacks of quality looking games making an appearance, including some awesome work in progress videos. Here are the competition details for those who haven't yet heard about this (and if you are one of those then DO take part, there are great prizes on offer and a real community buzz going on that you can join with.)

Split into two sections, one for FPS Creator and one for DarkBASIC Professional, there are some incredible prizes up for grabs, and a long healthy deadline too. Most of the deadline lays across the festive holiday period, so once you are stuffed with Turkey and have got bored with Wii Sports ;) you can turn back to FPSC/DBPro and carry on with your masterpiece. After all you would be insane not to enter this contest. Not only might it net you some great hardware, but also a potential publishing deal too. Here are the details ...

FPS Creator (Deadline: 16th January 2007)

Calling all FPS Creator users out there: Enter this competition and you could win a complete brand new PC set-up, cutting-edge NVIDIA graphics cards, or even a potential game publishing deal!

The task is to create a 1 level game in FPS Creator.

The level should be no larger than 15 x 15 x 5 grid units in size (that's 15 units square by 5 units in height). Into this relatively small space you need to cram as much gaming action as possible.

We will then judge all of the entries and pick out 5 winners.

The Prizes

• 1st: A complete PC system for the US
• 1st: A complete PC system for the ROW
• 2nd: A new NVIDIA 8800 graphics card
• 3rd: An NVIDIA 7950 GX2 graphics card
• 4th: An NVIDIA 7950 GX2 graphics card

Two '1st Prizes'? That's right. We've two complete PC systems to be won. One is for the best game coming from the US. The other PC system is for the best FPSC game coming from anywhere else (ROW = 'Rest of the World')

Each of the winners will be considered for a Publishing Deal. That's right, you could see your game on store shelves. If of a high enough quality the winning game/s will get funding to be developed into a full title. Upon satisfactory completion it will be published worldwide by Mastertronic.

Visit the FPSC Competition site for the rules and details

DarkBASIC Professional (Deadline: 16th February 2007)

Fire-up DarkBASIC Professional (we've a free trial version if you don't own it) and start coding to be in with a chance to win some great prizes in our biggest programming competition ever. Up for grabs are full PC systems, SLi motherboards and the latest NVIDIA graphics cards.

The task is to create a game using DarkBASIC Professional.

There are no restrictions on the genre, so anything goes. From a modern-day styled FPS, to a shoot-em-up, a cerebral puzzler, a platformer, or even a retro inspired remake; the choice is entirely yours. All games will be judged equally.

The Prizes

• 1st: A complete PC system for the US winner
• 1st: A complete PC system for the ROW winner
• 2nd: An SLi Motherboard and 2 x 7950 GX2 cards
• 3rd: An SLi Motherboard and 2 x 7950 GX2 cards

Two '1st Prizes' ? That's right. We've two complete PC systems to be won. One is for the best game coming from a developer living in the US. The other PC system is for developers living anywhere else (ROW = 'Rest of the World')

Competition Update: All games entered into the DarkBASIC Professional Competition will also be considered for a publishing deal by Mastertronic. If they like what they see, they will consider funding your game to be developed into a full title, and upon satisfactory completion it will be published worldwide by Mastertronic. Create something special and you could see it on store shelves.

Visit the DBPro Competition site for the rules and details

DBPro Tutorial - Space Invaders, Part 3 - by Steve Vink

Big Changes, Fast! One of the distinct advantages of putting in the effort to build a framework into which our game can be dropped piece by piece, is the speed at which it comes together in the final stages. It can inspire new features and functionality, simply because the process is now so simple!

Hopefully the pattern we are following is becoming clearer, and big changes will happen fast now. Work through the following stages, and investigate the changes at each step. Each stage is much more densely populated with actions, including acting on keypresses and firing at the invaders. Don't worry about the intricacies of each action, but study how the state engine has been built up using functions, and especially how each function is designed to act solely on one cycle of the program. The engine does the cycling, the actions react to one moment in time. Note also that the results of actions change the state of the engine.

Stage 7 - The player movement keys are added in checkKeys(). The movement is just the small step the player takes in one cycle. It is also immediately obvious that the base speed is too slow. It is quickly located in the Init() function, where we set up our data, and remedied. The function also checks if the spacebar is pressed to fire, and sets the bullet position and state accordingly. We now have moving invaders, and a moving player. The bullet is initiated, but no more.

Stage 8 - Here, we have implemented a new function, checkBullets(). It checks the state of both player and invader bullets, implements the collision with other valid objects, and triggers new invader bullets at random intervals. It does not yet handle the destruction of entities. Again, this highlighted the need to increase the invader bullet value in the Init() routine. It also displayed an unwanted feature, and that is the bullets passing through lower invaders. This was quickly fixed by disabling the Z-depth of the bullets, effectively forcing them to the front without having to make big changes in the positioning of objects in our game. Again, it is easily located in the GameInit() function, where we create our 3D objects.

Stage 9 - The Mothership has been actioned by using a new function, checkMothership(). We create a random factor in causing the mothership to appear, apply the movement (on a single cycle basis), and check when it disappears. There's not much else to do, as the checkBullets() function actually determines the destruction of the ship by the player. Again, the original estimate of speed was too low, and this has been adjusted in the Init() routine. We will continue to fine-tune the characteristics of the game as we progress.

Given that the entire code to bring the ship to life is a mere 15 lines, this stage also implements the objectsReposition() code. Although the primary role of this function is to put all the objects in their starting positions, it also sets the states of the objects too, and their visibility. The animation of the invaders has also been very simply added in the invadersAnimate() function.

Stage 10 - Now we have added the destruction of invaders, and the Mothership. This has necessitated an additional variable to count the number of hits, and ensure we know when the full array of invaders have been eliminated. This in turn will force a new state, to end the Level, and ultimately to start a new level. Destruction of invaders occurs in the checkBullet() function, in the code we have already established. Now we have additional information on the number of destroyed invaders, another traditional feature of Space Invaders can be implemented in the moveInvaders() function. The speed can be increased as the number of successful hits increases, and this has been done.

Stage 11 - Now is the time to add destruction of the player, again in the checkBullets() function. We have already detected collision with the player, it just doesn't do anything yet. Once added, the progression of states will expand to include the Dead state, and of course the game can also end. While we are adding this essential operation, and it is necessary to add a variable to the Player type to register the number of lives left, we'll also add a variable to record the score. We can register the score at each invader and Mothership hit. To prove it is working, a simple text output to the screen is implemented for now.

A further modification that has come to light only now is that the 2 states Dead and End of Life are in fact a duplication, and only complicate what is otherwise a much simpler process. So the End of Life state has been removed. This is a prime example of the rapid development process, where the original design is fluid and susceptible to change. It also accepts change quite willingly.

Stage 12 - We are getting close to a completed game. Models can now replace the placeholder primitive objects, and unwanted items such as the collision boxes can be hidden. This is the point at which the game visually changes into something worth presenting. In addition, the collision of invaders with the bases is added, and this action ends the game by setting the player state to Dead, and reduces the lives to zero. This action takes place in the invadersMove() function, the most appropriate place to test for the objects descending onto the bases. To add interest to the player object, it now rotates as it moves. This is naturally located in the checkKeys() function, where we test for and move the player in response to the user input.

Stage 13 - Now we will add the sound effects. This involves several areas:

• Constants - to define the sound numbers
• Loading and unloading the sounds in the GamePlayInit() and GamePlayDeinit() functions.
• Triggering the sounds at the different points - firing a new bullet (checkKeys()), hitting a target and being hit (checkBullets()), and the appearance of the Mothership (checkMothership())

Stage 14 - This final step simply adds feedback in the form of the score and the number of remaining lives. As this is a permanent feature of the in-game display, it is not placed in the SELECT clause, but just prior to the screen update. Also added is the final score, before the game returns to the menu. Simple High Score functionality retains the best attempt to date, and is loaded and saved as necessary, in the init() function and the Game End state

Conclusion

Believe it or not, we have just completed our game! It may not be the most sophisticated version of Space Invaders ever created, but there's nothing to stop it being updated, improved and finely polished. It's written in a way that makes the maintenance simple, even as far as adding new in-game features by adding self-contained functions. There's potential for explosions, particle effects and cut-scene sequences. You could add power-ups and special features without too much difficulty, and by following the same process as we have used so far.

Until next time, Happy Coding!

Download this tutorial. Read Part One and Part Two.

From the Forums

While forums worldwide explode in the heat of flames about 360 vs. PS3 vs. Wii, here we present a rather more docile, but no less interesting selection of current hot topics worth checking out ...

FPS Creator Newsfest

November was an exciting month for FPS Creator. Not only have we been busy on the Windows Vista / DirectX 10 version of it, we also got to present this release at the NVIDIA 8800 Launch event in San Francisco. As work on FPS Creator X10 progresses we're also busy updating the current version, with Upgrade 1.04 RC4 now available, and new Model Packs also on the way.

FPS Creator Upgrade 1.04 RC4

This is Release Candidate 4 of the new FPS Creator Upgrade. This beta upgrade incorporates lots of new changes including the ability to have fog in your levels, an optimised sound manager, increased loading of enemies, increased resource for attachments, capped player speeds and more.

You can download and test RC4 if you are registered on our forums by going here. Please note that this is a beta release of the Upgrade, and as always you should back-up your work / files before trying it.

The Commander Josh Chronicles published

Congratulations to Benjamin Aeilkema for getting his FPS Creator built game published by Manifesto Games: "Looking for a single-player, level-based FPS with the feel of Doom or Serious Sam, and not all that interested in getting pwned by smack-talking teenage jerks with way too much time on their hands in online play? Then Commander Josh is the thing for you." The game is on sale now for $9.49 and a 2 level demo is available to download.

Umbra

Our head boss guy Rick Vanner totally loved this game, and asked that it be included in the newsletter so everyone could check out its weirdness! The description from the web site goes like this: "Umbra is a new game creation from Peanutbutter media. Created by JJ Ribbins and Ali Wrigley, Umbra is a journey into a bizzare dream. This episode is a pilot, we want to know what you think, and if you like it, Umbra may become an episodic series with new dreams every few months. The aim of Umbra is to walk through your dream, and try to get out. Listen to sounds, look for symbols, and occasionally fight in an effort to survive until you wake up!"

Grab it, view shots and read the comments at: http://www.peanutbutterfingers.co.uk/umbra.htm

Medieval / Fantasy Pack

GameFun.4u have released their Medieval / Fantasy Pack for FPS Creator. The Pack is ready to use, no extra work needed, all Textures, Fpe files and .X model files are included. Just install and pick the wanted items from the FPSC libraries. It includes (taken from the web site): 89 segments, including 2 types of gates, 4 types of doors, 11 types of walls, 4 types of windows, 9 types of roofs, 2 types pallisades, 7 types gantries and some floors/ceilings. 52 static entities, including beds, table, chair, bench, cooking pot, paintings, chapel/church items (candle, pew, cross pulpit), weaponstands, swords and shields for wall mounting, wardrobe, plates, cups and much more.

Videos, shots and a 'Buy Now' link can be found at: http://www.gamefun4u.nl/page17.html

Dark Faction Free, and Dark Faction 2

Dark Faction is a complete game created in FPS Creator V1, with a good involved plot and interesting level design. We've featured it a few times in the past, and even feature it on the FPS Creator web site. The authors have decided to release the full game for free, so definitely check it out and leave them some feedback. They also posted to our forum details about Dark Faction II, which looks like it could be great fun, so we wish them all the best with it.

TGC Disclaimer: Please remember that The Game Creators provide newsletter information for your own use and do not support the products listed above. I.e. while we believe the traders to be responsible and honourable, we can't bail you out if they foul up an order.

Lee's Tip of the Month - X10, the Future

We recently announced the development of FPS Creator X10, a new product we plan to release next year to support the new Vista operating system and the new line of DirectX 10 graphics cards. In fact, we managed to get TGC on stage, in front of enthusiasts, engineers and journalists, at the launch of NVIDIA's GeForce 8800 in San Jose, California. No small thing.

What made X10 so news-worthy was the notion that it will be one of the first game making products on Vista which allows anyone to create a DirectX 10 game without the need for artistic or programming skills. Further, it will be one of the first development products overall that exclusively supports the new DirectX 10 architecture.

My tip this month is to prepare yourselves for this future. Not through new hardware, but through knowledge of the things you will need to know. First of all, there is no 'standard' way of rendering through a DirectX 10 application, as everything is driven by shaders, EVERYTHING! That means a shader is no longer the optional extra of yesterday, it is the universal language of the GPU and is going to redefine the way we make games.

More and more, development of a game will involve the development of shaders, not just for graphics but physics, AI and general math. Prior to DirectX 10, there was no way to extract data back from the GPU efficiently. Now you can, and you can bet that this stream-out feature will become as common place as bump mapping in years to come. An understanding of shaders now will become your strongest ally in the future!

TGC have provided easy and powerful game making tools for over six years, and we aim to provide them for another six years. We are dedicated to supporting the tools and community we have today, and determined to provide new tools as technology changes. X10 is the name we have given to this shift in technology, and rest assured when you decide to upgrade we'll have the software ready for you.

Dark Shader Preview

In Issue 45 we gave you a preview of the new TGC package Dark Shader. In this update we'll show you some new features that have been added to Dark Shader.

Project Files

These contain all information about the currently loaded model, shader, and textures so you can save your current workspace and share it with others.

Object Library

All models, shaders, and textures can be accessed through an object library browser where you can choose which objects you want to work with. These are added to the object bar on the left of the application to allow quick and easy access to your selected objects. The list of objects in your object bar is also saved with the project file.

Lights

This option allows you to see what your shader looks like with different lights without having to modify the shader code. Some lighting shader examples will be included to demonstrate what shader variables are used for this.

Fullscreen Shaders

As well as shaders which affect how an object is drawn DarkShader now supports fullscreen shaders which modify the entire look of the screen. You can have one object shader and one fullscreen shader active at the same time and you can quickly switch between which shader you want to control. Fullscreen shaders will also have more support in DBPro to the point where a long complicated fullscreen shader can be reduced to just a few commands without having to create a camera for every pass.

Unfortunately tree view modification is not expected to make it into the first release.

Dark Shader will be ready for beta testing soon.

Tech Tips - Strange Brew Forces - by Grant Clark

Hello fellow DBP'ers, Getting dynamic movement and behaviour into your games game be an absolute pain if your fairly new to programming. This month I want to show you a simple way of adding some strange properties to your in-game baddies, to do this we will play with faked forces. These forces can be used to effect your on screen objects and mainly deal with attraction and repulsion, the force of attraction and repulsion can create some very interesting behaviour and can lead you to think about games you would have never considered making before. Repulsive forces can hold objects apart from each other, and attractive forces can bring them together. By combining the attractive force with the repulsive force we can get some fairly complex looking behaviours from some simple rules. we'll be working in 2 dimensions based in a 3d environment for simplicity, but going full 3d with faked forces is only slightly more difficult.

For our first example we'll have a mouse controllable shape that exerts a repelling force on another object and explain the relevant parts of the process, the object that exerts the force feels nothing so allways remains under your control. Check out example_01 in this months download. The first example looks rather bland but it's only to show the principle, remember these are not real life forces, but faked forces.

As you can see from running the example, the red diamond pushes the blue sphere away with a preference to the diagonals, let's explain whats going on and how it all works. First of all we need to know the distance between the 2 objects, this can be done using a simple function that uses a vector length operation to return the distance, this might sound like a complex operation, but in reality it's simply the distance between 0,0,0 and another set of coordinates in 3d space. If we subtract one objects set of coordinates from the other objects coordinates, we can determine the distance between them by asking the vector length of the new set of coordinates, simple. Don't worry if vectors scare you a little, they give me the shivers too, and we don't need to deal with them any more after this operation. Our function is called get_distance_between(x1,y1,z1,x2,y2,z2), where the parameters are the co-ordinates of the 2 objects to test and the returned value is the distance in DBP units between the 2 objects.

distance# = get_distance_between(xpos1#,ypos1#,zpos1,xpos2#,ypos2#,zpos2)

Now we need to calculate how much the player object is repelling the other according to the distance between them, we will call the result of the calculation the acceleration value. You will notice in the calculation that we divide by a squared distance value, this gives the repulsive force a falloff similar to that seen in nature. The repulsive force will allways be present, but will falloff to a value near 0.0 very quickly and eventually have no noticable effect on the other object. The initial amount of acceleration is the maximum amount of acceleration the object can possibly push another object with. An element of tuning is needed here depending on the scale of your environment)

accel# = max_accel_amount# / (distance#^2.0)

Now we know how much acceleration should be applied to the object, we need to determine what directions on the X and Y axis to apply the acceleration value. This is done using simple logic to determine if the second object axis is higher or lower than the axis of the first object, and wether it's to the left or the right of the first object, so it's the same operation on both axis. if the second object is above the repelling object, we want to push it up by adding the acceleration value to its current velocity, if its lower we want to push it down by subtracting from its current velocity, the same is true of left and right, with left being lower and subtracting from the velocity, and right being higher with addition to the velocity. Really simple stuff.

if xpos2# < xpos1# : xvelocity2# = xvelocity2# - accel# : endif
if xpos2# > xpos1# : xvelocity2# = xvelocity2# + accel# : endif

if ypos2# < ypos1# : yvelocity2# = yvelocity2# - accel# : endif
if ypos2# > ypos1# : yvelocity2# = yvelocity2# + accel# : endif

If you want your objects to slow down after being repelled, you'll need to have some sort of friction system in place to slow down the object thats being repelled, this is simply done by dividing the X and Y velocities by a value greater than 1.0, this value is also subject to tuning for the desired effect in your production. Friction is optional and your game may not require friction. By simply flipping the + / - part of the above code, our repelling force now becomes an attracting force in a game, so its possible to have some game elements as attractors and others as repellers, just by flipping the direction in the logic.

Now we must add the new velocities to the second objects stored position, this updates the object with a new set of coordinates, then we physically position the object at those coordinates. Now we repeat the whole process over and over again, the effect is like trying to push 2 magnets together, the closer they get the higher the repulsive force. It is possible to have lots of objects repelling each other in a game, and the second example shows this. You can click the mouse to turn the players repulsive force into an attractive force, and the enemies on screen will allways try to stay away from each other.

In the second example I have also added forces to the screen edge that will push the blue enemies away. You should play with this example and think about how you can work this principle into your games to make them more interesting. The amount of possibilities for simple but fun games is amazing, apply it to shooters to have gravity wells and repulsive hazzards etc. The more dynamic the game becomes, the more fun and interesting the overall thing will be. Don't settle for bland linear motion in your games, get into the swing of adding forces and see your work in a new light.

Till next month, Cheerio :D

Download the Strange Forces Code 3.9MB

EzRotate - Understanding Rotation Tutorial

Steve Vink and has written this special tutorial on how to use the excellent EzRotate DLL for DarkBASIC Professional. The tutorial is no less than 12 pages in length, has 5 sample projects and even comes with a special time-limited version of EzRotate, so even if you don't own it you can still check out the tutorial and see just how powerful it really is.

Here is part of the introduction to the tutorial to give you an idea of the topics covered ...

Making an object follow a mouse sounds quite simple. And under certain controlled conditions it is. If the camera is oriented at 0,0,0, and your subject is directly in front of the camera, simple calculations can move the object left to right, up and down.

But what if the camera isn't simply facing forwards? Worse yet, the camera may be in no particular position when the call is made to drag the object across the screen. It could be behind the object, above the scene, looking down from an unspecified angle or even upside down. EzRotate has the functionality we need to deal with any of these scenarios.

Click here to download the tutorial, including all the examples and time-limited EzRotate.

PlayBasic News by Kevin Picone

November will no doubt go down in PB history as a month dedicated to rounding out the edges. Often so much focus is put into engine related concerns that other important aspects get pushed aside. So this month we've been fine turning everything, ranging from adding support for Type Collections, Type Pointers, complex Type assignments, FX fonts, Compiler Status Window, Syntax Highlighted Help files, various Debugger improvements and the further integration of our VM2 runtime technology. Plus the regular sprinkling of new commands and support libraries.

The New Age of Types

With release v1.59 we've made nice step towards rounding off the type collection / typed pointer features in PB. Which are fast becoming an incredibly powerful addition to the language. While nothing on the surface is that different, the biggest change relates to the the new addressing modes for typed variables and arrays. We now have three basic controls over addressing, those being "handle", "element" and "pointer". While that's fairly self explanatory to some, lets pick through it a little.

Handles - Handles refer to the entire variable/array structure and ALL of the elements that this structure contains. To address a Type variable/Array as a Handle I've streamlined the syntax a little and added support for short cutting these references using () token, just like normal arrays. So the type name isn't required.

Element Addressing - When we address the element were reading/writing into the types structure. Where not addressing the data fields within a particular type instance here though, just the containing structure that holds them. You can query the type of any returned element, using the "TypeOF()" function. This Function returns the [u]Type INDEX[/u] of a queried element. Both type variable and arrays can house not only types of their parent type declaration, but child types (types inherited from the parent) also. So you could store everything in the one array or variable if you like!

Pointer Addressing - Pointers give the address in memory of a particular type instance. So by pointer uses the address of this type instance (the first field in type), and not the structure if came from. You can get a pointer to any instance by adding the ."TypeName" after addressing the element. You can also get the pointer to any nested types. This allows us to copy type structures between instances directly. Moreover you can write totally generic functions that accept/return typed pointers. Were previously we would have passed the type array/variable handle, which meant passing the entire structure rather than a single instance ... Which could be a little painful at times.

Typed Variables = Typed Arrays

Behind the scene type variables and arrays are really the same thing. While compiler generates slightly different code when reference the two, the structure they use are identical. Now while structurally the same, the compiler used to treat them as two separate entities, in particular when passing them into functions, but not anymore. Previously if you declared a function that accepted a typed array as an input parameter for example, then you could only pass a similarly typed array into this function. Which occasional presented a limitation, when writing generic function libraries.As sometimes you might be working with a variable, and not an array. But still wish to pass it in and there you were stuck, but not anymore.

Another not so obvious ability in regards this with type variables and element addressing (above) is that you can now roll your own generic list functions for dealing with list inside a type variable. So if your functions are based upon a parent type, then you can use inherence to spawn new typed variables from this parent, which can then act as lists when passed into your list functions. The benefit of this can be you could store lists of items within a variable and thus not have to use the "index" when managing them. Which you can also do using Typed Pointers above. So it just gives you more options!

From the PlayBasic Forums

This month we've seen those crazy guys at [b] Team Calypson [/b] produced another complete game in 72 hours. I'm constantly impressed by what these guys produce.

• Mag-Man :: 72 hour entry
• Scramble Destructible Terrain
• Destructible Terrain
• Input Box
• Terrain /Particles Example (Cold Steel)

Well, that's enough to chew on for this month. PB1.59 is available for download for TGC and UW customer at the time of writing. But before I go, I'd just like to take this opportunity to wish all those in the TGC / PB's community a happy a safe holiday season.

This months Winner

Each month we pluck one lucky subscriber from the newsletter mailing list and award them a free copy of DarkBASIC Professional. The email address of this months winner is: ????@digitaldreams.?????.co.uk. If this is you then send me an email to claim your prize.

Outro

Share your news with over 13,000 active games developers!

If you have something you'd like featured in a future issue then please get in touch and include as much information as possible (including where applicable: screen shots, URLs and zip files).
Issue 48 deadline - January 28th.

Flon's Law: "There is not now, nor has there ever been, nor will there ever be, any programming language in which it is the least bit difficult to write bad code."

The Game Creators in no way endorse or support products mentioned in this newsletter that are not specifically published by them. Always check first before parting with your money. © The Game Creators Limited 2006.