seeseekey.net - Invictus Deus Ex Machina

Emu­la­to­ren für die unter­schied­lichs­ten Sys­teme gibt es wie Sand am Meer. Meist fol­gen die Emu­la­to­ren dabei der Maxime — ein Emu­la­tor für eine Platt­form. Das bedeu­tet natür­lich auch, das man meh­rere Appli­ka­tio­nen pfle­gen muss und nicht alles unter einer Haube zur Ver­fü­gung steht. Unter Mac OS X kann man die­ses Pro­blem nun mit­tels OpenEmu beheben.

Die Nut­zer­ober­flä­che von OpenEmu

Dabei han­delt es sich um einen Emu­la­tor, wel­cher unter­schied­li­che Sys­teme wie NES, SNES, Game­Boy, Sega Gene­sis und viele andere unter­stützt. OpenEmu ist dabei freie Soft­ware und unter der GPL2 lizen­ziert. Bezo­gen wer­den kann OpenEmu auf der offi­zi­el­len Web­seite. Der Quell­text für OpenEmu, das SDK und die ent­spre­chen­den Cores sind auf Git­Hub zu fin­den.

Den Raspberry Pi kann auf viel­fäl­tige Weise genutzt wer­den. Meist möchte man für einen Test nicht gleich die Hard­ware raus­kra­men, son­dern statt­des­sen das ganze erst ein­mal im Emu­la­tor aus­pro­bie­ren. Die ent­spre­chende ARM-Architektur lässt sich ohne Pro­bleme mit­tels QEMU emu­lie­ren, aller­dings ist die Kon­fi­gu­ra­tion eines Raspberry Pi etwas anspruchsvoller.

Die Emu­la­tion mit­tels QEMU

Ein­fa­cher wird es durch das Pro­jekt „Raspberry Pi emu­la­tion for Win­dows“ wel­ches auf SourceF­orge zu fin­den ist. Das Pro­jekt stellt eine knapp 550 MiB große Zusam­men­stel­lung bereit, in wel­cher eine kom­plette Raspberry Pi Emu­la­tion zu fin­den ist. Das Paket muss nur ent­packt wer­den, anschlie­ßend kann der Raspberry Pi Emu­la­tor durch Start der „run.bat“ aus­ge­führt werden.

Wer schon immer das tiefe und uner­klär­li­che Bedürf­nis hatte, Win­dows in der ers­ten Ver­sion aus­zu­pro­bie­ren, der kann dies nun tun. Mög­lich wird dies mit der Web­seite jsmachines.net. Das ganze basiert dabei auf dem unter GPL ste­hen­den PCjs. Dabei han­delt es sich um einen IBM PC Emu­la­tor, wel­cher in Java­script geschrie­ben ist. Der Quell­text soll spä­ter auf Git­Hub zur Ver­fü­gung stehen.

Der Win­dows 1 Emu­la­tor in Aktion

Die Windows-Emulation ist neben eini­gen ande­ren Emu­la­tio­nen (unter ande­rem Zork I und DONKEY.BAS) auf der Web­seite zu fin­den.

Seid eini­ger Zeit wird von Mojang das Spiel „0x10c“ ent­wi­ckelt. Dort befin­det man sich am Ende der Zeit in einem Uni­ver­sum und ist mit einem Raum­schiff aus­ge­rüs­tet wel­ches eine CPU vom Typ „DCPU-16″ besitzt. Diese CPU wird in einem ent­spre­chen­den Assem­bler pro­gram­miert und vom Spiel simuliert.

Mitt­ler­weile gibt es auch schon Betriebs­sys­teme für diese CPU, wie „Atlas 2″ wel­ches unter der MIT Lizenz steht. Das Sys­tem soll dabei Paging, Spei­cher­ma­nag­ment, ein Datei­sys­tem, Mul­ti­tas­king und meh­rere Nut­zer unter­stüt­zen. Anschauen kann man sich den Quell­text https://github.com/0x10cAtlas. Neben dem Quell­text gibt es dazu auch eine Wiki. Wer die CPU sel­ber aus­pro­bie­ren möchte, kann dies unter http://dcpu.ru/ tun.

Wei­tere Infor­ma­tio­nen gibt es unter:
http://en.wikipedia.org/wiki/0x10c

Es ist doch immer wie­der erstaun­lich was im Brow­ser mit­tels Java­script alles mög­lich ist. Zum Bei­spiel ein voll­stän­di­ger Game­Boy Color Emu­la­tor. Zu fin­den ist die­ser unter http://www.grantgalitz.org/gameboy/. Das ganze ist dabei Open Source wobei der Quell­text unter https://github.com/grantgalitz/GameBoy-Online ver­füg­bar ist.

Wei­tere Infor­ma­tio­nen gibt es unter:
http://de.wikipedia.org/wiki/Gameboy

