Benutzer-Werkzeuge

Webseiten-Werkzeuge


schule:manic_digger

Manic Digger

Manic Digger ist ein quelloffener Minecraft-Klon, der in C# programmiert wurde.

Level 1: Beispiel-Mod "Hallo Spieler"

Beginnen wir mit einem einfachen Mod. Er begrüßt den Spieler mit einer Chatnachricht, sobald ein Block gelöscht wurde.

using System;
using System.Collections.Generic;
using System.Text;
 
namespace ManicDigger.Mods
{
    class HalloSpieler : IMod
    {
        ModManager modManager;
 
        // Vor dem Start des Mod wird diese Methode vom Spiel aufgerufen.
        // Für die spätere Interaktion wird der übergebene ModManager in einem
        // Attribut gespeichert.
        public void PreStart(ModManager m)
        {
            modManager = m;
        }
 
        // Beim Start des Mod wird die Methode 'OnBlockDelete' für 
        // das Event registriert, das eintritt, wenn ein Block gelöscht wurde.
        public void Start(ModManager m)
        {
            m.RegisterOnBlockDelete(OnBlockDelete);
        }
 
        // Die Methode wird beim Löschen eines Blockes mit den 
        // Koordinaten und dem Typ des gelöschten Blocks aufgerufen.
        void OnBlockDelete(int player, int x, int y, int z, int oldblock)
        {
            modManager.SendMessageToAll("Willkommen Spieler");
            modManager.SendMessageToAll(
                "Du hast den Block  mit den Koordinaten " +
                "(" + x + "|" + y + "|" + z + ") entfernt");
        }
    }
}

Das folgende Video zeigt das Mod in Aktion.

Übungen

  1. Lade den Quelltext des Projektes herunter und öffne ihn mit einer C# Entwicklungsumgebung
    Beachte die Informationen für Entwickler
    Sollte es Probleme mit dem Quelltext geben, so probiere die Binärversion aus.
  2. Übersetze und starte das Spiel. Spiele ein wenig mit dem Spiel. Du erhältst mit /help im Chat eine Liste mit Befehlen, mit denen du z.B. die Zeit (/time 10:00) ändern kannst. Probiere es aus.
  3. Erstelle das obige Beispiel-Mod und probiere es aus.
  4. Überlege dir ein eigenes Mod und implementiere es. Nutze die Klasse ModManager.cs.

Level 2: Farbwechselspiel

Eine interessante Variante des Farbwechselspiels lässt sich mit Manic Digger sogar in 3D programmieren. Bei dem Spiel wird ein großer Würfel aus zwei unterschiedlichen Blocktypen aufgebaut. Beim Anklicken eines Blocks ändern der angeklickte und alle angrenzenden Blöcke ihre Farbe. Das folgende Video veranschaulicht das Prinzip.

Quelltext

Versuche selbst, den Quelltext für das Spiel zu entwickeln. Nur wenn, du nicht weiter kommst, kannst du den Quelltext in der Fußnote als Orientierung verwenden.1)

Level 3: Weitere Tutorials

Die folgende Videoreihe zeigt, wie man Erweiterungen für dieses Spiel erstellt.

  • Cuberite ist ein quelloffener Minecraft-Server für Windows, Linux und den Raspberry Pi.
  • Minetest ist ein weiterer quell-offener Minecraft-Clon, der über Mods erweitert werden kann. Diese werden in der einfach zu erlernenden Sprache Lua geschrieben.
1) Quelltext zum Farbwechselspiel:
using System;
using System.Collections.Generic;
using System.Text;
 
namespace ManicDigger.Mods
{
    public class Farbwechselspiel : IMod
    {
        ModManager modManager;
        int spieler;
 
        int blockTypSchwarz;
        int blockTypWeiß;
 
        Position startPosition;
        int ausdehnung = 2;
 
        public void PreStart(ModManager m)
        {
            modManager = m;
            spieler = -1;
 
            startPosition = new Position(0, 0, 0);
 
            blockTypSchwarz = 2;
            blockTypWeiß = 20;
        }
 
