The radiolaris family is getting bigger! In the coming weeks we’re going to merge our operations with our longtime friends and office colleagues Broken Rules, makers of the fabulous PC/Mac & upcoming WiiWare platformer And Yet It Moves.

“And Yet It Moves is a puzzle-platformer, set in a unique world, made of ripped paper. Within the paper collage, you can jump, run and last but certainly not least: rotate the world. Learn how to apply the physical consequences of rotation to master the many tricky situations you may encounter.” (andyetitmoves.net)

studio radiolaris and Broken Rules first worked together on the iPad 4-player classic Globetrotters. We are currently in the research and prototyping phase of a new game that’ll boldly fly where no man has flown before. Stay tuned for updates!

Our existing games will become part of the Broken Radio Games brand, an experimental games label that features game jam results, prototypes and full-fledged games for new platforms like the iPhone and the iPad.

Broken Rules is a licensed Nintendo and Sony developer. We’re happy to have the opportunity to work on larger and more diverse projects while staying an independent studio, although a new one. As Broken Rules we’re also able to take on more contract work. Feel free to drop us a line if you have an inquiry.

Follow @brokenrules or @me to stay up-to-date with us.

I also thought it’s wise to keep it compatible with 8bit computers so I truncated the number a great bit. It actually doesn’t matter too much, but I’d not use this code unchecked in production. Myself, I use it for building levels and I just need 999 different ones.

Generate an unsigned int pseudo-random number based on seed “seed”:
#define SONA_PRANDOM(seed) \
((unsigned)((seed * 1103515245 + 12345)/65536) % 32768)


Generate a float16 pseudo-random number based on seed “seed”:
#define SONA_PRANDOM_FLOAT(seed) \
(((float)SONA_PRANDOM(seed)) / (float) (1<<16-1))


Select x, y or z from a set:
#define SONA_PRANDOM_FROM_SET3(seed,x,y,z) \
(SONA_PRANDOM_FLOAT(seed) > 1.f/3.f ? (SONA_PRANDOM_FLOAT(seed) > 1.f/2.f ? x : y) : z)


Generate an int between __MIN__ and __MAX__:
#define SONA_PRANDOM_INT(seed,__MIN__, __MAX__) \
((__MIN__) + SONA_PRANDOM(seed) % ((__MAX__+1) - (__MIN__)))


In order to generate a sequence of random numbers you just reuse the last random number as seed:
unsigned random1 = SONA_PRANDOM(666);
unsigned random2 = SONA_PRANDOM(random1);
unsigned random3 = SONA_PRANDOM(random2);
// and so on


Final advice: Don't use it in production without checking every single value in a test run. If you pick the wrong seed, the random numbers might loop easily. Feel free to use it for prototyping or extend it.

Setting up shop

All backgrounds are nodes in the scene graph that stores the whole game scene. The backgrounds are flat (2D) and drawn in the background. They are semi-transparent and composed of straight & simple OpenGL. In the game, I use three different kinds of background elements: Texture-based (like the noise in the “Motor” level and the interlacing lines), PointSprite-based (like the rain and pollen in “Revolution Void”), and Vertex-based (all others, most of them based on basic shapes like lines and rectangles). Texture-based effects are the most simple: I just tile a texture over the whole screen and move it a little bit (in sync with the beat). The PointSprite-based ones are based on the Particle code I use. Comparable Open Source-code can be found in the particle class of Cocos2D. In the following paragraphs I will explain how to render Vertex-based psychedelic effects.

All vertices that will be drawn need to be stored in an array. The following code draws a waveform-like visual effect. In REDUX, it can be found in the “Motor” and the “DJ Glow” levels. Here’s a screenshot. The code here draws the striped waveform in the background.

The vertices are stored in an array called _vertices. The number of vertices stored is stored in _numVertices, the absolute number of vertices that fit in the allocated memory is stored in _numElements.

A point is added with the following function:

- (void) addPoint:(SONAVector2D)point {
if (_numVertices < _numElements-1) {
_vertices[_numVertices].x = point.x;
_vertices[_numVertices].y = point.y;
_vertices[_numVertices+1].x = point.x;
_vertices[_numVertices+1].y = -point.y;

_numIndices += 6;
_numVertices += 2;
}
}


As you can see there’s a second array called _indices that stores vertex indices to be used in the glDrawElements() call later on. Indices are used because some vertices are used repeatedly in order to draw one continuous stripe. The vertices are initialized with the following function call (gSize is a 2-dimensional grid size that determines how much memory is allocated for this object):

- (void) resetPoints:(SONAGrid)gSize {
// superclass calculates _numElements (=gSize.x * gSize.y)
[super resetPoints:gSize];

// add the points. one call to addPoint adds a whole square (ugly!)
for (int i=0; i<_numElements/2.f; i++) {
[self addPoint:makeVector2D(((float)i) * _xStride, 25.0f+SONA_RANDOM_FLOAT()*50.0f)];
}
}


The squares (the wave form is composed of cubes) are moved to the left at each beat of the music. This is achieved by copying over the y vertices. The leftmost square is moved all the way to the right.

- (void) moveSquares {
_vertices[_numVertices-2].y = _vertices[0].y;
_vertices[_numVertices-1].y = _vertices[1].y;

for (int i=0; i<_numVertices-2; i++) {
_vertices[i ].y = _vertices[i+2 ].y;
}
}

The following piece of code is the callback from the sound engine. The superclass administers some variables like _updateCountdown, a countdown that is set to 1 on each beat and linearly decreases to 0 over the duration of one beat.

- (void) onBeat:(unsigned int)beat ofBar:(unsigned int)bar {
[super onBeat:beat ofBar:bar];
[self moveSquares];
}

The last — and most important — function is the drawing function. My default OpenGL state has enabled vertex and texture coordinate arrays. I need to disable texturing in order to draw plain shapes. I also store the blending settings and color mode before proceeding to the actual drawing and reset it afterwards. Before drawing, I translate vertically to the centre of the screen and translate horizontally by a fraction of _updateCountdown and _xStride to smoothly scroll the whole wave form. Then I draw the stripe in 3 passes. Each pass is scaled differently on the y-axis and has a different alpha blending. The actual vertices are only transmitted once with the glVertexPointer() call. Subsequent passes draw the same vertices and indices again.

- (void) draw {

}

The other backgrounds are coded slightly different but basically similar. All of them are based on arrays of vertices. I will share some more interesting pieces of code in the future, but that's it for now.

Of course, the iPhone version will get updated, too.

To celebrate the sucessful launch of Globetrotters we will raffle 5 promo copies of the game on our Facebook fan page. Become a fan of studio radiolaris this week to be eligible.

“This game stands as one of very few truly excellent examples of gaming on Apple’s new devices. With fantastic visuals, solid gameplay, varied challenges, and excellent soundtrack, this game reminds me of contemporary greats such as everyday shooter, PixelJunk Eden, and Ikaruga.

I can’t think of a single reason why I would not recommend this game. Buy it now. Enjoy it regularly. Let’s hope to see more work like this from Studio Radiolaris in the near future.”