Das Problem liegt nicht im fetch-Request, sondern darin, wie du versuchst, die Daten weiterzugeben.

Ein sehr einfaches Beispiel kann zunächst so aussehen:

<script>
  import { onMount } from "svelte";

  let guides = [];

  onMount(async () => {
    const response = await fetch("https://jsonplaceholder.typicode.com/posts");

    if (response.ok) {
      guides = await response.json();
    }
  });
</script>

<div class="guides">
  <ul>
    {#each guides as guide}
      <li>{guide.title}</li>
    {/each}
  </ul>
</div>

Für die Verwendung von load-Funktionen lies zuerst in der Dokumentation, wie es funktioniert.

Beispielimplementation:

page.js

export async function load({ fetch }) {
  const response = await fetch("https://jsonplaceholder.typicode.com/posts");

  if (response.ok) {
    const result = await response.json();
    return { guides };
  }

  /* otherwise do some error handling ... */
}

page.svelte

<script>
  export let data;
</script>

<div class="guides">
  <ul>
    {#each data.guides as guide}
      <li>{guide.title}</li>
    {/each}
  </ul>
</div>
...zur Antwort

Du hast recht viele Fehler in deinem Dokument. Ich liste sie einmal auf:

1) In den head-Bereich eines Dokuments gehören nur Metainformationen, die nicht den Seiteninhalt, sondern das Dokument generell beschreiben (also z.B. wer der Autor ist, welche Stichworte sich mit ihm verbinden lassen, welche Zeichenkodierung genutzt werden soll, u.ä.).

Dein Bild/Logo ist jedoch ein Seitenelement. Es gehört in den body-Bereich.

2) Um zugleich beim Bildelement zu bleiben:

  • Das title-Attribut ist dazu da, um erweiterte Nutzungshinweise zu einem Element zu liefern. Ein klassisches Beispiel wäre ein Hinweis, dass man das Bild via Klick vergrößern kann (wenn so eine Funktion denn implementiert wäre). In deinem Fall ist es also fehl am Platz.
  • Die Attribute height und width erwarten nur numerische Werte, ohne Einheitsangabe. Wenn du Größen mit einer spezifischen Einheit setzen möchtest, nutze die CSS-Properties width und height.
  • Dem Bild fehlt ein alt-Attribut. Seinen Wert kannst du mit Hilfe dieses Guides bestimmen. Da es sich bei einem Logo um ein dekoratives Element handelt, bleibt der Attributwert leer.
  • Das align-Attribut gehört nicht zum Standard. Es wird dir vom Editor ja auch nicht grundlos rot markiert. Um das Bild zu positionieren, kannst du CSS (z.B. das text-align-Property) nutzen.

3) Der Wert des title-Elements gehört zwischen Start- und Endtag.

<title>Irgendein Titel</title>

4) Das type-Attribut des link-Elements erwartet einen validen MIME-Typ. Im Falle von CSS wäre das text/css. Du kannst das Attribut aber auch komplett weglassen, da der Browser den richtigen Typ dann auch automatisch ermitteln kann.

5) Das br-Element ist für Zeilenumbrüche innerhalb von Paragraphen gedacht. Für das Setzen größerer Abstände zwischen Elementen gibt es CSS-Properties wie margin oder padding.

6) In Zeile 19 verwendest du erneut Elemente/Attribute, die es im HTML5-Standard nicht gibt. Positionierungen, Schriftdefinitionen u.ä. kann man mit CSS vorgeben.

<h1 class="headline">Irgendein Titel</h1>

CSS:

.headline {
  color: green;
  font-family: "Broadway";
  font-size: 24px; /* for example */
  text-align: center;
}

7) In deinem CSS-Code fehlt hinter dem Wert für das border-radius-Property ein abschließendes Semikolon.

8) Tipp: Das ol-Element kann bereits für dich die Listenpunkte nummerieren. Das musst du nicht manuell machen.

Generell würde ich dir empfehlen, HTML und CSS mit einer aktuellen und seriösen Lernquelle zu lernen. Die Webdokumentation von Mozilla oder Mediaevent bieten sich da an.

...zur Antwort
Welche Sprachen und wie danach weitermachen?

