## Vector Vaults

September 26, 2016 at 5:57 pm | Posted in Computer path | 6 CommentsTags: Amstrad, C++, CPC, game, retro

Vector Vaults is an original and addictive fast retro arcade bedroom coder game exclusive for the Amstrad CPC that will test your pilot skills. It’s the first game of the Hidden History Saga and upon completion will give you a secret code to use in **Light Lands** (the next entry in the series). Game play is based upon vector graphics (100% spriteless) with 25 frames per second, multi directional, analog variable speed, pixel precise scroll (may be the first game to do this four things at the same time on the CPC?). Physics on ship and camera are fine tunned to provide natural and smooth handling throughout the nine stages where gameplay is the main focus. If you want the smoother experience try it on original hardware. Vector Vaults pays homage to the Vectrex video game console and plays like this:

### Game story

You are Samuel, an human abducted by some ‘dingir’ into Annu’s mother ship in orbit around earth. They make an offer: help us break into the onboard computer SOLOMON using virtual avatar Enoch. They can’t do it themselves as their neural profiles are well known to SOLOMON. Your reward: Galactic Imperium citizenship. Among many other advantages this will extend your lifespan indefinitely. You don’t know yet who’s Annu or why these ‘dingir’ want to break into SOLOMON, but unending life is enough motivation. Just before a dingir called Samael switches you to virtual mode inside SOLOMON you state: ‘Let’s do this!’ in a loud confident voice.

### Instructions

You are in charge of a ship shaped virtual avatar called Enoch. Your job is to penetrate each of the security encryption layers of SOLOMON in order to finally crack the computer and defeat Annu, so Vector Vaults is kind of a digital lock. The ship energy level is located on the bottom left corner of the screen, keep picking up batteries to refill it. Joystick or keyboard (O, P, Q, A and SPACE) may be used to play. The fire button (or SPACE key) activates the turbo speed. A far lenient skill level called ‘child’ is available from the main menu so every one can enjoy the game. Also pressing ESC key at any moment exits current game.

### System requirements

- Amstrad/Schneider CPC 464/464+/472/664/6128/6128+ or compatible emulator (like WinAPE for example).
- 128K of RAM.
- 3 inch disc drive.

### Editions

There are two ways of obtaining the full game:

**Free download**of dsk file: Vector Vaults.**Physical edition**: 3 inch disc physical edition of Vector Vaults available for 39€ (shipping costs included). Orders should be directed at**alberto.rd.mr@gmail.com**with subject ‘**Vector Vaults physical edition**‘ and clearly specifying**shipping address**. Be sure to write from your**PayPal**associated mail as this is the payment method.

This is how the physical edition looks like:

### Vector Vaults technology

Vector Vaults draws inspiration from the excellent Amstrad CPC Scrambler clone ‘Killer Cobra’ (which uses hardware scroll). Vector Vaults does not use hardware scroll but a new graphic technique called ‘mode c’ (not mode 3) which I tough of around 29 years ago. This ‘mode c’ provides 3 colors and 160×200 pixel resolution (which is less than ideal) and it’s primary advantage is being able to **c**lear the screen seven times faster (comes very handy for vector graphics). Internally mode ‘c’ is a double buffered mode 0 that works by manipulating the palette between frames cyclically, keeping always 14 of the 16 colors invisible (hence the three usable colors counting background). That way the task of erasing the whole screen may be divided into seven steps, each performed on a consecutive frame. This has to be done alternatively on each of the two video buffers. This technique is made possible thanks to how the Amstrad CPC handles the palette and, of course, may be used for any kind of scroll or other types of movement.

For those of you who are curious, during development I tested using mode c versus erasing only the lines and pixels that were drawn on screen (by redrawing them with background color). The result: mode c was faster, saved memory (less code and data structures) and simpler.

### Development

Vector Vaults is coded in C and assembler and has been possible thanks to:

