AmigaRobots V1.0 von Hanno Behrens © 1993 (Z-Netz: H.Behrens@AMTRASH.ZER) Rechtliches ----------- Dieses Programmpaket ist Giftware. Das Programmpaket mit Anleitung darf frei kopiert und benutzt werden, solange niemand Änderungen vornimmt. Jede militärische oder kommerzielle Nutzung ist untersagt, ebenso Gebührenerhebungen die den Preis einer Diskette um 5.- DM überschreiten. Für Hinweise auf Zuwiderhandlung bin ich dankbar. Es wird keinerlei Gewährleistungspflicht für die vollständige Funktionsfähigkeit des (der) in diesem Dokument beschriebenen Programmes (Programme) übernommen. Sie nutzen diese Software auf eigenes Risiko. Kontaktadresse -------------- Nochmals: Dieses Programm ist nicht public domain, sondern Giftware. Das bedeutet, daß man das Programm zwar frei benutzen darf, daß ich es aber fair fände, wenn man an den Programmierer denkt und mir eine kleine Aufmerksamkeit irgendeiner Art, am liebsten 10.- DM zukommen läßt. Die paar Mark sollte doch jeder übrig haben. Wenn man momentan nichts bezahlen kann, was niemand besser versteht als ich, denn ich bin momentan wirklich blank, aber sich trotzdem über das Programm freut oder ärgert oder sonst einen Kommentar dazu abgeben will, kann er es gern tun, ich habe noch niemanden gefressen (urps). Die Adresse: Real : Hanno Behrens, 2000 Hamburg 72, Overland 9, Germany Z-Netz: H.Behrens@AMTRASH.ZER USE-NET: h.behrens@amtrash.zer.de lokale Box: M.A.G Hamburg, Username behrens Kontonr. : BLZ 200 505 50 KONTO 1284 / 453 105 Dank ---- Colin Fox/Bruce Dawson für ihre req.library, ohne die ich das Programm nie so schön hinbekommen hätte. Tom Poindexter, David Wright für CRobots und die Amigaimplementation. P.D.Smith für seine hervorragende Vorlage und Anleitung mit PCRobots. Ihm zu Ehren werde ich seinen simple- und demo-Roboter diesem Paket beilegen. Dirk Hackmann, Marco Pöhler und Sven Spreier für Ideen, Vorschläge, Beta-testen und Zeit für Tee. China, Indien, Taiwan, u.a. für den Tee. Eirin für Liebe, Verständnis und Kochen von hervorragendem Tee. Isis, das pelzige Katzenvieh für ihre konstruktiven Beiträge zwei Stunden vor der Fütterungs-äöljuuuutttttttt ds ssssssssssssssssssssssssssssssssssssskm l,mmmm.mmmmmmmmmmmmm zeit Vieh! Einleitung ---------- AmigaRobots ist eine weiterentwickelte Implementation von PCRobots auf MS-Dos von P.D.Smith (psmithb@CIX) vom August 1992. Jenes Programm war seinerseits eine Weiterentwicklung von CRobots von Tom Poindexter. Grundsätzlich ist die Spielidee dieselbe wie von CRobots, von dem es auch eine Implementation auf dem Amiga von David Wright (1990) gab. Gegeben sind Roboter, die sich in einer Arena befinden und sich im Wettkampf miteinander messen. Der Wettkampf besteht darin, die anderen Roboter schnell und genau zu orten und durch Beschuß funktionsunfähig zu machen. Der Spieler programmiert für seinen Roboter dazu das nötige Steuerungsprogramm. AmigaRobots ist dabei nicht auf eine spezielle Sprache festgelegt. Grundsätzlich kann der Roboter in jeder Sprache geschrieben werden, die Taskkommunikation auf dem Amiga direkt oder durch Einbinden eines Objektfiles ermöglicht. Die Roboterprogramme werden dabei als normale Programme compiliert und gestartet. Durch dieses Konzept entfällt die Beschränkung der Rechenzeit, die bei CRobots zur Bestrafung jedes intelligenten Roboters führte. Beliebig komplexer Berechnung und Planung sind dadurch Tür und Tor geöffnet. Anders als bei PCRobots gibt es weder eine 64k Beschränkung, noch gibt es einen zwingenden Grund, Standardein und -ausgabe nicht zu benutzen. Auch die Beschränkung auf Integerarithmetik und die fehlende Speicherverwaltung entfällt. Man sollte allerdings zum einen aus Zeitgründen trotzdem auf Fließkommaarithmetik verzichten, zum anderen aus PC-Kompatibilitätsgründen Standartein und -ausgabe sowie Speicherverwaltungsfunktionen vermeiden. Der Verlust der Fließkommaarithmetik ist nicht weiter schmerzhaft, weil AmigaRobots ein weitreichendes Spektrum von Integerfunktionen anbietet, die soweit möglich, aus Tabellen ausgelesen werden. Wer auf die Speicherverwaltung nicht verzichten will, verzichtet eben nicht auf die Speicherverwaltung und ist nicht mehr PCRobots-kompatibel. Na und? Vorbereitet ist ein Linkfile für C, die Programmierung in Pascal, Modula, Oberon, Basic oder Assembler sollte kein Problem darstellen, denn die Sourcen für das Linkfile liegen bei. Ein weiteres Limit sind die gleichzeitig am Spiel teilnehmenden Roboter. Es liegt leider nicht wesentlich höher als 32000, vorausgesetzt der Hauptspeicher reicht - nur knapp über dem Limit von PCRobots von 7-8. Die Roboter sind konfigurierbar, das heißt wenn ein Programm einen schnellen wendigen Roboter braucht, der keine weitreichende Kanone nötig hat, ist dies ebenso machbar wie ein träger Kampfkoloß mit viel Panzerung und großem Geschütz. Eine weitere Erweiterung der Spielidee von CRobots ist die Arena. Diese ist nicht mehr unbedingt ein freies Feld, sondern kann den Robotern durch Wände, Tankstellen oder Schadensfelder eine anspruchsvollere Umwelt simulieren. Der Knüller von AmigaRobots sowie von PCRobots ist die Möglichkeit, die Roboter untereinander kommunizieren zu lassen. Dadurch sind Mannschaftswettkämpfe und Teamwork möglich. Die Entstehungsgeschichte und der Wettbewerb -------------------------------------------- AmigaRobots entstand aus einem unbeendeten Projekt, dessen Ziele weit über die von AmigaRobots hinausgingen. Ich griff die Idee wieder auf, als ich gegen Ende des Jahres 1992 PCRobots in die Finger bekam. Das Programm schrie regelrecht nach einer Implementation auf einem Multitasking-Grafikrechner wie dem Amiga. Sofort setzte ich mich daran, nur die Spielbeschreibung und den flüchtigen Eindruck eines einzigen Spieles vor Augen, das Programm in C zu schreiben. Die eigentliche Simulation war innerhalb von wenigen Tagen beendet, wenn man von wenigen Bugs absieht; aber der Kleinkram erstreckte sich auf weitere Wochen. Heute steht das Programm vor mir, wie ich es mir vorgestellt hatte. Die Beschränkungen von CRobots und PCRobots sind beseitigt, und die Benutzerführung ist grafisch. Leider hat eine Prüfungsvorbereitung darunter sehr gelitten und meine Kasse ist leer. Wenn jemand das Programm benutzt und für gut befindet, würde ich mich sehr zu einer kleinen Aufmerksamkeit von 10.- DM freuen oder wer es sich leisten kann, darf auch mehr bezahlen. Dies ist kein Zwang, denn ich habe mich entschlossen, das Programm als Giftware herauszugeben, doch man bedenke, daß man jedem bettelnden Penner in der U-Bahn ein paar Mark zusteckt... Natürlich soll das ganze nicht völlig umsonst sein. Ich freue mich über jede Art von Kritik, und wer sich registrieren läßt, der kann bei dem AmigaRobots-Wettbewerb teilnehmen. Dazu schickt ihr mir per Post oder E-Mail euren Roboter auf 68000-Code kompiliert und den Source. Ihr bekommt daraufhin alle bisher eingetroffenen Roboter. Natürlich ist ein kleiner Haken an der Sache: ihr bekommt nur den Source von Robotern, die Ihr besiegen konntet, die besseren werden ohne Source geliefert. Gleichzeitig werde ich eine Highscoreliste verwalten und für den besten werde ich mir etwas besonderes ausdenken. Systemanforderungen ------------------- AmigaRobots läuft nach meiner Erfahrung auf jedem Amiga, auf jedem Betriebssystem ab Kickstart 1.2 und jedem Prozessor ab 68000 aufwärts. Wer wie ich die 3D-Oberfläche von Kickstart 2.0 nicht missen will, der kann dies mit den gängigen PD-Patches erreichen. Mit TagScreens und ReqPatch z.B. sieht AmigaRobots prima aus. An externen Libraries benötigt AmigaRobots req.library mathieeedoubbas.library mathieeedoubtrans.library icon.library Leider mußte ich AmigaRobots auf einem Interlace-Schirm schreiben, da sonst die Grafik keine ausreichende Auflösung mehr gehabt hätte. Ich empfehle daher die Nutzung einer Antiflickerkarte oder eines Monitors mit langer Nachleuchtdauer. So sorry, aber da man ja nicht an dem Schirm arbeiten muß, denke ich, ist es erträglich. AmigaRobots vom CLI ------------------- AmigaRobots kann man einfach von CLI starten, indem man AmigaRobots eingibt. Man hat die Shell frei, wenn man run AmigaRobots eingibt, was ich empfehlen würde. Wenn man Roboter starten will, dann gibt man diese entweder AmigaRobots robot1 robot2 robot3 ... ein oder startet die Roboter nachträglich mit run robot1 run robot2 run robot3 Zusätzlich kann man AmigaRobots noch optionale Parameter mitgeben. Diese Parameter sind ebenso wie der Rest des Programmes weitgehend PC-kompatibel. Jedenfalls abwärtskompatibel. Die Optionen sind -d Der sogenannte Debuggingmodus wird aktiviert, das heißt, daß AmigaRobots nicht automatisch stoppt, wenn nur noch ein Roboter im Spiel ist. Dies ist nützlich um, ungestört das Verhalten eines Roboters auf einem leeren Spielfeld zu studieren. -l Mit dieser Option kann man die maximale Anzahl von Spielrunden begrenzen. Der voreingestellte Wert 0 bedeutet keine Zeitbegrenzung. Zum Beispiel würde die Option -l5000 das Spiel in jedem Fall bei 5000 Ticks abbrechen. -f Die Ausgabe von AmigaRobots wird dem File angehängt, statt einfach auf die Standard- ausgabe gedruckt zu werden. Zum Beispiel würde mit -ft:spiele.log in die Datei t:spiele.log gespeichert werden. -s Der Einzelschrittmodus wird aktiviert. Weiter- schalten kann man mit jeder beliebigen Taste. -q Im Quickmodus werden die Menüs deaktiviert, die Explosionen nicht mehr dargestellt und das Programm nach einem Durchlauf beendet. Damit sind nächtliche Stapeldateien mit langwierigen Wett- kämpfen möglich. Das Programm kann selbstverständlich trotzdem noch mit ESC abgebrochen werden. Ich empfehle bei Nutzung dieser Option gleichzeitig eine Spielbeschränkung auf höchstens 10000 Runden durch die Option -l. Zusätzliche Amigaoptionen (nicht bei PCRobots vorhanden) -a Gibt die zu ladende Arenadatei an. Normalerweise wird wie bei PCRobots die Datei PCRobots.rna geladen. Für eigene Arenen empfehlen ich das spezielle Verzeichnis zu nutzen, da dies der Übersichtlichkeit zuträglich ist. -p Bei AmigaRobots hat man die Möglichkeit, in der Arena die Roboter nicht an zufälligen, sondern an festen, definierten Positionen den Wettkampf beginnen zu lassen. Diese Option aktiviert diese Möglichkeit. Näheres dazu unter ->Arenen. -x Es gibt eine schnelle und eine langsame Methode, die Explosionen darzustellen. Mit x wählt man die langsame Methode, die allerdings hübscher anzusehen ist. -v Verzögerung bei schneller Darstellung in 1/50 sec. -r Die Batterien der Roboter werden normalerweise jede Runde um 4 Punkte geladen, das entspricht der Option -r40. Wenn man möchte, daß die Batterien schneller geladen werden, gibt man den Wert hier mit zehn multipliziert ein. Dadurch sind auch Zwischenwerte möglich. -m Normalerweise werden jedem Roboter zu Beginn des Spieles 1000 Schuß Munition mitgegeben, was eine blödsinnig hohe Zahl ist. Mit -m50 würde man dem normalen Roboter nur 50 Schuß mitgeben, dem Roboter mit Tarnvorrichtung nur 9/10 davon, also 45. Die Optionen können an jeder beliebigen Position in der Kommandozeile plaziert werden. Der Aufruf von der Workbench ---------------------------- Roboter können mit aufgerufen werden, wenn man nach dem Anklicken von AmigaRobots die Shift-Taste hält und die gewünschten Roboter mit anklickt. Beim einem Doppleklick beim letzten Roboter wird die Simulation mit den angeklickten Robotern gestartet. Wenn man dabei auch ein Arenafile anklickt, wird auch dieses geladen, wenn in dessen Infodatei FILETYPE=ARENA ist. In der Infodatei von AmigaRobots selbst haben folgende Tooltypes eine Bedeutung. DEBUG=OFF / ON - siehe -d Option TICKS= - siehe -l Option FILE= - siehe -f Option ARENA= - siehe -a Option SINGLESTEP=OFF / ON - siehe -s Option QUICKMODE=OFF / ON - siehe -q Option PREPOS=OFF / ON - siehe -p Option FASTEXPLOSION=ON / OFF - siehe -x Option EXP_TICKS= - siehe -v Option RELOAD= - siehe -r Option SHELLS= - siehe -m Option Menüfunktionen -------------- Menü Programm Informationen (I) ruft einen Requester mit Informationen über das Programm auf. Roboter laden (L) öffnet einen Filerequester, mit dem man die zu startenden Roboter auswählen kann. Dazu muß sich der RUN-Befehl in der C:-Directory oder sonstwie im Pfad befinden. Mehrere Roboter lassen sich durch Drücken der shift-Taste anwählen. Es werden nur Files mit der Endung *.rob angezeigt. Die Roboter sollten aus Gründen der Übersichtlichkeit diese Endung haben. Wenn ein Spiel läuft, wird dieser Menüpunkt deaktiviert. Arena laden (A) öffnet einen Filerequester für das Laden einer Arena. Es werden nur Files mit der Endung *.rna angezeigt. Wenn ein Spiel läuft, wird dieser Menüpunkt deaktiviert. Konfiguration (K) Hier kann man ein paar Werte verstellen, wie schon oben beim CLI- und WB-Aufruf erklärt. Das sind die Spielrunden, die Ladegeschwindigkeit der Batterien, die mitgegebene Munition und ein Verzögerungswert für zukünftige Superrechner. Die Verzögerung beträgt Eintrag * 1/50 sec. Bei Anklicken von Übernehmen oder Drücken von RETURN werden die Werte übernommen, bei Drücken von ESC oder klicken von Verwerfen, werden die Werte verworfen. Farbwahl (F) öffnet einen Farbwahlrequester. Die Farben werden im aktuellen Verzeichnis in der Datei AmigaRobots.colors abgelegt und beim nächsten Start geladen. Ist die Datei nicht vorhanden setzt das Programm beim Start seine voreingestellten Farben. Programmende (Q) Wenn gerade ein Spiel läuft, kommt vorher noch eine Sicherheitsabfrage. Menü Simulation Start Simulation (S) startet ein Spiel. Wenn der Menüpunkt 'Halt bei einem' aktiv ist, ist dieser Menüpunkt bei weniger als zwei Robotern deaktiviert. Wenn man diesen Punkt während eines laufenden Spieles anklickt, taucht der Spielenderequester auf. Bei anklicken von 'Weiter' wird das Spiel fortgesetzt, bei 'Abbruch' beendet. Einzelschritt (E) Nach jeder Runde wartet AmigaRobots auf eine Taste oder einen Mausklick. Halt bei einem (H) Bei einem Überlebenden stoppt das Programm automatisch und bringt den Spielausgangs-Requester hervor. Feste Postitionen (P) Die Startposition der Roboter wird nicht mehr zufällig gewählt, sondern jeder Roboter, der sich neu anmeldet, bekommt den Platz zugewiesen, den ihm die Arenadatei vorschreibt. Näheres unter dem Abschnitt über Arenen. Menü Position Nach Anwahl eines Roboters im Menü kann man ihn mit einem Mausklick an einem beliebigen Platz in der Arena platzieren. Zum Rückgängigmachen einfach nocheinmal ins Menü klicken. Menü Status Der angewählte Roboter wird ausführlich im Statusfenster angezeigt. Um das Statusfenster zu schließen, einfach das Schließgadget anklicken. Die AmigaRobots Arena --------------------- Die Arena ist ein großes Gebiet von 1000x1000 Feldern. Jeder Roboter kann jede Runde maximal ein Feld vorwärtskommen. Dies ist anders als bei CRobots, wo sich ein Roboter bis zu 100 Felder pro Zug bewegen konnte. Die Arena ist durch das linke Fenster von 500x500 Pixeln repräsentiert. In diesem Window kann man verschiedene Hindernisse sehen, wenn diese in der aktuellen Arenadatei verzeichnet sind. Jedes Hindernis ist weiß umrahmt, die Farbkodes im Inneren haben dabei folgende Bedeutung: Weiß Eine Wand Die Roboter können zwar durch die Wände sehen, sprich scannen, aber weder durchfahren noch durchschießen. Wenn ein Roboter gegen eine Wand fährt, verliert er ein Punkt der Panzerung. Die Wände schützen den Roboter zwar vor direktem Beschuß, aber die Druckwelle eines in der Nähe explodierenden Geschosses trifft ihn trotzdem. Rot Ein Schadensfeld Jede Runde, in der sich ein Roboter auf diesem Feld befindet, verliert er einen Punkt seiner Panzerung. Grün Ein Tankfeld Ein Roboter auf diesem Feld bekommt zusätzliche Energie für seine Batterien. Es gibt in einer Arena höchstens 10 solcher Felder. Später noch mehr zu den Feldern. Die Roboter ----------- Die Roboter werden in der Arena als 5x5 Pixel großes Ikon einer bestimmten Farbe repräsentiert. Die Form kann im Roboterprogramm definiert werden, ansonsten wird ein Roboter als Kreis mit einem Punkt in der Mitte dargestellt. Im umrandeten Fenster am rechten Bildrand sieht man eine Liste der Roboter. Hinter dem Roboternamen taucht ein 'I' auf, wenn dieser unsichtbar ist, dahinter werden die Debugflags '1' und '2' angezeigt. In der Zeile unter dem Roboternamen wird hinter dem 'B' die momentane Batteriefüllung, hinter dem 'P' der Zustand der Panzerung dargestellt. Wenn die Panzerung auf Null fällt scheidet der Roboter aus dem Spiel aus und sein Ikon wird in der Arena durch ein Kreuz ersetzt. Ein schnell fahrender Roboter wird seine Batterien schnell verbrauchen und mit leeren Batterien schließlich bewegungslos auf das Wiederaufladen harren müssen. Wenn ein Roboter eine Kugel abgefeuert hat, wird diese als ein kleiner Punkt dargestellt, der sich von dem Roboter entfernt. Eine Kugel ist doppelt so schnell wie der schnellste Roboter, also viermal schneller als ein normaler Roboter mit 100. Die Koordinaten --------------- Die Arena ist definiert mit dem Feld der Koordinaten 0,0 in der linken oberen Ecke und dem Feld mit den Koordinaten 999,999 in der rechten unteren Ecke des Fensters. Die Richtung 0° zeigt geradewegs nach rechts, und die Winkel steigen im Uhrzeigersinn, so daß 90° gerade nach unten, 180° nach links und 270° nach oben zeigen. Damit kann man original CRobot-Programme benutzen, nur daß dort der Koordinatenpunkt 0,0 rechts unten dargestellt wurde. Das heißt, daß nur die Darstellung gespiegelt wurde. Die Karte --------- Die Arena wird in der Voreinstellung in der Datei PCROBOTS.RNA definiert. Die Arena wird in Felder von 10x10 Pixel aufgeteilt, das sind also 100x100 Quadrate für die ganze Arena. Der Inhalt jedes Quadrates wird als ein Zeichen in der Arenadatei repräsentiert. Jede Zeile der Datei definiert eine Zeile der Arena und jedes Zeichen ein Quadrat in dieser Zeile. Im Idealfall besteht eine Arenadatei aus 100 Zeilen von 100 Zeichen. Jede Zeile, die kürzer als 100 Zeichen und jede Datei die kürzer als 100 Zeilen ist, wird entsprechend mit freien Feldern aufgefüllt. Die Zeichen haben die folgende Bedeutung: '.' Freies Feld Intern durch 'ARENA_FREE' in pcrobots.h deklariert 'X' Eine Wand hat den internen Wert 'ARENA_WALL' durch pcrobots.h 'D' Ein Schadensfeld hat den internen Wert 'ARENA_DAMAGE' 'R' Ein Tankfeld hat den internen Wert 'ARENA_REFUEL' '0'-'9' Vorwahlpositionen für die Roboter 0 bis 9. Das entsprechende Feld ist natürlich frei, also hat den internen Wert 'ARENA_FREE' Der Scanner vom Roboter sieht durch Wände hindurch; also muß man um Kollisionen zu vermeiden periodisch die Funktion 'get_local_map' aufrufen. Diese gibt ein 9x9 Felder großes Gebiet um den Roboter herum zurück. Der Aufruf ist relativ langsam, deshalb sollte man darauf achten ihn nicht häufiger als nötig zu benutzen. Kugeln können Wände nicht durchdringen, weshalb man einen Roboter hinter einer Wand zwar sehen, aber nicht treffen kann. Um zu sehen, ob eine Kugel eine Wand getroffen hat, gibt es die 'get_shell_status'-Funktion, die zurückmeldet, wie der Flug der letzten Kugel geendet hat. Die Batterien der Roboter ------------------------- Die Roboter werden von elektischen Batterien betrieben. Diese Batterien werden jede Spielrunde von einem Solargenerator aufgeladen und von den Robotermotoren entsprechend der Fahrgeschwindigkeit entladen. Bei Spielbeginn sind die Batterien auf 1000 Einheiten aufgeladen. Jede Runde laden die Batterien sich normalerweise um 4 Punkte auf, was einem Batterieladewert von 40 entspricht. Gleichzeitig entlädt sich die Batterie um die momentane Geschwindigkeit durch 10. Die Batterien werden etwas genauer als bei PCRobots behandelt. Dort konnte man nämlich mit 49 fahren, verbrauchte aber nur 4 Batterieeinheiten. Dieser Fehler wurde bei AmigaRobots behoben. Fährt ein Roboter bei AmigaRobots mit 49, bei einem Batterieladewert von 40, so verbraucht der Roboter 9 Runden lang 5 Einheiten und die zehnte Runde 4 Einheiten. Also ist seine Batterie nach zehn Runden effektiv um 9 Einheiten gesunken. Die Batterie kann nicht über 1000 Einheiten aufgeladen werden. Wenn die Batterie verbraucht ist, kommt der Roboter zum Stillstand. Um wieder anzufahren, muß sich dei Batterie erholen und ein 'move'-Befehl benutzt werden. Die Batterieenergie kann außer zum Fahren noch zum Kauf von Munition oder Panzerung verwendet werden. Andererseits kann man auch Panzerung gegen Batterieladung eintauschen. Der Roboter, dessen Treffer zum Ausscheiden eines anderen führte, wird mit dessen Restbatterieladung belohnt. Die erbeutete Ladung wird zu seiner eigenen addiert. Tankfelder ---------- Eine Arena kann bis zu 10 Tankfelder haben. Dort kann jeder Roboter seine Batterien schnell auffüllen. Diese Auffüllstationen sind selbst große, sich schnell aufladende Batterien. Sie laden sich jeden Zug um 5 Einheiten auf, solange sie nicht von einem Roboter angezapft werden. Ihre Kapazität liegt bei 2000 Einheiten. Damit ein Roboter sich aufladen kann, muß er sich auf so einem Feld befinden und sichtbar sein. Jede Runde werden seine Batterien dann zusätzlich um 10 Punkte geladen, solange die Batterien der Ladestation nicht selbst erschöpft sind. Die Konfiguration der Roboter ----------------------------- Roboter müssen sich bevor sie mitspielen können, ersteinmal mit den passenden Parametern konfigurieren. Anders als bei PCRobots ist dies nun bei AmigaRobots Pflicht. Der Konfigurationsbefehl *muß* der erste ausgeführte Befehl sein. Ansonsten ist es dem Roboter nicht möglich sich korrekt am Spiel anzumelden. Normale Roboter sollten bei allen Parametern den Wert 2 besitzen. Wert 0 1 2 3 4 Geschwindigkeit 50 75 100 150 200 Manövrierbarkeit 20% 35% 50% 75% 100% Reichweite 300 500 700 1000 1500 Panzerung 50 75 100 150 200 Beschleunigung 5 7 10 15 20 Man hat 10 Punkte, die man auf diese Eigenschaften verteilen kann, sind die 10 Punkte verbraucht, werden die übrigen Eigenschaften auf 0 gesetzt. Es ist außerdem noch möglich eine Tarnvorrichtung zu kaufen. Die Tarnvorrichtung kostet 1/10 der mitgelieferten Munition. Hat man normalerweise 1000 Kugeln, so startet man mit Tarngerät mit 900. Unsichtbarkeit -------------- Die Tarnung ist ein reines Defensiv-System und ist nutzlos in einem dummen Roboter. Wenn der Roboter unsichtbar wird, kann er nicht mehr von Scannern ausgemacht werden, trotzdem wird er von Kugeln beschädigt, die in seiner Nähe explodieren. Während der Unsichtbarkeit gibt es einige funktionelle Beschränkungen des Roboters. - Scannen ist nicht möglich - Schießen ist nicht möglich - Die Batterie lädt sich *nicht* auf Der Hauptnutzen der Tarnung ist wahrscheinlich das unbemerkte Entkommen eines beschossenen Roboters aus dem Gefahrenbereich und seine Rettung an einen sicheren Ort. Dort könnte er dann seine Batterien sich erholen lassen. Andererseits könnte ein Roboter unsichtbar bleiben, bis ihm ein Aufklärungsroboter die Zielkoordinaten eines gegenerischen Roboters sendet, um plötzlich aus dem Nichts aufzutauchen und diesen zu beschießen. Bevor der beschossene Roboter noch die Zeit gehabt hat, den Schützen genau zu orten, könnte der sich inzwischen wieder in getarnter Sicherheit wiegen. Wenn ein Roboter unsichtbar wird, taucht ein 'I' hinter seinem Namen auf. Ein Roboter kann maximal für 100 Runden unsichtbar bleiben, danach wird er wieder automatisch sichtbar werden. Nachdem ein Roboter wieder sichtbar geworden ist, muß er dieselbe Zeit sichtbar bleiben, die er vorher unsichtbar war. War ein Roboter zum Beispiel gerade für 39 Runden unsichtbar, dann muß er erst wieder mindestens 39 Runden abwarten, bevor er sich wieder unsichtbar machen kann. Schadennehmen ------------- Wenn ein Roboter gegen eine Wand fährt oder getroffen wird, wird er dabei beschädigt. Jeder Schadenspunkt wird ihm von seiner vorhandenen Panzerung abgezogen. Sobald der Roboter keine Panzerung mehr hat, scheidet er aus. Der Schaden wird folgendermaßen berechnet: Kollision mit einer Wand - 1 Punkt Explosion im 50er-Radius - 2 Punkte Explosion im 25er-Radius - 8 Punkte Explosion im 5er-Radius - 25 Punkte Die Explosion wird als Kreis mit drei verschiedenfarbigen Radien dargestellt. Die Farbe des 50er Kreises ist rot, der 25er ist gelb und der 5er ist weiß. Die Roboterprogramme -------------------- Jedes Roboterprogramm ist ein einzelnes ausführbares Amiga-Programm. Zum optimalen Zusammenspiel mit AmigaRobots sowie zur Aufrechterhaltung der Kompatibilität zu PCRobots ist die Einhaltung einiger Regeln vonnöten. - Als erster Befehl muß configure() aufgerufen werden. - man sollte die Datei includen. - es sollten keine Standard Ein/Ausgabefunktionen benutzt werden. Während auf dem Amiga nur der flüssige Ablauf darunter zu leiden hat, stürzt der PC in diesem Fall ab. Da die Roboter- programme auf dem Amiga wirklich selbstständig sind, wäre es denkbar, daß ein Roboter die vorhandenen Arenen einfach nachlädt, was schließlich nicht der Sinn der Sache sein kann. Ein solches Programm würde sich selbst disqualifizieren. Andererseits ist durch absichtliches Brechen mit dieser Regel und dem Nutzen von Amiga-Systemroutinen die reizvolle Implementation eines human-gesteuerten Roboters mit simuliertem Radarsystem denkbar. Der Phantasie sind hier keine Grenzen gesetzt. - Das Programm darf *niemals* enden. Das Hauptprogramm sollte aus einer Endlosschleife bestehen (while(1){}- Konstruktion). AmigaRobots selbst sorgt für die Beendigung des Programmes. Bei Beendigung wird automatisch Speicher, der mit malloc oder calloc angefordert wurde, freigegeben. Achtung! Bei Nutzung von malloc oder calloc geht selbstverständlich die PCRobots- Kompatibilität flöten. Dieser Absatz ist nur für Freaks... Um ein ordentliches Verlassen des Programmes zu Gewährleisten, wird in robotlib.c im Falle eines Spielendes die C-Funktion exit() aufgerufen. Diese Funktion verläßt ein C-Programm orgnungsgemäß mit dem Schließen aller offenen Files und dem Freigeben von alloziiertem Speicher. Hat man zusätzliche System-Resourcen mit Beschlag belegt, sollte man einen exittrap mit atexit() legen. In anderen Sprachen sollte an dieser Stelle ein Pendant zu exit() benutzt werden. - die Speicherbegrenzung von 64k von PCRobots entfällt. Trotzdem sollte man das Roboterprogramm kurz halten. Bei überschreiten dieser Grenze ist der Roboter nur noch auf dem Amiga ausführbar, man sollte also nicht mit Speicher aasen. Merke: es gibt immer einen kürzeren Weg, als den, den Du gehst, und weniger ist manchmal mehr. - Fließkommarechnungen sind nicht gern gesehen. Nicht nur, daß die PCRobots-Kompatibilität flöten geht, sondern der Roboter schluckt unnötig viel Rechenzeit, was die Simulation ermüdend macht. AmigaRobots bietet eine ganze Stange prima Integer-Berechnungen an, so daß Fließkommarechnung überflüssig ist. Sollte jemand eine Fließkommaberechnung wirklich vermissen, ist es kein Problem, AmigaRobots diese mal kurz, effektiv als Integer beizubringen. - Warteschleifen müssen immer einen rechenzeitabgebenden Befehl enthalten (zu rechenzeitabgebenden Befehlen später mehr). z.B. while(olddamage == damage()) { swaptask(); } Sonst kann AmigaRobots das Spiel nicht fortsetzen. Am besten veranschaulichen läßt sich das Spiel als Brettspiel, wo jeder in einer Runde einmal drankommt und dann solange am Zug ist, bis er den Zug beendet hat und der nächste dran ist. Das Spielfeld verändert sich erst am Ende der Runde. Wenn AmigaRobots plötzlich 'hängt' liegt das mit großer Sicherheit an der Mißachtung dieser Regel. Es wartet dann schlicht darauf, daß das fehlerhafte Programm endlich seinen Zug macht. - Der Programmname muß in der Variablen char *_ProgramName enthalten sein. Damit schlägt AmigaRobots zwei Fliegen mit einer Klappe. Einerseits ist die Kompatibilität zu PCRobots gewährleistet, andererseits erledigt der Startup-Code von einigen Compilern, wie z.B. SAS-C® dieses automatisch, so daß man sich nicht mehr darum kümmern muß. Auf Compilern, die dies nicht automatisch erledigen ist es ein Klacks, dies per Hand zu machen, z.B. /* nop ist der einfachste Roboter, auf SAS-C® entfällt die Programname-Zeile */ #include char *_ProgramName = "MeinBesterRoboter"; void main(void) { configure(2,2,2,2,2,0); while(1) { swaptask(); } } Die speziellen Funktionen ------------------------- Die speziellen Funktionen von AmigaRobots werden durch Taskkommunikation und Messageports realisiert. Dazu werden die Felder der Nachricht mit den benötigten Parametern ausgefüllt. Das cmds-Feld wird mit den Funktionswerten ausgefüllt, die den Interruptaufrufen von PCRobots entsprechen (AX). AmigaRobots gibt die Rückgabewerte in der selben Nachricht im ret-Feld zurück. Zusätzliche Parameter werden in vereinbarten Feldern zurückgegeben. Zum Beispiel beim scan-Befehl der Wert von Range. Um die Kommunikation zu ermöglichen, öffnet AmigaRobots zu Beginn einen Rendezvous-Port. Jeder Spieler, der teilnehmen möchte, sendet erst mit dem configure-Befehl seine Konfiguration an AmigaRobots. Dieses öffnet für jeden Spieler einen speziellen Spielerport, dessen Adresse es in der Konfigurationsnachricht zurückreicht. Alle weiteren Befehle des Spielers gehen sodann an den entsprechenden Spielerport. Nur der Rendezvousport ist Public, sodaß niemand die Kommunitation der Prozesse stören kann. Funktionsaufrufe mit einem Kode kleiner als 16 geben die Initiative an den nächsten Roboter ab. Im Moment gibt es für AmigaRoboter ein komfortables Standard- Objektmodul, das man zu jedem Roboter binden muß. Jede Sprache die ein Standart-Objektmodul binden kann, kann also mit geringstem Aufwand zur Programmierung eines AmigaRobot-Roboters benutzt werden. Für die Sprache C ist alles fertig, andere Sprachen sind ohne großen Aufwand implementierbar. Der Sourcecode des Objektmodules ist als robotlib.c und ar_comm.h beigelegt. Wenn jemand AmigaRobots-Roboter in einer anderen Sprache schreibt, kann er diesen Code frei benutzen. Ich bitte um Zusendung der entsprechenden Module, damit ich sie auch für zukünftige Erweiterung nutzbar machen kann. Funktionsnamen -------------- void swaptask(void); procedure swaptask; ==================== Diese Funktion beendet den Zug des Roboters und gibt die Kontrolle zurück an AmigaRobots. Die Funktion kann gut benutzt werden, um auf bestimmte Ereignisse zu warten. Dieser Befehl beendet den Zug des Roboters. void movement(int speed, int angle); procedure movement(speed,angle:integer); ======================================== Dieser Befehl veranlaßt den Roboter, sich in eine bestimmte Richtung mit einer bestimmten Geschwindikeit zu bewegen. speed = 0 - max speed of robot (<=200) angle = 0 - 359 degrees Die Geschwindigkeit ändert sich mit der konfigurierten Beschleunigungsrate. Wenn der Roboter außerhalb seiner Manövrierbarkeit ist, muß er für eine Richtungsänderung erst langsamer werden. Dieser Befehl beendet den Zug des Roboters. int scan(int angle,int res,int *range); function scan(angle,res:integer;var range:integer):integer; =========================================================== Dieser Befehl scannt nach einem Roboter in eine bestimmte Richtung mit gegebener Auflösung. angle = 0 - 359 degrees res = 0 - 45 degrees Zurückgegeben wird die ID-Nummer des nächsten Roboters oder -1 wenn keiner zu sehen war. Die Roboter haben die ID-Nummern von 0 bis 32k. Wenn ein Roboter gefunden wurde, enthält range seine Entfernung. Wenn kein Roboter gefunden wurde, hat range keine Bedeutung. Dieser Befehl beendet den Zug des Roboters. int shoot(int angle,int range); function shoot(angle,range:integer):integer; ============================================ Dieser Befehl veranlaßt den Roboter, in eine Richtung auf eine Entfernung zu schießen. Die Kugel zeigt erst an ihrem Zielpunkt Wirkung, es sei denn sie ist vorher gegen ein Hindernis geflogen und zerstört. angle = 0 - 359 degrees range = 0 - max range of robot's cannon Wenn der Roboter imstande war, einen Schuß abzugeben, gibt die Funktion eine 1 zurück, im anderen Falle eine 0. Das Geschütz des Roboters ist unabhängig von seiner Fahrrichtung, also kann in jede Richtung gefeuert werden. Die Nachladedauer der Kanone ist 50 Runden. Die Begrenzung von PCRobots auf gleichzeitig höchstens 7 Schuß pro Roboter in der Luft wurde auf 14 erhöht, so daß effektiv keine Begrenzung mehr existiert. Bei PCRobots bekommt jeder Roboter zu beginn 1000 Schuß. Da diese 1000 Schuß erst nach frühestens 50000 Runden verschossen werden können, rate ich, die mitgegebene Munition zu senken und bei der Programmierung den Fall einer Munitionsknappheit zu berücksichtigen. Mit der Funktion 'buy_shells' kann man Munition für Batterieeinheiten kaufen. Im Falle von konfigurierter Tarnfähigkeit werden nur 9/10 der üblichen Munition ausgeliefert. Dieser Befehl beendet den Zug des Roboters. Die folgenden Funktionen beenden nicht den Zug des Roboters ----------------------------------------------------------- void getxy(int *x,int *y); procedure getxy(var x,y:integer); ================================= Diese Funktion gibt die momentane Position des Roboters zurück. Die x/y-Koordinaten werden in den x/y-Variablen zurückgegeben. Die Werte reichen von 0 - 999. int transmit(int target,int data); function transmit(target,data:integer):integer; =============================================== Diese Funktion sendet dem Roboter mit der ID target das 32-Bit-Wort data. target = Roboter ID, wie in scan erhalten data = 32-Bit Wort Wenn erfolgreich gesendet werden konnte, gibt die Funktion den Wert 1 zurück, im Falle eines Fehlers 0. Roboter haben einen 20 Wort großen FIFO Puffer, wo hereinkommende Wörter auf ihren Abruf warten. Wenn der Puffer voll ist, oder der Zielroboter nicht (mehr) existiert, gibt die Funktion den Wert 0 zurück. Ein erfolgreiches Transmit heißt nicht, daß der Empänger die Nachricht auch gelesen hat. Das Senden einer Nachricht kostet eine Batterieeinheit. int receive(int *source,int *data); function receive(var source,data:integer):integer; ================================================== Mit dieser Funktion kann man Nachrichten lesen, die mit transmit von einem Roboter gesendet wurden. Wenn mindesten eine Nachricht vorhanden war, gibt die Funktion eine 1 zurück, im anderen Fall eine 0. Wenn eine Nachricht vorhanden war, enthält source die ID des Senderoboters und data die Nachricht. Im anderen Fall sind die Werte ohne Belang. Da diese Funktion den Roboter keinen Zug kostet, sollte sie periodisch von jedem Roboter aufgerufen werden, um den Empfangspuffer frei zu halten, selbst wenn er die Daten nicht benötigt. int damage(void); function damage:integer; ======================== Diese Funktion holt den Schadensstatus des Roboters. Bei einem heilen, durchschnittlich konfigurierten Roboter sind das 100 Punkte. Wenn der Roboter zerstört ist, sind es 0 Punkte. Je niedriger der Rückgabewert der Funktion ist, desto zerstörter ist der Roboter. int speed(void); function speed:integer; ======================= Diese Funktion gibt die momentane Geschwindikeit des Roboters zurück. int battery(void); function battery:integer; ========================= Diese Funktion meldet den Status der Batterie. long ticks(void); function ticks:longint; ======================= Diese Funktion meldet die Anzahl der gelaufenen Spielrunden seit Spielbeginn. Es hat nichts zu tun mit der real verstrichenen Zeit, sondern nur mit der Anzahl vollständig abgelaufener Runden. long l_sin(int angle); function l_sin(angle:integer):longint; ====================================== Diese Funktion gibt den Sinuswert des Winkels angle, multipliziert mit dem Faktor 100.000 zurück. angle = 0 - 359 Diese Funktion sollte benutzt werden um den Gebrauch von Fließkommazahlen in Programmen zu vermeiden. Integerzahlen sind schneller und völlig ausreichend. long l_cos(int angle); function l_cos(angle:integer):longint; ====================================== Diese Funktion gibt den Cosinuswert des Winkels angle, multipliziert mit dem Faktor 100.000 zurück. angle = 0 - 359 Diese Funktion sollte benutzt werden, um den Gebrauch von Fließkommazahlen in Programmen zu vermeiden. Integerzahlen sind schneller und völlig ausreichend. long l_tan(int angle); function l_tan(angle:integer):longint; ====================================== Diese Funktion gibt den Tangenswert des Winkels angle, multipliziert mit dem Faktor 100.000 zurück. angle = 0 - 359 Diese Funktion sollte benutzt werden um, den Gebrauch von Fließkommazahlen in Programmen zu vermeiden. Integerzahlen sind schneller und völlig ausreichend. int l_atan(long ratio); function l_atan(ratio:longint):integer; ======================================= Diese Funktion gibt den Arcustangens (inv tan) des Wertes ratio zurück. Ratio sollte mit dem Faktor 100.000 skaliert werden. Der Rückgabewert ist der Winkel von -90° bis +90°. Diese Funktion sollte benutzt werden, um den Gebrauch von Fließkommazahlen in Programmen zu vermeiden. Integerzahlen sind schneller und völlig ausreichend. long l_sqrt(long square); function l_sqrt(square:longint):longint; ======================================== Diese Funktion gibt die Quadratwurzel von square zurück. Diese Funktion sollte benutzt werden um, den Gebrauch von Fließkommazahlen in Programmen zu vermeiden. Integerzahlen sind schneller und völlig ausreichend. void set_pattern(const char *pattern); procedure set_pattern(Buffer:Patbuf_ptr); ========================================== Dieser Befehl definiert die Darstellung des Roboters in der Arena. Das Pattern besteht dabei aus 5 Bytes. Die unteren 5 Bits jedes Bytes werden dann als Bitmuster für die Darstellung des Ikons benutzt. In C könnte das so aussehen: const char pattern[5] = {1,3,7,0xf,0}; ... set_pattern(pattern); In Pascal geschieht dies so: Pattern_buffer=array[0..5] of shortint; Patbuf_ptr=^Pattern_buffer; void debug_flag(int flag_no,int flag_set); procedure debug_flag(flag_no,flag_set:integer); =============================================== Dieser Befehl erlaubt das Setzen oder Löschen von Debug-Flaggen im Anzeigefenster der Roboter. flag_no = 0 or 1 flag_set= 0 or 1 Diese beiden Flaggen können für jede beliebige Anzeige benutzt werden, die der Programmierer sich wünscht. Normalerweise benutzt man sie, um interne Zustände während des Ablaufes sichtbar zu machen. void buy_armour(int units); procedure buy_armour(units:integer); ==================================== Mit diesem Befehl kann man Panzerung kaufen oder verkaufen. units = Anzahl der zu kaufenden Einheiten Wenn units negativ ist, wird Panzerung verkauft. Eine Panzerungseinheit entspricht momentan 50 Batterieeinheiten. So kann ein schwer getroffener Roboter mit viel Restenergie die Energie zu seiner Reperatur benutzen. Andererseits kann ein flüchtender Roboter einige Panzerungseinheiten in Batterieeinheiten wandeln, um schnell das Weite suchen zu können. Weder kann die Panzerung über das konfigurierte Maß steigen, noch die Batterie über 1000. Jede Überschreitung der Maximalwerte führt zu Verschwendung und damit zu Verlust. Bei Verkauf der gesamten Panzerung (Schilde) zerstört sich der Roboter selbst. void buy_shells(unsigned int units); procedure buy_shells(units:word); ==================================== Dieser Befehle ermöglicht den Kauf von Munition. units = Anzahl der zu kaufenden Munition. Man kann Munition nicht wieder verkaufen und Batterieeinheiten bekommen. Eine Kugel kostet 10 Batterieeinheiten. int shells_left(void); function shells_left:integer; ============================= Diese Funktion meldet die verbleibende Munition. void get_local_map(char *buffer); procedure get_local_map(ptr:MapBuf_ptr); ======================================== Diese Funktion meldet dem Roboter das Aussehen der Arena in seiner näheren Umgebung. Dazu füllt sie ein 9x9 Bytes großes Feld aus, mit dem mittleren Feld als der momentanen Position des Roboters. Im Absatz über die Karte sind die Werte besprochen, die die einzelnen Felder erhalten. C/C++ Der Vektor muß mindesten 81 Bytes lang sein. Pascal Es gibt 2 Typdefinitionen: Map_buffer=array[0..8,0..8] of shortint; Mapbuf_ptr=^Map_buffer; Der Zeiger auf den Map_buffer muß übergeben werden. void invisibility(int invis_flag); procedure invisibility(invis_flag:integer); =========================================== Der Befehl erlaubt dem Roboter, unsichtbar oder sichtbar zu werden. invis_flag = 0 - Roboter ist sichtbar, = 1 - Roboter ist unsichtbar. Wenn der Roboter nicht unsichtbar werden konnte, tut dieser Befehl nichts. int get_shell_status(void); function get_shell_status:integer; ================================== Diese Funktion meldet dem Roboter, was mit der letzten aufgetroffenen Kugel passierte. Rückgabewert: 0 - Kugel traf nichts (SHELL_MISSED) 1 - Kugel traf eine Wand (SHELL_HIT_WALL) 2 - Kugel traf einen Roboter im 50er Radius (SHELL_CLOSE_BLAST) 3 - Kugel traf einen Roboter im 25er Radius (SHELL_NEAR_MISS) 4 - Kugel traf einen Roboter im 5er Radius (SHELL_DIRECT_HIT) -1 - Kugel traf einen Roboter im 50er Radius (SHELL_NOT_AVAIL) Diese Funktion kann zum Beispiel dazu benutzt werden, um festzustellen, ob sich der beschossene Roboter hinter einer Wand verschanzt. Der Wert SHELL_NOT_AVAIL ist eine Erweiterung von AmigaRobots gegenüber PCRobots. Wenn man die Funktion get_shell_status aufruft, wird das Register auf diesen Wert gesetzt. Damit ist eine Zeitsynchronisation möglich. Das heißt das der Status jedes Schußes kann nur genau einmal gelesen werden. Hat seit dem letzten get_shell_status keine weitere Kugel ihren Flug beendet, gibt die Funktion den Wert SHELL_NOT_AVAIL zurück. int isinvisible(void); function isinvisible:integer; ============================= Diese Funktion meldet, ob der Roboter gerade unsichtbar ist, oder nicht. Rückgabewert: 0 - Roboter ist sichtbar 1 - Roboter ist unsichtbar int l_atan2(int y,int x); function l_atan2(y,x:integer):integer; ====================================== Diese Funktion gibt den Wert des Arcustangens von y/x zurück, selbst wenn x gleich oder in der Nähe von 0 ist. Wenn sowohl x als auch y den Wert 0 haben, gibt diese Funktion 0 zurück. Die Funktion verhält sich genauso wie das entsprechende C-Pendant. int configure(int speed,int manouevre,int range,int armour,int acceleration,int invisibility); function configure(speed,manouevre,range, armour, acceleration,invisibility:integer):integer; ========================================================== Dieser Befehl erlaubt das Konfigurieren eines Roboters zu Beginn des Spieles. Es *muß* der erste ausgeführte Befehl sein. Für die Werte siehe im Abschnitt Konfiguration nach. Wenn die Konfiguration geklappt hat, gibt sie eine 1 zurück, im Falle, daß sie nicht der erste Befehl ist, eine 0. Assembler --------- Wer die Roboter unbedingt in Assembler programmieren will, kann dies sehr einfach tun. Er bindet die robotlib.o-Datei an seinen assemblierten Code, in dem er die obigen Befehle mit bsr _ aufruft. Der Rückgabewert wird in D0 zurückgegeben, die Parameter übergibt man auf dem Stack. move.l para1,-(a7) move.l para2,-(a7) move.l para3,-(a7) Das Setzen der __ProgramName - Variablen nicht vergessen! Hoffe ich jedenfalls... Wenn ich hier beim Assembler so ad hoc einen Fehler gemacht haben sollte, möge man das verzeihen. Pascal ------ Habe ich noch nicht ausprobiert. Das Original PC-Robotsfile habe ich beigelegt. Normalerweise müßte man einfach die robotlib.o-Datei binden und dem Pascal die Syntax der Befehle verklickern. Das sollte eigentlich reichen. Wenn jemand damit Erfolg haben sollte, wäre ich über das Zusenden sehr erfreut, damit ich es auch anderen Pascal-Fraggles zugänglich machen kann. Komplilieren eines Roboters in C ------------------------------ Ich habe dem Archiv ein Beispiel-Makefile beigelegt, das einwandfrei mit SAS-C® funktioniert. Zur Herstellung eines Roboters einfach den Source in das Roboterverzeichnis legen, den Namen des Roboters mit der Extension .rob in der obersten Zeile eintragen und 'make' aufrufen. Grundsätzlich muß folgendes getan werden: 1. C-Source erstellen, der die Mindestanforderung eines AmigaRoboters erfüllt, nämlich a) #include b) ein Einsprungpunkt (wie jedes C-Programm) main(){} c) der Aufruf der Funktion configure(...); d) eine Endlose Schleife, z.B. while(1){...} e) in dieser Schleife mindestens einen rechenzeitabgebenden Befehl, z.B. swaptask(); 2. Vorhandensein und Setzen der Variablen _ProgramName, bei SAS-C® im Startupcode, ansonsten durch den Befehl char *_ProgramName = "Beispiel.rob"; zu Beginn des Programmes. Im saubersten Falle in #ifdef und #endif eingeschlossen, die auf Vorhandensein des eigenen Compilers prüfen. 3. Als 68000er-Code komplilieren. 4. Binden mit a) Startup-code (c.o) b) Programm-Objektcode (Programmname.o) c) AmigaRobots-Objektcode (robotslib.o) d) Standard-C Library (c.lib, oder bei SAS® sc.lib) Viel Spaß mit AmigaRobots! wünscht euch Hanno Behrens