Fokussiere dich vor allem erst einmal nur auf eine Programmiersprache. An der Stelle immer wieder mit etwas Neuem zu beginnen, bringt dich ja nun nicht effektiv weiter.

Da du schreibst, dass du dich bisher am meisten mit Python beschäftigt hast, würde ich dir auch empfehlen, damit weiterzumachen.

Das Problem ist, das wenn ich von Neuem anfangen will, ich mich schnell langweile, weil ich ja schon weiß, wie man Variablen anlegt etc.

Wenn du dich in Themenbereichen bereits sicher genug fühlst, gehe zum nächsten über. Ein Buch, Lernkurs oder Tutorial kann dabei helfen, einen roten Faden zu finden.

Was ist eurer Meinung nach der beste Weg um programmieren zu lernen?

Suche dir seriöse Lernquellen und richte dir für den Start ebenfalls eine Entwicklungsumgebung ein, in der du das, was du dir anliest, testen kannst. Umso mehr Grundlagen du kennst, umso einfacher dürfte es fallen, Übungsaufgaben zu finden, in denen du deine Kenntnisse kombiniert einsetzen kannst.

Entweder du überlegst dir selbst Aufgaben, recherchierst in Foren (z.B. hier auf der Plattform) nach Übungsaufgaben oder schaust auf Webseiten wie Edabit, Exercism, w3resources, u.ä..

Ich könnte dir des Weiteren Processing.py sehr empfehlen. Diese Programmierumgebung stellt dir Zeichenfunktionen zur Verfügung, mit denen du schon früh Simulationen oder Minispiele (Breakout, Pong, Snake, ...) erstellen könntest. Was generell so mit Processing möglich ist, kannst du dir auch auf dieser Seite anschauen.

Was haltet ihr von solchen Online-Kursen wie von open.hpi.de?

OpenHPI kann man als Lernquelle empfehlen.

...zur Antwort

Die SVG sollte die gesamte Fläche des Bildes einnehmen. Die Marker würde ich eigentlich ebenso in die SVG hineinnehmen. Farben (fill, stroke), Transparenz (opacity) und Positionierung kannst du mittels CSS lösen.

Die Struktur für die Positionierung kurz angedeutet:

<div style="position: relative">
  <img alt="..." src="...">
  <svg height="..." style="height: 100%; left: 0; position: absolute; top: 0; width: 100%" viewport="..." width="...">
    <!-- svg elements ... -->
  </svg>
</div>

Für wiederkehrende Elemente (Marker, Pfeil) kannst du ein symbol anlegen und via use Instanzen davon erzeugen. Um die passend zu rotieren, hilft erneut CSS (siehe transform).

...zur Antwort

Dein Skript sowie die Methode, in dem die Log-Methode steht, müssen zur Laufzeit auch eingebunden/aufgerufen werden.

  1. Lege dir im Hierarchy-Fenster ein Game Object an und ziehe es via Drag & Drop in deine Szene.
  2. Lege dir im Projects-Fenster (unter Assets) ein Skript an (z.B. mit dem Namen MyScript) und ziehe es via Drag & Drop auf dein Game Object im Hierarchy-Fenster.
  3. Der Code im Script könnte folgendermaßen aussehen:
using UnityEngine;

public class MyScript : MonoBehaviour
{
  void Awake()
  {
    Debug.Log("Hello world!");
  }
}

Hierbei ist wichtig, das Klassenname und Name der Skriptdatei identisch sind.