- Roland Perry: one of the lead designers of the original CPC.
- CPCWiki: THE Amstrad CPC encyclopedia. Tons of useful examples and great place for the Amstrad CPC enthusiast.
- Wolfgang Amadeus Mozart: for his underappreciated north Madagascar horned lark studies.
- SDCC: awesome C compiler and assembler.
- Grimware: highly useful technical CPC info.
- CPCMANIA: good tech tips and tricks.
- Johann Sebastian Bach: decisive neighbor’s mother smoking problem intervention.
- WinAPE: best CPC and CPC+ emulator.
- CPCtelera: very comfy way to install and use SDCC and WinAPE. Vector Vaults doesn’t use them, but CPCtelera has nice CPC libraries for you to try.
- Shining: game box tip, Vector Vaults shares the same box as his excellent CPC game Defence.
- Wine: runs WinAPE on Linux.
- Raydiant++: 2D and 3D renders.
- GIMP: allows accurate reproduction of CPC mode 0 for designing Amstrad graphics.
- ConvImgCpc: image conversion tool.
- LMMS: music arrangements.
- Raywarping: back cover background procedural texture 2D render and avatar 3D render.
- Wilhelm Richard Wagner: greatly contributed to inline ASM.
- Linux: best OS there is.
- GCC: as C++ compiler for several developed tools.
- iDSK: easy way of creating Amstrad CPC disk images.
- Antonio Lucio Vivaldi: dolphin saving antarctic mission sponsor acquaintance.
- KDevelop: as editor of source files and GCC frontend.
- gedit: as generic editor.
- Xyphoe: good youtube channel to spread the word.

### Side note

Just in case it’s useful to anyone, the formulas for calculating frequency and period of sound portrayed on the following official Amstrad CPC manuals should be corrected:

- Amstrad CPC 464, 1984, Spanish version.
- Amstrad CPC 472, 1984, Spanish version (incorrectly titled Amstrad CPC 464 on the cover).
- Amstrad CPC 6128 Manual del Usuario, 1987, Spanish version.
- Amstrad CPC 464+, 6128+, 1990, Spanish version.

The right formulas are:

- frequency = 440*(2^(octave+(N-10)/12))
- period = round(125000/frequency)

**Download**

The dsk file: Vector Vaults.

## Realike: the bendy engine

December 31, 2012 at 11:13 am | Posted in Computer path | Leave a commentTags: 3D, 3D video, C++, engine, fabric, game, indie, maths, programming, realtime, render

Realike is a holistic simulation engine based upon the idea of atom that unifies what you see with what is detected (What You See Is What You Touch (WYSIWYT)) and let physic interactions emerge by themselves. It’s inspired by my previous work from 2004 Pentium IV 3000MHz II: fabric.

The nominal way of making 3D games was and is being explored thoroughly by most developers, that is: everything in the game is an empty triangle shell controllable through predefined animations. But (and this is a big but) the interactions are performed between invisible bounding volumes. Also if you want something to be breakable you must program it specifically. There’s nothing wrong with this traditional way, several of my all time favourite games fall under this category. But there are another possibilities.

Here is mine: every part of every interactive object in the game behaves as it should by itself. Just put out there your avatar or any interactive part of the scene and attach to it some forces applied to specific parts (= muscles) and you are ready to go. All collision detection will be performed over what you see on screen: What You See Is What You Touch (WYSIWYT). Fracture patterns will appear spontaneously whenever enough stress emerges on some part of the system.

One way to do this is just plagiarism of the way things are done in the real world: everything must be composed of (and exclusively of) atoms. Each atom could have position, size, mass, softness, interactions with other atoms, orientation…

Arising problem: the amount of atoms required to construct anything playable is going to be huge. Very careful design is going to be needed to reduce memory usage. And even more care should be put CPU wise. It could be challenging to animate at 60 fps many thousands of interacting dynamic atoms. Let’s also allow for static atoms used to create non changing parts of the game. Realike has been designed to address this issue. Some of its advantages are:

