Fenix Project

Uit Wikipedia, de vrije encyclopedie
Ga naar: navigatie, zoeken

Fenix is een vrij te gebruiken programmeertaal speciaal gericht op het programmeren van computerspellen. Het Fenix Project is gestart door Jose Luis Cebrián in 2000 en oorspronkelijk gebaseerd op DIV Games Studio. De huidige versie is 0.93.

Karakteristieken[bewerken]

Fenix is een geïnterpreteerde, semi-parallelle programmeertaal met een syntaxis die doet denken aan een kruising tussen Pascal en C++. Semi-parallel omdat de taal werkt met "processen" die 'tegelijkertijd' worden uitgevoerd. Procedurele functies zijn tevens mogelijk, maar de parallelliteit geeft over het algemeen zo'n ongelooflijk groot voordeel bij het programmeren van spellen dat er constant gebruik van wordt gemaakt. Fenix is niet hoofdlettergevoelig, wat erg fijn werkt en tevens beginners het een stuk makkelijker maakt. Fenix is gebaseerd op Simple Directmedia Library (SDL), wat ervoor zorgt dat je meteen aan de slag kan en niet eerst op zoek hoeft te gaan naar bijvoorbeeld een goede grafische library zoals bij talen zoals C++ en Java. Tevens heeft het ingebouwde functies voor geluid, tekst, rekenen, etc. Ondanks dat het niet benodigd is, heeft Fenix wel de mogelijkheid uitgebreid worden met DLL's, die door gebruikers in C++ geschreven kunnen worden.

Andere belangrijke eigenschappen van Fenix zijn volledig 2D support (schalen, transparantie, blendops...), 16 bit kleuren, geluidsondersteuning (.ogg, .mod, .it, .s3m, .wav), joystickondersteuning, en mode7.

Naast de taal zelf zijn er ook heel veel mensen die voor Fenix hun eigen DLL's hebben uitgebracht, zo zijn er bijvoorbeeld 3D libraries uitgebracht en meerdere netwerk libraries (die ook over internet werken). Dit brengt Fenix op een hoogte dat bijna alles mogelijk is, vooral nu netwerkspellen en 3D spellen ook tot de mogelijkheden behoren.

Platformen waar Fenix op draait[bewerken]

Fenix werkt onder andere op Windows (alle versies vanaf Windows 95 tot en met Windows Vista), Linux, Mac OS, BeOS, BSD, de Dreamcast (console), PS (console), de GP32 (handheld console) en de GP2X (handheld console). Dit maakt het ook voor Linux-programmeurs heel aantrekkelijk om in Fenix te ontwikkelen, en Fenix is tevens populair in de GP2X-scene.

Fenix gebruiken[bewerken]

