Ioquake3 Server und Build Service

Aus Gargi.org
Version vom 7. Juni 2018, 20:51 Uhr von Gargi (Diskussion | Beiträge)
(Unterschied) ← Nächstältere Version | Aktuelle Version (Unterschied) | Nächstjüngere Version → (Unterschied)
Zur Navigation springen Zur Suche springen

logo

Logo Phantasie

Prolog

Nachdem id Software den Quelltext ihres Ego-Shooter Quake III Arena im August 2005 (Meldung Golem.de 20.08.2005) freigegeben hat und den größten Teil davon unter die GPL (Wikipedia Link Thema GPL) gesetzt hat, haben sich mittlerweile einige Projekte daran gemacht, den Quellcode weiterhin zu pflegen und gar zu verbessern. Eines dieser Projekte findet sich unter ioquake3 (kurz ioq3) (ioq3 Projektseite), das hier einige neuen Features eingebaut hat und weiterhin den Quellcode verbessert. Einige zusätzlichen Features sind das Implementieren von openAL, was den Sound verbessert, die Implementierung von IPV6, Unterstützung von 64bit Betriebssystemen, Anaglyph stereo rendering für 3D Brillen, verbesserte QVM (Quake Virtual Machine) tools und im Spiel integriertes VOIP. Weitere Neuerungen findet Ihr im Bereich Improvements auf der ioq3 Projektseite.

Der Quellcode des Projekts war ursprünglich auf dem SVN icullus Server hinterlegt, auf dem sich viele Linux Projekte aus dem Spielesektor befinden. Ende 2012 hat man diesen dann auf git umgestellt. Der Quellcode liefert neben dem dedicated Server auch den Windows Client. So kann auf Windows selbst der Quelltext kompiliert werden, oder über einen Crosscompiler (mingw) auf Linux.

Bei der Freigabe des Quellcodes sei folgendes angemerkt: Sämtliche Hooks zum Punkbuster Dienst wurden entfernt, da Punkbuster closed Source ist. D.h. ioquake arbeitet nicht mit dem Punkbuster. Dennoch ist es soweit kompatibel zu den Servern, die online sind und kein Punkbuster verlangen. Ebenso lässt der dedicated ioquake3 Server herkömmliche Quake III Klienten zu. Desweiteren handelt es sich bei den übersetzten Dateien dann um die rein ausführbaren Files. Es wird deshalb das Originalspiel benötigt um zum einen einen CD Key einzugeben und zum anderen die auf der CD befindlichen pak Files zu kopieren. Die pak Datei beinhaltet nicht freigegebenes Material wie die Maps, Sounds, Models, Texturen und so weiter. Erst zusammen mit einer Original CD kann dann ioquake3 gespielt werden.

Auf der CD werdet Ihr die pak0.pk3 als einziges pak File finden. Mittlerweile sind bei dem rund 10 Jahre alten Spiel einige Patches erschienen, die diverse Updates über neu pak Files mitbringen. Damit wir auch alle aktuelle Versionen haben, könnt Ihr die neuen zhusätzlichen pak Files unter folgender URL herunterladen: Updated pak Files. Dazu müsst Ihr die EULA akzeptieren. In dem gepackten Archiv befinden sich dann die pak1.pk3 bis pak8.pk3 die in das baseq3 Verzeichnis der ioquake3 Installation kopiert werden.

orbi

Quake3 Gladiator aus dem Kugelschreiber

Fertige ioquake3 Pakete für Windows, Linux und Mac können hier heruntergeladen werden: ioq3 - get it Link-Text
Zudem halten einige Linuxdistributionen relativ aktuelle Versionen über entsprechende Repositories bereit, die über den jeweiligen Paketmanager der Distribution installiert werden können. Hier müsst Ihr entsprechend nachforschen, welches Repository bei Eurer bevorzugten Distribution verwendet werden muss.

Im Folgenden findet Ihr nun Texte, die sich um einige technische Dinge rund um das ioq3 Projekt drehen und weniger Tipps zum Spiel selbst. Da es hier um weiterführende Themen geht wie das Erstellen eines Servers oder das Kompilieren des Quellcodes auf Linux sei hier angemerkt, dass die Texte für Interessenten mit mittleren bis einwenig besseren Linuxkenntnissen verfasst sind. Ich versuche natürlich alles so detailiert wie möglich zu beschreiben, kann aber leider nicht überall auf die Basics eingehen. Zudem verwende ich sowohl Debian als auch openSUSE. Wobei Debian meine Wahl der Serversoftware ist und openSUSE auf meinem Desktop zum Einsatz kommt und nur wenig hierüber berichtet wird (bis auf die Anleitung, ioq3 unter openSUSE zu kompilieren). Von daher solltet Ihr halbwegs fit auf Debian (oder debianähnlichen Systemen wie Ubuntu) sein und wissen, wie man Pakete an der Konsole erstellt und sich auf der Konsole bewegt. Zudem ist es von Vorteil, grundlegendes über Networking unter Linux zu kennen, damit auch ein Connect von außen auf den dedicated Server funktioniert.