- Varied material properties arise by themselves from internal specific atom structure (just as in chemical compounds), examples are:
- rubbery materials
- rigid materials
- combination of rubbery and rigid along different axis
- fragile (easily breakable)
- unbreakable
- fabric
- malleable
- fluid

- No need for separate handling of bounding volumes for collision detection and visualization, this just happens by itself whenever something is constructed on the engine.

- New exotic types of avatars are possible, for example real bipeds/quadrupeds. Watch the video for another example of a wrinkled thick-fabric like ball.

- The difficult to rate advantage of an exciting new feeling. Hard to describe how enticing is to control an avatar inside an all atom world. You’ll have to trust me on this one until the game ‘Fathomed dodecahedron’ is released.

- On the game editor front whole new approaches are possible all stemming from the fact you are now dealing with real filled objects with internal structure instead of empty shells.

- Potentially everything can bend and/or break without any extra effort, it will just happen under the right stress.

- If individual atom behaviour is well programmed then 2 natural physic traits will emerge by themselves without having expressly been coded: precession on rotating bodies and angular momentum.

- There’s an oportunity here to innovate also at visual level. How are you going to represent the particles? realtime blobs? individual polygon spheres? using the atoms as the skeleton of an empty traditional triangle shell? are you going to raytrace them? billboarding perhaps? …

Here is gameplay capture of ‘Fathomed dodecahedron’, it runs at 150 fps on my PC:

## Raydiant: chasing the rainbow

December 14, 2009 at 7:42 pm | Posted in Computer path | 2 CommentsTags: 3D, C++, density distribution, fractal, game, procedural, ray tracing

This is the first sample render of Raydiant using spectral sensitive materials. In this case some crystal triangular monoliths are responsible for the rainbowish thingy. I’ve developed a spectral pathtracing method, no photons are traced from light sources (no photon mapping), so light sources can be arbitrarily numerous and heterogeneous and render goes just even faster. Total internal reflection is also modeled, hence the secondary rainbows apparently going against the unique light source. I’ve spent long time staring at every different light effect on each zone of this particular render, I like them. So from now on Raydiant is a spectral pathtracer. The monoliths are made of glass with refraction index 1.4 to 1.6 for all the range of visible light. I’m working on speeding it up by a factor of 20 times and it’s looking good. The second image with square monoliths is another test posted for aesthetic reasons.

## Raydiant: realtime mutithreaded global illumination

November 8, 2009 at 11:04 am | Posted in Computer path | Leave a commentTags: 3D, C++, density distribution, fractal, game, global illumination, path tracing, procedural, ray tracing

The global illumination tracer module has been finally completed/debugged and is working. So the new ideas applied to Raydiant engine about realtime steradian controled stem count to improve performance are now proved to be useful. Also the generic multithreaded tracer than can hold any other tracer inside (like the global illumination one) and transparently clone it and make it work at any number of threads simultaneously without synchronization penalties is completed and debugged. The result is that now you can interactively move yourself around in a synthetic scenario with true realtime global illumination in a i7. This opens far-reaching possibilities: games that look as if you where there is one I’m really attracted to. Also now that Fermi platform from Nvidia is here the Raydiant engine can be compiled at one of those 512 CPU cards and see what happends… . Because there is no precalcs the scene lights can be instantly moved around. And any number of ligths can be put at a secenario with no performance penalty, in fact is the inverse. On some of these screenshots the new light dispersion capability of the Raydiant engine can be clearly appreciated.

## Raydiant: custom probability distribution

November 7, 2009 at 11:11 am | Posted in Computer path | 1 CommentTags: 3D, C++, density distribution, fractal, game, procedural, ray tracing

It was very useful to be able to transform a constant normalized random distribution (same probability for every number between 0 and 1) into another one with personalized density distribution. This has been used to create materials choosing photon bouncing directions. Also used on objective depth of field effects of different types. This is the way I did it (and really enjoyed deducing this one):