Des Weiteren wird die Log-Methode in einem von Unity zur Verfügung gestellten Hook aufgerufen (Awake). Eine Auflistung verfügbarer Hooks mitsamt Erklärung findest du in der API-Dokumentation (Abschnitt: Messages). Falls du die von mir genannten Fenster/Views nicht findest, schau ebenfalls in das Manual (Unity's Interface).

Starte im Anschluss den Play-Mode (via Klick auf den Play-Button über der Scene View). Die Ausgabe wird daraufhin im Console Window angezeigt.

Ich bin ein KOMPLETTER Anfänger im programmieren (...)

Gerade deswegen würde ich davon abraten, mit/in Unity C#-Programmierung zu lernen. Fokussiere dich erst einmal nur auf die C#-/.NET-Grundlagen. Konsolenanwendungen in Visual Studio bieten ein gutes, reduzierteres Umfeld für den Start.

...zur Antwort

Dieses Tutorial zeigt dir anhand eines Fallbeispiels, wie man eine Webanwendung mit React und Stripe bauen kann.

Es vermittelt dir aber nur Informationen zu einzelnen, spezifischen Werkzeugen, die für die dort angepeilten Funktionalitäten gerade benötigt werden. Ein solides Grundlagenwissen zu JavaScript/Node.js/React/Stripe/o.ä. baust du dir in diesem Verlauf wohl nicht auf. Eine tatsächliche Projektplanung sehe ich ebenso nicht.

Du müsstest dir im Anschluss zu diesem Tutorial die ehrliche Frage stellen, ob du mit diesem Wissen nun auch eigenständig größere Erweiterungen/Verbesserungen vornehmen sowie völlig andere Projekte auf mindestens demselben Komplexitätsniveau umsetzen könntest. Diese Art an Flexibilität würde ich für einen Industrielevel erwarten.

Dieses Tutorial sehe ich dahingehend nur als ein Puzzleteil von vielen.

...zur Antwort
Ich kann bereits HTML und CSS (...)

Um das Trio komplett zu machen, könntest du dich auch JavaScript widmen. So hättest du auch ein Werkzeug, mit dem du deine erstellten Webseiten im Browser dynamischer gestalten könntest.

Youtube. Das sollte die Antwort sein, (...)

Es gibt meiner Meinung nach viel bessere Quellen. Beispielsweise gibt es Lernkurse in der JetBrains Academy oder verschiedene Bücher vom Rheinwerk-Verlag (Schrödinger programmiert Java, Java ist auch eine Insel, u.ä.). Diese Lernquellen sind im Vergleich zu vielen Videotutorials umfangreicher, inhaltlich besser geprüft und lektorisch hochwertiger aufbereitet.

(...) aber dann sagt der eine Youtuber "Don't do tutorials to learn a programming langauge or you'll be trapped in tutorial hell", (...)

Was er damit genau meint, ist aus diesem Auszug nicht klar ableitbar. Wenn er das nicht weiter ausgeführt hat, ist es wohl keine Aussage, an der man sich länger festmachen sollte.

Ob sich ein Tutorial lohnt oder nicht, muss man fallabhängig bewerten. Du kannst sowohl auf schlechte, als auch gute Tutorials treffen, wobei ich unter schlecht explizit solche einordne, die Informationen zu den jeweiligen (Grundlagen-)Themen unzureichend oder mangelhaft vermitteln. Crashkurse, bei denen der Tutor meint, die wichtigsten Punkte in einer Viertelstunde herunterzubeten, würde ausreichen, bringen dir beispielsweise nichts. Das Gleiche gilt für Tutorials, in denen Code zum Nachtippen vorgegeben, aber kaum erklärt wird.

Wie lernen ich Programmieren richtig (Java)?

Ich halte es für hilfreich, sich für das Erlernen der Theorie einen roten Faden zu suchen - den eben ein Buch, ein Kurs oder ein Tutorial bieten kann.

An dem, was du dir anliest, solltest du dich allerdings auch praktisch üben. Richte dir also gleich zu Beginn eine Entwicklungsumgebung ein, in der du mit Java herumexperimentieren kannst.

Anfangs wird es sicherlich nicht leicht sein, sinnvolle Übungen zu finden. Sobald du allerdings ein paar Grundlagenkenntnisse zu Kontrollstrukturen, Variablen, Arrays und Operatoren gesammelt hast, öffnen sich schon mehr Gelegenheiten (z.B. Entwicklung von Such- und Sortieralgorithmen).

Persönlich empfehle ich Programmieranfängern gern Processing. Mit Processing könntest du recht früh kleine Minispiele wie Pong oder Snake programmieren (generell dürfte es leichter fallen, Übungen zu finden). Ein weiterer Vorteil dieser Sprache liegt darin, dass sie auf die strikte objektorientierte Struktur von Java (die anfangs eh nicht ausreichend verständlich erklärt werden kann) verzichtet. Das macht es einfacher, sich für den Einstieg auf das Wesentliche zu fokussieren. Ein späterer Wechsel zurück zu Java kann nahezu nahtlos erfolgen, ohne dafür die Grundsyntax neu lernen zu müssen.

(...) wenn ich auch eigene Plugins schreiben könnte.

Bezüglich Minecraft nur eine Randbemerkung: Widme dich diesem Bereich (damit meine ich auch jegliche Lernquellen aus dieser Richtung) besser erst, sobald dir die Konzepte der objektorientierten Programmierung bekannt sind. Du brauchst sie für die Entwicklung.

...zur Antwort
Customtkinter?

Ist es normal dass das erstellen von Labels, Textfelder oder Buttons in Klassen als Vorlage super viel Schreibarbeit ist oder geht das auch eleganter und sauberer?

main:

maclass Main(ctk.CTk):
    def __init__(self):
        super().__init__()
        self.main_window()
        self.chatbot_output = InputBox(self, 1, 1, 10, 10, "s", 500, 500, "#202222", "red", "white", "Gib einen Text ein...")
        self.chatbot_output.grid(row=1, column=1, pady=10, padx=10, sticky="s")
        self.chatbot_input = InputBox(self, 2, 1, 0, 10, "n", 500, 50, "#202222", "red", "white", "Gib einen Text ein...")
        self.chatbot_input.grid(row=2, column=1, pady=0, padx=10, sticky="n")
        self.placeholder = Label(self, 0, 1, 0, 10, "n", 500, 320, "transparent", "transparent", "white", ".")
        self.placeholder.grid(row=0, column=1, pady=0, padx=10, sticky="n")
    def main_window(self):
        height = 920
        width = 1680
        x = (self.winfo_screenwidth()//2)-(width//2)
        y = (self.winfo_screenheight()//2) - (height//2)
        self.geometry(f"{width}x{height}+{x}+{y}")
        self.title("YourTerminal")
        self.grid_columnconfigure(0, weight=0)
        self.grid_rowconfigure(0, weight=0)



if __name__ == "__main__":
    main = Main()
    main.mainloop()
    sys.exit()

Vorlage in einer Klasse und in einer anderen Datei:

class InputBox(ctk.CTkFrame):
    def __init__(self, master, row, column, pady, padx, sticky, width, height, entry_fg_color,frame_fg_color, textcolor, placeholder, *args, **kwargs):
        super().__init__(master, fg_color=frame_fg_color, *args, **kwargs)
        self.set_setup(row, column, pady, padx, sticky, width, height, entry_fg_color, textcolor, placeholder)

    def set_setup(self, row, column, pady, padx, sticky, width, height, entry_fg_color, textcolor, placeholder):
        self.input = ctk.CTkEntry(self,
                                  width=width,
                                  height=height,
                                  fg_color=entry_fg_color,
                                  text_color=textcolor,
                                  placeholder_text=placeholder,
                                  )
        self.input.grid(row=row, column=column, pady=pady, padx=padx, sticky=sticky)
...zum Beitrag

Lange Parameterlisten können mit kwargs abgekürzt werden.

Andernfalls könntest du deine GUI ebenso direkt mit einem GUI Designer (z.B. Tkinter-Designer oder Pygubu) zusammenbauen oder eine Webseite via cefpython integrieren.

Bessere Alternativen zu tkinter wären kivy oder PyQt. Dort kannst du Oberflächen mit kv bzw. QML beschreiben.

...zur Antwort

Sofern möglich, wäre es gut, Objekte wiederzuverwenden, statt durchgehend neue Instanzen zu erstellen. Das setzt allerdings voraus, dass die Objekte nach einer bestimmten Zeit oder Aktion (z.B. Kollision) verschwinden.

Lege dir beispielsweise eine Datenstruktur an, die nur eine begrenzte Anzahl an Objekten aufnehmen darf. Sobald das Limit erreicht wurde, werden keine neuen Objekte erstellt. Objekte, die verschwinden, werden neu positioniert.

Wie hoch du das Limit setzt, musst du ausprobieren oder du rechnest dir aus, wie oft die Objekte in der Fläche, in der sie erzeugt werden sollen, hineinpassen würden.

Um die Fläche sinnvoll zu füllen, sollte beim Positionieren der Objekte darauf geachtet werden, dass sie sich nicht (oder nur zu einem bestimmten Teil) gegenseitig überlagern (man könnte je Objekt einen Radius festlegen, in dem kein anderes neues Objekt positioniert werden darf). Es wäre zum Beispiel ungünstig, wenn sich drei Objekte auf der exakt selben Position befinden. Nutze bestenfalls einen Quadtree um die Objekte zu verwalten.

Außerdem würde ich schauen, inwiefern sich die Objekte Ressourcen teilen können. Wenn jedes Objekt eine Bildtextur/ein Sprite o.ä. hat, sollte dieses im Programm nur einmal geladen werden.

Bezüglich Kollisionsprüfungen u.ä. wäre es vorteilhaft, wenn die vom Spielerobjekt ausgehen (d.h. es wird nur geprüft, ob der Spieler mit einem anderen Objekt kollidiert ist, nicht andersherum). Ob sich das mit deiner Spiellogik deckt, musst du allerdings selbst prüfen.

...zur Antwort

Du kannst das AutoScale Lite-Plugin nutzen. Schau dir das in der Beschreibung angegebene YouTube-Tutorial an. Es beschreibt das grundsätzliche Problem, dessen Lösung sowie die Bedienung des Plugins leicht verständlich.

...zur Antwort

Die Methode hi ist objektgebunden. Du versuchst dennoch, sie über die Klasse aufzurufen.

Insofern gibt es zwei Lösungsoptionen. Entweder machst du aus hi eine statische Methode

public static void hi()
{
  /* ... */
}

oder du kreierst eine Instanz von MainClass, um sie aufrufen zu können. Wobei man hier überlegen sollte, ob das Objekt bei jedem Aufruf von Update erstellt werden muss, oder ob nicht ein Objekt ausreicht.

private MainClass mainClassObject = new MainClass();

void Update()
{
  Debug.Log(mainClassObject.hi());
}

Generell empfiehlt es sich, sich erst mit C#-Grundlagen sowie OOP auseinanderzusetzen, bevor man mit Unity beginnt, Spiele zu entwickeln.

...zur Antwort
Customtkinter "master" Parameter beim erstellen von einem Textfeld?

Hey,

ich habe eine Klasse erstellt die ein Hauptfenster erstellt und möchte aus einer anderen klasse einen Textfeld erstellen der sich auf das Hauptfenster bezieht.
So wie ich es verstanden habe braucht man dafür den Parameter "master" um vorzugeben in welchem Fenster nun der Textfeld angezeigt werden soll.
Leider funktioniert das bei mir nicht so richtig. Hat jemand davon Ahnung und kann mir meinen Fehler zeigen?
lieben Dank! :)

main.py

import view
import controller
import customtkinter as ctk

class Main(view.MainWindow):
   def __init__(self):
       super().__init__()
       self.main_window = view.MainWindow()
       self.main_window.set_size("1680", "900")
       self.main_window.set_title("YourTerminal")
       controller.InputBoxMain()# Nach meinem Verständnis muss hier der Master-Parameter angegeben werden. Wie übergebe ich diesen?

   def run(self):
       self.main_window.get_window().mainloop()

if __name__ == "__main__":
    app = Main()
    app.run()

view.py

import customtkinter as ctk


class MainWindow:
   def __init__(self):
       self.window = ctk.CTk()

   def set_size(self, width, height):
       self.window.geometry(f"{width}x{height}")

   def set_title(self, title):
       self.window.title(title)

   def get_window(self):
       return self.window

class WindowTemplate:
   def __init__(self):
       self.window = ctk.CTkToplevel()

   def set_size(self, width, height):
       self.window.geometry(f"{width}x{height}")

   def set_title(self, title):
       self.window.title(title)

   def get_window(self):
       return self.window

# der master Parameter gibt an wo diese Box angezeigt werden soll
class InputBoxTemplate:
    def __init__(self, master):  # Wie übergebe ich den master Parameter?
        self.master = master
        self.box = ctk.CTkEntry(self.master)

    def set_size(self, width, height, y, x):
        self.box.place(width=width, height=height, pady=y, padyx=x)

    def set_placeholder(self, placeholder):
        self.box._placeholder_text(f"{placeholder}")

controller.py

import view
import customtkinter as ctk
import main
class InputBoxMain(view.InputBoxTemplate, main.Main):
    def __init__(self):
        super().__init__()
        self.master = ctk.CTk()
        self.window = view.InputBoxTemplate(self.master)# Oder der Master-Parameter wird hier übergeben? Hier versuche ich master auf ctk.CTk zu beziehen. Das ist das Haupfenster.
        self.window.set_size(200, 200, 10, 10)
        self.window.set_placeholder("Hier steht der Placeholder")

Hier die Fehlermeldung falls relevant:

Traceback (most recent call last):

 File , line 1, in <module>

  import view

 File , line 2, in <module>

  import main

 File , line 2, in <module>

  import controller

 File " line 4, in <module>

  class InputBoxMain(view.InputBoxTemplate, main.Main):

            ^^^^^^^^^^^^^^^^^^^^^

AttributeError: partially initialized module 'view' has no attribute 'InputBoxTemplate' (most likely due to a circular import)

...zum Beitrag

Deine Vererbungsstrukturen erscheinen etwas chaotisch. Um das also einmal vorauszunehmen: Solltest du dich hinsichtlich der objektorientierten Programmierung noch nicht auskennen, wäre es vorteilhaft, sich erst einmal diesem Thema zu widmen, bevor du mit CustomTkinter weitermachst.

1) Ich sehe keinen Sinn, wieso die Main-Klasse von view.MainWindow erben sollte. Sie repräsentiert kein Fensterobjekt. Sie besitzt lediglich ein Attribut (main_window), welches ein view.MainWindow-Objekt hält.

Auch für InputBoxMain solltest du die Hierarchie überdenken.

2) Im gesamten Programm sollte es nur einen einzigen Root (zeitgleich die oberste Komponente) geben. Du erstellst in InputBoxMain bereits einen zweiten. Das window-Attribut von MainWindow verweist auf den ersten Root.