Fragen hierzu beantworte ich aber immer gerne auf meinem Forum unter http://www.gargi.org

Jetzt wünsche ich Euch viel Vergnügen beim Basteln und Spielen mit dem Quellcode!

Dedicated Server auf Linux

Ich verwende hierfür ein Debian Linux Squeeze (64 bit) auf einem intel Atom 270er Server mit 2GB Ram. Die Entwicklertools sollten hierfür installiert sein: 

apt-get install build-essential git

Installiert zudem noch folgende Pakete: 

apt-get install screen libcurl4-dev openssl-dev libsdl1.2-dev libopenal-dev

Jetzt ziehen wir uns den Quellcode. In einem Buildverzeichnis führt folgenden Befehl aus: 

git clone git://github.com/ioquake/ioq3.git quake3

Danach wechselt in das quake3 Verzeichnis: 

cd quake3

Kompiliert nun das Game: 

make USE_LOCAL_HEADERS=0

Multicore CPU Besitzer starten den Vorgang mit einem 

make -j3 USE_LOCAL_HEADERS=0

Danach installiert alles mit einem 

make copyfiles

Die Installationsdateien landen somit erstmal alle in /usr/local/games/quake3

Wir legen nun noch einen Link auf unsere Serverbinärdatei: 

ln -s /usr/local/games/quake3/ioq3ded.x86_64 /bin/q3ded

Wir wollen nun das Spiel nicht als root ausführen, also legen wir uns einen eigenen User mit einem eigenen Homeverzeichnis dafür an: 

adduser gameserver

Loggt Euch nun als Euer neuen User gameserver ein und legt in Eurem Homeverzeichnis folgende Verzeichnisse an: 

mkdir .q3a
mkdir .q3a/baseq3


Launcher

Ihr solltet nun Q3A bereits auf Euren Rechner normal installiert und mindestens auf die Version 1.32 gepatcht haben. Kopiert nun von Eurem Desktop Rechner alle *.pk3 Dateien aus dem /baseq3 Verzeichnis auf Euren Server. Hierfür loggt Euch am besten via ftp auf den User gameserver ein und transferiert die pk3s dort hin.

Zum Schluss müsst Ihr noch in Eurem /baseq3 Verzeichnis Eures Servers (im Homeverzeichnis des Users gameserver) eine Konfigurationsdatei anlegen. Diese nennen wir mal server.cfg . Ein gutes Sample findet Ihr unter folgender URL: Quake3 Dedicated Server unter Linux Ändert entsprechend noch die Bereiche wie Servername, E-Mail etc. ab. Das Sample ist sehr gut dokumentiert wobei dieses fast selbsterklärend ist. Wenn Ihr die Datei angelegt habt können wir eigentlich schon den Server als normaler User starten.

Da Ihr dies sicherlich aus der Konsole heraus tut, startet zu erst screen: 

screen

Danach kann der Server gestartet werden: 

q3ded +set dedicated 2 +com_hunkMegs 64 +exec server.cfg

Wenn Ihr die Konsole schließt, dann könnt Ihr beim nächsten Einloggen wieder mit einem 

screen -R

den laufenden Server wieder aufrufen.

Hinweise:
a) Die Konfigurationsdatei sollten mindesten 4 Buchstaben haben (1234.cfg). Bei nur drei startete der Server bei mir nicht richtig

b) Folgende Ports müssen auf einem internen Server freigegeben sein:
- UDP IN: 27960
- UDP OUT: 27950 und 27960
- Router auf internen Server: UDP IN 27960 -> IP interner Server

Windows Client via mingw Crosscompiler

Interessant ist nun, wie man das Teil für Windows kompiliert. Wir werden in diesem Howto einen etwas "anderen" Weg dafür über Linux geben, da hierfür die Compiler recht einfach zu installieren und zu handaben sind. Als Buildumgebung nutze ich ein Debian Linux 5 Lenny.

Zunächst installieren wir entsprechende die Buildfiles und noch ein paar Kleinigkeiten nach: 

apt-get install subversion libcurl4-openssl-dev libsdl1.2-dev libopenal-dev build-essential git

Das zieht noch einige Pakete nach.

Jetzt benötigen wir den Crosscompiler, der uns hilft, Windowsdateien zu bauen: 

apt-get install gcc-mingw32 mingw32-runtime mingw32-binutils

Das war's dann auch schonmal für's erste an neuen Dateien.

Jetzt legen wir uns ein Buildverzeichnis an und wechseln dorthin: 

mkdir work
cd work

Nun holen wir uns den aktuellen Quellcode: 

git clone git://github.com/ioquake/ioq3.git quake3

Hier der Hinweis, dass Ihr den Port 9418 (TCP_OUT) freischalten müsst, solltet Ihr eine Firewall am Laufen haben.

Danach in das Quellverzeichnis wechseln: 

cd quake3

