Multiplayer-Konsolenspiel in Java

Hallo zusammen, ich habe das Spiel schon vor langer Zeit fertig geschrieben, aber ich bin immer noch nicht dazu gekommen, einen Artikel zu schreiben, es ist eine logische Fortsetzung dieser Arbeit . Falls Sie noch nicht versucht haben, etwas anderes zu tun Wenn Sie mehr als JavaRush-Aufgaben haben, ist das Kennenlernen des Spiels genau der Punkt, an dem Sie beginnen möchten. Sie müssen sich auf die Testaufgaben eines echten Projekts vorbereiten, an denen ich jedem dringend empfehle, daran teilzunehmen. Und im Allgemeinen ist es an der Zeit, aufzuhören, ein sphärischer Programmierer im luftleeren Raum zu sein, und anzufangen, etwas außerhalb von Java-Core zu lernen. Um das Spiel einfach anzusehen, muss MySQL installiert sein. Wenn Sie es noch nicht verwendet haben, zögern Sie nicht – installieren Sie es, dies ist eine dieser Datenbanken, die Sie bei Ihrer Arbeit und Ihren persönlichen Projekten verwenden werden! Ich werde die Installation und Arbeit mit der Datenbank nicht beschreiben; es gibt eine Menge Tutorials und Videos im Internet; ich empfehle, dies selbst herauszufinden, dies ist auch eine der wichtigsten Fähigkeiten eines Programmierers – das Herausfinden Machen Sie es auf eigene Faust :) Im Leben benötigen Sie die Fähigkeit, Abfragen in SQL zu schreiben, nativ und über JDBC, Ruhezustand , Frühling, Frühlingsdaten, vielleicht kann die Liste fortgesetzt werden, aber mein Wissen endet hier. Hören Sie jetzt auf, diesen Artikel zu lesen, und verstehen Sie MySQL. Es ist eigentlich überhaupt nicht schwierig. Sie müssen den Server selbst installieren. Die einzigen Einstellungen dort sind Login und Passwort. Lesen Sie dann, welche Befehle beim Arbeiten verwendet werden. Befehle für die Arbeit mit dem Server: create , show, useund andere, Befehl help– ​​gibt eine vollständige Liste der Befehle an. Abfragen zum Arbeiten mit einer bestimmten Tabelle: select , insertund deleteandere. Gehen Sie nicht zu tief, es besteht die Möglichkeit, dass Sie sich nur an einen kleinen Teil erinnern, wenn Sie die Befehle einfach lesen. Sie werden mit der Zeit alles lernen. Sie können im MySQL-Terminal spielen, eine Datenbank erstellen, Tabellen erstellen, diese ausfüllen, eine Anfrage zur Anzeige von Daten stellen und Abfragekriterien hinzufügen. Höchstwahrscheinlich werden Sie dafür nicht länger als 2-3 Stunden brauchen; wenn es länger dauert, machen Sie sich keine Sorgen, mit Erfahrung werden Sie neues Material schneller beherrschen. Wenn Sie keine Probleme mit den Grundlagen haben, können Sie mit der Entwicklung des Spiels beginnen, basierend auf dem Spiel, das ich bereits über Tic-Tac-Toe geschrieben habe. Lange Zeit konnte ich nicht herausfinden, wie man Multiplayer umsetzt, ich fand eine Lösung in der Verwendung einer Datenbank. Der Spielablauf geht davon aus, dass die Spieler abwechselnd spielen. Alle Änderungen im Spiel werden in der Datenbank aufgezeichnet. Bereits auf dieser Grundlage verstehen wir, dass wir einen Spieler haben und es ein Spielfeld gibt, das Links zu Spielern enthält. In das Spielfeld sollte die Logik eingebunden werden, in der ein Spieler darauf wartet, dass der zweite Spieler einen Zug macht und danach ändern sich ihre Rollen und der erste Spieler macht einen Zug und der zweite wartet. Und da alle Änderungen in der Datenbank dupliziert werden müssen, müssen wir nach jeder Verschiebung das Feld speichern. Wir sind also zu dem ersten Schluss gekommen, dass es in der Datenbank ein Spielfeld geben muss und da es sich um einen Mehrspielermodus handelt, müssen wir dort Spieler hinzufügen. Lassen Sie uns Tabellen in MySQL erstellen. Ich habe es nativ über das MySQL-Terminalfenster gemacht. Das Spielfeld enthält Links zu Spielern, daher wäre es logisch, zunächst eine Tabelle mit den Spielern zu erstellen. Unsere Spieler haben:

• id– Sequenznummer, wir machen sie zum Primärschlüssel;
• name– gebräuchlicher Name, Zeichenfolge;
• wins– Anzahl der Siege;
• loses– Anzahl der Läsionen;
• games– die Gesamtzahl der gespielten Spiele.

Spieltisch:

• id– Sequenznummer, wir machen sie zum Primärschlüssel;
• x– ID des spielenden Spielers х– Sekundärschlüssel;
• o– ID des spielenden Spielers o– Sekundärschlüssel;
• field– das Feld selbst, sein Format wird unten beschrieben;
• status– Dies ist notwendig, damit der Multiplayer korrekt funktioniert. Der Status charakterisiert den Status des Spiels:
  erstellt, gespielt, Spiel vorbei

• current– auch im Mehrspielermodus, insbesondere während des Spiels steuert dieses Feld, wer gerade an der Reihe ist,
  und verkündet nach dem Ende den Gewinner oder das Unentschieden

Wir haben die Tabellen sortiert, jetzt müssen wir Java-Klassen mit den entsprechenden Feldern erstellen – Gameund User.

public class Game {
    private Integer id;
    private Integer x;
    private Integer y;
    private Integer field;
    private String status;
    private String current;
}

public class User {
    private Integer id;
    private String name;
    private Integer wins;
    private Integer loses;
    private Integer games;
    private Boolean busy;
}

Fügen wir einen leeren Konstruktor ohne Parameter hinzu – für die Arbeit mit der Datenbank und einen weiteren Konstruktor, mit dem wir Objekte erstellen. Fügen wir Setter und Getter für alle Felder hinzu. Kommen wir nun zum Ruhezustand :) Es wird von Stunde zu Stunde nicht einfacher. Es ist etwas komplizierter als bei MySQL, ich gehe kurz auf die allgemeine Struktur ein. Auch hier ist nicht alles so kompliziert, die Grundlagen können durch jedes Tutorial in ein paar Stunden erlernt werden, und es ist besser, beim Schreiben Ihrer Projekte gründlich zu lernen. Die Arbeit mit einer Datenbank aus JAVA erfordert die Verwendung von JDBC, lesen Sie mehr darüber im Wiki . Aber wenn Sie es beim Schreiben von Code verwenden, wird es viel Schmerz im Anus mit sich bringen, eine gewisse Komplexität beim Schreiben von DAO-Klassen ( auch ein Wiki ), der Ruhezustand wird die Situation ein wenig verbessern, damit haben Sie viel weniger repetitive (Vorlage )-Code. Damit der Ruhezustand funktioniert, müssen Sie eine Bibliothek mit dem Projekt verbinden. Dies geht ganz einfach: Strg+Alt+Umschalt+S(Datei-Projektstruktur), gehen Sie zur Registerkarte Bibliotheken, klicken Sie auf „+“ und fügen Sie eine hinzu vorab heruntergeladene Bibliothek ( als Option hier ). Um Klassen zu verknüpfen, müssen UserSie GameAnnotationen verwenden – diese sind sehr einfach zu verwenden, mit ihnen sieht der Code so aus:

@Entity
@Table(name="games")
public class Game {
    private Integer id;
    private Integer x;

    @Id
    @GeneratedValue
    @Column(name = "id")
    public Integer getId() {
        return id;
    }

    @Column(name = "x")
    public Integer getX() {
        return x;
    }
}

Hier ist es einfach

• @Entity– besagt, dass die Klasse eine „Entität“ ist, in einfachen Worten, sie ist an eine Tabelle in der Datenbank gebunden.
• @Table(name="games")– sagt welche Tabelle, games– der Name der Tabelle in der Datenbank
• @Id, @GeneratedValue, @Column(name = "id")– Mit diesen drei Anmerkungen kennzeichnen wir, dass es sich bei diesem Feld um ein Identifikationsfeld handelt, es automatisch generiert wird und die Spalte in der Datenbank id heißt.
• @Column(name = "x")– Name der Spalte in der Datenbank.

Als nächstes müssen Sie Ebenen erstellen – die DAO-Ebene und die Serviceebene. Wenn wir alles auf Vakuumbedingungen vereinfachen, durchläuft die Arbeit mit Daten die Serviceebene. Dies ist eine der Abstraktionsebenen. Dadurch können Sie die Anwendung unabhängiger gestalten, sodass der Entwickler der Spiellogik nicht auf Details eingehen muss Wenn wir beispielsweise den Zugriff auf die Datenbank einrichten oder uns plötzlich anstelle des einfachen Ruhezustands für die Verwendung von Spring entscheiden, gehen die Änderungen nicht über die Serviceschicht hinaus, ohne die die Hälfte der Anwendung neu geschrieben werden müsste! Dies ist eines der Designmuster. Beginnen wir mit dem Schreiben des DAO-Levels.

