Gra konsolowa dla wielu graczy w Javie

Witam wszystkich, grę skończyłem już dawno temu, ale nadal nie zabrałem się za pisanie artykułu, jest to logiczna kontynuacja tego tekstu . Jeśli jeszcze nie próbowałeś zrobić nic innego niż zadania JavaRush, to zapoznanie się z grą będzie dokładnie od tego, od czego chcesz zacząć. Będziesz musiał zacząć przygotowywać się do zadań testowych prawdziwego projektu, w którym gorąco wszystkim polecam udział. I ogólnie rzecz biorąc, czas przestać być programistą sferycznym w próżni i zacząć uczyć się czegoś poza Java-core. Aby po prostu oglądać grę, musisz mieć zainstalowany MySQL, jeśli jeszcze go nie używałeś, nie wahaj się - zainstaluj, to jedna z tych baz danych, których będziesz używać w swojej pracy i osobistych projektach! Nie będę opisywał instalacji i pracy z bazą danych, w Internecie jest mnóstwo tutoriali i filmów, polecam samemu to rozgryźć, to też jedna z najważniejszych umiejętności programisty - obliczanie zrób to sam :) W życiu potrzebna będzie umiejętność pisania zapytań w sql, natywnie, a poprzez JDBC, hibernate , spring, spring data, być może listę można ciągnąć dalej, ale na tym moja wiedza się kończy. Teraz przestań czytać ten artykuł i zapoznaj się z MySQL, w rzeczywistości nie jest to wcale trudne, musisz zainstalować sam serwer, jedyne ustawienia to login i hasło. następnie przeczytaj, jakich poleceń używa się podczas pracy. Komendy do pracy z serwerem: create , show, use, i inne, komenda help- wyświetli pełną listę komend. Zapytania do pracy z konkretną tabelą: select , insert, deletei inne. Nie wchodź zbyt głęboko, istnieje szansa, że ​​tylko niewielka część zostanie zapamiętana z prostego przeczytania poleceń. wszystkiego dowiesz się z czasem. Można grać w terminalu MySQL, tworzyć bazę danych, tworzyć tabele, wypełniać je, składać żądanie wyświetlenia danych, dodawać kryteria zapytania. Najprawdopodobniej zajmie Ci to nie więcej niż 2-3 godziny, jeśli będzie dłużej, nie martw się, z doświadczeniem szybciej opanujesz nowy materiał. Jeśli nie masz problemów z podstawami, możesz zacząć tworzyć grę w oparciu o grę, o której pisałem już o kółko i krzyżyk. Przez bardzo długi czas nie mogłem wymyślić, jak zaimplementować tryb wieloosobowy, znalazłem rozwiązanie w użyciu bazy danych. Proces gry zakłada, że ​​gracze na zmianę, wszystkie zmiany w grze są rejestrowane w bazie danych. już na tej podstawie rozumiemy, że mamy gracza i istnieje pole gry, które zawiera linki do graczy, to na polu gry należy powiązać logikę, w której jeden gracz czeka na ruch drugiego gracza i po czym ich role się zmieniają. Pierwszy gracz wykonuje ruch, a drugi czeka. A ponieważ wszystkie zmiany muszą zostać zduplikowane w bazie danych, po każdym ruchu musimy zapisać pole. Doszliśmy więc do pierwszego wniosku, w bazie danych musi istnieć pole do działania, a ponieważ mówimy o trybie wieloosobowym, musimy tam dodać graczy. Stwórzmy tabele w MySQL, zrobiłem to natywnie, poprzez okno terminala mysql. pole gry zawiera linki do graczy, więc logiczne byłoby najpierw utworzenie stołu z graczami. Nasi gracze posiadają:

• id– numer sekwencyjny, czynimy go kluczem podstawowym;
• name– nazwa zwyczajowa, ciąg znaków;
• wins– liczba zwycięstw;
• loses– liczba zmian;
• games– łączna liczba rozegranych gier.

Stół do gry:

• id– numer sekwencyjny, czynimy go kluczem podstawowym;
• x– identyfikator grającego gracza х– klucz dodatkowy;
• o– identyfikator grającego gracza o– klucz dodatkowy;
• field– samo pole, jego format zostanie opisany poniżej;
• status– jest to konieczne do prawidłowego działania trybu wieloosobowego, status charakteryzuje stan gry:
  utworzono, gra, koniec gry

• current– także dla trybu wieloosobowego, szczególnie podczas gry to pole kontroluje, czyja jest teraz tura,
  a po jej zakończeniu ogłasza zwycięzcę lub remis

Uporządkowaliśmy tabele, teraz musimy utworzyć klasy Java z odpowiednimi polami - Gamei 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;
}

