Jeu de console multijoueur en Java

Bonjour à tous, J'ai déjà fini d'écrire le jeu depuis longtemps, mais je n'ai pas encore eu le temps d'écrire un article, c'est la suite logique de cet écrit . Si vous n'avez pas encore essayé de faire autre chose que les tâches JavaRush, alors vous familiariser avec le jeu sera exactement là où vous voulez commencer, vous devrez commencer à vous préparer aux tâches de test d'un projet réel, auquel je recommande fortement à tout le monde de participer. Et en général, il est temps d'arrêter d'être un programmeur sphérique dans le vide et de commencer à apprendre quelque chose en dehors de Java-Core. Pour regarder simplement le match, vous devez avoir MySQL installé, si vous ne l'avez pas encore utilisé, n'hésitez pas - installez-le, c'est une de ces bases de données que vous utiliserez dans votre travail et vos projets personnels ! Je ne donnerai pas de description de l'installation et de l'utilisation de la base de données ; il existe une tonne de didacticiels et de vidéos sur Internet ; je recommande de le découvrir par vous-même, c'est aussi l'une des compétences les plus importantes d'un programmeur - comprendre par vous-même :) Dans la vie, vous aurez besoin de la capacité d'écrire des requêtes en SQL, de manière native, et via JDBC, hibernate , spring, spring data, peut-être que la liste peut être continuée, mais mes connaissances s'arrêtent là. Maintenant, arrêtez de lire cet article et découvrez MySQL, ce n'est en fait pas difficile du tout, vous devez installer le serveur lui-même, les seuls paramètres sont le login et le mot de passe. puis découvrez quelles commandes sont utilisées lorsque vous travaillez. Commandes pour travailler avec le serveur : create , show, use, et autres, commande help- donnera une liste complète des commandes. Requêtes pour travailler avec une table spécifique : select ,insert et deleteautres. N’allez pas trop loin, il est possible que seule une petite partie soit mémorisée en lisant simplement les commandes. vous apprendrez tout au fil du temps. Vous pouvez jouer dans le terminal MySQL, créer une base de données, créer des tables, les remplir, faire une demande d'affichage de données, ajouter des critères de requête. Très probablement, cela ne vous prendra pas plus de 2-3 heures ; si c'est plus long, ne vous inquiétez pas, avec l'expérience, vous maîtriserez le nouveau matériel plus rapidement. Si vous n'avez aucun problème avec les bases, vous pouvez alors commencer à développer le jeu, basé sur le jeu que j'ai déjà écrit sur le tic-tac-toe.. Pendant très longtemps, je n'ai pas compris comment implémenter le multijoueur, j'ai trouvé une solution en utilisant une base de données. Le processus de jeu suppose que les joueurs se relaient, tous les changements intervenus dans le jeu sont enregistrés dans la base de données. déjà sur cette base, nous comprenons que nous avons un joueur et qu'il y a un terrain de jeu qui contient des liens vers les joueurs, c'est dans le terrain de jeu que doit être liée la logique dans laquelle un joueur attend que le deuxième joueur fasse un mouvement et après quoi leurs rôles changent et le premier joueur fait un mouvement et le second attend. Et comme toutes les modifications doivent être dupliquées dans la base de données, nous devons sauvegarder le champ après chaque déplacement. Nous sommes donc arrivés à la première conclusion : il doit y avoir un terrain de jeu dans la base de données et puisque nous parlons de multijoueur, nous devons y ajouter des joueurs. Créons des tables dans MySQL, je l'ai fait nativement, via la fenêtre du terminal mysql. le terrain de jeu contient des liens vers les joueurs, il serait donc logique de créer d'abord une table avec les joueurs. Nos joueurs ont :

• id– numéro de séquence, on en fait la clé primaire ;
• name– nom commun, chaîne ;
• wins– nombre de victoires ;
• loses– nombre de lésions ;
• games– le nombre total de parties jouées.

Table de jeu :

• id– numéro de séquence, on en fait la clé primaire ;
• x– identifiant du joueur qui joue х– clé secondaire ;
• o– identifiant du joueur qui joue o– clé secondaire ;
• field– le champ lui-même, son format sera décrit ci-dessous ;
• status– ceci est nécessaire au bon fonctionnement du multijoueur, le statut caractérise l'état du jeu :
  créé, en cours de jeu, game over

• current– également pour le multijoueur, en particulier pendant le jeu, ce champ contrôle à qui revient le tour,
  et après la fin, il déclare le vainqueur ou le match nul

Nous avons trié les tables, nous devons maintenant créer des classes Java avec les champs correspondants - Gameet 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;
}

