Das Erstellen eines Web-Block-Avoiding-Spiels

JavaScriptBeginner
Jetzt üben

Einführung

In diesem Projekt werden wir ein lustiges und einfaches Block-Avoiding-Spiel mit HTML, CSS und JavaScript erstellen. Bei diesem Spiel handelt es sich um das Bewegen von Blöcken, bei dem der Spieler die schwarzen Blöcke anklicken muss, um Punkte zu erzielen, und die weißen Blöcke vermeiden muss. Lassen Sie uns beginnen, es schrittweise zu bauen!

👀 Vorschau

Vorschau auf das Block-Avoiding-Spiel

🎯 Aufgaben

In diesem Projekt lernen Sie:

  • Wie man das Spiellayout mit HTML entwirft
  • Wie man das Spiel mit CSS stilisiert
  • Wie man die grundlegenden Spiellogiken mit JavaScript implementiert
  • Wie man das Spiel initialisiert und den ersten Satz von Blöcken erstellt
  • Wie man die Spielfunktionalität implementiert, einschließlich der Block-Klick-Erkennung, Game-Over-Szenarien, Block-Erstellung und Bewegung
  • Wie man die Spielpunktzahl und die Geschwindigkeitsverwaltung abschließt

🏆 Errungenschaften

Nach Abschluss dieses Projekts werden Sie in der Lage sein:

  • Weblayouts mit HTML zu entwerfen
  • Styling-Techniken mit CSS anzuwenden
  • Spiellogiken mit JavaScript zu implementieren
  • Das Document Object Model (DOM) zu manipulieren
  • Ereignisse und Benutzereingaben zu verarbeiten
  • Spielzustandsvariablen zu erstellen und zu verwalten
  • Die Spielanzeige dynamisch zu modifizieren und zu aktualisieren
  • Die Spielimplementierung zu testen und zu debuggen

Das Design der Spieloberfläche mit HTML

Anforderungen:

  • Öffnen Sie die Datei index.html.
  • Vertrautheit mit HTML-Tags und -Struktur.

Funktionalität:

  • Layouten des Hauptspielcontainers.
  • Anzeige des Spielscores.
  • Bereitstellung eines Startbuttons, um das Spiel zu starten.

Schritte:

<!doctype html>
<html>
  <head>
    <meta charset="utf-8" />
    <title>Avoid the white block</title>
    <link rel="stylesheet" href="styles.css" />
  </head>
  <body>
    <h2>score</h2>
    <h2 id="score">0</h2>
    <div id="main">
      <div id="con"></div>
      <!-- Spielcontainer -->
    </div>
    <div class="btn">
      <button class="start" onclick="start()">Start</button>
      <!-- Startbutton -->
    </div>
  </body>
  <script src="script.js"></script>
</html>

In obigem Code haben wir eine grundlegende HTML-Struktur für unser Spiel erstellt. Wir haben eine div mit id="main", die unser Spielcontainer sein wird. Innerhalb des Spielcontainers haben wir eine weitere div mit id="con", die unser Spieler sein wird. Wir haben auch einen button mit class="start" erstellt, der zum Starten des Spiels verwendet werden wird.

✨ Lösung prüfen und üben

Füge Stilgebung zum Spiel hinzu

Anforderungen:

  • Öffnen Sie die Datei styles.css.
  • Grundkenntnisse über CSS-Eigenschaften und -Selektoren.
  • Verständnis von Styling-Techniken für responsive Designs.

Funktionalität:

  • Die visuelle Attraktivität des Spiels verbessern.
  • Die Spieloberfläche auf verschiedene Bildschirmgrößen anpassen.

Schritte:

body {
  background-color: #f0f0f0;
  font-family: "Arial", sans-serif;
}
h2 {
  text-align: center;
  color: #333;
  margin-bottom: 8px;
}
#main {
  width: 408px;
  height: 408px;
  background: white;
  border: 8px solid #ccc;
  border-radius: 10px;
  /* Rundungen hinzugefügt für einen weicheren Look */
  margin: 20px auto;
  overflow: hidden;
  position: relative;
  /* Relative Positionierung hinzugefügt für die Positionierung der Kinder */
}
#con {
  width: 100%;
  height: 400px;
  position: absolute;
  /* Auf absolute geändert */
  top: -408px;
}
.row {
  height: 100px;
  width: 100%;
}
.cell {
  height: 100px;
  width: 100px;
  float: left;
  border-bottom: rgb(200, 200, 200) 1px solid;
  /* Leichtere Bordfarbe */
}
.black {
  background: #444;
  /* Dunkles Grau statt Schwarz für einen weicheren Look */
}
.btn {
  width: 100%;
  text-align: center;
  margin-top: 20px;
}
.start {
  margin: 20px auto;
  width: 150px;
  height: 50px;
  border-radius: 25px;
  /* Erhöhte Rundungen für eine Tablettenform */
  background: #4caf50;
  /* Grüner Button */
  color: #fff;
  font-size: 16px;
  /* Erhöhte Schriftgröße */
  border: none;
  /* Standard-Border entfernen */
  cursor: pointer;
  /* Cursor-Effekt */
  transition: background 0.3s;
  /* Transition-Effekt */
}
.start:hover {
  background: #45a049;
  /* Dunklerer Grün beim Hovern */
}

In obigem Code haben wir einigen grundlegenden Stil hinzufügt zu unserem Spiel. Wir haben eine Hintergrundfarbe für den body und eine Schriftfamilie für den Text hinzugefügt. Wir haben auch eine Bordrundung zum Spielcontainer hinzugefügt, um ihn weicher aussehen zu lassen. Wir haben auch eine position: relative zum Spielcontainer und position: absolute zum Spieler hinzugefügt. Dies wird uns ermöglichen, den Spieler innerhalb des Spielcontainers zu positionieren. Wir haben auch einen Transitionseffekt zum Startbutton hinzugefügt.

✨ Lösung prüfen und üben

Implementiere die Grundlagen der Spiel-Logik

Anforderungen:

  • Öffnen Sie die Datei script.js.
  • Vorläufiges Verständnis der JavaScript-Grundlagen.
  • Verständnis des Konzepts des Document Object Models (DOM).

Funktionalität:

  • Einrichten von wichtigen Hilfsfunktionen.
  • Initialisierung von wichtigen Spielzustandsvariablen.

Schritte:

// Hilfsfunktionen und Initialisierung der Variablen
// Hole ein Element anhand seiner ID
function $(id) {
  return document.getElementById(id);
}

// Erstelle ein div-Element mit einem angegebenen Klassenamen
function creatediv(className) {
  var div = document.createElement("div");
  div.className = className;
  return div;
}
// Setze die Intervall-ID zunächst auf null
var clock = null;
// Zustand des Spiels (0 bedeutet gestoppt und 1 bedeutet gestartet)
var state = 0;
// Geschwindigkeit der Bewegung der Spielblöcke
var speed = 6;
// Flag, um zu überprüfen, ob das Spiel gestartet ist oder nicht
var flag = false;

In obigem Code haben wir zwei Hilfsfunktionen erstellt. Die erste Funktion $(id) wird verwendet, um ein Element anhand seiner ID zu erhalten. Die zweite Funktion creatediv(className) wird verwendet, um ein div-Element mit einem angegebenen Klassenamen zu erstellen. Wir haben auch einige Variablen initialisiert, die später im Spiel verwendet werden werden.

✨ Lösung prüfen und üben

Initialisiere das Spiel

Anforderungen:

  • Fähigkeit, JavaScript-Funktionen zu schreiben.
  • Vertrautheit mit JavaScript-Ereignis-Listenern.

Funktionalität:

  • Bereiten Sie das Spiel auf zum Starten.
  • Erstellen Sie den ersten Satz von Blöcken für das Spiel.

Schritte:

// Klicken Sie auf den Startknopf, um das Spiel zu starten
function start() {
  if (!flag) {
    init();
  } else {
    alert("Das Spiel hat bereits begonnen! Kein erneuter Klick erforderlich!");
  }
}

