Multiplayer console game sa java

Kumusta sa lahat, matagal ko nang natapos ang pagsusulat ng laro, ngunit hindi pa rin ako nakakagawa ng isang artikulo, ito ay isang lohikal na pagpapatuloy ng piraso ng pagsulat na ito . Kung hindi mo pa nasusubukang gumawa ng iba pa kaysa sa mga gawain sa JavaRush, pagkatapos ay ang pagkilala sa laro ay magiging eksakto kung saan mo gustong magsimula, kakailanganin mong simulan ang paghahanda para sa mga pagsubok na gawain ng isang tunay na proyekto, kung saan mariing inirerekumenda kong lumahok ang lahat. At sa pangkalahatan, oras na upang ihinto ang pagiging isang spherical programmer sa isang vacuum at magsimulang matuto ng isang bagay sa labas ng java-core. Upang mapanood lamang ang laro, kailangan mong naka-install ang MySQL, kung hindi mo pa ito ginagamit, huwag mag-atubiling - i-install ito, ito ay isa sa mga database na gagamitin mo sa iyong trabaho at personal na mga proyekto! Hindi ako magbibigay ng isang paglalarawan ng pag-install at pagtatrabaho sa database; mayroong isang tonelada ng mga tutorial at video sa Internet; Inirerekumenda ko ang pag-uunawa nito sa iyong sarili, ito rin ay isa sa pinakamahalagang kasanayan ng isang programmer - pag-uunawa it out on your own :) Sa buhay, kakailanganin mo ng kakayahang magsulat ng mga query sa sql, natively , at sa pamamagitan ng JDBC, hibernate , spring, spring data, marahil ang listahan ay maaaring ipagpatuloy, ngunit ang aking kaalaman ay nagtatapos doon. Ngayon itigil ang pagbabasa ng artikulong ito at alamin ang MySQL, talagang hindi ito mahirap, kailangan mong i-install ang server mismo, ang mga setting lamang doon ay pag-login at password. pagkatapos ay basahin ang tungkol sa kung anong mga utos ang ginagamit kapag nagtatrabaho. Mga utos para sa pagtatrabaho sa server: create , show, use, at iba pa, command help- ay magbibigay ng kumpletong listahan ng mga command. Mga query para sa pagtatrabaho sa isang partikular na talahanayan: select , insert, deleteat iba pa. Huwag masyadong malalim, may pagkakataon na maliit na bahagi lamang ang maaalala mula sa simpleng pagbabasa ng mga utos. matututuhan mo ang lahat sa paglipas ng panahon. Maaari kang maglaro sa MySQL terminal, lumikha ng isang database, lumikha ng mga talahanayan, punan ang mga ito, gumawa ng isang kahilingan upang ipakita ang data, magdagdag ng mga pamantayan sa query. Malamang, aabutin ka nito ng hindi hihigit sa 2-3 oras; kung mas mahaba, huwag mag-alala, na may karanasan ay mas mabilis kang makakabisado ng bagong materyal. Kung wala kang mga problema sa mga base, maaari mong simulan ang pagbuo ng laro, batay sa laro na isinulat ko na tungkol sa tic-tac-toe. Sa napakatagal na panahon hindi ko maisip kung paano ipatupad ang multiplayer; Nakahanap ako ng solusyon sa paggamit ng database. Ipinapalagay ng proseso ng laro na ang mga manlalaro ay humalili, ang lahat ng mga pagbabago sa laro ay naitala sa database. base na rin dito, naiintindihan namin na may player kami at may playing field na naglalaman ng mga link sa mga manlalaro, nasa playing field na dapat itali ang logic kung saan naghihintay ang isang player na gumawa ng hakbang ang pangalawang player. at pagkatapos nito ay nagbabago ang kanilang mga tungkulin at Ang unang manlalaro ay gumawa ng isang hakbang, at ang pangalawa ay naghihintay. At dahil ang lahat ng mga pagbabago ay dapat na madoble sa database, pagkatapos ng bawat paglipat kailangan naming i-save ang field. Kaya dumating kami sa unang konklusyon, dapat mayroong isang larangan ng paglalaro sa Database at dahil pinag-uusapan natin ang tungkol sa multiplayer, kailangan nating magdagdag ng mga manlalaro doon. Gumawa tayo ng mga talahanayan sa MySQL, ginawa ko ito nang katutubong, sa pamamagitan ng mysql terminal window. ang playing field ay naglalaman ng mga link sa mga manlalaro, kaya lohikal na gumawa muna ng table kasama ang mga manlalaro. Ang aming mga manlalaro ay mayroong:

