Programmeren in Fenix

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

Voorbeelden

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 dichtbij 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.