public class UserDAO {

    public void addUser(User user) throws SQLException {
        Session session = null;
        try{
            session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();
            session.save(user);
            session.getTransaction().commit();
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            if (session != null && session.isOpen()) {
                session.close();
            }
        }
    }
}

So sieht der Vorgang zum Hinzufügen eines neuen Benutzers zur Datenbank aus. Bitte beachten Sie, dass nur ein Objekt der Entitätsklasse an die Methode übergeben wird; hier sind keine zusätzlichen Informationen erforderlich. Dies wird dadurch gewährleistet, dass wir von der Klasse HibernateUtil eine fertige Kommunikationssitzung mit der Datenbank erhalten. Betrachten wir es.

public class HibernateUtil {
    private static SessionFactory sessionFactory = null;

    static {
        try {

            sessionFactory = new Configuration().configure().buildSessionFactory();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

Wie Sie sehen, ist auch hier alles sehr einfach SessionFactory– es handelt sich um eine Schnittstelle aus der Hibernate-Bibliothek, die wir mit unserem Projekt verbunden haben. Für den korrekten Betrieb müssen Sie lediglich die Konfigurationsdatei hibernate.cfg.xml ausfüllen

<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/tictactoe</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>
        <property name="connection.pool_size">100</property>
        <property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
        <property name="show_sql">false</property>
        <property name="hbm2ddl.auto">update</property>
        <property name="hibernate.connection.autocommit">false</property>
        <property name="current_session_context_class">thread</property>
        <property name="hibernate.enable_lazy_load_no_trans">true</property>
        <mapping class="entity.User" />
        <mapping class="entity.Game" />
    </session-factory>
</hibernate-configuration>

Wenn Sie einen Blick auf die Tags werfen, wird klar, was und wie wir hier einrichten. Eine weitere Funktion des Ruhezustands besteht darin, dass wir, wenn wir uns plötzlich dazu entschließen, die Datenbank von MySQL auf eine andere zu ändern, nur den Treiber innerhalb des Tags ändern müssen property name="connection.driver_class" . Die DAO-Schicht ist bereit, erstellen wir eine Serviceschicht. Um die Erstellung von DAO-Objekten in der Serviceschicht zu vermeiden, verwenden wir das Factory-Muster.

public class Factory {
    private static UserDAO userDAO = null;
    private static Factory instance = null;
    private Factory() {
    }

    public static synchronized Factory getInstance() {
        if (instance == null) {
            instance = new Factory();
        }
        return instance;
    }

    public UserDAO getUserDAO() {
        if (userDAO == null) {
            userDAO = new UserDAO();
        }
        return userDAO;
    }
}

Und hier ist eine der Service-Level-Methoden

public class UserService {
    static void setUserBusy(User user){
        user.setBusy(true); //делаем его занятым
        //и обновляем его в БД
        Factory.getInstance().getUserDAO().updateUser(user);
    }

}

Der Code für die Arbeit mit der Datenbank ist fertig, wir schreiben die Spiellogik unter Berücksichtigung der Änderungen neu. Lassen Sie uns zunächst die Hauptstartmethode in eine separate Klasse unterteilen Main. Es wird nur eine Kontrollklasse sein – ein Spielmenü, in dem Sie das Spiel starten oder Statistiken anzeigen können. Lassen Sie uns eine Klasse erstellen GameLogic, die die gesamte Logik des Spiels beschreibt und das Spielfeld überprüft. Er delegiert die Speicherung aller Änderungen am Spielfeld und den Spielerstatistiken nach dem Spiel an den Service-Layer. Es gibt eine interessante Funktion: Wir enthalten das Spielfeld in Form von Arrays, sie können in der Datenbank gespeichert werden, aber zu diesem Zeitpunkt habe ich beschlossen, das Rad neu zu erfinden und in meiner Datenbank ist das Feld als int enthalten, nämlich als 9 -stellige Zahl, die mithilfe von Klassenmethoden durch zwei geparst wird GameLogic. Ich empfehle dies nicht, ich werde es in den nächsten Versionen des Spiels verbessern :) Viel Glück an alle beim Erlernen von JAVA! Sie können das Projekt hier herunterladen .