• id– Sequence number, ginagawa namin itong pangunahing key;
• name– karaniwang pangalan, string;
• wins- bilang ng mga tagumpay;
• loses- bilang ng mga sugat;
• games– ang kabuuang bilang ng mga larong nilalaro.

talahanayan ng laro:

• id– Sequence number, ginagawa namin itong pangunahing key;
• x– id ng player na naglalaro х– pangalawang key;
• o– id ng player na naglalaro o– pangalawang key;
• field– ang patlang mismo, ang format nito ay ilalarawan sa ibaba;
• status– ito ay kinakailangan para gumana nang tama ang multiplayer, ang katayuan ay nagpapakilala sa estado ng laro:
  nilikha, naglalaro, natapos ang laro

• current– para din sa Multiplayer, partikular sa panahon ng laro, kinokontrol ng field na ito kung kaninong turn na ito ngayon,
  at pagkatapos ng pagtatapos ay idineklara nito ang panalo o draw.

Inayos namin ang mga talahanayan, ngayon kailangan naming lumikha ng mga klase ng Java na may kaukulang mga patlang - Gameat 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;
}

Magdagdag tayo ng isang walang laman na constructor na walang mga parameter - para sa pagtatrabaho sa database at isa pang constructor kung saan gagawa tayo ng mga bagay. Magdagdag tayo ng mga setter at getter para sa lahat ng field. Ngayon ay haharapin natin ang hibernate :) hindi ito nagiging mas madali sa bawat oras. Ito ay medyo mas kumplikado kaysa sa MySQL, mabilis kong tatalakayin ang pangkalahatang istraktura. Muli, hindi lahat ay sobrang kumplikado, ang mga pangunahing kaalaman ay maaaring matutunan sa pamamagitan ng anumang tutorial sa loob ng ilang oras, at mas mahusay na mag-aral nang malalim habang isinusulat ang iyong mga proyekto. Ang pagtatrabaho sa isang database mula sa JAVA ay nagsasangkot ng paggamit ng JDBC, basahin ang tungkol dito sa wiki . Ngunit kung gagamitin mo ito sa pagsulat ng code, magdadala ito ng maraming sakit sa anus, ilang kumplikado sa pagsulat ng mga klase ng DAO ( isa ring wiki ), mapapabuti ng hibernate ang sitwasyon nang kaunti, kasama nito ay magkakaroon ka ng mas kaunting paulit-ulit (template ) code. Upang gumana ang hibernate, kailangan mong ikonekta ang isang library sa proyekto, ito ay ginagawa nang napakasimple: Ctrl+Alt+Shift+S(File-Project Structure), pumunta sa tab na Mga Aklatan, i-click ang "+" at magdagdag ng isang paunang na-download na library ( bilang isang opsyon, mula dito ). Upang mai-link ang mga klase kailangan Usermong Gamegumamit ng mga anotasyon - napakadaling gamitin ng mga ito, sa kanila ang code ay ganito ang hitsura:

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

Simple lang dito