3) Die set_size-Methode von InputBoxTemplate tut nicht das, was ihr Name verspricht. In ihr versuchst du, die Komponente an eine bestimmte Position zu verschieben. Außerdem vergibst du der place-Methode dabei falsche Argumente.

Richte die Komponente am besten gleich nach dem Erstellen mit pack aus.

self.box.pack(padx=x, pady=y)

Die Größe des Feldes kannst du entweder über Argumente des Konstruktors bestimmen oder nachträglich via configure:

self.box.configure(width=width)
self.box.configure(height=height)

Wirf diesbezüglich auch einen Blick in die Dokumentation.

4) Bei _placeholder_text handelt es sich um ein Attribut, keine Methode. Auch hier gilt: Wenn du dessen Wert nachträglich ändern möchtest, nutze configure.

self.box.configure(placeholder_text=f"{placeholder}")

5) Mit dem master gibst du das Parent Widget (die Elternkomponente) für ein Widget an.

In deinem Fall soll das Eingabefeld in dein Hauptfenster gehängt werden. Demzufolge müsstest du dir in Main das Rootobjekt der MainWindow-Instanz holen und sie an InputBoxMain weitergeben.

controller.InputBoxMain(self.main_window.get_window())

Der Konstruktor von InputBoxMain muss demzufolge um einen Parameter ergänzt werden. Dessen Wert wird an den Konstruktor von InputBoxTemplate überreicht.

