| |
Inhoud opgave
| Inleiding spellen programmeren |
(C) 2008 Hein Pragt
|
Vanaf het moment dat ik 30 jaar geleden mijn eerste computer kocht ben ik aan het programmeren. Eerst
in basic, daarna in z80 assembler, daarna vele jaren in C en C++. Hier is een lijst van programmeertalen
waarin ik "beroepsmatig" gewerkt heb: Java, Perl, Php, C, C++,Delphi, Unix Shell scripts, JavaScript, VBScript,
Xslt, Turbo Pascal, Basic, Cobol en Assembly voor diverse processors (8080,Z80,8031,80186,80386,Pentium). Ook
programmeerde ik 30 jaar geleden al spellen, eerst in Basic, toen in Basic en assembler, daarna in C en Assembler
en de laatste jaren C++ en Assembler. Een van de dingen die nog op het verlanglijstje staat is een spel ontwikkelen
in Java, hoewel Java voor mij als doorgewinterde C++ programmeur nog altijd "C++ voor Dummies" is (LOL).
| |
Tevens heb ik demo's geschreven, hiervoor gebruikte ik C en assembler waarmee ik mijn eigen 3D library heb
geschreven op basis van fixed point getallen. (32 bits, 16 bits voor de komma en 16 bits na de komma). Dit leverde
mooie snelle flitsende animaties op, maar uiteindelijk ben ik uit tijdgebrek gestopt. Maar alle kennis die ik in
deze periode heb opgedaan heb ik nog jarenlang kunnen gebruiken.
De spellen die ik ooit gemaakt heb bestonden uit strategische spellen zoals reversi, adventure spellen
(adventure interpreters) simpele platform spellen (voor Philips MSX). Later heb ik nog een simpele versie
van een 3D spel gemaakt in C++ maar dat werd niet echt een succes omdat ik de techniek wel beheerste maar
niet de fantasie had om een goed 3D spel te ontwerpen. Op deze pagina wil ik een stukje van mijn evaring
delen en een naslagwerk voor spel programmeurs creëren. Dit in combinatie met de site http://www.codebank.nl
waar een snippet database staat.
Vriendelijke groet, Hein Pragt
|
| Het programmeren van spellen |
(C) 2008 Hein Pragt
Het programmeren van spellen is leuk, verslavend, een bron van heel veel ergernis maar ook heel veel plezier.
Maar hoe kunt u een spel programmeren? Grafische vormgeving en geluid zijn de dingen die het
eerst opvallen wanneer we computer spellen bekijken. Maar schitterende animaties en goede geluidseffecten zijn
slechts de buitenste laag van deze fascinerende vorm van technologie. 3D techniek vereist een goede kennis van
wiskunde en verder is een spel vaak een ingewikkelde structuur van logica en regels. Ook raken spellen vaak het
vak psychologie omdat het spel een vorm van actie en reactie is en de speler een mens is die op menselijke wijze
reageert op het spel. Hoe men vermoedt dat de speler gaat reageren, is vaak al van te voren goed overdacht. Ook
is het zo dat in adventure games of role playing games (rpg) de spelfiguren een eigen karakter hebben, ook dit
vergt enig inzicht in de menselijke psyche. Het programmeren van spellen brengt vaak vele disciplines bij elkaar,
techneuten, programmeurs, grafisch ontwerpers, verhaal vertellers e.d.
Het programmeren van spellen is wezenlijk niet anders dan elke andere vorm van programmeren, behalve dat
het vaak heel efficiënt moet zijn en voor erg voor snelheid geoptimaliseerd. U zult moeten leren om programma's
te schrijven die snel en efficiënt 2D en 3D plaatjes weer kunnen geven, die muziek en geluidseffecten kunnen
weergeven en die razendsnel kunnen reageren op gebruiker invoer. Wanneer u een multiplayer spel schrijft dat
over een netwerk kan worden gespeeld, zult u ook netwerkcode moeten schrijven. Het programmeren van spelletjes
is geen eenvoudige zaak en vergt zeker veel studie.
Natuurlijk zijn veel van deze taken al gedaan voor u, er zijn meerder programmacode bibliotheken die u kunt
gebruiken. Deze bibliotheken zijn gebouwd om specifieke taken uit te voeren zoals het tonen van graphics, geluid
weergeven en gebruikersinvoer afhandeling. Er zijn ook libraries die als een APIs gebruikt kunnen worden als
interfaces tussen het programma en de onderliggende hardware. Een succesvolle spelprogrammeur weet wat hij
zelf moet doen en wat hij van anderen kan "lenen".
| Beginnen met programmeren van spellen |
(C) 2010 Hein Pragt
JGAME game framwork in Java
JGame is een 2D game engine dat draait op een Java JRE 1.2+ platform (met optioneel OpenGL)
en het mobiele J2ME platform (CLDC1.1 / MIDP2.0). Het heeft een uitgebreide klassen bibliotheek
waarmee met slechts enkele regels code een "klassiek" type arcade game kan worden ontwikkeld.
Het is gebaseerd op tiles en sprites met automatische animatie en collision detectie en een tile
gebaseerde achtergrond met eenvoudige sprite en tegel interactie faciliteiten. JGame games kunnen
worden uitgevoerd met Web Start, als applets, of als MIDlets, zonder dat er wijzigingen in de
code nodig is. Het grafische scherm past zich automatisch aan op elke schermgrootte. Bij JGAME
worden veel voorbeelden meegeleverd, de documentatie beperkt zich echter tot javadoc. Wel is
er een goede tutorial op het web beschikbaar. Voor het werken met JGAME is wel enige kennis
van de programmeertaal Java nodig maar vooral veel fantasie.
Voorbeeld code:
package examples;
import jgame.*;
import jgame.platform.*;
/** Space Run III, a variant on Space Run, illustrating scrolling and wrapping
* playfield. */
public class SpaceRunIII extends StdGame {
public static void main(String [] args) {
new SpaceRunIII(parseSizeArgs(args,0));
}
public SpaceRunIII() { initEngineApplet(); }
public SpaceRunIII(JGPoint size) { initEngine(size.x,size.y); }
public void initCanvas() {
setCanvasSettings(20,15,16,16,null,null,null);
if (isMidlet())
setScalingPreferences(3.0/4.0,4.0/3.0, 0,7,0,7);
}
public void initGame() {
defineMedia("space_run.tbl");
if (isMidlet()) {
setFrameRate(18,1);
setGameSpeed(2.0);
} else {
setFrameRate(45,1);
}
lives_img="ship";
startgame_ingame=true;
leveldone_ingame=true;
title_color = JGColor.yellow;
title_bg_color = new JGColor(140,0,0);
title_font = new JGFont("Arial",0,20);
setHighscores(10,new Highscore(0,"nobody"),15);
highscore_title_color = JGColor.red;
highscore_title_font = new JGFont("Arial",0,20);
highscore_color = JGColor.yellow;
highscore_font = new JGFont("Arial",0,16);
}
public void defineLevel() {
removeObjects(null,0);
switch (stage%2) {
case 0:
leveldone_ingame=true;
setPFSize(150,40);
setPFWrap(false,false,0,0);
int tunnelheight = 11-level/2;
int tunnelpos = pfTilesY()/2 - tunnelheight/2;
fillBG("#");
int firstpart=15;
int oldpos=0;
for (int x=0; x0) {
firstpart--;
} else {
if (random(0,5) < 1)
new JGObject("enemy",true,tileWidth()*x,
tileHeight()*(oldpos+tunnelheight/2),
2, "enemy", 0,0,16,16,
-1,0, JGObject.suspend_off_view);
if (random(0,5) < 1)
new JGObject("pod",true,tileWidth()*x,
tileHeight()*(oldpos+random(2,tunnelheight-3,1)),
4, "pod", 0,0,14,14, 0,0, JGObject.suspend_off_view);
oldpos = tunnelpos;
tunnelpos += random(-1,1,2);
if (tunnelpos < 1) tunnelpos = 1;
if (tunnelpos + tunnelheight >= pfTilesY()-1)
tunnelpos = pfTilesY()-tunnelheight-1;
}
}
break;
case 1:
leveldone_ingame=false;
setPFSize(21,16);
setPFWrap(true,true,-8,-8);
fillBG("");
for (int i=0; i<5+level/2; i++) {
new BombDropper();
new JGObject("pod",true,random(pfWidth()/2,pfWidth()),
random(0,pfHeight()),
4, "pod", 0,0,14,14, 0,random(0.5,1.2), -1);
}
break; }
new Player(0,pfHeight()/2,3);
}
public void initNewLife() {
defineLevel();
}
public void startGameOver() { removeObjects(null,0); }
public void doFrameInGame() {
moveObjects();
checkCollision(2+4,1); // enemies, pods hit player
checkBGCollision(1,1); // bg hits player
if (stage%2==1 && countObjects("pod",0)==0) levelDone();
setViewOffset((int)getObject("player").x+100,
(int)getObject("player").y,true);
}
public void incrementLevel() {
if (level<10) level++;
stage++;
}
JGFont scoring_font = new JGFont("Arial",0,8);
public void paintFrameLifeLost() {
setColor(title_bg_color);
drawRect(160,50,seqtimer*7,seqtimer*5,
true,true,false);
int ypos = posWalkForwards(-24,viewHeight(), seqtimer,
80, 50, 20, 10);
drawString("You're hit !",160,ypos,0,
getZoomingFont(title_font,seqtimer,0.2,1/40.0),
title_color);
}
public void paintFrameGameOver() {
setColor(title_bg_color);
setStroke(1);
drawRect(160,51,seqtimer*2,seqtimer/2,
true,true,false);
drawString("Game Over !",160,50,0,
getZoomingFont(title_font,seqtimer,0.2,1/120.0),
title_color);
}
public void paintFrameStartGame() {
drawString("Get Ready!",160,50,0,
getZoomingFont(title_font,seqtimer,0.2,1/80.0),
title_color);
}
public void paintFrameStartLevel() {
drawString("Stage "+(stage+1),160,50+seqtimer,0,
getZoomingFont(title_font,seqtimer,0.2,1/80.0),
title_color);
}
public void paintFrameLevelDone() {
drawString("Stage "+(stage+1)+" Clear !",160,50,0,
getZoomingFont(title_font,seqtimer+80,0.2,1/80.0),
title_color);
}
public void paintFrameTitle() {
drawString("Space Run III",160,50,0,
getZoomingFont(title_font,seqtimer+20,0.3,0.03),
title_color);
drawString("Press "+getKeyDesc(key_startgame)+" to start",160,120,0,
getZoomingFont(title_font,seqtimer+5,0.3,0.03),
title_color);
if (!isMidlet())
drawString("Press "+getKeyDesc(key_gamesettings)+" for settings",
160,160,0,getZoomingFont(title_font,seqtimer,0.3,.03),
title_color);
}
public class Player extends JGObject {
public Player(double x,double y,double speed) {
super("player",false,x,y,1,"ship",0,0,speed,speed,-1);
}
public void move() {
setDir(0,0);
if (getKey(key_up)) ydir=-1;
if (getKey(key_down)) ydir=1;
if (getKey(key_right)) { x += getGameSpeed()*3*xspeed/2; }
else { x += getGameSpeed()*xspeed; }
if (!isOnPF(0,0)) levelDone();
}
public void hit(JGObject obj) {
if (and(obj.colid,2)) lifeLost();
else {
score += 5;
obj.remove();
new StdScoring("pts",obj.x,obj.y,0,-1.0,40,"5 pts",scoring_font,
new JGColor [] { JGColor.red,JGColor.yellow },2);
}
}
public void hit_bg(int tilecid) { lifeLost(); }
}
class BombDropper extends JGObject {
public BombDropper() {
super("enemy",true,random(pfWidth()/3,pfWidth()),
random(0,pfHeight()), 2, "enemy");
setSpeed(random(-0.7,-0.3),random(-0.5,0.5));
}
public void move() {
if (random(0,1) < 0.005) {
JGPoint cen = getCenterTile();
setTile(cen.x,cen.y,"#");
}
}
}
}
Setup and Use JGame in Netbeans
Setting up JGame 3.3 (JRE or J2ME) with Eclipse 3.3
Turbo Pascal sourcecode van het spel Mario
Het spel werd oorspronkelijk geschreven in Borland Turbo Pascal 6.0, er is ook een
versie van de broncode voor TP 5.5 waarvan de compiler gratis beschikbaar is op Borland's Museum.
De meeste gegevens (sprites, niveaus, enz.) wordt opgeslagen in de procedures, hierdoor kunnen
de sprites worden opgeslagen in het code-segment i.p.v. het data segment dat beperkt is tot 64 Kb.
Mario werkt met een 320x200 scherm modus, met page flipping, het viruele scherm is twee blokken
breder (360 pixels), dit om scrolling mogelijk te maken. Ook maakt deze versie gebruik van
parallax scrolling.
Turbo Pascal source van Mario spel.
(C) 2008 Hein Pragt
Visual Studio
Visual Studio is de programmeer en ontwikkel omgeving van Microsoft, het is een geweldige set
aan geïntegreerde tools samen met een zeer goede compiler en editor. Het pakket heeft daarnaast
nog een debugger, een visuele ontwerper voor (dialoog) vensters en een profiler. Verder wordt er
ook een gehele versie van de MSDN-library meegeleverd en kan een complete toolkit voor het ontwikkelen
van spellen gedownload worden. Sinds november 2007 is er de Microsoft Visual Studio .NET 2008 uitvoering,
hiermee is het mogelijk programma's te ontwikkelen voor de PC maar ook voor de Pocket PC en Windows
Mobile toestellen.
Gratis Express Editions
Naast de commerciële versies van Visual Studio 2008 stelt Microsoft ook gratis versies voor studenten
en hobbyisten ter beschikking. Dit is de Express Edition die in diverse smaken gedownload kan worden voor
verschillende programmeertalen zoals: C#, Visual Basic en C++. Deze versies zijn gratis te downloaden,
en bieden vrijwel de volledige functionaliteit van de commerciële versie, met uitzondering van enkele
professionele features en tools zoals de resource editor. Het is zelfs toegestaan om de Express editie
te gebruiken voor het ontwikkelen van commerciële applicaties.
http://msdn.microsoft.com/vstudio/express
Spellen ontwikkelen voor mobile met de NetBeans IDE
Het ontwikkelen van spellen in Java was nog nooit zo eenvoudig als met de Netbeans Mobility Pack 6.0. Er
zit een editor in voor Scenes, Sprites, en Tiled Layers.
http://blogs.sun.com/JavaFundamentals/entry/creating_games_for_mobility_in
Last update: 27-02-2010
|
Wilt u deze site steunen dan kunt u dit doen door VIA deze site iets te bestellen op:

Spelcomputers
|