Programmer: Carlos García Cordero
I studied Mathematics in the Complutense University
of Madrid, when I finished I taught programming in an academy for
other Mathematics students and translated several books from English
to Spanish. This does not mean that I have a good English, those
books were technical ones and their English was very easy to understand.
At that time, about five years ago, I had a friend who knew that
Friendware was forming a development group for creating videogames,
I had always liked videogames a lot (a friend and me did a videogame
for the spectrum that was almost published), and so I got in touch
with them.
I
work with two monitors, that's the reason why the image is so wide.
In the left one you can see the game window, i turned on toon render
to make it a little different from most of the screen shots that
you can see. Visual C++ is under it. In the other monitor is the
game console and PythonWin that is the editor I use to edit Python
files.
I saw a demo of an Intel product that did toon
rendering and liked it a lot, later I read an article in game developer
about that and decided to implement it in Blade. The basic algorithm
for shading is based in the one that appeared in game developer,
the rest are experiments I did. I'm quite pleased with the result.
It's done at the raster level; the rest of the engine doesn't know
anything about it. This limits a little the information that I can
use to implement different effects; I don't want to slow the normal
rendering to improve toon render. Unfortunately now I have very
little spare time, we are working extra time to finish Blade. I
was thinking about implementing a watercolour look, but this, as
well as a line-shading mode that is half done, will have to wait
until Blade is finished.
I don't know if it will be released. It's only
implemented in the OpenGL raster. Blade has switched to D3D for
commercial reasons and as I do this for fun, I'm not going to port
it to D3D. Maybe the OpenGl raster will be released as an unsupported
option (it has other extra stuff also), but I can't promise anything.
It is a little more difficult to play in toon mode because you tend
to look around to see the environment and when an enemy attacks,
you are still looking at it saying "Its very cute!!"
In the PythonWin window (the right part of
the desktop) you can see a tree with the classes and functions of
that file. This file defines the basic behaviour of the non-player
characters. There is a class for every type of enemy, in this file
is one of the most basic classes. These classes define the call-back
functions that are triggered when something happens (the character
has been attacked, has seen another entity etc.), the derived classes
refine the behaviour. For example, the function RespondToHit is
called when the characters have been hit and launches the appropriate
hurt animation, decreases the life etc.
I have done a lot of things in Blade, after
all, I've been here for quite a while. I've done several tools,
including the LED. I did the port to Windows (the first engine run
in DOS) and I've done almost all the Glide raster and all the OpenGL
raster. In the game I've done a lot of internal work. I did the
entities system with their attributes and methods (well, I did the
first ones, other programmers have completed it), added the scripting
module with Python and the first scripts (mostly as examples), several
graphic effects... and a couple extra things that I don't remember
or I prefer to forget :).
The LED must be updated. It was done a long
time ago and has only had a couple of bug fixes since then. The
2D/3D integration must be improved as well as the entity treatment.
When the LED was done, the script system wasn't finished (by the
way, the LED has a script interface, which I did as an example to
see how it worked and if it was adequate for Blade) and the entities
system was still in design. Although it worked very well on my Pentium
90, we have Pentium III 500's and up now, and it could use the extra
power.
There are also a couple of features that have
not been tested much, like hierarchical grouping. There is a Depeche
Mode icon to activate the grid, I think that Enric would like it
if I improve this and add an MP3 player to listen to Depeche Mode
music. I think that Prodigy would be OK too :).
We use Max for the objects, Angel did an exporter
to use the objects in the engine. I did a tool to Pack textures
and calculate palettes, which is called BaB. Angel and me also did
a compiler (well almost everything was done by Angel) that converts
the maps that LED produces into the maps that the engine understands.
The scripts are written with any text editor. As you have seen I
use PythonWin, other people in Rebel use Visual C++ or any other
one that they prefer.
You can play Blade in first person, so the
engine is not tied to a 3rd person game. Most of Blade behaviour
is done with properties or Python scripts. The engine is very flexible.
I think it has the best physics and lightning system, as well as
a very flexible biped system for animations.
The engine has several sub-engines. The physics
engine is one of them. It uses mainly the mesh of the object and
its mass, but there are also friction coefficients. The code for
the physic engine is in the main executable, as is the entities
system. So maybe we can call them the core. The graphic system is
in separate DLLs. It's possible to write a raster that shows the
world in a completely different way, as the toon render shows. It's
possible to write a raster that uses light maps, for example.
It's also possible to implement entities behaviour
or other things in separate DLLs, although we do not use this very
often. You can use Python as a link to call any DLL if you want.
The geometry is tessellated for the distortion
effect, but the objects aren't. Their vertices are moved depending
on where they are; this is why you sometimes can see that their
distortion is not the same as the rest of the architecture. This
is done this way to improve the efficiency.
The water has attributes for setting the level,
colour and reflection. You can also specify a callback function
that is called when an entity touches it. There is also a transparency
attribute, but although Angel designed it to have transparency,
he hasn't had the time to implement it.
Blade does not ask a lot of the graphic card.
For example, a GeForce is almost free to run with full screen anti
aliasing. We have tried this and all the cards work well with Blade.
In short term, it would be easy to add Radiosity
and volumetric fog to the Blade engine (we almost have volumetric
fog already). In a long term, we may add a true outdoors engine,
progressive detail-level, more authentic lightning...we'll have
to wait and see.
I don't know what we'll be releasing, but to
create new models you'll need the MAX export plugin. Also, you have
to define the set of animations by script. If it's not documented,
this will be very difficult. To change the damage that a weapon
produces you only have to put something like this: weapon.Damage=200.
This is not exact, but this is the idea. The weapons have several
attributes that are defined in a script. To change their damage
zones, you must define them in the mesh and use our exporter.
Previous
| Index | Next
|