Jogo de console multijogador em java

Olá a todos, já terminei de escrever o jogo há muito tempo, mas ainda não consegui escrever um artigo, é uma continuação lógica deste texto . Se você ainda não tentou fazer outra coisa do que as tarefas JavaRush, então conhecer o jogo será exatamente por onde você deseja começar. Você precisará começar a se preparar para as tarefas de teste de um projeto real, no qual recomendo fortemente a participação de todos. E, em geral, é hora de deixar de ser um programador esférico no vácuo e começar a aprender algo fora do java-core. Para simplesmente assistir ao jogo é necessário ter o MySQL instalado, se ainda não o utilizou, não hesite - instale-o, este é um daqueles bancos de dados que você utilizará em seus trabalhos e projetos pessoais! Não vou dar uma descrição de como instalar e trabalhar com o banco de dados; existem muitos tutoriais e vídeos na Internet; recomendo descobrir isso por conta própria, essa também é uma das habilidades mais importantes de um programador - descobrir faça você mesmo :) Na vida, você precisará da capacidade de escrever consultas em sql, nativamente e por meio de JDBC, hibernate , spring, spring data, talvez a lista possa continuar, mas meu conhecimento termina aí. Agora pare de ler este artigo e descubra o MySQL, na verdade não é nada difícil, você precisa instalar o próprio servidor, as únicas configurações lá são login e senha. em seguida, leia sobre quais comandos são usados ​​​​durante o trabalho. Comandos para trabalhar com o servidor: create , show, usee outros, comando help- fornecerá uma lista completa de comandos. Consultas para trabalhar com uma tabela específica: select , inserte deleteoutras. Não se aprofunde muito, há uma chance de que apenas uma pequena parte seja lembrada pela simples leitura dos comandos. você aprenderá tudo com o tempo. Você pode brincar no terminal MySQL, criar um banco de dados, criar tabelas, preenchê-las, fazer uma solicitação de exibição de dados, adicionar critérios de consulta. Provavelmente, isso não levará mais do que 2 a 3 horas; se demorar mais, não se preocupe, com a experiência você dominará o novo material mais rapidamente. Se você não tiver problemas com as bases, então você pode começar a desenvolver o jogo, baseado no jogo que já escrevi sobre o jogo da velha. Por muito tempo não consegui descobrir como implementar o multiplayer; encontrei uma solução usando um banco de dados. O processo do jogo pressupõe que os jogadores se revezem, todas as alterações no jogo são registradas no banco de dados. já com base nisso, entendemos que temos um jogador e existe um campo de jogo que contém links para jogadores, é no campo de jogo que deve estar amarrada a lógica em que um jogador está esperando o segundo jogador fazer uma jogada e depois disso seus papéis mudam e o primeiro jogador faz um movimento e o segundo espera. E como todas as alterações devem ser duplicadas no banco de dados, após cada movimentação precisamos salvar o campo. Então chegamos à primeira conclusão, deve haver um campo de jogo no Banco de Dados e como estamos falando de multiplayer, precisamos adicionar jogadores lá. Vamos criar tabelas no MySQL, fiz isso de forma nativa, através da janela do terminal mysql. o campo de jogo contém links para jogadores, então seria lógico criar primeiro uma mesa com os jogadores. Nossos jogadores têm:

• id– número de sequência, fazemos dele a chave primária;
• name– nome comum, string;
• wins– número de vitórias;
• loses– número de lesões;
• games– o número total de jogos disputados.

Mesa de jogo:

• id– número de sequência, fazemos dele a chave primária;
• x– id do jogador que joga х– chave secundária;
• o– id do jogador que joga o– chave secundária;
• field– o campo em si, seu formato será descrito a seguir;
• status– isso é necessário para que o multiplayer funcione corretamente, o status caracteriza o estado do jogo:
  criado, jogando, fim do jogo

• current– também para multiplayer, especificamente durante o jogo este campo controla de quem é a vez
  e após o final declara o vencedor ou empate

Classificamos as tabelas, agora precisamos criar classes Java com os campos correspondentes - 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;
}