Und nun können wir schon mit dem Compile beginnen: 

make PLATFORM=mingw32 ARCH=x86

Das kann jetzt eine kleine Weile dauern. Es sollte soweit alles fehlerfrei durchlaufen. Wenn fertig habt Ihr alle benötigten Dateien unter folgendem Verzeichnis:

/work/quake3/build/release-mingw32-x86

Diese kopiert dann (via ftp oder ähnliches) auf Euren Windowsrechner in ein beliebiges Verzeichnis:

---Q3A
-ioq3ded.x86.exe
-ioquake3.x86.exe
-renderer_opengl1_x86.dll
---baseq3
-cgamex86.dll
-qagamex86.dll
-uix86.dll
---missionpack
-cgamex86.dll
-qagamex86.dll
-uix86.dll

Das alleine genügt natürlich noch nicht zum Spielen.

Gauntlet

Gauntlet mit Kulli gezeichnet

In das Verzeichnis baseq3 muss dann noch die Datei pak0.pk3 von Eurer Original CD kopiert werden. Dieses File (ca. 500MB) beinhaltet die ganzen Level, Modelle, Texturen etc. und ist dementsprechend urheberrechtlich geschützt.

Um nun alle Patches zu verwenden macht einfach folgendes: Ladet Euch ein vorkompiliertes ioquake3 Pakete für Windows hier herunter: Get it | ioquake3

Alternativ gibt es auch die aktuellen pak file Updates unter folgender URL: http://ioquake3.org/patch-data

Kopiert nach der Installation einfach aus dem baseq3 und missionpack Verzeichnis alle weiteren pak*.pk3 Dateien in Euer eigenes baseq3 Verzeichnis.

Zudem benötigt Ihr noch openAL für den Sound. Diese könnt Ihr falls noch nicht installiert hier herunterladen und installieren: Downloads In Eurem Windows System Verzeichnis findet sich dann eine openAL32.dll. Dise kann natürlich auch gleich in das neue Q3A Stammverzeichnis (also dort wo sich die exe Dateien befinden) kopiert werden.

Last but not least muss noch eine SDL.dll her. Diese Medialibrary bekommt Ihr unter folgender URL: Simple DirectMedia Layer Ladet die entsprechende win32 zip Datei herunter und packt die SDL.dll ebenso in das Rootverzeichnis Eurer Q3A Installation (auch zu den exe - Dateien).

Das war's dann auch schon. Das Spiel kann dann über die ioquake3.x86.exe gestartet werden.

Testsystem bei mir: Kompiliert auf Debian Lenny 5 64bit intel Atom 270 Windowsmaschine: intel C2D 8400, Windows Vista 64bit.

Wenn alles sauber läuft, dann startet das Game durch und Ihr habt in der Konsole einen in etwa so aussehenden Output: 

4073 files in pk3 files
execing default.cfg
execing q3config.cfg
couldn't exec autoexec.cfg
Hunk_Clear: reset the hunk ok
----- Client Initialization -----
Couldn't read q3history.
----- Initializing Renderer ----
-------------------------------
QKEY found.
----- Client Initialization Complete -----
----- R_Init -----
SDL using driver "directx"
Initializing OpenGL display
Estimated display aspect: 1.250
...setting mode 8: 1280 1024
Using 8/8/8 Color bits, 24 depth, 0 stencil display.
Available modes: '1280x1024 720x576 640x480 800x600 1024x768 1152x864 1280x960 720x480 960x600 1280x800 
1280x768 848x480 1280x720'
GL_RENDERER: GeForce 8800 GT/PCI/SSE2
Initializing OpenGL extensions
...ignoring GL_EXT_texture_compression_s3tc
...ignoring GL_S3_s3tc
...using GL_EXT_texture_env_add
...using GL_ARB_multitexture
...using GL_EXT_compiled_vertex_array
...ignoring GL_EXT_texture_filter_anisotropic

GL_VENDOR: NVIDIA Corporation
GL_RENDERER: GeForce 8800 GT/PCI/SSE2
GL_VERSION: 3.0.0
GL_EXTENSIONS: GL_ARB_color_buffer_float GL_ARB_depth_texture GL_ARB_draw_buffers GL_ARB_draw_instanced 
GL_ARB_fragment_program GL_ARB_fragment_program_shadow GL_ARB_fragment_shader 
GL_ARB_half_float_pixel GL_ARB_half_float_vertex GL_ARB_framebuffer_object 
 
[...]

GL_MAX_TEXTURE_SIZE: 8192
GL_MAX_TEXTURE_UNITS_ARB: 4

