Also einmal vorweg: Wenn du eine AES-Verschlüsselung für eine eigene Anwendung produktiv nutzen möchtest, dann nimm dafür eine etablierte Programmbibliothek, die das Ganze bereits implementiert. Das ist sicherer.

Für Python gibt es cryptography oder PyCryptodome. Für C++ könnte man auf libsodium zurückgreifen.

Um so eine Verschlüsselung selbst zu entwickeln, müsstest du dich mit folgenden Themen beschäftigen:

• Den Grundlagen einer Programmiersprache: Variablen, Operatoren (speziell Bitoperatoren), Kontroll- und Datenstrukturen (Array, Liste) wären das Mindestmaß
• Binärlogik (Bits, Bytes, Bitoperationen)
• Matrizen- und modulare Arithmetik (speziell Galois-Feld-Berechnungen)
• Ein paar Kryptographiegrundlagen (ein paar Stichworte: Betriebsmodi, Padding, Blockverschlüsselung)
• AES selbst und einem dazugehörigen, sicheren Betriebsmodi (siehe AEAD: CCM oder GCM)

Aber wie kompliziert ist es wirklich, den Algorithmus zu verstehen (...)

Du musst kein Genie sein, um das Prinzip verstehen zu können. Es braucht halt Einarbeitung / Recherche und natürlich Motivation/Geduld. Ich denke, dass es genügend Quellen zu dem Thema geben dürfte. Ob nun in Buchform oder online.

(...) und richtig zu programmieren?

Das ist etwas schwerer, denn wenn du eine Operation falsch umsetzt, wird die gesamte Anwendung ja unbrauchbar. Noch härter wird es, sich vor Seitenkanalangriffen zu schützen. Beispielsweise können Angreifer anhand der Laufzeit Rückschlüsse auf den Schlüssel ziehen. Weitere solcher Angriffsmöglichkeiten werden unter anderem auf Wikipedia gelistet.

Muss man dafür viel Mathe können oder braucht man einfach nur Programmiererfahrung?

Siehe oben. Du musst Mathematik dafür nicht explizit studieren, aber du solltest zumindest mit den Grundlagen, die du in der Schule gelernt haben dürftest, nicht extrem fremdeln.

Und wie lange müsste ich ungefähr üben, um so eine Verschlüsselung selbst schreiben zu können, die auch sicher funktioniert?

Rechne in Monaten für Einarbeitung und Implementation, genauer lässt es sich meiner Meinung nicht abschätzen. Es sind übliche Faktoren (z.B. Lerngeschwindigkeit, Vorkenntnisse), die eine große Rolle spielen. Wobei ich dir ebenso noch den Rat mitgeben würde, dir keinen Zeitdruck dahinter aufzubauen. Durch irgendwelche Themen zu hetzen, bringt dich nicht weiter.

(...) und bereits kleinere Projekte umgesetzt (...)

Demzufolge hättest du Material, um dir schon einmal ein Online-Portfolio anzulegen, welches 2-3 Projekte in den Fokus setzt.

(...) in erster Linie geht es mir darum, praktische Erfahrung zu sammeln und reale Projekte umzusetzen. (...)

Eine weitere Option wäre vielleicht ein Praktikum bei einem Unternehmen, welches in diesem Bereich tätig ist.

Wo finde ich passende Aufträge oder Kunden, die jemanden mit meinen Voraussetzungen suchen?

Du kannst versuchen, dich aktiv selbst zu bewerben. Beispielsweise über schwarze Bretter (Hochschule, Supermarkt). Dort (oder in hochschulinternen Studierendenforen) findet man andersherum auch manchmal Anfragen. Schau zudem nach dem Webauftritt kleiner, lokaler Unternehmen (Friseursalons, Restaurants, Bäcker, Lektoren) oder Vereine. Entweder haben sie noch keinen oder der derzeitige ließe sich (sinnvoll!) überarbeiten. Dementsprechend könntest du bei ihnen nachfragen.

Mir ist bewusst, dass ich anfangs wenig oder gar kein Geld verlangen kann (...)

Gerade wenn du für Unternehmen arbeitest, sollte das nicht unter Mindestlohn geschehen (Ausnahme: freiwillige Praktika). Sei einfach transparent in der Angabe deiner Kompetenzen.

(...) etwa auf CMS-basierte Websites (z. B. WordPress), anstatt gleich individuelle Entwicklungen anzubieten?

Bitte nach Möglichkeit (speziell bei Anwendungen mit Inhalt, der sich mit der Zeit ändern kann) auf individuelle Entwicklungen verzichten. Software soll einfach wartbar und erweiterbar sein. Es ist bei Webseiten (z.B. Portfolios, Corporate Sites, u.ä.) nicht unüblich, dass der Kunde einmal Informationen anpassen möchte, ohne dafür einen Entwickler kontaktieren zu müssen. Bestehende Systeme (seien es CMS oder Webframeworks) bieten eine bewährte Basis, eine ständige Neuerfindung des Rads ist unnötig und schafft im Nachhinein für andere nur Mehraufwand.

Im übrigen hast du bei der Arbeit mit einem CMS (z.B. für Theme- und Templateanpassungen) oft immer noch dieselben Aufgaben vor dir, die du ebenso beim Bau einer statischen Webseite hättest. Es kommt halt noch eine Komplexitätstufe hinzu, da sich die Entwicklung entsprechend in das System einfügen muss. Sofern du bisher noch mit keinem CMS gearbeitet hast, wäre es gut, sich damit einmal genauer zu beschäftigen. Es muss ja nicht WordPress sein. Andere Systeme wie z.B. Strapi, Umbraco, typo3 oder Wagtail sind aus technischer Perspektive sicherlich interessanter.

