Gioco per console multigiocatore in java

Ciao a tutti, ho già finito di scrivere il gioco molto tempo fa, ma non sono ancora riuscito a scrivere un articolo, è la logica continuazione di questo scritto . Se non avete ancora provato a fare altro rispetto alle attività JavaRush, quindi familiarizzare con il gioco sarà esattamente il punto in cui vuoi iniziare, dovrai iniziare a prepararti per le attività di test di un progetto reale, al quale consiglio vivamente a tutti di partecipare. E in generale, è ora di smettere di essere un programmatore sferico nel vuoto e iniziare a imparare qualcosa al di fuori di Java-core. Per poter guardare semplicemente la partita, devi avere MySQL installato, se non l'hai ancora utilizzato, non esitare: installalo, questo è uno di quei database che utilizzerai nei tuoi progetti lavorativi e personali! Non descriverò l'installazione e l'utilizzo del database; ci sono tantissimi tutorial e video su Internet; consiglio di capirlo da solo, questa è anche una delle abilità più importanti di un programmatore: capire fallo da solo :) Nella vita, avrai bisogno della capacità di scrivere query in SQL, in modo nativo e tramite JDBC, hibernate , spring, spring data, forse l'elenco può essere continuato, ma la mia conoscenza finisce qui. Ora smetti di leggere questo articolo e scopri MySQL, in realtà non è affatto difficile, devi installare il server stesso, le uniche impostazioni sono login e password. quindi leggi quali comandi vengono utilizzati durante il lavoro. Comandi per lavorare con il server: create , show, use, e altri, comando help- fornirà un elenco completo di comandi. Query per lavorare con una tabella specifica: select , inserte deletealtre. Non andare troppo in profondità, c'è la possibilità che solo una piccola parte venga ricordata semplicemente leggendo i comandi. imparerai tutto col tempo. Puoi giocare nel terminale MySQL, creare un database, creare tabelle, compilarle, effettuare una richiesta per visualizzare dati, aggiungere criteri di query. Molto probabilmente, non ti ci vorranno più di 2-3 ore; se è più lungo, non preoccuparti, con l’esperienza padroneggerai il nuovo materiale più velocemente. Se non hai problemi con le basi, puoi iniziare a sviluppare il gioco, basato sul gioco di cui ho già scritto sul tris. Per molto tempo non sono riuscito a capire come implementare il multiplayer, ho trovato una soluzione nell'utilizzo di un database. Il processo di gioco presuppone che i giocatori si alternino, tutti i cambiamenti nel gioco vengono registrati nel database. già sulla base di questo, capiamo che abbiamo un giocatore e c'è un campo di gioco che contiene collegamenti ai giocatori, è nel campo di gioco che dovrebbe essere legata la logica in cui un giocatore aspetta che il secondo giocatore faccia una mossa e dopo di che i loro ruoli cambiano e il primo giocatore fa una mossa e il secondo aspetta. E poiché tutte le modifiche devono essere duplicate nel database, dopo ogni spostamento dobbiamo salvare il campo. Quindi siamo giunti alla prima conclusione: deve esserci un campo di gioco nel database e poiché stiamo parlando di multiplayer, dobbiamo aggiungere giocatori lì. Creiamo tabelle in MySQL, l'ho fatto in modo nativo, tramite la finestra del terminale mysql. il campo di gioco contiene collegamenti ai giocatori, quindi sarebbe logico creare prima un tavolo con i giocatori. I nostri giocatori hanno:

• id– numero progressivo, lo rendiamo la chiave primaria;
• name– nome comune, stringa;
• wins– numero di vittorie;
• loses– numero di lesioni;
• games– il numero totale di partite giocate.

Tavolo da gioco:

• id– numero progressivo, lo rendiamo la chiave primaria;
• x– id del giocatore che gioca х– chiave secondaria;
• o– id del giocatore che gioca o– chiave secondaria;
• field– il campo stesso, il suo formato sarà descritto di seguito;
• status– questo è necessario affinché il multiplayer funzioni correttamente, lo status caratterizza lo stato del gioco:
  creato, in gioco, game over

• current– anche per il multiplayer, in particolare durante il gioco questo campo controlla di chi è il turno adesso,
  e alla fine dichiara il vincitore o il pareggio

Abbiamo sistemato le tabelle, ora dobbiamo creare classi Java con i campi corrispondenti - Gamee 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;
}