Fenix is, in tegenstelling tot DIV, een commandline compiler en heeft dus geen grafische ontwikkelomgeving, ingebouwd tekenprogramma, sprite generator zoals DIV had. Het enige dat Fenix doet is code compilen en interpreteren. Uiteindelijk is dit voor Fenix gebruikers juist een voordeel – het geeft hen de mogelijkheid om in Windows een eigen IDE/editor te kiezen, en snel te wisselen tussen Windows tools (zoals grafische programma's, geluidseditors, etc.) en de gebruikte Fenix-editor.

Er zijn een aantal IDE's speciaal voor Fenix ontwikkeld, die onder meer Fenix code highlighting bevatten, ingebouwde hotkeys en bijvoorbeeld de mogelijkheid om snel tussen processen te navigeren door het indexeren van alle processen in een lijstje. Firebird is de bekendste IDE speciaal voor Fenix. Tevens kunnen universele programmeereditors gebruikt worden zoals Context, waar ook Fenix highlighting voor bestaat en waar men zelf hotkeys in kan stellen.

Fenix voorbeelden[bewerken]

Hieronder een voorbeeld van een willekeurige standaard lay-out van een Fenix programma:

Program Mijn_programma;
Global
        //Globale variabelen
Local
        //Lokale variabelen
Begin
        Set_mode(1024,768,16);
        Set_fps(70,0);
        
        Mijn_process();
        Mijn_process();

        // Hoofdloop van het programma:
        Loop
                Frame;
        End
End


Process Mijn_process()
Private
        //Private variabelen
Begin
        Loop
                Frame;
        End
End


Het "program" blok wordt altijd uitgevoerd zodra het programma gestart wordt, te vergelijken met main() van sommige andere talen (C++, Java). Binnen dat blok wordt er eerst de mogelijkheid geboden om globale en lokale variabelen te declareren in initialiseren. Globale variabelen kunnen overal gebruikt worden (zowel in "program" als in processen), en lokale variabelen zijn variabelen die elk proces standaard meekrijgt. Vervolgens begint het 'echte' programma tussen "Begin" en "End", keywords ook wel bekend van Pascal.

Met Set_mode() wordt eerst de resolutie van het spel op 1024*768 gezet en de kleurendiepte op 16 bit, en met Set_fps() wordt de framerate (in het voorbeeld 70) en frameskip (in het voorbeeld 0) van het programma vastgelegd. Vervolgens wordt er 2x het proces Mijn_process aangeroepen, waarna het hoofdprogramma blijft draaien door middel van een oneindige loop. Dit is nodig om het programma draaiende te houden, want zodra de "End" van het "Program"-blok bereikt wordt, is het programma afgelopen en stopt het.

Zoals te zien is in het Process Mijn_process blok, kunnen er eerst 'private' variabelen gedefinieerd worden, variabelen die alleen in het process zelf gebruikt kunnen worden. Vervolgens komt er ook in dit proces een oneindige loop, zodat het proces 'levend' blijft en niet afloopt.

Het "frame"-commando behoeft enige toelichting: het volgende beeld van het programma wordt pas weergeven zodra er in elk proces en het "program"-blok een "frame" commando is uitgevoerd. Op deze manier worden alle processen gesynchroniseerd. De semi-parallelliteit kan dus ook worden toegeschreven aan dat alle processen worden langs gegaan en de code tussen 2 "frame"-commando's uitgevoerd wordt in elk proces, en vervolgens wordt dit herhaald en wordt weer de code tussen 2 frame's per proces uitgevoerd voor het volgende beeldje, enzovoort.

Wat er in het voorbeeld gebeurt, is dat er eerst een Mijn_process wordt aangeroepen, dat blijft draaien, en vervolgens een tweede Mijn_process, dat ook blijft draaien. Na het aanroepen van deze twee processen draaien ze dus naast elkaar. In vergelijking: in een strikt procedurele taal zou Mijn_process worden uitgevoerd, en de 2e Mijn_process zou pas worden aangeroepen zodra de eerste Mijn_process zou zijn afgelopen.

Terwijl dit voorbeeld niets nuttigs doet, laat het goed de basisstructuur van een Fenix-programma zien. Om te begrijpen waar parallelliteit nou goed voor is, kun je je bijvoorbeeld indenken dat het hoofdprogramma tien "vliegtuig"-processen oproept, die naast elkaar blijven bestaan. Elk van de processen draait dan bijvoorbeeld naar links als een ander vliegtuig te dicht bij komt. Dit zou op zijn minst gezegd behoorlijk vervelend zijn om procedureel te programmeren, maar in Fenix is het zo gedaan. Juist omdat spellen bestaan uit autonome eenheden zoals vliegtuigen, voetballers, tanks, spelers, etc die op elkaar reageren is het zo handig om ze ook als onafhankelijke parallelle processen te beschrijven, met ieder hun eigen regels die tegelijkertijd worden uitgevoerd.

Geschiedenis en status[bewerken]

Fenix is een in 2000 begonnen project met het doel een gratis DIV Games Studio compiler te maken die zowel op Linux als Windows werkt. Fenix heette oorspronkelijk "DIVC", maar dat werd al snel in "Fenix" veranderd. Fenix is gestart door Jose Luis Cebrián, en oorspronkelijk was het de bedoeling om alle DIV 1 commando's ook in Fenix te implementeren. Dat lukte, de compiler werd volop ontwikkeld door Cebrián en naast het feit dat alle DIV 1 functies geïmplementeerd werden, werd er ook begonnen met het implementeren van DIV 2 functies.

Toen Fenix bij versie 0.7 was aangeland, kreeg Cebrián het heel druk en liet hij voor lange tijd niets van zich horen omtrent de ontwikkelingen van Fenix. Het project werd toen door meerdere mensen opgepakt en er werd in verschillende richtingen mee verder gegaan, ieder voor zich. Uiteindelijk is de versie van Slainte, Fenix Project 1.0, de versie die het gehaald heeft en nog steeds in ontwikkeling is. Slainte heeft het project ontwikkeld tot versie 0.84b, met in het achterhoofd het doel om een versie 1.0 te bereiken.

Fenix was inmiddels al uitgebreid met allerhande dingen die niet in DIV Games Studio 1 of 2 voorkwamen. Naast dat Fenix natuurlijk 16 bit kleuren ondersteunde en in Windows werkte, waren allerlei commando's uitgebreid met extra parameters, waren er nieuwe commando's en lokale variabelen toegevoegd en bleek Fenix torenshoog boven DIV 2 uit te steken. Tevens was Fenix veel sneller dan DIV ooit was daar het op SDL gebaseerd was, wat ook de mobiliteit van Fenix vergrootte.

Toen Fenix op versie 0.84b was aangekomen, rond 2004, bleef het een aantal jaren stil rondom de ontwikkeling. De oorspronkelijke ontwikkelaars van Fenix waren met een Fenix 2.0 project begonnen, waar ze bepaalde interne zaken anders wilden regelen, zodat de taal makkelijker uit te breiden was. Tevens was het plan om met Fenix Project 1.0 zo veel mogelijk te breken met de oorspronkelijke DIV compatibiliteit, omdat de Fenix ontwikkelaars vreesden dat ze zouden worden aangeklaagd door Fasttrak (uitgever van DIV Games Studio). Dat is ook wel een logische gedachte, omdat Fenix inmiddels meer was dan dat DIV ooit zou worden, op de IDE na dan. Er werden allerlei nieuwe fileformaten bedacht voor Fenix die niets meer met de oorspronkelijke fileformaten te maken hadden, en in de nieuwste versie Fenix-versie bestaan deze formaten naast de oude DIV formaten.

In 2007 heeft Juan, een Argentijnse ontwikkelaar, Fenix Project 1.0 op zich genomen (onder goedkeuring van Slainte) en is aan het werk geslagen om alle bugs eruit te halen en het naar een versie 1.0 te leiden. Fenix 0.84b was zeer onstabiel waardoor veel mensen op Fenix 0.84a waren blijven hangen, en deze instabiliteit heeft Juan er helemaal uitgewerkt. Juan heeft Fenix tot versie 0.93 ontwikkeld, waarna hij is verder gegaan met een afsplitsing ('fork') van Fenix, genaamd Bennu. Juan heeft onder meer meerdere commando's, een nieuwe variabelesoort ('public variabelen') en meerdere functies voor de debug console toegevoegd aan de taal.

Zie ook[bewerken]

Externe links[bewerken]