PIXELFORMAT: color(24-bits) Z(24-bit) stencil(0-bits)
MODE: 8, 1280 x 1024 fullscreen hz:N/A
GAMMA: hardware w/ 0 overbright bits
rendering primitives: single glDrawElements
texturemode: GL_LINEAR_MIPMAP_LINEAR
picmip: 0
texture bits: 0
multitexture: enabled
compiled vertex arrays: enabled
texenv add: enabled
compressed textures: disabled
Initializing Shaders
----- finished R_Init -----
------ Initializing Sound ------
Loading "OpenAL32.dll"...
Allocated 96 sources.
OpenAL default capture device is 'Mikrofon (USB Audio)'
OpenAL capture device opened.
OpenAL info:
  Vendor:     Creative Labs Inc.
  Version:    1.1
  Renderer:   Software
  AL Extensions: EAX EAX2.0 EAX3.0 EAX4.0 EAX5.0 EAX3.0EMULATED EAX4.0EMULATED AL_EXT_OFFSET 
AL_EXT_LINEAR_DISTANCE AL_EXT_EXPONENT_DISTANCE
  ALC Extensions: ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE ALC_EXT_EFX
  Device:     ******* Software
Available Devices:
SB Audigy 4 [D000]
******* Software
Sound initialization successful.
--------------------------------
Loading vm file vm/ui.qvm...
VM file ui compiled to 594408 bytes of code
ui loaded in 1368576 bytes on the hunk
35 arenas parsed
32 bots parsed



Crosscompiler auf openSUSE

YAST

Um den freien Port ioquake3 des id Shooters Q3A via Crosscompiler auf openSUSE (in unserem Beispiel ein openSUSE leap 42.2 64bit) für Microsoft Windows zu übersetzen, müssen wir zuerst den Compiler mingw installieren. Hiefür müssen wir ein neues Repository unter YAST anlegen, da der mingw nicht in den Standard Repositories zu finden ist.

Das Repository findet Ihr unter folgender Adresse:

SERVER: http://download.opensuse.org

VERZEICHNIS: repositories/windows:/mingw:/win32/openSUSE_42.2/


Tragt diese Informationen wie im rechten Bild zu sehen ein und übernehmt die Änderung. Es wird zudem noch ein Sicherheitsschlüssel mit installiert.

Danach könnt Ihr über YAST folgende Pakete installieren:

  • mingw32-binutils
  • mingw32-gcc
  • mingw32-cross-binutils
  • mingw32-cross-gcc


Jetzt legen wir uns im Homeverzeichnis unseres Users ein Buildverzeichnis work an: 

mkdir work

Dort laden wir uns die aktuellen Quellen herunter: 

git clone git://github.com/ioquake/ioq3.git quake3

Danach wechseln wir in das Verzeichnis quake3: 

cd quake3

Dort stoßen wir dann den Kompile an: 

make PLATFORM=mingw32 ARCH=x86

Nach einer kurzen Wartezeit solltet Ihr dann nun unter dem Verzeichnis quake3/build/release-mingw32-x86 Eure fertigen Dateien finden. Diese könnt Ihr dann auf Euren Windowsrechner wie gewohnt installieren.

Crosscompile Windows 64 bit Version unter openSUSE

Basis hierfür ist ein openSUSE leap 42.2 in einer 64bit Version.

Als erstes installieren wir dafür einen 64bit Crosscompiler. Dazu legen wir eine neue Installationsquelle via YAST an. Bei den Software Repositories legt ein neues Repository an, indem Ihr folgende URL (als http Variante) angebt: 

http://download.opensuse.org/repositories/windows:/mingw:/win64/openSUSE_42.2/

Die Änderung speichert dann ab. Jetzt geht Ihr auf Software installieren und installiert folgende Pakete:

mingw64-cross-binutils
mingw64-cross-gcc
mingw64-headers
mingw64-libSDL
mingw64-libSDL2
mingw64-libcurl4
mingw64-openal-soft

Das zieht Euch noch einige Pakete nach.

Legt Euch nun irgendwo ein neues Verzeichnis an, in dem Ihr Eure fertigen Dateien später kopiert, z.B. ioquake3. Darunter legt zwei weitere Verzeichnisse an: baseq3 und missionpack.
Kopiert danach zunächst folgende dlls nach Euer ioquake3 Verzeichnis:

/usr/x86_64-w64-mingw32/sys-root/mingw/bin/libcurl-4.dll
/usr/x86_64-w64-mingw32/sys-root/mingw/bin/OpenAL32.dll
/usr/x86_64-w64-mingw32/sys-root/mingw/bin/SDL.dll

Die letztere SDL.dll benennt in SDL64.dll um.

Danach wechselt in ein beliebiges Arbeitsverzeichnis auf der Konsole und zieht Euch die ioquake3 sourcen herunter: 

git clone git://github.com/ioquake/ioq3.git quake3

Wechselt in das neue Verzeichnis quake3: 

cd quake3

Dann stoßt den Kompile an: 

make PLATFORM=mingw32 ARCH=x86_64

Dieser sollte dann sauber durchlaufen. Wenn alles okay ist, dann liegen Eure neuen Daten unter /quake3/build/release-mingw32-x64.

Aus dem dortigen Verzeichnis kopiert folgende Dateien in Euer ioquake3 Verzeichnis:

ioq3ded.x86_64.exe
ioquake3.x86_64.exe
renderer_opengl1_x86_64.dll
renderer_opengl2_x86_64.dll

Aus dem baseq3 Verzeichnis dann in das ioquake3/baseq3 Verzeichnis:

cgamex64.dll
qagamex64.dll
uix64.dll

Aus dem missionpack Verzeichnis dann in das ioquake3/missionpack Verzeichnis:

cgamex64.dll
qagamex64.dll
uix64.dll

Das war es im Grunde auch. Ihr benötigt dann natürlich noch die pak0.pak Datei von Eurer Original Quake 3 CD. Dazu die PAK Patches, die Ihr unter anderem hier http://ioquake3.org/get-it/ findet. Unter Windows kopiert dann alles entsprechend zusammen und startet das Spiel mit ioquake3.x86_64.exe.

Q3mon installieren

Der Q3mon ist ein Servermonitor, der auf Perl geschrieben ist. Damit dieser auf Eurem Webserver läuft muss ersteinmal das Perl Modul für den Apache installiert werden: 

apt-get install libapache2-mod-perl2

Damit das Perl aktiv wird muss der Server neu gestartet werden. Da wir aber eh noch etwas an der Konfiguration basteln müssen, genügt es, wenn wir das am Schluss erledigen.

Wir benötigen zuerst die q3mon Dateien, die wir von folgender URL herunterladen:

http://files.dev1ance.net/quake3/q3mon/

Wir packen das Paket aus und laden das Verzeichnis q3mon auf unseren Webserver hoch. Legt dieses Verzeichnis am besten nicht in Euer normales Apache Dokumenten Verzeichnis, sondern wir legen dann einen Allias an, der den entsprechenden Zugriff regelt.

Vergebt nun für das Verzeichnis q3mon die Dateirechte auf 755: 

chmod -R 755 q3mon

Nun benötigen wir noch die qstat, die zunächst kompiliert werden müssen. Dazu laden wir uns die aktuelle Version von folgender URL herunter:

http://sourceforge.net/projects/qstat/

Das tar.gz wird dann mit einem 

tar zvxf *.tar.gz

in Eurem Buildverzeichnis entpackt. Wechselt in das neu entstandene qstat Verzeichnis und bereitet den Compile vor: 

./configure

Danach werden die Quellen übersetzt: 

make

und installiert: 

make install

Jetzt editieren wir noch die Apache Konfigurationsdatei /etc/apache2/sites-enabled/000-default
Hier fügen wir direkt über den </VirtualHost> folgenden Abschnitt ein: 

    Alias /q3mon/EUER_PFAD/q3mon
      <Directory /EUER_PFAD/q3mon>
       Options ExecCGI Indexes FollowSymLinks MultiViews
       AddHandler cgi-script .cgi .pl
       AllowOverride None
       DirectoryIndex index.php index.htm index.html
       Order allow,deny
       allow from all
    </Directory>

Startet nun den Apache neu, nachdem Ihr die Änderung gespeichert habt: 

/etc/init.d/apache2 restart

Danach ruft die q3mon in Eurem Browser auf: [EURE_URL]/q3mon

Jetzt könnt Ihr schonmal nach den Quakeservern suchen.

Einfaches Buildservice Script

map

Im Folgenden erkläre ich eine Möglichkeit, eine Art kleinen Buildservice für den ioquake3 dedicated Linux Server und dem Windows Client einzirichten. Dieses Howto richtet sich zudem an Leute mit etwas fortgeschritteneren Linuxkenntnisse.


Meine Überlegung war, ein Script zu schreiben, dass den dedicated Linux ioquake3 Server immer auf den aktuellen Stand hält und parallel dazu den aktuellen Windows Client via Crosskompiler übersetzt und mit den benötgigten upgedateten pk3 Dateien zur Verfügung stellt. Das Script soll dann über einen Cron Job regelmäßig (am besten einmal pro Tag) ausgeführt werden. Es prüft dann, ob eine neue Version auf dem SVN Tree zur Verfügung steht. Dann holt es sich die aktuellen Quelldateien, übersetzt den Server, ersetzt die aktuellen Serverdateien und startet diesen neu. Danach baut es den Windowsclient und stellt sowohl den Server als auch den Client als zwei gepackte Dateien auf dem FTP Server zum Download bereit. Wenn dies fertig gestellt ist, soll das Script uns via E-Mail benachrichtigen.

Folgendes muss eingerichtet sein und funktionieren:

  • Der Windows Client muss sich kompilieren lassen
  • Der dedicated Server muss sich kompilieren lassen
  • Der dedicated Server läuft auf der Maschine
  • Der Exim oder ein entsprechender MTA sollte laufen
  • Dieser Port muss freigegeben sein, wenn iptables aktiv sind:TCP OUT 3690 für SVN
  • Screen muss installiert sein
  • Für das Pingen an einen anderen Rechner um festzustellen, dass dieser online ist muss noch im Firewallscript folgendes ergänzt werden:
iptables -A OUTPUT -p ICMP            --icmp-type echo-request -j ACCEPT
iptables -A INPUT  -p ICMP            --icmp-type echo-reply   -j ACCEPT

Jetzt legen wir unter /usr/bin eine neue Datei an, z.B. ioq3build und machen diese ausführbar: 

chmod +x /usr/local/bin/ioq3build

Im Hauptverzeichnis des Servers legen wir noch ein Workdirectory an, unter dem in Zukunft alles abgewickelt wird: 

mkdir /work

Zudem legen wir auf unserem FTP Verzeichnis auf dem Server den Inhalt des letzten ioq3 Windows Client ab, den wir von der ioquake3.org wie im Windows Tutorial heruntergeladen haben. Dazu kopieren wir nur die pk3 Datein, Lizenstexte gemäß EULA und GPLv.2 (siehe http://wiki.ioquake3.org/Installer_Features ) und die dlls in die entsprechenden dazu angelegten baseq3 und missionpack Verzeichnisse. Also ungefähr so (wenn das Verzeichnis dort ioq3files heißt):

-ioq3files (Verzeichnis)
--openAL.dll
--SDL.dll
--Copying.txt
--CopyingXYZ.txt
--baseq3 (Verzeichnis)
--- pak1.pk3
--- pak2.pk3
...
--- pak8.pk3
--missionpack (Verzeichnis)
--- pak1.pk3
--- pak2.pk3
--- pak3.pk3

Das war's dann mit den entsprechenden Vorbereitungen. Jetzt füllt Euer Script wie nun im Folgenden aufgeführt. An den entsprechenden Stellen müsst Ihr noch eventuell Anpassungen vornehmen. Ich erkläre den Aufbau erst einmal und zeigen das Script dann nochmal an einem Stück. Natürlich sollte es erst manuell ausgeführt und geprüft werden bevor Ihr einen Eintrag in die /etc/crontab macht, um es automatisch arbeiten zu lassen. 

#!/bin/bash

quakeuser=blah
files=/home/blah/files
fileuser=blah
buildfiles=/home/blah/q3abuildfiles
mailadresse=blah
madeat=$(date +%Y_%m_%d)

Im Kopfbereich legen wir zunächst einige Variablen fest. Während das Script darauf aufbaut, dass sich alles in einem Verzeichnis /work abspielt können diverse Einstellungen im Kopfbereich gemacht werden:

quakeuser: Der Nutzeraccount, unter dem der Server normalerweise läuft. Der Quake3 Server sollte nicht als root betrieben werden, sondern extra dafür ein eigener Nutzeraccount eingerichtet werden.

files: Hier werden dann später unsere fertigen Pakete landen. Idealerweise ist das ein Verzeichnis, das dann per ftp erreichbar ist und man die fertigen Pakete herunterladen kann.

fileuser: Der Nutzername, unter dem der ftp läuft.

buildfiles: In diesem Verzeichnis findet dann unser Script die zusätzlichen Dateien, die er zum bündeln für den Windowsclient benötigt. Das sind ein paar fertige dlls und natürlich die pk3 Dateien aus dem letzten Patch.

mailadresse: Dies ist Eure Mailadresse, an der das Script die Mailbenachrichtigungen schickt, wenn ein Paket fertig ist.

madeat: Das wird später unser Zeitstempel für die gepackten Dateien. 

#before doing anything check server availability
ping -c 1 github.com
if [ $? != 0 ]; then

  echo "Server down, stopping now!"
  
  exit 1

else

Hier wird erstmal überprüft, ob der git Server erreichbar ist. Wenn dieser down sein sollte, oder mal keine Internetverbindung steht, dann bricht das Script ab. Sollte der Server erreichbar sein, dann geht es weiter: 

#prepare version.txt
rm /work/version_alt.txt
mv /work/version.txt /work/version_alt.txt

#get latest files
cd /work
rm -R quake3
git clone git://github.com/ioquake/ioq3.git quake3

Hier bereiten wir dann den Versionscheck vor. Zuerst wird die alte Versionsdatei, in der die letzte Versionsnummer gespeichert ist umbenannt. Dann rufen wir die Informationen aus dem git Hub ab und speichern den output in einer Datei "version.txt". Dort befindet sich die aktuelle Versionsnummer, die ausgelesen werden muss: 

#write new version.txt
cd /work/quake3
git show | grep -m 1 commit | cut -b 8-14 > /work/version.txt

Der nächste Abschnitt ist simpel. Es wird nun verglichen, ob die neue Versionsnummer von der alten abgespeicherten abweicht. 

#checkout if something is to be done
   ver_neu=$(cat version.txt)
   ver_alt=$(cat version_alt.txt)

   if [ $ver_neu = $ver_alt ]; then
      rm /work/aktuell.txt
      rm /work/unveraendert.txt
      echo "Version $ver_neu unverändert" > /work/unveraendert.txt
   exit 1

   else
      rm /work/aktuell.txt
      rm /work/unveraendert.txt
      echo "Version $ver_neu neu, beginne compile" > /work/aktuell.txt
      cd /work

Hat sich diese zur letzten Überprüfung nicht verändert, beendet sich das Script. Es gibt schließlich nichts zu tun. Ist die Nummer anders, dann liegt eine Änderung vor und das Script beginnt, die neue Version zu bauen: 

#build new linux version
      cd /work/quake3
      make -j3

Dann beginnt der Compile. Wenn Ihr einen Dualcore Prozessor oder noch mehr Kerne einsetzt, dann startet den make mit dem Parameter -j3 . Die 3 resultiert aus 2 Kerne + 1 . Wenn es also 4 Kerne sind, dann lautet der Parameter -j5. 

      pkill -u $quakeuser
      rm -R /usr/local/games/quake3

#quake install
      make copyfiles

#built date reminder
      rm /work/built.txt
      date +%d.%m.%Y > /work/built.txt

#server start
      su $quakeuser -c 'screen -d -m q3ded +set dedicated 2 +com_hunkMegs 64 +exec death.cfg'

Im nächsten Abschnitt wird dann der laufende Quake3 Server beendet, das alte Quake3 Verzeichnis gelöscht und der neue Server installiert. In der Datei built.txt wird dann nur das Datum hinterlegt, das eventuell von einer anderen Datei noch verwendet werden kann (q3mon Statistik eventuell). Danach wird der Server mit den Benutzerrechten des Quakeusers innerhalb einer Screensession gestartet. Ihr könnt Euch später dann als Quakeuser via ssh anmelden und dann die Session mittels screen -R wieder aufrufen. In dieser Zeile müsst Ihr noch entsprechend den Namen der Konfigurationsdatei anpassen. Bei mir heißt diese death.cfg. 

#upload installpackage
      cd /usr/local/games
      tar cf ioq3_git-$ver_neu.$madeat.tar .
      gzip ioq3_git-$ver_neu.$madeat.tar
      cp ioq3_git-$ver_neu.$madeat.tar.gz /$files/
      chown $fileuser:$fileuser /$files/ioq3_git-*.tar.gz
      rm /usr/local/games/*.gz

Hier werden nun die Serverfiles zusammengepackt und auf Euren eigenen FTP Server in das entsprechend dafür vorgesehene Verzeichnis verschoben. 

#build windows client
      cd /work/quake3
      make clean
      make PLATFORM=wingw32 ARCH=x86

Hier wird der Windowsclient über den Crosscompiler gebaut. 

 
      mkdir /work/temp
      mkdir /work/temp/ioquake3_$ver_neu
      mkdir /work/temp/ioquake3_$ver_neu/missionpack
      mkdir /work/temp/ioquake3_$ver_neu/baseq3
      cp /work/quake3/build/release-mingw32-x86/*.exe /work/temp/ioquake3_$ver_neu/
      cp /work/quake3/build/release-mingw32-x86/*.dll /work/temp/ioquake3_$ver_neu/
      cp /work/quake3/build/release-mingw32-x86/baseq3/*.dll /work/temp/ioquake3_$ver_neu/baseq3/
      cp /work/quake3/build/release-mingw32-x86/missionpack/*.dll /work/temp/ioquake3_$ver_neu/missionpack/
      cp $buildfiles/* /work/temp/ioquake3_$ver_neu/
      cp $buildfiles/baseq3/* /work/temp/ioquake3_$ver_neu/baseq3/
      cp $buildfiles/missionpack/* /work/temp/ioquake3_$ver_neu/missionpack/

Ihr habt entsprechend die pk3 Files und dlls in Euer Dateiverzeichnis kopiert. Hier werden dann alle entsprechenden Filles zusammenkopiert. 

#pack and upload client version
      cd /work/temp/
      zip -r ioq3_git-$ver_neu.$madeat.zip ioquake3_$ver_neu
      cp ioq3_git-$ver_neu.$madeat.zip /$files/
      chown $fileuser:$fileuser /$files/ioq3_git-$ver_neu.$madeat.zip

#remove temporary files
      cd /work
      rm -R /work/temp

Nun noch die Windowsclientdateien gepackt und auch auf Euer FTP Verzeichnis geschoben. Danach alle temporären Verzeichnisse entfernt. 

#call the boss
      rm /var/log/quakeready.log
      echo "Sir, your Quake is ready! Get revision git-$ver_neu from your ftp. Server is up and running!" //Zeilenumbruch
            > /var/log/quakeready.log
      mail -a "Content-Type: text/plain; charset=UTF-8" -s "[System] Your Quake is ready!" //Zeilenumbruch
           $mailadresse < /var/log/quakeready.log

    fi

fi
Bitte achtet im Script auf den Hinweis //Zeilenumbruch. Diesen bitte entfernen und die darunterliegende Zeile mit der oberen wieder zusammenfügen, sonst produziert das Skript Fehler!

Jetzt geht noch eine E-Mail raus, die Euch über eine neue Version des ioquake3 informiert.

Hier nocheinmal das Script an einem Stück: 

#!/bin/bash

quakeuser=blah
files=/home/blah/files
fileuser=blah
buildfiles=/home/blah/q3abuildfiles
mailadresse=blah
madeat=$(date +%Y_%m_%d)

#before doing anything check server availability
ping -c 1 github.com
if [ $? != 0 ]; then

  echo "Server down, stopping now!"

  exit 1

else

#prepare version.txt
rm /work/version_alt.txt
mv /work/version.txt /work/version_alt.txt

#get latest files
cd /work
rm -R quake3
git clone git://github.com/ioquake/ioq3.git quake3

#write new version.txt
cd /work/quake3
git show | grep -m 1 commit | cut -b 8-14 > /work/version.txt

#check if something is to be done
   ver_neu=$(cat /work/version.txt)
   ver_alt=$(cat /work/version_alt.txt)

   if [ $ver_neu = $ver_alt ]; then
      rm /work/aktuell.txt
      rm /work/unveraendert.txt
      echo "Version $ver_neu unverändert" > /work/unveraendert.txt
   exit 1

   else
      rm /work/aktuell.txt
      rm /work/unveraendert.txt
      echo "Version $ver_neu neu, beginne compile" > /work/aktuell.txt

#build new linux version
      make -j3
      pkill -u $quakeuser
      rm -R /usr/local/games/quake3

#quake install
      make copyfiles

#built date reminder
      rm /work/built.txt
      date +%d.%m.%Y > /work/built.txt

#server start
      su $quakeuser -c 'screen -d -m q3ded +set dedicated 2 +com_hunkMegs 64 +exec death.cfg'

#upload installpackage
      cd /usr/local/games
      tar cf ioq3_git-$ver_neu.$madeat.tar .
      gzip ioq3_git-$ver_neu.$madeat.tar
      cp ioq3_git-$ver_neu.$madeat.tar.gz /$files/
      chown $fileuser:$fileuser /$files/ioq3_git-*.tar.gz
      rm /usr/local/games/*.gz

#build windows client 32bit
      cd /work/quake3
      make clean
      make PLATFORM=mingw32 ARCH=x86
      mkdir /work/temp
      mkdir /work/temp/ioquake3_$ver_neu
      mkdir /work/temp/ioquake3_$ver_neu/missionpack
      mkdir /work/temp/ioquake3_$ver_neu/baseq3
      cp /work/quake3/build/release-mingw32-x86/*.exe /work/temp/ioquake3_$ver_neu/
      cp /work/quake3/build/release-mingw32-x86/*.dll /work/temp/ioquake3_$ver_neu/
      cp /work/quake3/build/release-mingw32-x86/baseq3/*.dll /work/temp/ioquake3_$ver_neu/baseq3/
      cp /work/quake3/build/release-mingw32-x86/missionpack/*.dll /work/temp/ioquake3_$ver_neu/missionpack/
      cp $buildfiles/* /work/temp/ioquake3_$ver_neu/
      cp $buildfiles/baseq3/* /work/temp/ioquake3_$ver_neu/baseq3/
      cp $buildfiles/missionpack/* /work/temp/ioquake3_$ver_neu/missionpack/

#pack and upload client version
      cd /work/temp/
      zip -r ioq3_git-$ver_neu.$madeat.zip ioquake3_$ver_neu
      cp ioq3_git-$ver_neu.$madeat.zip /$files/
      chown $fileuser:$fileuser /$files/ioq3_git-$ver_neu.$madeat.zip

#remove temporary files
      cd /work
      rm -R /work/temp

#call the boss
      rm /var/log/quakeready.log
      echo "Sir, your Quake is ready! Get revision git-$ver_neu from your ftp. Server is up and running!" //Zeilenumbruch
             > /var/log/quakeready.log
      mail -a "Content-Type: text/plain; charset=UTF-8" -s "[System] Your Quake is ready!" //Zeilenumbruch 
             $mailadresse < /var/log/quakeready.log

    fi

fi
Bitte achtet im Script auf den Hinweis //Zeilenumbruch. Diesen bitte entfernen und die darunterliegende Zeile mit der oberen wieder zusammenfügen, sonst produziert das Skript Fehler!

Wenn das Script nach ein paar manuellen Testläufen funktioniert könnt Ihr dieses über einen Cronjob nun laufen lassen. Dann solltet Ihr immer auf dem aktuellen Stand sein.

Links

ioquake3 Projekt Seite
mingw Crosscompiler Projekt
Pro-Linux - Quake 3 Arena Server
Creative Labs - OpenAL
Simple DirectMedia Layer (SDL)
Q3mon Quake3 Serverbrowser
Qstat Projekt
Debian Linux
openSUSE Linux


Pierre "Gargi" Kretschmer

Abgerufen von „https://www.gargi.org/index.php?title=Ioquake3_Server_und_Build_Service&oldid=791“