Mein langfristiges Ziel ist es, durch solche Projekte neben meinem Hauptjob (...)

Vergiss nicht, dass du für diese Tätigkeit ein Gewerbe anmelden und evt. (je nach Arbeitsvertrag) ebenso deinen Hauptarbeitgeber darüber informieren müsstest.

Prinzipiell möglich ist es, aber einfach ganz sicher nicht.

Möglicherweise kannst du auf einem Portal wie Upwork zusätzliche Arbeitsaufträge einfangen.

Bau dir Debug-Ausgaben ein oder nutze wenn möglich gleich einen Debugger. Von speziellem Interesse wäre, in welche Strukturen der Programmfluss überhaupt hineingeht oder nicht.

Es ist durchaus möglich, dass bestimmte angenommene Strukturen so nicht existieren oder die zur Laufzeit ermittelten Werte (z.B. von v.Object.Value oder v.Dependency.Value) falsch sind.

(...) ich denke hreflang ist sinnvoll (...)

Wenn du Seiten mit gleichen Inhalt, aber in jeweils anderer Sprache hast, solltest du definitiv hreflang-Tags setzen. Anhand dessen kann Google entscheiden, auf welche Version deiner Seite sie Nutzer leitet und ebenso, welche Inhalte sie im Suchergebnis ausspielen soll.

Allerdings spielen für die korrekte Sprachzuordnung noch weitere Faktoren eine Rolle. Achte darauf, das lang-Attribut (für den html-Tag) korrekt zu setzen und für Sprache X auch wirklich Inhalt in Sprache X auszuliefern.

Des Weiteren sollte die URL-/Domainstruktur passend sein. Angenommen, du hast die Sprachen DE und EN, könntest du entweder zwei Domains (example.de, example.com) nutzen oder eine Sprachinformation im URL-Pfad einbauen (example.com/de/, example.com/en/).

(...) weil Google glaube keine Möglichkeit hat automatisch die json Datei zu crawln bzw traue ich Google nicht zu dass es das kann (...)

Der Google Crawler kann mit JavaScript umgehen. Wenn man davon ausgeht, dass das Skript, welches die Übersetzungen in das DOM einfügt, schnell und zuverlässig funktioniert, ist es also nicht abwegig davon auszugehen, dass auch diese Daten erfasst werden. Voraussetzung ist natürlich, dass das Skript nicht nur bei Klick die richtigen Übersetzungen lädt, sondern ebenso beim Aufruf der entsprechenden Seite.

Nichtsdestotrotz wäre eine serverseitige Lösung definitiv besser und zuverlässiger. Zum einen kannst du doch bereits mit der ersten Anfrage (anhand der URL/des User-Agent) bestimmen, welche Sprache du brauchst, zum anderen können die Inhalte schneller geladen und auch von Crawlern ohne JavaScript-Support gelesen werden.

Wie eine konkrete Implementation dafür aussehen könnte, ist unter anderem davon abhängig, worauf deine Webanwendung aufbaut und was der Webhoster / der genutzte Webserver unterstützt. In der Logik könntest du deine JSON-Datei weiter nutzen oder stattdessen auf bewährte Formate wie .po/.mo-Dateien wechseln. Es gibt für solche Fälle oft bereits passende Implementationen (siehe bspw. gettext in PHP oder i18n für Node.js). Solltest du ein Webframework oder CMS nutzen, solltest du zunächst in dessen Dokumentation nach passenden Funktionen schauen.

Was sind führende Programmiersprachen?

Ich würde so etwas generell mit einer Sprache verbinden, die in einem bestimmten Kontext (Anwendungsgebiet; in einem bestimmten Nutzungskreis, wie Industrie, Wissenschaft, o.ä.) besonders verbreitet, einflussreich, zukunftssicher oder stark nachgefragt ist. Die Größe des Ökosystems und des dahinterliegenden Supports (durch Unternehmen/eine Community) spielt eine Rolle. Aber auch den Einfluss auf andere Sprachen (inwiefern hat sie sie verändert) könnte man als Faktor dazunehmen.

Stimmt das?

Ich denke, bei dieser Aufzählung kann man durchaus von Sprachen reden, die in vielen Anwendungsgebieten (z.B. der Entwicklung von Webanwendungen, mobilen Apps, Office-Anwendungen, ...) mindestens gut aufgestellt bzw. fest etabliert oder z.T. auch führend sind.

Eine pauschale Führungsrolle in allen Anwendungsbereichen, die es so gibt, kann man selbst bei dieser Liste nicht zuordnen. Nimm nur einmal Shell-Skripting und Systemautomatisierung oder die Implementationen von Logikschaltungen in der Chipentwicklung als Beispielanwendungsfälle: In denen spielt keine der aufgezählten Sprachen eine wesentliche Rolle.

Die Einordnung von CSS ist übrigens falsch, denn es handelt sich weder um eine Programmier- noch eine Auszeichnungssprache. Mit ihr kann man weder Anwendungslogiken formulieren, noch semantische Datenstrukturierungen vornehmen. Es sind einfach nur Stylesheets.

Der pauschalen Ableitung des zweiten Satzes würde ich nicht folgen, denn es hängt doch immer noch zu stark davon ab, was denn nun für welches System entwickelt werden soll.

