An Amiga 500 with 1 MB ram + 20Mb hard drive
A camcorder, a genlock and a video recorder to create the animations according
to the rotoscoping technique.
A tape recorder to record sound effects.
"The items used for rotoscoping…"
Deluxe Paint, a superb tool for pixel art, used now and then for
Devpac assembler, used to program the game engine and the polygons
GFA basic, used to create the game editor specific to Another World.
With the arrival of the 16 bit machines, the C language became more popular
in the video game industry, it had many advantages compared to Assembler
(portability, structuring and ease of comprehension). Three years before
becoming a graphic designer for some time, I tried it on Atari ST with no
success. The compiler was shaky, the smallest mistake of programming would
result in the machine crashing and the compiling times were exasperating.
That experience really put me off. As I always liked simplicity, the evolving
languages that didn't need compiling always drew my attention so I intuitively
orientated myself towards GFA basic. As simple as a standard Basic and very
well-strucured by a proceeding system that manages local variables, a bit
like C. GFA is a master work.
Besides, you can extend its features by calling an external program written
in Assembler. And that's what I did: I gathered the best of both, first,
GFA to quickly program the game editor and second, the Assembler only used
for the engine and the graphical features that needed the best performance.
Between the two, there was the Game Data to interpret !
I wanted to get a complete tool that would allow me to create and test the
whole game without having to compile anything or having to change applications
I don't like wasting time with technology and especially with what is
specific to an operating system.
So, here is what the first objectives were:
- The game logic should be coded in a language independent from all platforms,
without needing compiling or data conversion. So I naturally orientated
myself towards the creation of a script interpreter. I developed a mini-language
structured in 64 independent execution channels and 256 variables.
- Polygon assembling: each visual display unit of the game was composed
by many polygons, so it was essential to gather many polygons in one item,
to facilitate their manipulation.
For example; in a character.
- Hierarchical structure of display: The polygon groups could be put together
in turn to form another item. This hierarchical structure avoided redundancy
through the creation of a priority system. For example, making a specific
group for the head of the hero could be re-used in all phases of animation.
This technique used in traditional animation consists of filmimg real
actors, and then copying each step of their movement on celluloid. It
makes very realistic animations. It was used in Another World to create
a few animations, especially the ones that were linked to realism, such
as the car drifting, that was filmed with a scale model. The shot of the
feet in the introduction, and also the character's walking and running.
Trying to do this on a computer at that time was like DIY... the technology
was difficult to aquire. The first thought was to use cellophane as carbon
copy. It means applying cellophane on a TV screen in order to trace the
outlines of a paused video image with a felt pen, and then applying it
on the computer screen and reproducing the image with a graphics program.
This method isn't too bad for fixed images, like a drawing for example.
I had already used it in "Le pacte" for Amstrad, but to actually
use this method for a whole video sequence would have been insane.
The second idea was to connect a GenLock to an Amiga. It is a device that
allows computers to interpret realtime video, coming from a camcorder
for example... It sounds simple, but it wasn't the case, because at the
time, there was no DVD, no digital camcorder to make a perfect freeze
frame. The only device that would cycle through each frame accurately
without flickering was a VHS ITT video player that had a digital frame
memory. So I had to reproduce all the recorded sequences from the analog
camcorder on VHS tape...
In practice, each video image was copied with polygons manually under
the editor. I had to be as quick as possible as the video player would
not stay in pause for long, it would stop automatically to keep the tape
heads in good condition. It was a time attack race, and in the end, it
is especially the introduction that benefited from that technique.
Two video sequences of that time used for the rotoscoping process :
1 , extract
Detailed description of the game engine
I. The polygons editor :
Click on the picture to see the description of the icons.
II. Script editor:
This game has been programmed in a made-up language, between Basic and
Assembler. At the top window, you'll find the edit functions and at the
bottom, the code to edit line by line. The instruction set of the language
is very reduced, at around only thirty "words". And within this
the game logic has been programmed, including the joystick instructions.
Instruction set :
Instructions related to media, graphics, sound, palette:
Load "file number"
Loads a file in memory, such as sound, level or image.
Play "file number" note, volume, channel
Plays the sound file on one of the four game audio channels with specific
height and volume.
Song "file number" Tempo, Position
Initialises a song.
Fade "palette number"
Changes of colour palette.
Clr "Screen number", Color
Deletes a screen with one colour.
Ingame, there are 4 screen buffers.
Copy "Screen number A", "Screen number B"
Copies screen buffer A to screen buffer B.
Show "Screen number" :
Displays the screen buffer specified in the next video frame.
SetWS "Screen number" :
Sets the work screen, which is where the polygons will be drawn by default.
Spr "'object name" , x, y, z
In the work screen, draws the graphics tool at the coordinates x,y and
the zoom factor z. A polygon, a group of polygons...
Text "text number", x, y, color
Displays in the work screen the specified text for the coordinates x,y.
Variables and their manipulation :
Set.i variable, value
Initialises the variable with an integer value from -32768 to 32767.
Initialises variable 1 with variable 2.
Variable1 = Variable2
Addi Variable, Value
Variable = Variable + Integer value
Add Variable1, Variable2
Variable1 = Variable 1 + Variable2
Sub Variable1, Variable2
Variable1 = Variable1 - Variable2
Andi Variable, Value
Variable = Variable AND valeur
Ori Variable, Value
Variable = Variable OR valeur
Lsl Variable, N
Makes a N bit rotation to the left on the variable. Zeros on the right.
Lsr Variable, N
Makes a N bit rotation to the right on the variable.
Instruction branch :
Continues the code execution at the indicated address.
Executes the subroutine located at the indicated address.
End of a subroutine.
Conditional instructions :
Si (Variable) Condition (Variable ou value) jmp
If (=Si) the comparison of the variables is right, the execution continues
at the indicated address.
Dbra Variable, Adress
Decrements the variable, if the result is different from zero the execution
continues at the indicated address.
At last but not least, structural instructions :
Setvec "numéro de canal", adresse
Initialises a channel with a code address to execute
Vec début, fin, type
Deletes, freezes or unfreezes a series of channels.
Temporarily stops the executing channel and goes to the next.
Permanently stops the executing channel and goes to the next.
The game execution is structured by 64 independent execution channels
and 256 variables. A bit like multithread.
Each channel executes a part of the specific code. For example, a channel
will manage a character's movements and logic, and the other one its display.
Another channel will display birds in the background, and another one
will trigger a given animation during a given event.
Channels are executed in order, and the Break instruction indicates to
go to the next channel. Once channel 64 is reached, the game frame is
displayed and the cycle restarts. Each channel can set up another one
with Setvec instruction. In the example below, we can assume that channel
2 manages a character, it decides to shoot and initialises in channel
64 of the loaded code to display and manage a laser shot.
Skim through the image to observe the evolution.
The laser becomes autonomous and disappears when it's out of the screen
or hits something, like a door for example, it will then initialise a
variable that will make the door explode.
The flow of settings among the channels occurs only through the 254 global
variables of the game. Even the joystick positions were written in these