• @Entity– sinasabi na ang klase ay isang "entity", sa simpleng salita, ito ay nakatali sa isang table sa database.
• @Table(name="games")– sabi kung aling talahanayan, games– ang pangalan ng talahanayan sa database
• @Id, @GeneratedValue, @Column(name = "id")– sa tatlong annotation na ito ay tinutukoy namin na ang field na ito ay isang field ng pagkakakilanlan, awtomatiko itong nabuo, at ang column sa database ay tinatawag na id.
• @Column(name = "x")– pangalan ng column sa database.

Susunod, kailangan mong bumuo ng mga antas - ang antas ng DAO at ang antas ng serbisyo. Kung pinasimple namin ang lahat sa mga kondisyon ng vacuum, pagkatapos ay gumagana ang data sa pamamagitan ng antas ng serbisyo, ito ay isa sa mga antas ng abstraction, pinapayagan ka nitong gawing mas independiyente ang application, upang ang developer ng logic ng laro ay hindi pumasok sa mga detalye ng pagse-set up ng access sa database, o halimbawa, kung biglang kami sa halip na simpleng hibernate ay nagpasya na gumamit ng spring, ang mga pagbabago ay hindi lalampas sa layer ng serbisyo, kung wala ang kalahati ng application ay kailangang muling isulat! ito ay isa sa mga pattern ng disenyo. Simulan natin ang pagsulat ng antas ng 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();
            }
        }
    }
}

Ganito ang hitsura ng operasyon ng pagdaragdag ng bagong user sa database. Pakitandaan na isang object lang ng klase ng entity ang ipinapasa sa pamamaraan; walang karagdagang impormasyon ang kailangan dito. Tinitiyak ito ng katotohanang nakakatanggap kami ng isang handa na sesyon ng komunikasyon kasama ang database mula sa klase ng HibernateUtil. Isaalang-alang natin ito.

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

Tulad ng nakikita mo, ang lahat ng bagay dito ay napaka-simple SessionFactory- ito ay isang interface mula sa hibernate library, na ikinonekta namin sa aming proyekto. Para sa tamang operasyon, ang natitira na lang ay punan ang hibernate.cfg.xml configuration file

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

Kung susulyapan mo ang mga tag, magiging malinaw kung ano at paano kami nagse-set up dito. Ang isa pang tampok ng hibernate ay kung bigla tayong magpasya na baguhin ang database mula sa MySQL patungo sa isa pa, kailangan lang nating baguhin ang driver sa loob ng tag na property name="connection.driver_class" DAO layer ay handa na, gumawa tayo ng isang layer ng serbisyo. Upang maiwasan ang paglikha ng mga bagay ng DAO sa layer ng serbisyo, ginagamit namin ang pattern ng pabrika.

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

At narito ang isa sa mga pamamaraan sa antas ng serbisyo

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

}

Ang code para sa pagtatrabaho sa database ay kumpleto na, muling isinulat namin ang lohika ng laro na isinasaalang-alang ang mga pagbabago. Una, paghiwalayin natin ang pangunahing paraan ng paglulunsad sa isang hiwalay na klase Main, ito ay magiging isang control class lamang - isang menu ng laro kung saan maaari mong simulan ang laro o tingnan ang mga istatistika. Gumawa tayo ng isang klase GameLogicna maglalarawan sa lahat ng lohika ng laro at suriin ang larangan ng paglalaro. Ide-delegate niya ang pag-save ng lahat ng pagbabago sa playing field at mga istatistika ng player pagkatapos ng laro sa service layer. Mayroong isang kagiliw-giliw na tampok, naglalaman kami ng larangan ng paglalaro sa anyo ng mga array, maaari silang mai-save sa database, ngunit sa yugtong ito ay nagpasya akong muling likhain ang gulong at sa aking database ang patlang ay nilalaman bilang isang int, lalo na isang 9 -digit na numero, na na-parse ng dalawa gamit ang mga pamamaraan ng klase GameLogic, I don’t recommend doing this, I will improve in the next releases of the game :) Good luck sa lahat sa pag-aaral ng JAVA! Maaari mong i-download ang proyekto dito .