Wenn es beispielsweise darum geht, eine Anwendung für Apple OS zu bauen, bieten die nativen Apple-Technologien (Swift und dazugehörige Frameworks/SDKs) den besten Support für die neuesten Features. Nicht-native Technologien müssen dafür erst nachziehen. Das lässt sich ebenso auf die Android-Entwicklung übertragen. Java ist in dem Zuge zwar noch eine native Technologie, doch sie bietet in der Entwicklung nicht mehr die neuesten Features (Bsp.: das UI-Toolkit Jetpack Compose wird nicht unterstützt). Im Vergleich ist hier Kotlin ganz klar führend.

Einen weiteren speziellen Fall hat man, sollte eine bestehende Anwendung angepasst/erweitert werden. Ihr Technologiestack kann die Möglichkeiten in der Entwicklung stark einschränken. Sei es die Sprache selbst, die Sprachversion, Wirkungsbereiche aufgrund von Sicherheitseinschränkungen, o.ä..

Alles in allem handelt es sich bei dem Text um klassischen Werbetext, der, wenn man ihn sehr genau auseinandernimmt, Schwächen aufweisen kann. Das würde ich allerdings nicht allzusehr auf die Goldwaage legen bzw. es sollte meines Erachtens kein direktes Ausschlusskriterium sein, so lange von deiner Seite noch keinerlei Anforderungen stehen, an denen man überhaupt versuchen könnte, abzuschätzen, ob die Agentur das überhaupt leisten kann.

Ein Wildcard-Import erlaubt es dir, dem Compiler ein komplettes Package als Suchbereich für deine verwendeten Typen zu übergeben.

Beispiel:

import java.util.*;

public class Main {
  public static void main(String[] args) {
    List<Integer> numbers = new ArrayList<Integer>();
  }
}

In diesem Fall weiß der Compiler, dass er, um einen unbekannten Typ wie List aufzulösen, in dem Package java.util suchen soll. Bei einem spezifischen Import:

import java.util.List;

wäre der Suchaufwand natürlich geringer, doch der fällt zeitlich zu gering aus, als dass er beim Kompilieren tatsächlich auffallen würde.

Einige Vor- und Nachteile der beiden Wege werden aufgrund der Features von IDEs wie Eclipse oder IntelliJ schon lange ausgeglichen. Beispielsweise ist die Länge der Import-Liste nicht mehr so wichtig, da es Ein-/Ausklappmechanismen im Code Editor gibt. Die Herkunft und die Definition eines Typs kann man ebenfalls schnell herausfinden, da die IDE Typnamen in der Regel verlinkt, sodass man via Klick direkt zur Implementation springen kann.

Wobei ein konkreter Import dir natürlich immer noch am deutlichsten sagt, welcher konkrete Typ von Anfang an zur Nutzung angedacht war. Das ist gerade in den Fällen relevant, in denen es sonst zu Namenskonflikten kommt.

Auf dem herkömmlichen Weg würde man einfach einen zusätzlichen spezifischen Import ergänzen:

import java.awt.*;
import java.util.*;
import java.util.List; // use always List from java.util

und wenn man beide Namensvertreter nutzen will, müsste für einen eben der volle Packagename genutzt werden:

import java.awt.*;

// main:
List awtList;
java.util.List someList;

Problematischer wird es allerdings, wenn ein Namenskonflikt erst im Nachgang entsteht. Nimm nur einmal an, du hast eine Anwendung mit einer externen Bibliothek, dessen Package du via Wildcard einbindest:

import someExternPackage.*;
// other imports ...

Nun wird diese Bibliothek vielleicht irgendwann einmal aktualisiert (für ein Sicherheitspatch, o.ä.) und für diese Version ist eine Klasse hinzugekommen, die zufälligerweise denselben Namen wie eine von dir genutzte Klasse aus einem anderen eingebundenen Package hat. In dem Fall müssten die Import-Anweisungen nochmal angepasst werden, damit der Compiler wieder weiß, welchen Typ er denn nun auflösen soll.

Vor allem bei größeren Projekten kann das einen ziemlichen Aufwand bedeuten, den Anwendungscode wieder kompilierbar zu machen.

Oft kannst du in Foren, die sich der Spieleentwicklung widmen, eine entsprechende Rubrik finden.

Beispiele:

• Itch: Help wanted or offered
• Unity: Collaboration & Jobs
• Unreal: Got Skills, Looking for Talent
• Reddit: INAT
• GameDev.net: Hobby Project Classifieds
• indiedb: Recruiting & Resumes
• Develteam

Wenn du bereits ein ganz bestimmtes Entwicklungstool im Sinn hast (eine Game Engine / ein bestimmtes Framework / o.ä.), dann würde es sich lohnen, einmal via Suchmaschine zu recherchieren, ob es zu dem auch ein Forum gibt. Das gilt ebenso für modifizierbare Spiele (GMod, Minecraft, ...), solltest du die Absicht haben, für diese Software bauen zu wollen. Alternativ dazu gibt es möglicherweise Subreddits, Discord-/Google-/Facebook-Gruppen.

Im Falle von Roblox (da du es in Kommentaren hier erwähnst) wären dafür wohl der Talent Hub oder das Recruitment-Subforum die richtigen Anlaufstellen.

Schau bevor du eine Suchanfrage stellst in den jeweiligen Foren-/Gruppenregeln, ob deine Art Anfrage richtig platziert wäre. Überlege dir generell, wie du eine Anfrage am besten formulierst: Es sollte definitiv eine Kurzbeschreibung deines Projekts beinhalten (lies dazu hier, dort habe ich im Übrigen noch andere Ideen aufgeführt) und eine Angabe der Aufgaben, die übernommen werden sollen. Des Weiteren solltest du erwähnen, dass es sich um ein Hobbyprojekt ohne Vergütung handelt.