Ajoutons un constructeur vide sans paramètres - pour travailler avec la base de données et un autre constructeur avec lequel nous créerons des objets. Ajoutons des setters et des getters pour tous les champs. Parlons maintenant de la mise en veille prolongée :) cela ne devient pas plus facile d'heure en heure. C'est un peu plus compliqué qu'avec MySQL, je vais rapidement passer en revue la structure générale. Encore une fois, tout n'est pas si compliqué, les bases peuvent être apprises grâce à n'importe quel tutoriel en quelques heures, et il est préférable d'étudier en profondeur lors de l'écriture de vos projets. Travailler avec une base de données JAVA implique l'utilisation de JDBC, lisez-en sur le wiki . Mais si vous l'utilisez pour écrire du code, cela apportera beaucoup de douleur dans l'anus, une certaine complexité dans l'écriture de classes DAO ( également un wiki ), la mise en veille prolongée améliorera un peu la situation, avec elle vous aurez beaucoup moins de répétitivité (modèle )code. Pour qu'hibernate fonctionne, vous devez connecter une bibliothèque au projet, cela se fait très simplement : Ctrl+Alt+Shift+S(Structure Fichier-Projet), allez dans l'onglet Bibliothèques, cliquez sur "+" et ajoutez un bibliothèque pré-téléchargée ( en option, à partir d'ici ). Afin de lier des classes, Uservous Gamedevez utiliser des annotations - elles sont très simples à utiliser, avec elles le code ressemble à ceci :

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

C'est simple ici

• @Entity– dit que la classe est une « entité », en termes simples, elle est liée à une table dans la base de données.
• @Table(name="games")– indique quelle table, games– le nom de la table dans la base de données
• @Id, @GeneratedValue, @Column(name = "id")– avec ces trois annotations, nous indiquons que ce champ est un champ d'identification, il est généré automatiquement et la colonne de la base de données est appelée id.
• @Column(name = "x")– nom de la colonne dans la base de données.

Ensuite, vous devez créer des niveaux – le niveau DAO et le niveau de service. Si l'on simplifie tout aux conditions du vide, alors le travail avec les données passe par le niveau de service, c'est l'un des niveaux d'abstraction, il permet de rendre l'application plus indépendante, afin que le développeur de la logique du jeu n'entre pas dans les détails de la configuration de l'accès à la base de données, ou par exemple, si du coup nous décidions d'utiliser Spring au lieu d'une simple mise en veille prolongée, les changements n'iront pas au-delà de la couche de service, sans laquelle il faudrait réécrire la moitié de l'application ! c'est l'un des modèles de conception. Commençons par écrire le niveau 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();
            }
        }
    }
}

Voici à quoi ressemble l'opération d'ajout d'un nouvel utilisateur à la base de données. Veuillez noter que seul un objet de la classe d'entité est transmis à la méthode ; aucune information supplémentaire n'est requise ici. Ceci est assuré par le fait que nous recevons une session de communication prête à l'emploi avec la base de données de la classe HibernateUtil. Considérons-le.

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

Comme vous pouvez le voir, tout ici est également très simple SessionFactory- il s'agit d'une interface de la bibliothèque hibernate, que nous avons connectée à notre projet. Pour un fonctionnement correct, il ne reste plus qu'à remplir le fichier de configuration 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>

Si vous jetez un coup d'œil aux balises, vous comprendrez clairement ce que nous configurons ici et comment. Une autre caractéristique d'hibernate est que si nous décidons soudainement de changer la base de données de MySQL à une autre, il nous suffit de changer le pilote à l'intérieur de la balise. La property name="connection.driver_class" couche DAO est prête, créons une couche de service. Pour éviter de créer des objets DAO dans la couche de service, nous utilisons le modèle d'usine.

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

Et voici l'une des méthodes de niveau de service

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

}

Le code pour travailler avec la base de données est terminé, nous réécrivons la logique du jeu en tenant compte des changements. Tout d'abord, séparons la méthode de lancement principale en une classe distincte Main, ce ne sera qu'une classe de contrôle - un menu de jeu dans lequel vous pouvez démarrer le jeu ou afficher des statistiques. Créons un cours GameLogicqui décrira toute la logique du jeu et vérifiera le terrain de jeu. Il déléguera la sauvegarde de toutes les modifications sur le terrain de jeu et des statistiques des joueurs après le match à la couche service. Il y a une fonctionnalité intéressante : nous contenons le terrain de jeu sous forme de tableaux, ils peuvent être enregistrés dans la base de données, mais à ce stade j'ai décidé de réinventer la roue et dans ma base de données le champ est contenu sous forme d'int, à savoir un 9 -numéro à chiffres, qui est analysé par deux à l'aide de méthodes de classe GameLogic, je ne recommande pas de faire cela, je m'améliorerai dans les prochaines versions du jeu :) Bonne chance à tous pour apprendre JAVA ! Vous pouvez télécharger le projet ici .