Bei VICE han­delt es sich um einen Emu­la­tor für ver­schie­dene Com­mo­dore Rech­ner wie z.B. den Com­mo­dore 64 oder den Com­mo­dore 128. VICE kann dabei mit­tels

sudo apt-get install vice

instal­liert wer­den. Bei Ubuntu wer­den die ROMs für die jewei­li­gen Rech­ner aller­dings nicht mit­ge­lie­fert (das Copy­right hält die nie­der­län­di­sche Firma Tulip) so das diese manu­ell hin­zu­ge­fügt wer­den müs­sen. Dazu lädt man sich von der offi­zi­el­len VICE Seite unter http://viceteam.org/ die Win­dows Ver­sion her­un­ter und ent­packt diese. Die Ord­ner wel­che sich in die­sem Archiv befin­den wer­den dabei in den Ord­ner /usr/lib/vice kopiert. Anschlie­ßend star­tet VICE ohne Pro­bleme :)

Wei­tere Infor­ma­tio­nen gibt es unter:
http://wiki.ubuntuusers.de/VICE
http://de.wikipedia.org/wiki/VICE
http://www.c64-wiki.de/index.php/VICE
http://de.wikipedia.org/wiki/Commodore_64

Bei AndEn­gine han­delt es sich um eine Game­en­gine für Andro­id­ge­räte. Die Apps für diese Platt­form wer­den ja bekannt­lich in Java geschrie­ben. Und darum soll es hier auch gehen. Im ers­ten Schritt wird Eclipse auf­ge­setzt und anschlie­ßend neh­men wir die AndEn­gine in Betrieb. Im ers­ten Schritt muss also das Paket eclipse instal­liert wer­den. Danach sollte das Android SDK für Linux unter http://developer.android.com/sdk/index.html her­un­ter­ge­la­den wer­den und auf der Fest­platte ent­packt wer­den. Dann geht es in den Ord­ner tools des SDKs und dort wird dann

./android update sdk 

aus­ge­führt. Nun bestä­tigt man die Lizenz und instal­liert die ver­schie­de­nen SDK Ver­sio­nen. Dies kann dabei einige Minu­ten dauern.

Nun kann man Eclipse star­ten. Beim ers­ten Start erscheint ein Begrü­ßungs­bild­schirm den man schlie­ßen kann. Danach sollte man unter Help -> Install new Soft­ware die Android Deve­lop­ment Tools instal­lie­ren. Dazu wird in dem sich öff­nen­den Dia­log die URL http://dl-ssl.google.com/android/eclipse/ ein­ge­ge­ben und durch einen Druck auf den Add… But­ton hin­zu­ge­fügt. Dann kli­cken wir die Check­box Deve­l­oper Tools an und betä­ti­gen die Instal­la­tion mit dem Next… But­ton. Mit­tels eines Assis­ten­ten wird man nun durch die Instal­la­tion gelei­tet. Nach­dem die Instal­la­tion been­det ist emp­fiehlt Eclipse einen Neu­start der Umge­bung. Die­sem sollte Wunsch sollte man Folge leisten.

Nun benö­tigt Eclipse die Infor­ma­tion wo das Android SDK sich auf der Fest­platte befin­det. Dazu geht man auf Win­dow -> Pre­fe­ren­ces -> Android. Dort wählt man den Pfad des Android SDKs aus und bestä­tigt den Dia­log mit OK.

Die grund­le­gende Kon­fi­gu­ra­ti­ons­ar­beit ist damit geleis­tet. Nun kann mit dem ers­ten Pro­jekt begon­nen wer­den. Dazu gehen wir auf File -> New -> Pro­ject und wäh­len dort Android Pro­ject aus und kli­cken dann auf Next. In dem dar­auf fol­gen­den Dia­log geben wir dem Pro­jekt einen Namen z.B. Hello World. Im Feld Package Name geben wir den Namen des Package an z.B. net.seeseekey.hello_world und bei Activity name z.B. Form­Main und bei App­li­ca­tion name z.B. Hello World und bestä­ti­gen das ganze mit dem Finish Button.

Danach wird auto­ma­tisch das Grund­ge­rüst für eine Android Appli­ka­tion erzeugt. Sollte es beim Erzeu­gen der Anwen­dung der Fehler

Pro­ject ‚Run­ti­me­An­droid‘ is mis­sing requi­red source fol­der ‚gen’
The pro­ject can­not be built until build errors are resolved 

auf­tre­ten so hilft es die R.java Datei zu löschen. Sie wird danach auto­ma­tisch neu erzeugt. Wenn wir nun auf den grü­nen Play Knopf (Run) in der Sym­bolleiste kli­cken so star­tet Eclipse das Pro­gramm im Android Emu­la­tor. Beim ers­ten Start sollte aller­dings ein Dia­log erschei­nen wel­cher einem anbie­tet ein vir­tu­el­les Gerät für den Emu­la­tor anzu­le­gen. Nach­dem dies gesche­hen ist, wird das Hello World Pro­gramm im Emu­la­tor gela­den und aus­ge­führt. Und schon ist das erste Hello World Pro­gramm geschrie­ben und die Funk­ti­ons­fä­hig­keit der IDE getestet.