Vamos adicionar um construtor vazio sem parâmetros - para trabalhar com o banco de dados e outro construtor com o qual criaremos objetos. Vamos adicionar setters e getters para todos os campos. Agora vamos lidar com a hibernação :) não fica mais fácil de hora em hora. É um pouco mais complicado do que com MySQL, examinarei rapidamente a estrutura geral. Novamente, nem tudo é tão complicado, o básico pode ser aprendido através de qualquer tutorial em algumas horas, e é melhor estudar a fundo enquanto escreve seus projetos. Trabalhar com um banco de dados JAVA envolve o uso de JDBC, leia sobre isso no wiki . Mas se você usar na escrita de código, vai trazer muita dor no ânus, alguma complexidade na escrita de classes DAO ( também um wiki ), o hibernate vai melhorar um pouco a situação, com ele você terá muito menos repetitividade (template ) código. Para que o hibernate funcione, você precisa conectar uma biblioteca ao projeto, isso é feito de forma muito simples: Ctrl+Alt+Shift+S(Arquivo-Estrutura do Projeto), vá até a aba Bibliotecas, clique em "+" e adicione um biblioteca pré-baixada ( como opção, daqui ). Para vincular classes Uservocê Gameprecisa usar anotações - elas são muito fáceis de usar, com elas o código fica assim:

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

É simples aqui

• @Entity– diz que a classe é uma “entidade”, em palavras simples, está vinculada a uma tabela do banco de dados.
• @Table(name="games")– diz qual tabela, games– o nome da tabela no banco de dados
• @Id, @GeneratedValue, @Column(name = "id")– com essas três anotações denotamos que este campo é um campo de identificação, é gerado automaticamente e a coluna do banco de dados é chamada de id.
• @Column(name = "x")– nome da coluna no banco de dados.

Em seguida, você precisa construir níveis - o nível DAO e o nível de serviço. Se simplificarmos tudo para condições de vácuo, então o trabalho com os dados passa pelo nível de serviço, este é um dos níveis de abstração, permite fazer com que a aplicação funcione de forma mais independente, para que o desenvolvedor da lógica do jogo não entre em detalhes de configurar o acesso ao banco de dados, ou por exemplo, se de repente em vez do simples hibernate decidirmos usar o spring, as alterações não irão além da camada de serviço, sem a qual metade da aplicação teria que ser reescrita! este é um dos padrões de design. Vamos começar a escrever o nível 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();
            }
        }
    }
}

Esta é a aparência da operação de adição de um novo usuário ao banco de dados. Observe que apenas um objeto da classe de entidade é passado para o método; nenhuma informação adicional é necessária aqui. Isso é garantido pelo fato de recebermos uma sessão de comunicação pronta com o banco de dados da classe HibernateUtil. Vamos considerar isso.

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

Como você pode ver, tudo aqui também é muito simples SessionFactory- esta é uma interface da biblioteca de hibernação que conectamos ao nosso projeto. Para o correto funcionamento, basta preencher o arquivo de configuração 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 você olhar as tags, ficará claro o que e como estamos configurando aqui. Outra característica do hibernate é que se de repente decidirmos mudar o banco de dados MySQL para outro, só precisamos mudar o driver dentro da tag property name="connection.driver_class" DAO layer is ready, vamos criar uma camada de serviço. Para evitar a criação de objetos DAO na camada de serviço, usamos o padrão de fábrica.

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

E aqui está um dos métodos de nível de serviço

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

}

O código para trabalhar com o banco de dados está completo, reescrevemos a lógica do jogo levando em consideração as alterações. Primeiro, vamos separar o método principal de inicialização em uma classe separada Main, será apenas uma classe de controle - um menu de jogo no qual você pode iniciar o jogo ou visualizar estatísticas. Vamos criar uma classe GameLogicque irá descrever toda a lógica do jogo e verificar o campo de jogo. Ele delegará o salvamento de todas as alterações no campo de jogo e nas estatísticas dos jogadores após o jogo para a camada de serviço. Há uma característica interessante, contém o campo de jogo na forma de arrays, eles podem ser salvos no banco de dados, mas nesta fase resolvi reinventar a roda e no meu banco de dados o campo está contido como um int, ou seja, um 9 -número de dígitos, que é analisado por dois usando métodos de classe GameLogic, não recomendo fazer isso, vou melhorar nas próximas versões do jogo :) Boa sorte a todos no aprendizado de JAVA! Você pode baixar o projeto aqui .