def __init__(self, master):
  self.window = view.InputBoxTemplate(master)
  # etc. ...

Dort kannst du das empfangene Objekt nutzen, um das Eingabefeld zu kreieren.

def __init__(self, master):
  self.box = ctk.CTkEntry(master=master)
...zur Antwort

Stelle zuerst sicher, das auch der Signal-Slot gelöscht ist.

Starte dann einen Rebuild für dein Projekt (oder lösche den Ordner mit dem Kompilat und kompiliere das Projekt neu).

...zur Antwort

Funktionen zur direkten Bearbeitung bietet Qt nicht. Du kannst dafür aber andere Bibliotheken nutzen (z.B. Aspose.PDF, PDFHummus oder PoDoFo).

...zur Antwort

Überzeichne den Text einfach mit einem neuen, leeren String (oder null). Wichtig ist, dass die Koordinaten gleich bleiben.

w.showText(null, w.getWidth() / 2, w.getHeight() / 2);
...zur Antwort

Nimm das Minimalbeispiel aus der Dokumentation. Beachte die auf der Seite angegebenen Hinweise. Sobald es lauffähig ist, nimmst du es als Grundlage für Weiteres.

...zur Antwort
Wo Webseiten-Programmieren lernen?

Für die Erstellung dynamischer Webseiten solltest du dich mit HTML, CSS und JavaScript befassen. Mit den beiden erstgenannten Sprachen kannst du die Seitenstruktur und das Design bestimmen. Mit JavaScript schaffst du die Interaktivität zwischen Nutzer und Oberfläche.