Nun geht es an die AndEn­gine. Erst ein­mal holen wir uns den Source­codes mit­tels hg (Mer­cu­rial) auf die Festplatte:

hg clone https://andengine.googlecode.com/hg/ anden­gine
hg clone https://andengineexamples.googlecode.com/hg/ andengineexamples 

Anschlie­ßend impor­tie­ren wir das anden­gi­neexam­ples Pro­jekt (File -> Import…) in den Works­pace. In dem Pro­jekt AndEn­gi­neExam­ples sind dabei viele Bei­spiele zur Anwen­dung der Engine zu finden.

Nun neh­men wir unser bereits ange­leg­tes Hello World Pro­jekt und erzeu­gen in die­sem (mit­tels New -> Fol­der) einen Ord­ner namens lib. In die­sen kopie­ren wir die andengine.jar aus dem AndEn­gine Exam­ples Pro­jekt. Nun kli­cken wir mit der rech­ten Maus­taste auf die andengine.jar und wäh­len dort Build Path -> Add To Build Path… aus. Damit ist die Biblio­thek refe­ren­ziert. Nun gehen wir in unsere Activity, in die­sem Fall Form­Main und löschen dort alles bis auf die packa­ges Zeile. Nun fügen wir dort fol­gen­den Quell­text ein:

public class FormMain extends BaseGameActivity {
	// Konstanten
	private static final int CAMERA_WIDTH = 720;
	private static final int CAMERA_HEIGHT = 480;

	// Variablen
	private Camera mCamera;

	@Override
	public Engine onLoadEngine() {
		this.mCamera = new Camera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);
		return new Engine(new EngineOptions(true, ScreenOrientation.LANDSCAPE, new RatioResolutionPolicy(CAMERA_WIDTH, CAMERA_HEIGHT), this.mCamera));
	}

	@Override
	public void onLoadResources() {
	}

	@Override
	public Scene onLoadScene() {
		this.mEngine.registerUpdateHandler(new FPSLogger());

		final Scene scene = new Scene(1);
		scene.setBackground(new ColorBackground(0, 0, 0.8784f));

		return scene;
	}

	@Override
	public void onLoadComplete() {

	}
}

Anschlie­ßend wer­den mit­tels Strg + Shift + O alle benö­tig­ten Importe in die Datei ein­ge­fügt. Wich­tig ist es jetzt noch dem Mani­fest fol­gende Zeile hinzuzufügen:

<uses-permission android:name="android.permission.WAKE_LOCK"/>

Nun kann man das ganze im Emu­la­tor star­ten. Es dürfte ein blauer Bild­schirm ange­zeigt wer­den. Nun kann man sich damit begin­nen das ganze mit Leben zu erfül­len :)

Wei­tere Infor­ma­tio­nen gibt es unter:
http://www.andengine.org/
http://code.google.com/p/andengine/
http://code.google.com/p/andengineexamples/
http://developer.android.com/sdk/installing.html
http://www.andengine.org/forums/tutorials/getting-started-updated-t2198.html
http://www.andengine.org/forums/tutorials/andengine-core-terminology-t316.html
http://www.andengine.org/forums/tutorials/getting-started-with-andengine-t11.html
http://www.andengine.org/forums/tutorials/eclipse-andengine-and-helloworld-t380.html
http://www.andengine.org/forums/tutorials/mimminito-s-tutorial-list-t417.html

Secret of Ever­more ist ein Spiel für das SNES. Im Gegen­satz zur Secret of Mana Reihe (wel­che einen Mehr­spie­ler­mo­dus bot) besitzt Secret of Ever­more kei­nen Mehr­spie­ler­mo­dus. Wobei nun müsste es rich­tig hei­ßen es besaß kei­nen Mehr­spie­ler­mo­dus. Bei Secret of Ever­more war es näm­lich schon immer mög­lich beide Cha­rak­tere zu steu­ern. Der andere Cha­rak­ter wurde dann von der KI über­nom­men. Nun hat sich jemand die Arbeit gemacht und einen Patch für Secret of Ever­more erstellt wel­cher die­sem einen Mehr­spie­ler­mo­dus hin­zu­fügt, so das man beide Figu­ren steu­ern kann. Zu fin­den ist die­ser Patch unter http://fusoya.eludevisibility.org/soe/index.html. Viel Spaß beim aus­pro­bie­ren :)

Wei­tere Infor­ma­tio­nen gibt es unter:
http://de.wikipedia.org/wiki/Secret_of_Evermore