Eine andere Möglichkeit, um persönlich Entwickler zu finden, sind GameJams. Ein paar Seiten, auf denen du bevorstehende Events findest:

• Itch: Jams
• indiedb: Contests & Jams
• GameDev.net: Gamejam
• Global Game Jam

Du bräuchtest eine zentrale Speicherstelle, auf die du von deinen unterschiedlichen Systemen aus zugreifen kannst.

Eine Option wäre irgendein Cloud Service, eine andere Option wäre ein Remote Repository (wie GitHub, GitLab, Bitbucket, o.ä.).

Letzteres dient nicht nur der zentralen Speicherung von Dateien, sondern ebenso der Versionierung. Das heißt, du hast einen Datenspeicher, dem du immer wieder neue Versionen (via Commit) hinzufügen kannst. Daraus ergibt sich der Vorteil, dass du jederzeit zu früheren Projektständen wieder zurückspringen, bzw. Änderungen leicht rückgängig machen kannst.

Du müsstest dir dafür erst einen Account auf einem der erwähnten Dienstleister anlegen und dort dann ein Projekt/Repository erstellen. Mit einem Git Client (eine Auswahl findest du hier) kannst du dir im Anschluss dieses Repository auf dein jeweiliges System klonen (jedes System hat also einen eigenen Klon vom zentralen Ordner, ein eigenes lokales Repository) und dann die Projektdateien, die geteilt werden sollen, mittels Commit + Push in das Remote Repository schieben. Sinnvollerweise solltest du Dateien, die von Unity dynamisch immer wieder generiert werden, nicht in das Repository schieben.

Immer wenn du auf einem System Änderungen vornimmst, müssen sie in das Remote Repository gepusht werden, damit die anderen lokalen Repositories sich diese Änderungen via Fetch + Pull holen können.

Ein paar hilfreiche Quellen für Git findest du hier:

• Kurzreferenz
• A Grip on Git

Es kommt darauf an, von welchem Kontext aus du das Projekt startest. Damit main_data als Package wahrgenommen wird, müsstest du das Projekt außerhalb (vom Projektroot aus) als Modul starten.

cd "path/to/module-test-import/module not found error"
python -m main_data.test1.test2.test3.test4.file4

Die Importzeilen in main.py bräuchten zudem noch eine Korrektur. Es fehlt jedenfalls der Packagename main_data davor.

from main_data.test1.test2.test3.file3 import fil3
from main_data.test1.test2.file2 import fil2
from main_data.test1.file1 import fil1

a) Du nutzt den Emulator der Webentwicklungstools deines Browsers. Das kann oftmals für Tests bereits ausreichen. In deinem Fall sicherlich ebenso.

b) Du nutzt Remote Debugging.

• Chrome: https://developer.chrome.com/docs/devtools/remote-debugging
• Safari: https://dev.to/nimajafari/remote-debugging-using-safari-on-ios-devices-with-macos-16p5

c) Du nutzt einen Dienstleister wie Browserstack, mit dem du verschiedene Geräte über ein Webinterface testen kannst.

Zu Godot: Lerne GDScript und probiere dich dann erst einmal an kleinen (Übungs-)Projekten aus. Minispiele wie Asteroids, Pong, Flappy Bird, Snake oder Pacman eignen sich sicherlich gut.

Mache dir einen Plan, bevor du mit einer Umsetzung beginnst. Der sollte beispielsweise beinhalten, was du für Komponenten benötigst, welche Zustände sie haben, wie sie sich verhalten oder welche Fähigkeiten ihnen innewohnen. Am Beispiel von Pacman betrachtet, kann die Spielfigur nach oben/unten/links/rechts laufen, sofern das nächste Feld in dieser Richtung frei ist. Sie kann Punkte fressen und bei Kollision mit einem Gegner gefressen werden. Sie hat eine bestimmte Maximalanzahl an Leben. Nach Fressen eines Powerups kann sie für eine gewisse Zeit Geister mampfen.

Auf diese Weise erlangst du einen besseren Überblick über dein zu implementierendes Spielsystem und verminderst das Risiko, in Designfallen zu tappen oder wichtige Spielelemente bei der Implementation zu vergessen. Für die ermittelten Funktionen/Verhaltensweisen lohnt es sich, einen Lösungsalgorithmus mittels Programmablaufplan oder Pseudocode zu bilden. Ist die Planung abgeschlossen, hast du beim Skripting bestenfalls nur noch Übersetzungsarbeit (Lösungsschritte zu GDScript) zu leisten.

Tutorials/Lernpfade, Nachschlagematerial u.ä. findest du unter anderem hier:

• Offizielle Dokumentation
• GDQuest
• Von Godot empfohlene Third-Party-Tutorials
• YouTube: @GodotEngineOfficial

Hinsichtlich Blender findest du auf YouTube zahlreiche Kanäle, die sich der 3D-Modellierung widmen.

• Sebastian Lague: Blender to Unity Character Creation (zwar im letzten Teil auf den Import und die Animation in Unity bezogen, doch dazu kannst du dir passend für Godot ja noch etwas heraussuchen)
• YouTube-Kanäle: blenderguru, CG Boost, CGMasters, Grant Abbitt (grabbitt), Greyscalegorilla
• Selbst wenn du Tutorials für andere Modellierungssoftware wie Autodesk Maya oder Cinema 4D findest: Die Funktionen mögen in Blender vielleicht ein wenig anders heißen und sich in der GUI woanders befinden, doch sie sind in der Regel übertragbar.

Und da gibt es natürlich noch die offizielle Trainingssektion mit einem Basiskurs und weiterem Material.

