Linux (Ubuntu) vorbereiten


Für alle weiteren Schritte nötig
Benötigte Pakete wie scons und build-essential installieren:

sudo apt-get install scons ant pkg-config libx11-dev libxcursor-dev build-essential libasound2-dev libfreetype6-dev libgl1-mesa-dev libglu-dev libssl-dev libxinerama-dev

1. Godot Pfad anlegen und Godot-Source herunterladen:

mkdir ~/godot
cd ~/godot
wget https://github.com/okamstudio/godot/archive/master.zip

2. Entpacken nach ~/godot

unzip master.zip -d ~/godot
mv godot-master/* .

1-Zeiler – „Linux (Ubuntu) vorbereiten“:

sudo apt-get install scons ant gcc-multilib lib32z1 lib32stdc++6 pkg-config libx11-dev libxcursor-dev build-essential libasound2-dev libfreetype6-dev libgl1-mesa-dev libglu-dev libssl-dev libxinerama-dev && mkdir ~/godot && cd ~/godot && wget https://github.com/okamstudio/godot/archive/master.zip && unzip master.zip -d ~/godot && mv godot-master/* .

 

Java einbinden:


Für Android und Linux Compiling notwendig

Quelle: http://tecadmin.net/install-java-8-on-centos-rhel-and-fedora/

Linux x64 165.17 MB jdk-8u40-linux-x64.tar.gz  Download über wget Befehl

1. Download und entpacken:

cd /opt/
sudo wget --no-cookies --no-check-certificate --header "Cookie: gpw_e24=http%3A%2F%2Fwww.oracle.com%2F; oraclelicense=accept-securebackup-cookie" "http://download.oracle.com/otn-pub/java/jdk/8u40-b25/jdk-8u40-linux-x64.tar.gz"
sudo tar xzf jdk-8u40-linux-x64.tar.gz

2. Version als aktuell verwendete setzen:

sudo su
cd /opt/jdk1.8.0_40/
update-alternatives --install /usr/bin/java java /opt/jdk1.8.0_40/bin/java 2
update-alternatives --config java

optional (wenn nötig) – oft wird nur die oben heruntergeladene Java Version im System gefunden, dann überspringen:

There are 3 programs which provide 'java'.
Selection Command
-----------------------------------------------
* 1 /opt/jdk1.8.0/bin/java
+ 2 /opt/jdk1.8.0_25/bin/java
3 /opt/jdk1.8.0_40/bin/java
Enter to keep the current selection[+], or type selection number: 3

3. Pfade setzen:

update-alternatives --install /usr/bin/jar jar /opt/jdk1.8.0_40/bin/jar 2
update-alternatives --install /usr/bin/javac javac /opt/jdk1.8.0_40/bin/javac 2
update-alternatives --set jar /opt/jdk1.8.0_40/bin/jar
update-alternatives --set javac /opt/jdk1.8.0_40/bin/javac
exit

4. Java Version überprüfen:

java -version

java version „1.8.0_40“

Java(TM) SE Runtime Environment (build 1.8.0_40-b25)
Java HotSpot(TM) 64-Bit Server VM (build 25.40-b25, mixed mode)

5. JAVA_HOME /JRE_HOME / PATH Variable setzen:

export JAVA_HOME=/opt/jdk1.8.0_40
export JRE_HOME=/opt/jdk1.8.0_40/jre
export PATH=$PATH:/opt/jdk1.8.0_40/bin:/opt/jdk1.8.0_40/jre/bin

1-Zeiler – „Java einbinden“:

cd /opt/ && sudo wget --no-cookies --no-check-certificate --header "Cookie: gpw_e24=http%3A%2F%2Fwww.oracle.com%2F; oraclelicense=accept-securebackup-cookie" "http://download.oracle.com/otn-pub/java/jdk/8u40-b25/jdk-8u40-linux-x64.tar.gz" && sudo tar xzf jdk-8u40-linux-x64.tar.gz && cd /opt/jdk1.8.0_40/ && sudo update-alternatives --install /usr/bin/java java /opt/jdk1.8.0_40/bin/java 2 && sudo update-alternatives --config java && sudo update-alternatives --install /usr/bin/jar jar /opt/jdk1.8.0_40/bin/jar 2 && sudo update-alternatives --install /usr/bin/javac javac /opt/jdk1.8.0_40/bin/javac 2 && sudo update-alternatives --set jar /opt/jdk1.8.0_40/bin/jar && sudo update-alternatives --set javac /opt/jdk1.8.0_40/bin/javac && export JAVA_HOME=/opt/jdk1.8.0_40 && export JRE_HOME=/opt/jdk1.8.0_40/jre && export PATH=$PATH:/opt/jdk1.8.0_40/bin:/opt/jdk1.8.0_40/jre/bin && java -version

 

Android SDK einbinden:


Für Android (apk) Export aus Godot

Quelle: http://maheo.eu/330-android-entwicklung-unter-opensuse-linux.php

1. SDK Download

–> http://dl.google.com/android/android-sdk_r24.1.2-linux.tgz (herunterladen)  Download über wget Befehl

mkdir ~/devl/
cd ~/devl/
wget http://dl.google.com/android/android-sdk_r24.1.2-linux.tgz
tar xzf android-sdk_r24.1.2-linux.tgz

( android-sdk_r24.1.2-linux.tgz in devl entpacken )

2. Pfad setzen

~/.bashrc/ bearbeiten (z.B. in Dolphin öffnen)

Hier nun irgendwo am Ende der Datei einfügen und speichern, ausloggen und wieder einloggen:

#AndroidDev PATH

PATH=$PATH:$HOME/devl:$HOME/devl/tools
export PATH

# For SDK version r_08 and higher, also add this for adb:
PATH=$PATH:$HOME/devl/platform-tools
export PATH

Alternativ im Terminal:

cp ~/.bashrc ~/.bashrc_backup
echo '#AndroidDev PATH' >> ~/.bashrc
echo 'PATH=$PATH:$HOME/devl/android-sdk-linux:$HOME/devl/android-sdk-linux/tools' >> ~/.bashrc
echo 'export PATH' >> ~/.bashrc
echo 'PATH=$PATH:$HOME/devl/android-sdk-linux/platform-tools' >> ~/.bashrc
echo 'export PATH' >> ~/.bashrc

 

3. Android Tool öffnen / testen

Nach einem Neustart – nun im Terminal:

android

Folgende Pakete installieren:

  • Tools
  • Android 4.0.3 (API 15)
  • Android 2.2 (API 8)
  • Android 4.4.2 (API 19)
  • Extras – Android Support Library

Bildschirmfoto4

und wieder schließen 😉

4. ADB installieren

sudo apt-get install android-tools-adb
# Testen mit dem Befehl adb

5. debug.keystore erstellen

cd ~/.android/
keytool -keyalg RSA -genkeypair -alias androiddebugkey -keypass android -keystore debug.keystore -storepass android -dname "CN=Android Debug,O=Android,C=US" -validity 9999

6. NDK Download – optional
( nur für Android-Vorlagen Compilierung notwendig s.u. )

Download NDK (440Mb): http://developer.android.com/tools/sdk/ndk/index.html  Download über wget Befehl

android-ndk-r10c-linux-x86_64.bin – es handelt sich dabei um eine mit 7 zip entpackbare Datei, welche sich aber auch über folgende Befehle ins aktuelle Verzeichnis entpacken lässt:

cd ~/devl/
wget http://dl.google.com/android/ndk/android-ndk-r10d-linux-x86_64.bin

chmod +x android-ndk-r10d-linux-x86_64.bin
./android-ndk-r10d-linux-x86_64.bin

7. NDK-Pfad im System einbinden – optional:
( nur für Android-Vorlagen Compilierung notwendig s.u. )

export ANDROID_NDK_ROOT=$HOME/devl/android-ndk-r10d/
export NDK=$HOME/devl/android-ndk-r10d/

8. SDK-Pfad im System einbinden

export ANDROID_HOME=$HOME/devl/android-sdk-linux/

 9. Godot konfigurieren:

Bildschirmfoto3

Nun können die .apk direkt aus Godot heraus erstellt werden.

2-Zeiler – „Android SDK einbinden“:

mkdir ~/devl/ && cd ~/devl/ && wget http://dl.google.com/android/android-sdk_r24.1.2-linux.tgz && tar xzf android-sdk_r24.1.2-linux.tgz && cp ~/.bashrc ~/.bashrc_backup && echo '#AndroidDev PATH' >> ~/.bashrc && echo 'PATH=$PATH:$HOME/devl/android-sdk-linux:$HOME/devl/android-sdk-linux/tools' >> ~/.bashrc && echo 'export PATH' >> ~/.bashrc && echo 'PATH=$PATH:$HOME/devl/android-sdk-linux/platform-tools' >> ~/.bashrc && echo 'export PATH' >> ~/.bashrc && sudo apt-get install android-tools-adb 

# Aus und wieder einloggen
# Nach der nächsten Zeile wird das Android Install Fenster aufpoppen.
# Hier bitte o.g. Pakete auswählen und installieren (Punkt: folgende Pakete installieren)

android && cd ~/devl/ && wget http://dl.google.com/android/ndk/android-ndk-r10d-linux-x86_64.bin && chmod +x android-ndk-r10d-linux-x86_64.bin && ./android-ndk-r10d-linux-x86_64.bin && export ANDROID_NDK_ROOT=$HOME/devl/android-ndk-r10d/ && export NDK=$HOME/devl/android-ndk-r10d/ && export ANDROID_HOME=$HOME/devl/android-sdk-linux/ && cd ~/.android/ && keytool -keyalg RSA -genkeypair -alias androiddebugkey -keypass android -keystore debug.keystore -storepass android -dname "CN=Android Debug,O=Android,C=US" -validity 9999

 

Quellen:
http://drm.sourceforge.net/wiki/index.php/Building_on_Linux_for_Android
http://stackoverflow.com/questions/26967722/how-to-install-android-ndk-in-linux

 

Android Export Vorlage / Template erzeugen


ACHTUNG: wie ich herausgefunden habe, kann mit der aktuellen stable, welche auf der Download-Seite angeboten wird, nach einer abgewandelten Export-Vorlage kein Spiel erstellt werden. Es muss auch das Programm compiliert werden (siehe unten). Möglicherweise wird dies mit dem nächsten Update obsolet.

Normalerweise reichen die Export-Templates von der Godot-Download-Seite vollkommen aus. Wer allerdings zusätzliche Module wie Admob einbinden möchte, kommt um eine selbst erstellte Version nicht herum.

Punkt 6 und 7 von der „Android“ Anleitung oben müssen in diesem Fall zuerst noch durchgeführt werden!

1. Scons auf Android Ressourcen überprüfen

1.1. in den Godot-Source Ordner wechseln:

cd ~/godot

1.2. Prüfen, ob Scons die benötigten Android Ressourcen hat

scons

Hier muss „android“ in der Liste auftauchen

2. Android .SO erzeugen

scons platform=android

Das führt zu einer normalen .so im Verzeichnis /bin als wäre der Vorgang mit „tools=no target=debug“ durchgeführt worden.

Das Ergebnis ist daher eine sehr große Datei, da alle debug-Symbole enthalten sind.

Für die nächsten Vorgänge wird also
target=release_debug“ oder „target=release
empfohlen (siehe „zur Info“ unten)

3. Benötigte Unterordner in ~/godot anlegen:

mkdir platform/android/java/libs
mkdir platform/android/java/libs/armeabi

4. Datei (.so) kopieren / verlinken

Nun muss die .so in den Android-Ordner „libs/armeabi“ kopiert oder symbolisch verlinkt werden (bei Linux):

ln -s bin/libgodot.android.<Deine compilierte .so Version>.so platform/android/java/libs/armeabi/libgodot_android.so

Bitte den Pfad <Deine compilierte .so Version> anpassen.

Hinweis 1: es darf immer nur eine .so im Verzeichnis liegen. Daher muss bei anderen Build-Typen (release, debug etc.) diese Datei immer ausgetauscht werden.

Hinweis 2: die Datei im Ordner bzw. der Name des symbolischen Links MUSS „libgodot_android.so“ lauten. Andernfalls kommt es zu Fehlern.

Alternative —

X86 Alternative apk – einfach die o.g. Punkte gegen die folgenden austauschen:

2. Scons X86 Unterstützung (64bit)

Wer Unterstützung für x86 Android einbinden möchte, kann dies mit dem Compiler-Zusatz „x86=yes“ bei scons tun (siehe 2.)
Dies führt allerdings dazu, dass die .apk am Ende rund 6 MB größer ist.

3. Benötigte Unterordner in ~/godot anlegen

mkdir platform/android/java/libs
mkdir platform/android/java/libs/x86

4. Datei (.so) kopieren / verlinken

Nun muss die .so in den Android-Ordner „libs/x86“ kopiert oder symbolisch verlinkt werden (bei Linux)

ln -s bin/libgodot.android.<Deine compilierte .so Version>.x86.so platform/android/java/libs/x86/libgodot_android.so

Alternative ENDE

5. Toolchain Version anpassen – optional bei einem Versions-Fehler 

Es wird versucht, den Godot Android-Build aktuell zu halten, allerdings ändert Google seine Toolchain Version sehr oft. Sollte das Compilieren wegen einer falschen Toolchain Version abbrechen, kann diese erneurt werden.

5.1. Zuerst im NDK Ordner nach den aktuellen Versionen sehen.

~/devl/android-ndk-r10d/toolchains/
~/devl/android-ndk-r10d/platforms/

5.2. Nach „arm-linux-androideabi-4.8“ oder einer aktuelleren Version schauen (derzeitiger Stand: 4.9)

5.3. Umgebungs-Variablen setzen:

Achtung: bei einem 32bit NDK-Download lautet „linux-x86_64“ natürlich linux-x86

5.3. Für ARM:

export NDK_TOOLCHAIN=${NDK}/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/bin/arm-linux-androideabi
export NDK_SYSROOT=${NDK}/platforms/android-21/arch-arm
export NDK_TARGET${NDK}/toolchains/arm-linux-androideabi-4.9/

 5.3. Für x86:

export NDK_TOOLCHAIN=${NDK}/toolchains/x86-4.9/prebuilt/linux-x86_64/bin/i686-linux-android
export NDK_SYSROOT=${NDK}/platforms/android-21/arch-x86
export NDK_TARGET${NDK}/toolchains/arm-linux-androideabi-4.9/

NDK_SYSROOT könnte auch „android-9“ sein…

6. APK erstellen

Jetzt kommen wir zur eigentlichen Template-Erstellung

Godot benötigt eine frisch erstelle APK als Export Vorlage. Es öffnet diese APK, ändert ein paar Dinge im Innern, fügt die eigentlichen Programm Dateien hinzu und fügt alles wieder zusammen. Sehr praktisch das ganze.

Die Standard-Vorlage wurde mit folgendem Befehl compiliert:

cd ~/godot/platform/android/java
ant debug

#oder

ant release

Nun liegt im Ordner /godot/platform/android/java/bin die jeweilige APK (debug und / oder release), welche als Vorlage dient.

 

Hinweis: Cannot run program „~/devl/android-sdk-linux/build-tools/22.0.1/aapt“ 

Sollte es zu einem Fehler kommen, kann es sein, dass ein 64bit System verwendet wird und einige 32bit Pakete fehlen. Diese können mit folgendem Befehl nachinstalliert werden:

sudo apt-get install gcc-multilib lib32z1 lib32stdc++6

 

Die beiden Dateien müssen nun mit dem folgenden Namen in deb Godot Vorlagen Ordner kopiert werden::

android_debug.apk
android_release.apk

– Fertig –

 

Sollte „android“ wieder aus scons verschwinden, kann es sein, dass durch ein Update die Pfade entfernt wurden. Dann einfach nochmal folgenden Befehl im Terminal durchführen:

export ANDROID_NDK_ROOT=$HOME/devl/android-ndk-r10d/
export NDK=$HOME/devl/android-ndk-r10d/
export ANDROID_HOME=$HOME/devl/android-sdk-linux/

 

Zur Info:

Original Export Vorlage wurde wie folgend erstellen:

(debug)

scons platform=android target=release_debug
cp bin/libgodot.android.opt.debug.so platform/android/java/libs/armeabi/libgodot_android.so
cd platform/android/java
ant release
cd bin && cp Godot-release-unsigned.apk ~/godot/templates/android_debug.apk

Ausgabe APK liegt in:

platform/android/java/bin/Godot-release-unsigned.apk
(release)

scons platform=android target=release
cp bin/libgodot.android.opt.debug.so platform/android/java/libs/armeabi/libgodot_android.so
cd platform/android/java
ant release
cd bin && cp Godot-release-unsigned.apk ~/godot/templates/android_release.apk

Ausgabe APK liegt in:

platform/android/java/bin/Godot-release-unsigned.apk
(… wie zuvor)

1-Zeiler – „Android Export Vorlage / Template erzeugen“:

export ANDROID_NDK_ROOT=$HOME/devl/android-ndk-r10d/; export NDK=$HOME/devl/android-ndk-r10d/; export ANDROID_HOME=$HOME/devl/android-sdk-linux/; cd ~/godot; mkdir platform/android/java/libs; mkdir platform/android/java/libs/armeabi; mkdir ~/godot/templates; scons platform=android target=release_debug && cp bin/libgodot.android.opt.debug.so platform/android/java/libs/armeabi/libgodot_android.so && cd platform/android/java && ant release && cd bin && cp Godot-release-unsigned.apk ~/godot/templates/android_debug.apk && cd ~/godot && scons platform=android target=release && cp bin/libgodot.android.opt.debug.so platform/android/java/libs/armeabi/libgodot_android.so && cd platform/android/java && ant release && cd bin && cp Godot-release-unsigned.apk ~/godot/templates/android_release.apk

 


Godot Linux Version Compilierung


Für jene, die Godot aus dem Source-Code selbst compilieren möchten:
Derzeit zwingend erforderlich, wenn eine eigene Export-Vorlage benutzt werden soll:

1. Scons auf X11 testen:

cd ~/godot/
scons

>>  muss x11 anzeigen <<

2. Compilierung durchführen

scons platform=x11

Die erstellte Datei liegt nun als .bin im /bin Ordner und kann von dort kopiert / ausgeführt werden.

Quellen:
https://github.com/okamstudio/godot/wiki/compiling_linux
http://ashonit.blogspot.de/2014/03/compiling-godot-from-source-on-kubuntu.html
https://github.com/Mavhod/GodotAdmob