Zum Lernen eignen sich diese Quellen gut:

  • MDN
  • Mediaevent
  • SelfHTML
  • javascript.info
  • HTMLDog (die Artikel zu JavaScript sind allerdings veraltet)

Da sich all die Webtechniken immer wieder ändern, solltest du auch nach dem Erlernen der Grundlagen weiter am Ball bleiben. Nicht jedes neues Feature wird in jedem Tutorial/Lernkurs/... erwähnt. Webblogs, die sich mit Webentwicklung befassen, können an der Stelle nützlich sein. Des Weiteren gibt es etliche Bibliotheken/Frameworks (z.B. Angular, Bootstrap, Foundation, React, Svelte, Tailwind, ...), bei denen sich ein tieferer Einblick lohnen würde.

Ein paar zusätzliche Quellen (für danach), die hilfreich sein können:

  • CSS-Tricks (Blog über Webtechniken: CSS, SVG, u.ä.)
  • Medium (über Tags wie html, css, u.ä. kannst du dort einige nützliche Artikel finden)
  • Modern CSS Solutions
  • Smashing Magazine (Blog über Webtechniken)
  • web.dev
  • W3Schools (Nachschlagewerk mit praktischen Beispielen zum Ausprobieren)

Die drei angesprochenen Sprachen sind soweit Frontendtechnologien. Das heißt, sie werden direkt im Browser geladen und ausgeführt. Im Backend (also auf Seite des Webservers, der die Webseite ausspielt) kann man allerdings ebenso noch ansetzen, um dort beispielsweise Daten vorzubereiten oder Daten persistent zu speichern (z.B. Nutzerdaten für einen Loginbereich).