Ich würde für Praxisübungen den vorrangigen Fokus auf die Modellierung der Grundfigur legen. Texture-Mapping, Rigging u.ä. kann man sich später nach und nach widmen (keine Frage, es ist ebenso wichtig für deine Spielassets).

An Übungsideen dürfte es nicht scheitern. Lege dir ein Blueprint von deinem Zielmodell an (am besten Front- und Seitenansicht) oder suche nach Blueprints im Internet. Dann kannst du auch schon anfangen. Ich verlinke an dieser Stelle immer wieder gern dieses Tutorial für Bart Simpson.

Python benötigst du für dein Vorhaben gar nicht. Du kannst damit zwar Aufgaben in Blender automatisieren oder Blender funktional erweitern, aber eine Notwendigkeit dafür sehe ich nicht.

Was Gimp angeht: Basistutorials findest du auf der offiziellen Webseite und auf YouTube. Es gibt ebenso Bücher oder Videokurse auf Plattformen wie Udemy.

Für das praktische Erstellen von Texturen wiederum gibt es keinen festen Weg. So manches musst du einfach ausprobieren. Wenn du bestimmte Vorstellungen hast, aber nicht weißt wie, macht es wohl mehr Sinn, einfach zu schauen, ob es schon Tutorials gibt, die zumindest ähnliches realisieren. Dabei würde ich mich bei der ersten Recherche nicht völlig auf Gimp versteifen. Manchmal ist der Weg (bzw. die Benamung von Funktionen in Zeichenprogrammen wie Adobe Photoshop) einfach nur etwas anders oder du kannst mit anderen Gimp-Funktionen zumindest ähnliche Effekte erzielen.

Ein paar theoretische Grundlagen zu Texturen kannst du übrigens im Polycount Wiki nachschlagen (Texturing).

Zusätzliche Tipps für den Anfang:

• Achte beim Zeichnen darauf, erst sehr spät (beim Export) zu komprimieren und arbeite so lange mit Gimps Projektformat (xcf).
• Auf Alphakanäle würde ich verzichten, so lange Transparenz nicht benötigt wird.
• Bei der Texturgröße ist es in der Regel besser, die Po2-Regel zu berücksichtigen.
• Überlege dir für dein Spiel eine Farbpalette, bevor du beginnst, deine Texturen zu erstellen. So entsteht eher ein konsistenter bzw. stimmiger Stil.

Bezüglich Reaper findest du Grundlagentutorials im Videoformat auf ihrer Online-Präsenz und YouTube kann man erneut als weitere Lernquelle nutzen. Nach kurzer Recherche habe ich zum Beispiel den Kanal von @AkashThakkarAudio gefunden, der hilfreich erscheint.

(...) könnt ihr mir helfen wie ich das alles gut lernen kann?

Alles in allem solltest du definitiv viel Motivation und Zeit mitbringen, denn keines dieser Themen (Modelling, Texturing, Audiocreation, Programmierung) ist in wenig Tagen gelernt und für so manches wirst du zusätzliche Recherchearbeit aufbringen müssen. In jedes kann man sich sogar leicht jahrelang spezialisieren/verlieren, wenn man das Interesse dafür hat.

Vermutlich macht es Sinn, wenn du anfangs stärker reduzierst und mit auf fertige Assets setzt. Es gibt für Godot eine Asset Library und abseits davon ebenfalls mehrere Online-Portale, auf denen du 2D-/3D-Modelle, Texturen, Sounds, u.ä. findest.

Fange mit kleinen Projekten an.

Ich möchte ein Videospiel entwickeln (...)

Fange hierbei mit einer Planungsphase an, sofern noch nicht getan. Ein Game Concept hilft als Startpunkt und kann anschließend weiter zu einem Design Document ausgearbeitet werden. Diese Artikel beschreiben genauer, um was es sich handelt:

• The Anatomy of a design document
• How to write a game design document
• Tom Sloper: Sample outline for a Game Design Document

Es geht hierbei vor allem um Selbstorganisation, um das Schaffen einer Projektübersicht und Beschränkung zum Schutz vor Überforderung/dem Scheitern des Projekts. Konzentriere dich vorrangig auf Schlüsselfunktionen, die dein Spiel erfüllen soll. Erweiterungen/Nice-To-Have's/neue Ideen können auf einen gesonderten Zettel, der erst angerührt wird, wenn das Fundament steht.

Des Weiteren machst du es dir in der Umsetzungsphase einfacher, wenn du grob beginnst und erst in weiteren Schritten den Feinschliff ansetzt. Das heißt konkret, dass du ganz am Anfang definitiv noch keine ausgearbeiteten, hochqualitativen Modelle und Texturen benötigst. Du könntest soweit gehen, deine Spielwelt vorerst nur mit Blöcken als Platzhalter auszustatten, die dann nach und nach ersetzt werden. So lange du noch nicht soweit bist, kannst du dich dennoch bereits anderen Aufgaben (wie der Programmierung der Spiellogik) widmen.

Außerdem würde ich dir empfehlen, dich mit einem Versionierungssystem wie Git oder Mercurial auseinanderzusetzen und das auf deinen Projektordner anzuwenden. Wenn du deine Änderungen regelmäßig in das Repository einspeist, hast du, solltest du dir mal etwas zerschießen, eher die Chance, den Fehler leicht rückgängig zu machen. Ein lokales Repository anzulegen reicht für deine Zwecke übrigens vollkommen. Du benötigst kein Remote-Repository wie GitHub.

Tutorials/Guides zu Git findest du unter anderem hier:

• Kurzreferenz
• A Grip on Git

Wobei ich dir empfehlen würde, mit einem GUI-Client (z.B. gitExtensions, GitKraken, SourceTree, ...) zu arbeiten. Das ist meiner Meinung nach übersichtlicher und so musst du nicht mit der Kommandozeile arbeiten oder dir die einzelnen Befehle merken.

Ein paar allgemeine Nutzungshinweise für Godot mit einem Versionierungssystem gibt es übrigens in der Dokumentation.

Zuerst einmal solltest du dich mit Lua bzw. der Spracherweiterung Luau, die Roblox nutzt, beschäftigen. Schau dazu unter anderem auf folgenden Seiten:

• Offizielle Dokumentation von Lua
• Offizielle Dokumentation von Luau
• Roblox Creator Hub: Luau
• Codecademy: Lua
• Codecademy: Luau

Zusätzlich wirst du lernen/üben müssen, wie man überhaupt an Probleme in der Welt der Programmierung herangeht und einen entsprechenden Lösungsalgorithmus zusammenbauen kann. An der Stelle würde ich empfehlen, mit Programmablaufplänen oder Struktogrammen zu arbeiten. Zur Übung könntest du dir kleine Probleme überlegen/herausgreifen (schau zum Beispiel auf Exercism) und die dann mit Hilfe eines solchen Diagramms lösen. Im Anschluss implementierst du die Lösung in Lua.

Im Bezug auf der Entwicklung mit Roblox solltest du dich letzten Endes noch mit der API-Referenz vertraut machen. Du wirst sie als Nachschlagewerk benötigen.

(...) dass die Restaurantkette keine Website hat (...)

Wenn es sich um eine eigene Kette handelt, wird da im Vorfeld noch einiges an Absprache notwendig sein. Für den Fall, dass du tatsächlich eine Webseite bauen darfst, gibt es sicherlich irgendeine Form an Corporate Design, welches berücksichtigt werden müsste.

Zudem müsste ich wahrscheinlich auch die Verantwortung über das Hosting übernehmen.

Für das Hosting wäre es besser, einen Dienstleister zu nutzen. Hetzner, IONOS, Strato oder wen auch immer. Je nachdem, wie viel Flexibilität es tatsächlich bedarf, könnte sogar ein SaaS (Wix, WordPress.com, ...) völlig ausreichen und den Wartungsaufwand deutlich senken. Dabei würde ich die Aufgabe, dort einen Vertrag abzuschließen (das Gleiche gilt ebenso für die Registrierung für weitere Dienstleistungen: Das Reservieren einer Domain, eine Anbindung an Google Maps, o.ä.), an die Kundin weitergeben. So bist du nicht auf ewig an das Projekt gebunden und deine Kundin hat mehr Kontrolle über die Anwendung.

Bau in jedem Fall mindestens auf einem CMS auf und schaffe (bis auf eigene Themes/Templates) keine Eigenlösungen.

Bezüglich notwendiger Wartungsarbeiten oder Erweiterungen/Anpassungen würde ich an deiner Stelle vorschlagen, dass sie sich bei Bedarf bei dir meldet und dann könnt ihr den notwendigen Support als neue Tätigkeit mit Entgeld (mit einem ungefähren Stundensatz von 20-25€) aushandeln. Eine durchgängige Wartungsphase sollte bei so einer recht statischen Webseite kaum notwendig sein.

Beim ersten Erstellen der Webseite sollte lediglich noch eine Support-Phase (~3-5h) mit einberechnet werden, die du auf jeden Fall leistest.

Nicht zu vergessen sind auch die rechtlichen Aspekte (z.B. Cookie-Banner, Impressum). Ich würde dir raten, zwar auf die Pflicht hinzuweisen, jedoch keine Verantwortung bzw. rechtliche Beratung zu übernehmen. Die Inhalte sollten von der Kundin kommen (selbst wenn sie die mit irgendeinem Tool nur generiert), in keiner Form von dir. Ein Consent Manager ist für den Cookie-Hinweis die wohl beste/sicherste Lösung.

Für wie viel Geld wäre es vernünftig das zu machen?

Ich denke, ein Pauschalpreis zwischen 600-800 Euro wäre aufgrund der Anforderungen (vmtl. One Pager mit Stage, statischer PDF-Verlinkung der Speisekarte, Kontakt, integrierte Google Maps, Consent Manager-Integration, CMS-Basis, Recherche/Kommunikation) und deinem Erfahrungsgrad angemessen. Man kann dabei davon ausgehen, dass du für die Umsetzung ungefähr 40-50h (Supportzeit bereits einberechnet) benötigst. Dieser Schätzwert kann durch die notwendige Einarbeitung in neue Tools zwar noch weiter überschritten werden, das würde ich allerdings nicht gänzlich der Kundin anrechnen wollen.

Die Pseudoklasse selbst greift durchaus. Du würdest es sehen, wenn du ein anderes Property ändern würdest (z.B. background-color).

Die Wertänderung für flex-basis zeigt keine visuelle Wirkung, da die Größenberechnung der Flexbox-Items durch flex-grow und flex-shrink bestimmt wird. Der Wert von flex-basis ist nur ein Vorschlag, auf dessen Grundlage der Browser austariert. Außerdem hast du doch eine Maximalbreite für die Box vorgegeben, die kleiner ist, als der Zielwert.

Gib dem flex-Shorthand also andere Werte (flex-basis kann aus der Regel raus, der Wert kann schon gleich mit dem Shorthand richtig gesetzt werden)

flex: 0 0 300px;