// Initialisierungsfunktion (init)
function init() {
  flag = true;
  for (var i = 0; i < 4; i++) {
    createrow();
  }

  // Hinzufügen von Ereignis-Listenern mit addEventListener
  $("main").addEventListener("click", function (ev) {
    judge(ev);
  });

  // Timer ruft move() alle 30 Millisekunden auf
  clock = setInterval(move, 30);
}

In obigem Code haben wir eine start()-Funktion erstellt, die aufgerufen wird, wenn der Startknopf geklickt wird. Innerhalb der start()-Funktion haben wir die init()-Funktion aufgerufen, die das Spiel initialisiert. Innerhalb der init()-Funktion haben wir die flag-Variable auf true gesetzt, die verwendet werden wird, um zu überprüfen, ob das Spiel gestartet ist oder nicht. Wir haben auch vier Reihen von Blöcken mit der createrow()-Funktion erstellt. Wir haben auch einen Ereignis-Listener auf den Spielcontainer hinzugefügt, der verwendet werden wird, um das Klickereignis auf dem Spielcontainer zu erkennen. Wir haben auch einen Timer gesetzt, der die move()-Funktion alle 30 Millisekunden aufruft.

✨ Lösung prüfen und üben

Implementiere die Spielfunktionalität

Anforderungen:

  • Beherrschung von JavaScript-Schleifen und -Bedingungen.
  • Kenntnisse bei der Manipulation des DOM mit JavaScript.

Funktionalität:

  • Entwerfe die Kernspielmechaniken.
  • Planne Szenarien für das Spielende.
  • Implementiere Mechanismen für das Erstellen und Bewegen von Blöcken.

Schritte:

  1. Prüfe, ob der Spieler auf einen schwarzen oder weißen Block geklickt hat. Aktualisiere den Spielstatus basierend auf dem Spielerinput.
// Bestimme, ob auf einen schwarzen oder weißen Block geklickt wurde
function judge(ev) {
  if (
    ev.target.className.indexOf("black") == -1 &&
    ev.target.className.indexOf("cell") !== -1
  ) {
    ev.target.parentNode.pass1 = 1; // Definiert das pass-Attribut, das angibt, dass der weiße Block dieser Zeile angeklickt wurde
  }

  if (ev.target.className.indexOf("black") !== -1) {
    // Klicken auf ein Element mit "black" im Klassenamen ist ein schwarzer Block
    ev.target.className = "cell";
    ev.target.parentNode.pass = 1; // Definiert das pass-Attribut, das angibt, dass der schwarze Block dieser Zeile angeklickt wurde
    score();
  }
}
  1. Bestimme, wann das Spiel vorbei ist, basierend auf Spielerinteraktionen. Lösse Endspieleaktionen aus, wenn das Spiel vorbei ist.
// Prüfe, ob das Spiel vorbei ist
function over() {
  var rows = con.childNodes;
  if (rows.length == 5 && rows[rows.length - 1].pass !== 1) {
    fail();
  }
  for (let i = 0; i < rows.length; i++) {
    if (rows[i].pass1 == 1) {
      fail();
    }
  }
}

// Spiel vorbei
function fail() {
  clearInterval(clock);
  flag = false;
  confirm("Das Endspielstand ist " + parseInt($("score").innerHTML));
  var con = $("con");
  con.innerHTML = "";
  $("score").innerHTML = 0;
  con.style.top = "-408px";
}
  1. Generiere Reihen von Blöcken für das Spielgeschehen. Positioniere den "schwarzen" Block zufällig unter anderen.
// Erstelle eine <div class="row"> mit vier Kindern <div class="cell">
function createrow() {
  var con = $("con");
  var row = creatediv("row"); // Erstelle div: className=row
  var arr = createcell(); // Definiere den Klassenamen der div-Zelle, wobei eine von ihnen cell black ist

  con.appendChild(row); // Füge das Kindknoten mit row als con hinzu

  for (var i = 0; i < 4; i++) {
    row.appendChild(creatediv(arr[i])); // Füge die Kindknoten der Zeilenzelle hinzu
  }

  if (con.firstChild == null) {
    con.appendChild(row);
  } else {
    con.insertBefore(row, con.firstChild);
  }
}