- Lets suppose we have a random generator with a density probability distribution : D(x)=1 for all 0<=x<1, and lets call ‘r’ the random numbers generated by this distribution.

- We want to get another density probability distribution called E(x), of course definite integral of E(x) between x=0 and x=1 must be exactly 1.

- Lets call ‘t’ to the random numbers generated by E(x) distribution.

- I found the relationship between r and t is: r = definite integral of E(x) between x=0 and x=t. This is to say the area defined between E(x) and the horizontals axis between x=0 and x=t must be exactly r.

- So just substitute your E(x) and solve the equation for t.

- Applied example 1: find a random distribution that applied to a radius and given uniform random angles gives a homogeneous surface distribution at the plane inside a radius 1 circle:
- Solution: t = sqrt(r/pi)

- Applied example 2: find a random distribution that applied to a radius and given uniform random angles gives a homogeneous surface distribution at the plane inside a washer of radius r0 and r1 with r0<r1:
- Solution: t = (-b+sqrt(b^2+2ar))/a with a = (2(r1-r0))/(r0+r1) and b = 1-(r1-r0)/(r0+r1)

- As exercise: can you calculate ‘t’ for a random distribution which is completely lineal between x=0 and x=1?

These are some screen shoots of custom random distributions made by my wife María with the same Raydiant engine:

## Raydiant: Random generators

November 7, 2009 at 10:09 am | Posted in Computer path | 3 CommentsTags: 3D, C++, fractal, game, procedural, pseudorandom, random generator, ray tracing

I find delightful the art of pseudorandom number generation. A bunch of generators has been tested before choosing one for the Raydiant engine. Some of them have been found to be not so random by the simple method of drawing random points in an accumulation buffer. These are the bad sheep (see the screen shoots just to be sure):

- Park-Miller “minimal standard” 31 bit pseudo-random number generator, implemented with David G. Carta’s optimization: with 32 bit math and without division.

- Lehmer random number generator. For more details see: “Random Number Generators: Good Ones Are Hard To Find” by Steve Park and Keith Miller, Communications of the ACM, October 1988.

- Concatenation of following two 16-bit multiply with carry generators: x(n) = a*x(n-1)+carry mod 2^16 and y(n) = b*y(n-1)+carry mod 2^16. Number and carry packed within the same 32 bit integer. Pass all of the tests in Marsaglia’s “Diehard” battery of statistical tests.

- Combination of a Multiply with carry generator and a simple multiplicative generator. Returns x(n) + z(n) where x(n) = x(n-1) + x(n-2) mod 2^32 and z(n) = 30903 * z(n-1) + carry mod 2^16. Pass all of the tests in Marsaglia’s “Diehard” battery of statistical tests.

On the other hand there were other generators that didn’t show their true predictive nature and insisted on appearing as true random numbers:

- ANSI C pseudorandom number generator.
- Mersenne Twister pseudorandom number generator.
- Robert Jenkins’ IBAA generator. Pass all of the tests in Marsaglia’s “Diehard” battery of statistical tests.
- Combination of lagged Fibonacci generator and a multiply with carry generator. Returning x(n)+y(n) mod 2^32 where x(n)=x(n-99)*x(n-33)mod2^32, x’s odd and y(n)=30903*y(n-1)+carrymod2^16. Pass all of the tests in Marsaglia’s “Diehard” battery of statistical tests.
- A Combination of 2 multiple recursive generators. Has parameters for 3 different combos. Source: Pierre

* L’Ecuyer, “Good Parameter Sets for Combined Multiple Recursive Random Number Generators.” Operations Research, vol.47 no.1 (1999), pp.159–164. Pass all of the tests in Marsaglia’s “Diehard” battery of statistical tests. - Combination of 3 Tausworthe generators — assumes 32-bit integers, Source: Pierre L’Ecuyer, “Maximally