und überlege dir nochmal, wie du mit max-width verfahren willst. Entweder muss es raus oder du verteilst andere Werte.

Ein CMS wie Contao arbeitet mit eigenen Templates, in die man als Nutzer dann Daten einpflegen kann. Es liegt nicht im Sinn, dieses Prinzip zu brechen, indem man eine eigene statische HTML-Webseite in das System lädt, um es von diesem ausliefern zu lassen. Die Seite soll zudem doch einfach wartbar bleiben. Das ist bei deiner Lösung nicht gegeben.

Es gibt nun folgende Lösungswege:

a) Du erstellst neue Contao (Twig) Templates, in denen du dein HTML-Layout anführst. An den Stellen, in denen Textinhalte ausgegeben werden, gehören die entsprechenden Platzhalter. Das CSS gehört normalerweise in ein eigenes Theme.

Im CMS kannst du dann Seiten deiner Templates anlegen und die jeweiligen Inhalte einfügen.

b) Contao hat ein HTML-Element, über welches man HTML einfügen kann. Sollten Tags notwendig sein, die per Standard nicht erlaubt sind, muss entweder die Konfiguration geändert werden oder du fügst die Seite via iFrame ein. Um deine Dateien auf das System zu laden, bräuchtest du Dateizugriff (bspw. via FTP oder RDP).

c) Du lädst deine Dateien (bestenfalls gebündelt in einem eigenen Ordner) in das web-Verzeichnis. Dafür brauchst du Dateizugriff (bspw. via FTP oder RDP) und musst evt. nochmals prüfen, ob es zu Konflikten kommt (z.B. wegen irgendwelcher htaccess-Regeln).

Angenommen, du hättest dann diese Dateistruktur:

/web
/web/mysite/index.html

Dann sollte deine Seite so auch aufrufbar sein: https://yourdomain.de/mysite/index.html.

Der erste Lösungsweg wäre der saubere Weg, wenn auch mit mehr Aufwand und Einarbeitung verbunden. Die beiden anderen sind mehr behelfsmäßig bzw. Pfuscherei.

Bei einem Decision Tree handelt es sich um eine Baumstruktur, die unter Abfolge der einzelnen Knoten zu einem spezifischen Ergebnis für eine Frage kommt. Dabei startet man bei einem abstrakteren Merkmal und wird nach und nach konkreter.

Ein einfaches Beispiel:

Alter < 18 --- ja ---> Geschlecht --- männlich ---> Junge
  |                      |
  |                      --- weiblich ---> Mädchen
  |
  --- nein ---> ...

Er ist einfach verständlich und lässt sich natürlich schnell trainieren. Allerdings ist die Wahrscheinlichkeit, später ungenauere Ergebnisse zu bekommen, hoch. Du trainierst die Anwendung mit dieser Struktur ja nur auf deine starren Merkmale und lässt gegebenenfalls Ausreißer außer Acht.

Ein Random Forest ist ein Zusammenschluss (bzw. ein Ensemble) mehrerer Entscheidungsbäume, die mit unterschiedlichen Teilen deiner Testdaten trainiert werden. Um eine letztendliche Entscheidung zu fällen, kann dann statistisch nach einer Tendenz (oder einem Mittelwert) ausgewertet werden. Durch diese Komplexität ist es natürlich (im Vergleich zum einzelnen Decision Tree) schwerer, die Struktur und Auswertung nachzuvollziehen und die Berechnung dauert länger / fordert mehr Ressourcen, doch sie fällt genauer aus und ist weniger starr auf ein einzelnes Muster geeicht.

Zusätzlich zu meiner Kurzerklärung sind m.E. diese beiden Artikel hilfreich:

• IBM: Random Forest
• BigData Insider: Was ist Random Forest?

Den primären Fokus würde ich an deiner Stelle erst einmal auf C++ richten. Nimm dir dafür genügend Zeit, es fällt dir sonst später nur auf die Füße. Auch wenn dir deine bisher gesammelten Java-Kenntnisse ganz sicher helfen werden, birgt C++ neben der Syntax einige Funktionen und Verhaltensweisen, die dir völlig neu sein werden und die du definitiv für dein Projektziel benötigen wirst.

Zum Lernen könnte ich dir folgende Quellen empfehlen:

• Bücher (in Deutsch): Schau nach den Autoren Breymann, Theis oder Will
• Bücher (in Englisch): Schau auf diese Liste
• Learn C++
• Studyplan
• Codeacademy (für einen ersten Einstieg)
• Tim Buchalka: Beginning C++ Programming - From Beginner to Beyond (Udemy Videokurs)
• Vertiefende Literatur bieten unter anderem Scott Meyers und Herb Sutter

Vermutlich findest du ebenfalls passende Kurse auf Educative, PluralSight oder Udemy.

Ich würde allerdings darauf achten, möglichst Quellen zu nutzen, die mindestens C++ 17 behandeln, denn die Sprache hat sich im Verlauf der Zeit ziemlich gewandelt.

Des Weiteren kann es gut sein, dass Tutorials nur die üblichen Grundlagenthemen abklappern, aber nicht in die Tiefe gehen. Also beispielsweise Coroutines, Lambdas, Smart Pointer, (IO-)Streaming, Reflection, Templates, u.ä. völlig außer Acht lassen. Deshalb ist es besser, immer wieder mehrere Quellen im Mix zu nutzen, zumal sie durch unterschiedliche Erklärweisen Themen nochmal besser/leichter verständlich machen können.

Für den praktischen Einstieg könntest du mit OpenFrameworks experimentieren oder du überlegst dir eigene kleine Ziele für die Konsole. Lerne schrittweise (z.B. nach Kapitel) und wiederhole zuvor Gelerntes immer wieder (z.B. indem du es mit neuen Themen kombinierst).