// Erstelle ein Array von Klassenamen; einer von ihnen ist "cell black", die anderen sind "cell"
function createcell() {
  var temp = ["cell", "cell", "cell", "cell"];
  var i = Math.floor(Math.random() * 4); // Generiere zufällig die Position des schwarzen Blocks Math.random() Funktionsparameter 0~1 Zufallszahl
  temp[i] = "cell black";
  return temp;
}
  1. Lasse die Blöcke kontinuierlich nach unten bewegen. Lösche alte Zeilen, wenn sie außerhalb des Sichtfelds geraten.
// Bewege die schwarzen Blöcke nach unten
function move() {
  var con = $("con");
  var top = parseInt(window.getComputedStyle(con, null)["top"]);

  if (speed + top > 0) {
    top = 0;
  } else {
    top += speed;
  }
  con.style.top = top + "px"; // Halte den Top-Wert bei der Bewegung so, dass er sich bewegt
  over();
  if (top == 0) {
    createrow();
    con.style.top = "-102px";
    delrow();
  }
}

// Lösche eine Zeile
function delrow() {
  var con = $("con");
  if (con.childNodes.length == 6) {
    con.removeChild(con.lastChild);
  }
}
✨ Lösung prüfen und üben

Beende die Spielbewertung und die Geschwindigkeitsverwaltung

Anforderungen:

  • Verständnis von JavaScript-Variablen und arithmetischen Operationen.
  • Fähigkeit, komplexe Spiellogik in JavaScript zu schreiben.

Funktionalität:

  • Etablieren eines Belohnungssystems.
  • Schaffe ein System, um die Schwierigkeit des Spiels sukzessive zu erhöhen.

Schritte:

// Beschleunigungsfunktion, erhöht die Geschwindigkeit
function speedup() {
  speed += 2;
  if (speed == 20) {
    alert("Das ist großartig!");
  }
}
// Punktezählen
function score() {
  var newscore = parseInt($("score").innerHTML) + 1; // Punkt um eins erhöhen
  $("score").innerHTML = newscore; // Punktzahl ändern
  if (newscore % 10 == 0) {
    // Verwende die Beschleunigungsfunktion, wenn der Rest bei der Division durch 10 null ist, wird es immer schneller
    speedup();
  }
}

In obigem Code haben wir eine speedup()-Funktion erstellt, die verwendet werden wird, um die Geschwindigkeit des Spiels zu erhöhen. Wir haben auch eine score()-Funktion erstellt, die verwendet werden wird, um die Punktzahl des Spiels zu erhöhen. Wir haben auch eine Bedingung in der score()-Funktion hinzugefügt, die die speedup()-Funktion aufruft, wenn die Punktzahl ein Vielfaches von 10 ist.

✨ Lösung prüfen und üben

Teste dein Spiel

  • Öffne index.html in einem Webbrowser.
öffne das Web
  • Spiele das Spiel und überprüfe, ob alle Funktionen wie erwartet funktionieren.
  • Die Wirkung der Seite ist wie folgt:
Spielablauf-Demonstrationsanimation
✨ Lösung prüfen und üben

Zusammenfassung

Toller Job! Du hast gerade von Grund auf ein einfaches, aber spannendes Block-Avoiding-Spiel mit HTML, CSS und JavaScript gebaut. Dieses Projekt hat dich mit der Handhabung von Benutzereingaben, Spiel-logik und dynamischen CSS-Stilierungen auf der Grundlage von Spielzustandsänderungen vertraut gemacht. Du kannst dieses Grundspiel um weitere Funktionen wie Levels, Zeitgrenzen oder verschiedene Schwierigkeitsgrade erweitern. Viel Spaß beim Experimentieren mit deinem neuen Spiel!