Dodajmy pusty konstruktor bez parametrów - do pracy z bazą danych oraz kolejny konstruktor za pomocą którego będziemy tworzyć obiekty. Dodajmy setery i gettery dla wszystkich pól. A teraz zajmijmy się hibernacją :) z godziny na godzinę wcale nie jest łatwiej. Jest to trochę bardziej skomplikowane niż w przypadku MySQL, szybko omówię ogólną strukturę. Powtórzę: nie wszystko jest takie skomplikowane, podstaw można się nauczyć w dowolnym samouczku w ciągu kilku godzin, a lepiej uczyć się dogłębnie podczas pisania projektów. Praca z bazą danych w języku JAVA wiąże się z wykorzystaniem JDBC, przeczytaj o tym na wiki . Ale jeśli użyjesz go do pisania kodu, przyniesie to dużo bólu odbytu, pewną złożoność w pisaniu klas DAO ( także wiki ), hibernacja trochę poprawi sytuację, dzięki niemu będziesz miał znacznie mniej powtarzalności (szablon ) kod. Aby hibernacja działała, należy podłączyć bibliotekę do projektu, można to zrobić w bardzo prosty sposób: Ctrl+Alt+Shift+S(Struktura pliku-projektu), przejdź do zakładki Biblioteki, kliknij „+” i dodaj wstępnie pobrana biblioteka ( opcjonalnie, stąd ). Aby powiązać klasy Usernależy Gameskorzystać z adnotacji - są one bardzo proste w obsłudze, przy nich kod wygląda następująco:

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

Tutaj jest to proste

• @Entity– mówi, że klasa jest „bytem”, najprościej mówiąc, jest powiązana z tabelą w bazie danych.
• @Table(name="games")– mówi, która tabela, games– nazwa tabeli w bazie danych
• @Id, @GeneratedValue, @Column(name = "id")– tymi trzema adnotacjami oznaczamy, że pole to jest polem identyfikacyjnym, jest generowane automatycznie, a kolumna w bazie nazywa się id.
• @Column(name = "x")– nazwa kolumny w bazie danych.

Następnie musisz zbudować poziomy - poziom DAO i poziom usługi. Jeśli uprościmy wszystko do warunków próżniowych, to praca z danymi przechodzi przez poziom usługi, jest to jeden z poziomów abstrakcji, pozwala na uniezależnienie działania aplikacji, dzięki czemu twórca logiki gry nie wnika w szczegóły ustawienia dostępu do bazy danych, czy też gdybyśmy nagle zamiast zwykłej hibernacji zdecydowali się na użycie springa, zmiany nie wyjdą poza warstwę usługi, bez której połowę aplikacji trzeba by przepisać! to jeden ze wzorców projektowych. Zacznijmy pisać poziom 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();
            }
        }
    }
}

Tak wygląda operacja dodania nowego użytkownika do bazy. Należy pamiętać, że do metody przekazywany jest jedynie obiekt klasy encji, nie są tu wymagane żadne dodatkowe informacje. Zapewnia to fakt, że gotową sesję komunikacyjną z bazą danych otrzymujemy z klasy HibernateUtil. Rozważmy to.

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

Jak widać tutaj również wszystko jest bardzo proste SessionFactory- jest to interfejs z biblioteki hibernate, którą podłączyliśmy do naszego projektu. Do poprawnego działania wystarczy wypełnić plik konfiguracyjny 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>

Jeśli spojrzysz na tagi, stanie się jasne, co i jak tutaj konfigurujemy. Inną cechą hibernacji jest to, że jeśli nagle zdecydujemy się na zmianę bazy danych z MySQL na inną, wystarczy zmienić sterownik w tagu property name="connection.driver_class" Warstwa DAO gotowa, utwórzmy warstwę usług. Aby uniknąć tworzenia obiektów DAO w warstwie usługi, używamy wzorca fabrycznego.

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

A oto jedna z metod poziomu usług

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

}

Kod do pracy z bazą danych jest kompletny, przepisujemy logikę gry uwzględniając wprowadzone zmiany. Najpierw wydzielmy główną metodę uruchamiania na osobną klasę Main, będzie to tylko klasa kontrolna - menu gry, w którym można uruchomić grę lub wyświetlić statystyki. Stwórzmy klasę GameLogic, która opisze całą logikę gry i sprawdzenie pola gry. Deleguje zapisywanie wszelkich zmian na boisku i statystykach zawodników po meczu do warstwy usług. Jest tam ciekawa funkcja: pole gry zawieramy w postaci tablic, można je zapisać w bazie danych, ale na tym etapie zdecydowałem się na wynalezienie koła na nowo i w mojej bazie danych pole jest zawarte w postaci int, czyli 9 -cyfrowa liczba, która jest analizowana przez dwa metodami klasowymi GameLogic, nie polecam tego robić, poprawię się w kolejnych wydaniach gry :) Powodzenia wszystkim w nauce JAVA! Projekt możesz pobrać tutaj .