Als Entwicklungsumgebung würde ich auf Visual Studio setzen oder alternativ den QtCreator.

Ein Einstieg in DirectX ist nochmal eine Ecke schwieriger. Ein paar Einstiegspunkte (Lernquellen) findest du hier:

• Referenz: Die Microsoft Dokumentation
• Buch: Introduction to 3D Game Programming With DirectX 12 von Frank Luna
• Braynzar
• Blog: 3dgep
• Blog von Alain Galvan (nur für einen ersten Einstieg)
• YouTube: OlympusMonsTutorials - DirectX 12 Game Engine Series
• Referenzprojekte: DirectX-Graphics-Samples (speziell die MiniEngine wäre für dich keine schlechte Basis)

In der Entwicklung kannst du es dir ein bisschen einfacher machen, indem du Hilfsbibliotheken wie DirectXTK12 und D3D12MA einbindest.

In der Lernkurve wäre es einfacher, mit Vulkan oder DirectX 11 zu starten. Vulkan hat eine ähnliche Architektur zu DirectX, doch es sollten sich mehr zugängliche Quellen finden lassen. DirectX 11 wiederum ist fehlertoleranter als Version 12 und die konkrete Ressourcenverwaltung wird dir abgenommen.

Das Kernproblem liegt hier:

installed tzdata package post-installation script subprocess returned error exit status 10

Da die Konfiguration von tzdata (einem Paket, welches Zeitzonendaten enthält) gescheitert ist, werden die nachfolgenden Abhängigkeiten nicht mehr richtig installiert.

Probiere es erst einmal erneut mit:

sudo dpkg --configure -a

Das startet die Konfiguration aller noch unkonfigurierten Packages. Alternativ könntest du zuerst einmal auch nur das eine Package neukonfigurieren lassen:

sudo dpkg --configure tzdata

Wenn das fehlschlägt, erhältst du womöglich neue/bessere Fehlerinformationen.

Ebenso einen Versuch wert wäre eine Neuinstallation des Pakets:

DEBIAN_FRONTEND=noninteractive apt install --reinstall tzdata

Die Umgebungsvariable verhindert das Erstellen/Öffnen interaktiver Dialoge während der Installation, die womöglich auf eine Eingabe (z.B. der aktuell gewünschten Zeitzone für das System) warten. Stattdessen müsste tzdata auf einen Standardwert (UTC) zurückfallen.

Ein paar Quellen, die ich empfehlen kann:

• JetBrains Academy
• Buch: Programmieren lernen mit Java von Habelitz
• Buch: Java ist auch eine Insel von Ullenboom (gibt es in der 16. Auflage auch als Open Book)
• Buch: Schrödinger programmiert Java von Ackermann
• Core Java Tutorial by Pankai

Richte dir gleich zu Beginn eine Entwicklungsumgebung ein, in der du das, was du dir anliest, direkt ausprobieren kannst. IDEs, die sich hierfür gut eignen, wären IntelliJ IDEA, Eclipse oder NetBeans IDE.

An der Stelle empfehle ich zudem gern Processing, denn diese Sprache erlaubt dir einen einfacheren Einstieg, indem sie sinnvoll reduziert und es erlaubt, schnell grafisch-visuelle Erfolge zu erzielen. Ein späterer Umstieg zu Java sollte nahtlos klappen.

Welche Anwendung sich für dich am ehesten lohnt, hängt von deinen Anforderungen und deinem technischen Verständnis ab.

Wix eignet sich sehr gut für kleine Webseiten (z.B. Portfolios) und ist ziemlich einfach zu bedienen. Du kommst sehr schnell zu einem Ergebnis. Allerdings bist du technisch auf das limitiert, was Wix dir bietet. Themes/Templates lassen sich mit Velo modifizieren, doch du kannst keine eigenen Templates von grundauf anlegen.

Jimdo ist ebenfalls für Einsteiger ausgerichtet, die schnell eine einfache Seite basteln wollen. Hinsichtlich individueller Anpassungen (z.B. beim Design) bist du eingeschränkt: Du kannst zwischen vorhandenen Themes auswählen und bei denen einzelne Änderungen (Farben für bestimmte Elemente, Schriften, evt. ebenso Abstände, Positionierung von Elementen an vordefinierte Plätze, ) vornehmen, aber hast keine direkte Kontrolle über das Layout.

WordPress gehört zu den einfacheren CMS und lohnt sich für kleine bis mittelgroße Webseiten (Portfolios, Blogs, Businessprofile, zusammen mit WooCommerce für kleine Shops). Verglichen mit Baukästen wie Jimdo und Wix würde ich die Lernkurve leicht höher einschätzen.

Wie bei den vorherigen Anwendungen gibt es WordPress als SaaS (wordpress.com), d.h. dir wird ein System gestellt, auf dem die Anwendung bereits gehostet wird. Du kannst allerdings auch die Alternative (wordpress.org) nutzen, bei der du selbst entscheiden kannst, wie und wo du sie hostest. Das erfordert mehr technisches Know-How und Einrichtungs-/Wartungsaufwand, dafür hast du allerdings Zugriff auf das technische Backend. Bei der org-Variante hast du zudem mehr Freiheit über die Installation von Plugins, dem Anlegen neuer Templates oder dem Anpassen von Themes. Dafür solltest du mindestens mit HTML und CSS etwas vertraut sein. PHP und JavaScript wird benötigt, falls du Anwendungslogiken anpassen/hinzufügen möchtest.