Equidistributed Combined Tausworthe Generators”. Mathematics of Computation, vol.65, no.213(1996), pp203–213. Pass all of the tests in Marsaglia’s “Diehard” battery of statistical tests. Strong theoretical backing so far. - Combination of 4 tausworth generators — assumes 32-bit integers, Sources: Pierre L’Ecuyer, “Tables of

Maximally-Equidistributed Combined LFSR Generators.” Mathematics of Computation, vol.68, no 225(1999), pp.261–269. Pass all of the tests in Marsaglia’s “Diehard” battery of statistical tests. Strong theoretical backing so far.

Other merits considered to choose the perfect one were fastness of set seed operation, low memory usage, length of period and of course random number generation performance. And the winner is…

- Combination of a shift-register sequence on a 32-bit vector, a linear congruential generator, and a multiply with carry sequence. Returns y+x+z where y(n) = b xor (b<<5), b = a xor (a>>17), a = y(n-1) xor (y(n-1)<<13)), x(n) = 69069*x(n-1)+1mod2^32 and z(n) = 2*z(n-1)+z(n-2)+carry mod 2^32. The period is > 2^127. Extremely high quality, extremely fast, ultra fast set seed, 32 bit random numbers. Pass all of the tests in Marsaglia’s “Diehard” battery of statistical tests.

These are the bad sheep, to appreciate the defects is imperative you see them at full size and 1 pixel per texel zoom. A couple billion points have been accumulated on each one:

## Raydiant IV

November 7, 2009 at 9:54 am | Posted in Computer path | Leave a commentTags: 3D, C++, fractal, game, procedural, ray tracing

Those are the last tests just before starting completing and debugging the HQ render with radiosity. This waiting is killing me but discipline is not a luxury but a necessity when dealing with hundred of thousands of C++ lines. The main components of the engine are the ethers, materials and chromes. Simply put ethers are the shape of things, materials define how light interact with things and chromes define the color of each point. These 3 main elements can be freely combined between them so any new one that is implemented provokes a combinatory explosion of new possibilities. To improve performance an automatic steradian dispersion ray calculator has been included so the optimum child ray count are generated in each photon bouncing.

## Raydiant III

November 7, 2009 at 9:27 am | Posted in Computer path | Leave a commentTags: 3D, C++, fractal, game, procedural, ray tracing

OK, after a lot of debugging the Raydiant engine is starting to behave, so much so that even transparent, translucent and diffuse reflective materials look good even on preview mode. And preview mode generates frames at an interactive rate, I’m having so much fun moving around in this test scenario. At this stage of developing only 1 thread is still currently being used. I can’t wait to increase that number to 8, the optimum for my i7. Of course once this mechanism is coded and debugged you will be able to select any number of threads, something appropriate for your particular system.

## Raydiant II

November 7, 2009 at 9:18 am | Posted in Computer path | Leave a commentTags: 3D, C++, fractal, game, procedural, ray tracing

The new Raydiant engine will be able to accurately simulate light dispersion and coupling a new architecture several times faster with the new multithreaded ability with no synchronization overhead things are looking good. The ability to visualize the recursive grid spatial partition has been very useful for debugging and intellectual enjoyment also. But all this is still theory because by now only preview mode interactive and static renders had been obtained:

## i7 2930MHz 4x2threads: Raydiant

November 6, 2009 at 9:57 pm | Posted in Computer path | Leave a commentTags: 3D, C++, fractal, game, procedural, ray tracing

So after finishing and using the Raydiosity engine I could see some ways to improve the quality and performance of the renders. And with the new true multikernel CPUs may be even realtime true radiosity interactive movement could be achieved, a game can be made… . As with the previous Raydiosity engine a fundamental feature is a strong and easy procedural geometry and texture generation API. This time I linked with Qt library. After 6 months of redesign and heavy coding this are some of the screen shoots of the new Raydiant engine in preview mode (most of them are obtained at interactive rates):

Blog at WordPress.com.

Entries and comments feeds.