Aggiungiamo un costruttore vuoto senza parametri - per lavorare con il database e un altro costruttore con cui creeremo oggetti. Aggiungiamo setter e getter per tutti i campi. Ora occupiamoci dell'ibernazione :) non diventa più facile di ora in ora. È un po' più complicato che con MySQL, ne parlerò velocemente la struttura generale. Anche in questo caso, non è tutto così complicato, le basi si imparano attraverso qualsiasi tutorial in un paio d’ore, ed è meglio approfondirle mentre scrivi i tuoi progetti. Lavorare con un database JAVA implica l'uso di JDBC, leggilo sul wiki . Ma se lo usi nella scrittura del codice, ti porterà un sacco di dolori al culo, una certa complessità nello scrivere classi DAO ( anche un wiki ), l'ibernazione migliorerà un po' la situazione, con esso avrai molto meno ripetitività (template ) codice. Affinché l'ibernazione funzioni, è necessario connettere una libreria al progetto, questo viene fatto in modo molto semplice: Ctrl+Alt+Shift+S(Struttura file-progetto), vai alla scheda Librerie, fai clic su "+" e aggiungi un libreria pre-scaricata ( opzionale, da qui ). Per collegare le classi Userè Gamenecessario utilizzare le annotazioni: sono molto facili da usare, con esse il codice assomiglia a questo:

@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;
    }
}

È semplice qui

• @Entity– dice che la classe è una “entità”, in parole semplici è legata ad una tabella nel database.
• @Table(name="games")– indica quale tabella, games– il nome della tabella nel database
• @Id, @GeneratedValue, @Column(name = "id")– con queste tre annotazioni indichiamo che questo campo è un campo identificativo, viene generato automaticamente e la colonna nel database si chiama id.
• @Column(name = "x")– nome della colonna nel database.

Successivamente è necessario creare dei livelli: il livello DAO e il livello di servizio. Se semplifichiamo tutto in condizioni di vuoto, il lavoro con i dati passa attraverso il livello di servizio, questo è uno dei livelli di astrazione, consente di rendere l'applicazione più indipendente, in modo che lo sviluppatore della logica del gioco non entri nei dettagli di impostare l'accesso al database o, ad esempio, se all'improvviso invece della semplice ibernazione decidessimo di utilizzare Spring, le modifiche non andrebbero oltre il livello di servizio, senza il quale metà dell'applicazione dovrebbe essere riscritta! questo è uno dei modelli di progettazione. Iniziamo a scrivere il livello DAO.

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();
            }
        }
    }
}

Ecco come appare l'operazione di aggiunta di un nuovo utente al database. Tieni presente che solo un oggetto della classe entità viene passato al metodo; qui non sono richieste informazioni aggiuntive. Ciò è garantito dal fatto che riceviamo una sessione di comunicazione già pronta con il database dalla classe HibernateUtil. Consideriamolo.

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;
    }
}

Come puoi vedere, anche qui tutto è molto semplice SessionFactory: questa è un'interfaccia della libreria di ibernazione, che abbiamo collegato al nostro progetto. Per un corretto funzionamento non resta che compilare il file di configurazione hibernate.cfg.xml

<!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>

Se dai un'occhiata ai tag, diventa chiaro cosa e come stiamo impostando qui. Un'altra caratteristica dell'ibernazione è che se decidiamo improvvisamente di cambiare il database da MySQL a un altro, dobbiamo solo cambiare il driver all'interno del tag Il property name="connection.driver_class" livello DAO è pronto, creiamo un livello di servizio. Per evitare di creare oggetti DAO nel livello di servizio, utilizziamo il modello factory.

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;
    }
}

Ed ecco uno dei metodi del livello di servizio

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

}

Il codice per lavorare con il database è completato, riscriviamo la logica del gioco tenendo conto delle modifiche. Innanzitutto, separiamo il metodo di avvio principale in una classe separata Main, sarà solo una classe di controllo: un menu di gioco in cui puoi avviare il gioco o visualizzare le statistiche. Creiamo una classe GameLogicche descriverà tutta la logica del gioco e il controllo del campo di gioco. Delegherà al livello di servizio il salvataggio di tutte le modifiche sul campo di gioco e le statistiche dei giocatori dopo la partita. C'è una caratteristica interessante: conteniamo il campo di gioco sotto forma di array, possono essere salvati nel database, ma in questa fase ho deciso di reinventare la ruota e nel mio database il campo è contenuto come un int, cioè un 9 -cifre, che viene analizzato da due utilizzando i metodi di classe GameLogic, non consiglio di farlo, migliorerò nelle prossime versioni del gioco :) Buona fortuna a tutti per imparare JAVA! Potete scaricare il progetto qui .