        public void Start(ModManager m)
        {
            m.RegisterOnBlockDelete(OnBlockDelete);
            m.RegisterOnPlayerChat(OnPlayerChat);
        }
 
        void OnBlockDelete(int player, int x, int y, int z, int oldblock)
        {
            // gelöschten Block wiederherstellen
            ErstelleBlock(x, y, z, oldblock);
 
            FarbeWechseln(x, y, z, oldblock);
        }
 
        private void FarbeWechseln(int _x, int _y, int _z, int oldblock)
        {
            for (int x = _x - 1; x <= _x + 1; x++)
            {
                for (int y = _y - 1; y <= _y + 1; y++)
                {
                    for (int z = _z - 1; z <= _z + 1; z++)
                    {
                        if (AufFeld(x, y, z) && Benachbart(x, y, z, _x, _y, _z))
                        {
                            BlockTypWechseln(x, y, z);
                        }
                    }
                }
            }
            BlockTypWechseln(_x, _y, _z);
        }
 
        private bool Benachbart(int x1, int y1, int z1, int x2, int y2, int z2)
        {
            return
                // Der Abstand beträgt genau 1
                Math.Pow(x1 - x2, 2) + Math.Pow(y1 - y2, 2) + Math.Pow(z1 - z2, 2) == 1;
        }
 
        private bool AufFeld(int x, int y, int z)
        {
            return
                startPosition.X() <= x &&
                startPosition.X() + ausdehnung > x &&
                startPosition.Y() <= y &&
                startPosition.Y() + ausdehnung > y &&
                startPosition.Z() <= z &&
                startPosition.Z() + ausdehnung > z;
        }
 
        private void BlockTypWechseln(int x, int y, int z)
        {
            if ( SchwarzerBlock(x, y, z) )
            {
                ErstelleBlock(x, y, z, blockTypWeiß);
            }
            else
            {
                ErstelleBlock(x, y, z, blockTypSchwarz);
            }
        }
 
        public bool SchwarzerBlock(int x, int y, int z)
        {
            return modManager.GetBlock(x, y, z) == blockTypSchwarz;
        }
 
        public string OnPlayerChat(int player, string message, bool toteam)
        {
            if(message.Equals("starte Farbwechselspiel"))
            {
                spieler = player;
                startPosition = SpielerPosition().Verschieben(1, 1, 1);
                ErstelleGroßenWürfel(startPosition);
                return "Farbwechselspiel gestartet";
            }
            return "";
        }
 
        private Position SpielerPosition()
        {
            return new Position(
                (int)modManager.GetPlayerPositionX(spieler),
                (int)modManager.GetPlayerPositionY(spieler),
                (int)modManager.GetPlayerPositionZ(spieler));
        }
 
        private void ErstelleGroßenWürfel(Position position)
        {
            for (int x = position.X(); x < position.X() + ausdehnung; x++)
            {
                for (int y = position.Y(); y < position.Y() + ausdehnung; y++)
                {
                    for (int z = position.Z(); z < position.Z() + ausdehnung; z++)
                    {
                        ErstelleBlock(x, y, z, blockTypSchwarz);
                    }
                }
            }
        }
 
        private void ErstelleBlock(int x, int y, int z, int blockTyp)
        {
            modManager.SetBlock(x, y, z, blockTyp);
        }
    }
 
    public class Position
    {
        int x;
        int y;
        int z;
 
        public Position(int x, int y, int z)
        {
            this.x = x;
            this.y = y;
            this.z = z;
        }
 
        public int X()
        {
            return x;
        }
        public int Y()
        {
            return y;
        }
        public int Z()
        {
            return z;
        }
 
        public Position Verschieben(int deltaX, int deltaY, int deltaZ)
        {
            x += deltaX;
            y += deltaY;
            z += deltaZ;
            return this;
        }
    }
}
schule/manic_digger.txt · Zuletzt geändert: 19.04.2017 08:39 (Externe Bearbeitung)