Es gibt verschiedene Programmiersprachen, die hierbei Einsatz finden könnten. Welche genau, hängt vor allem vom Webserver (und seiner Konfiguration) ab. Weit verbreitet sind C#, Java, JavaScript (auf Basis von NodeJS oder Deno), PHP, Python oder Ruby. Es gibt aber noch weitere Optionen.

Da die Frage explizit mit den Tags C Sharp und Java versehen wurde, gehe ich nur auf diese beiden kurz ein. In beiden Fällen solltest du dich erst einmal der Sprache selbst widmen (lies bezüglich C# hier und zu Java hier). Sobald du mit ihr und der objektorientierten Entwicklung einigermaßen vertraut bist, solltest du ein Webframework in dein Repertoire mit aufnehmen.

Für die Webentwicklung mit C#/.NET wäre das ASP.NET. Neben der Lernplattform von Microsoft würde ich das Buch ASP.NET Core in Action zu empfehlen. Des Weiteren kannst du auf diesen Seiten schauen:

  • Learn Razor Pages
  • .NET Microservices (für die schnelle und einfache Entwicklung von kleinen Webanwendungen)
  • Lernkurse auf PluralSight
  • Auf YouTube kannst du in die Kanäle von IAmTimCorey oder Teddy Smith schauen

Hinsichtlich Java könntest du unter anderem JakartaEE, Play oder Spring wählen. Ich hatte dazu in diesem Beitrag schon einmal mehrere Informationen zusammengefasst.

...zur Antwort
Wo kann ich Programmiersprachen lernen.

Zu vielen Programmiersprachen kannst du online eine (offizielle) Dokumentation finden. Wenn du die nicht selbst findest, schau auf die jeweilige Wikipedia-Seite zur Programmiersprache.

Außerdem gibt es eine große Bandbreite an Büchern und Lernplattformen (Codecademy, Exercism, Hyperskill, Pluralsight, Udemy, ...). Je nach Programmiersprache kann man noch weitere, konkretere Lernquellen ergänzen.

Welche Programiersprache bietet die meisten Möglichkeiten? Welche Programiersprache ist am meisten verbreitet?

Für dich wäre die Frage relevant, welche Programmiersprache guten Support innerhalb der Spieleenwicklung bietet. Vor allem durch Tools, die dir dahingehend schon verschiedene Basisfunktionen (z.B. Grafikrendering, Audiowiedergabe, Eingabeverarbeitung, u.ä.) zur Verfügung stellen.

Die wohl größte Verbreitung in diesem Bereich erfahren C/C++, C# und Lua. Wobei C/C++ vorrangig für die Entwicklung der dahinterliegenden Funktionalitäten genutzt werden (also z.B. dem Rendering) und C#/Lua für die Formulierung der Spiellogik. Ansonsten finden im Vergleich zu anderen Programmiersprachen ebenso JavaScript, Python sowie denen ähnliche abgeleitete Sprachvariationen öfter Anwendung.

Gibt es auch Möglichkeiten komplexere Spiele für Anfänger, ohne eine Programiersprache zu erstellen?

Eine Reihe an Tools bietet inzwischen auch visuelle Programmiersprachen an (z.B. Flowgraph in der CryEngine, ScriptCanvas in O3DE, Blueprints in Unreal). Die sind für Anfänger/Laien einfacher zu bedienen, haben aber dennoch ihre Grenzen. Umso komplexer die Logik wird, umso schneller werden sie unübersichtlich und es wird schwerer, Fehler zu finden. Die Eingriffsmöglichkeiten, die du mit einer textuellen Programmiersprache hast, fehlen dir.

Falls du bei einem komplexeren Spiel direkt an Multiplayer-Spiele, 3D-Shooter, 3D-Action Adventures, Open Worlds u.ä. denkst, würde ich dir definitiv von so einem Vorhaben abraten.

Kann man überhaupt ein Spiel erstellen ohne Vorkenntnisse?

Sicherlich schafft man es auch ohne Vorkenntnisse, sich etwas zusammenzubasteln. Zumal es sehr leicht gestaltete Baukastensoftware wie BuildBox, GDevelop, Ren'Py, RPG Maker, Scratch Lab gibt.

Ob das letzten Endes auch den eigenen Vorstellungen entspricht, ist schon eine andere Sache.

Was würdet ihr mir empfehlen?

Überlege dir zuerst, wie deine Zielvorstellungen aussehen. Wenn du dabei merkst, dass dir die im letzten Abschnitt genannten Baukastensysteme für die Umsetzung bereits genügen würden, dürfte es ausreichen, sich nur mit diesen zu beschäftigen.

Andernfalls würde ich dir empfehlen, eine textuelle Programmiersprache zu lernen, mit der du später in einem passenden Tool (z.B. CryEngine, Defold, FLAX, GameMaker: Studio, Godot, O3DE, Stride, Unity, Unreal, o.ä.) deine Spiellogik zu einer entworfenen Spielwelt formulieren kannst.

Lerne erst die Sprache, bevor du mit der Entwicklung deines Zielprojekts beginnst. Es ist nichts, was man sich in ein paar Tagen einfach so aneignet. Das heißt, du brauchst auch einiges an Eigenmotivation und Geduld.

Zur Entwicklung von Spielen gehören aber auch noch andere Bestandteile. Zum Beispiel Sprites, Texturen, ein passendes Sound- und Leveldesign, usw.. Ein paar Quellen, die dir dabei helfen dürften, habe ich in diesem Beitrag schon einmal erwähnt.

...zur Antwort

Die Fehlermeldung beschreibt in ihrer letzten Zeile schon, was erwartet wird. Einen validen Schlüssel kannst du mit der generate_key-Methode erstellen (ein praktisches Beispiel findest du am Seitenanfang).

...zur Antwort