Seksyon ng mga laro sa CodeGym: Kapaki-pakinabang na teorya

Sa seksyong "Mga Laro" sa CodeGym, makakahanap ka ng mga kapana-panabik na proyekto na kinabibilangan ng pagsusulat ng mga sikat na laro sa computer. Gustong gumawa ng sarili mong bersyon ng mga sikat na laro 2048, Minesweeper, Snake, at iba pang laro? Simple lang. Ginawa naming hakbang-hakbang na proseso ang pagsulat ng laro. Upang subukan ang iyong mga kakayahan bilang developer ng laro, hindi mo kailangang maging isang advanced na programmer, ngunit kinakailangan ang isang partikular na hanay ng kaalaman sa Java. Dito makikita mo ang impormasyon na magiging kapaki-pakinabang sa pagsulat ng laro .

1. Pamana

Ang pagtatrabaho sa CodeGym game engine ay nagsasangkot ng paggamit ng mana. Ngunit paano kung hindi mo alam kung ano iyon? Sa isang banda, kailangan mong maunawaan ang paksang ito: ito ay pinag-aaralan sa Antas 11. Sa kabilang banda, ang makina ay espesyal na idinisenyo upang maging napaka-simple, para makatakas ka sa mababaw na kaalaman sa mana. Kaya ano ang mana? Sa madaling salita, ang mana ay isang relasyon sa pagitan ng dalawang klase. Ang isa sa kanila ay nagiging magulang, at ang isa ay nagiging anak (kaapu-apuhan). Bukod dito, maaaring hindi alam ng parent class na mayroon itong mga inapo. Sa madaling salita, hindi ito nakakakuha ng anumang partikular na kalamangan sa pamamagitan ng pagkakaroon ng mga inapo. Ngunit ang mana ay nagbibigay sa isang inapo ng maraming pakinabang. At ang pinakamahalaga ay ang lahat ng mga variable at pamamaraan ng parent class ay lilitaw sa descendant na parang ang code ng parent class ay kinopya sa descendant class. Ito ay hindi isang ganap na tumpak na paglalarawan, ngunit ito ay sapat na para sa isang pinasimpleng pag-unawa sa mana. Halimbawa 1: Ang pinakasimpleng pamana. Halimbawa 2: Paggamit ng mga variable ng parent class. Halimbawa 3: Paggamit ng mga pamamaraan ng parent class. Ito ang hitsura ng klase ng Bata sa compiler:

public class Child extends Parent{

   public int age;  // Inherited variable
   public String name;  // Inherited variable

   public getName() {  // Inherited method.
      return name;
  }
   public void printInfo() {

     System.out.println(getName()+" "+age);
   }
}

2. Overriding na mga pamamaraan

Minsan may mga sitwasyon kung saan ginagawa naming magmana ang aming Child class ng ilang napaka-kapaki-pakinabang na Parent class, kasama ang lahat ng variable at pamamaraan nito, ngunit ang ilan sa mga pamamaraan ay hindi gumagana kung paano namin gusto ang mga ito. O hindi sa lahat ng gusto natin sa kanila. Ano ang magagawa natin sa ganitong sitwasyon? Maaari nating i-override ang pamamaraang hindi natin gusto. Ito ay napakadaling gawin: sa aming klase ng Bata, ipinapahayag lang namin ang isang pamamaraan na may parehong lagda bilang ang pamamaraan sa klase ng Parent, at pagkatapos ay isusulat namin ang aming sariling code dito. Halimbawa 1: Pag-override sa isang paraan. Ito ang hitsura ng klase ng Bata sa compiler:

public Child extends Parent {

   public String name;  // Inherited variable

   public void setName(String nameNew)  // Overridden method instead of the inherited method {

       name = nameNew + ", No!!!";
   }
   public getName() {  // Inherited method.

      return name;
   }
   public void printInfo() {

     setName("Luke");
     System.out.println( getName());
   }
}

Halimbawa 2: Ilang inheritance magic (at overriding na paraan). Sa halimbawang ito, kung ang printInfopamamaraan (mula sa klase ng Parent) ay hindi na-override sa klase ng Bata, kapag ang pamamaraang ito ay tinawag sa isang bagay na Bata, ang getName()pamamaraan nito ay tatawagin sa halip na ang getName()paraan ng klase ng Parent. Ito ang hitsura ng klase ng Bata sa compiler:

public class Child extends Parent {

   public getName() {
      return "Luke, I am your father";
   }
   public void printInfo() {

     System.out.println(getName());
   }
}

3. Mga listahan

Kung hindi mo pa nakikilala ang mga listahan (List), narito ang isang maikling pangkalahatang-ideya. Makakahanap ka ng kumpletong impormasyon sa Mga Antas 6-7 ng kursong CodeGym . Ang mga listahan ay may maraming pagkakatulad sa mga array:

• maaari kang mag-imbak ng maraming data ng isang partikular na uri;
• hinahayaan ka nilang makakuha ng mga item ayon sa kanilang index;
• Ang mga indeks ng elemento ay nagsisimula sa 0.

Mga pakinabang ng mga listahan: Hindi tulad ng mga array, ang mga listahan ay maaaring magbago ng laki nang pabago-bago. Kapag ginawa ang isang listahan, ang laki nito ay 0. Habang nagdaragdag ka ng mga item sa isang listahan, tataas ang laki nito. Narito ang isang halimbawa ng paggawa ng listahan:

ArrayList<String> myList = new ArrayList<String>(); // Create a new ArrayList

Ang halaga sa mga angle bracket ay nagpapahiwatig ng uri ng data na maaaring iimbak ng listahan. Narito ang ilang mga paraan para magtrabaho kasama ang listahan: Maaari kang matuto nang higit pa tungkol sa mga listahan mula sa mga sumusunod na artikulo:

1. klase ng ArrayList
2. ArrayList sa mga larawan
3. Pagtanggal ng elemento mula sa isang ArrayList

4. Mga array

Ano ang isang matrix? Ang isang matrix ay hindi hihigit sa isang hugis-parihaba na talahanayan na maaaring punan ng data. Sa madaling salita, ito ay isang two-dimensional array. Tulad ng malamang na alam mo, ang mga array sa Java ay mga bagay. Ang isang karaniwang one-dimensional intarray ay ganito ang hitsura:

int [] array = {12, 32, 43, 54, 15, 36, 67, 28};

Maaari nating mailarawan ito tulad nito: Ang itaas na hilera ay nagpapahiwatig ng mga address ng mga cell. Sa madaling salita, para makuha ang numerong 67, kailangan mong i-access ang array element na may index 6:

int number = array[6];

Napakasimple ng lahat. Ang dalawang-dimensional na array ay isang hanay ng mga one-dimensional na array. Kung narinig mo ito sa unang pagkakataon, huminto at isipin ito sa iyong isip. Ang isang two-dimensional array ay ganito ang hitsura: Sa code:

int [][] matrix = {
{65, 99, 87, 90, 156, 75, 98, 78},
{76, 15, 76, 91, 66, 90, 15, 77},
{65, 96, 17, 25, 36, 75, 54, 78},
{59, 45, 68, 14, 57, 1, 9, 63},
{81, 74, 47, 52, 42, 785, 56, 96},
{66, 74, 58, 16, 98, 140, 55, 77},
{120, 99, 13, 90, 78, 98, 14, 78},
{20, 18, 74, 91, 96, 104, 105, 77}
}

Upang makuha ang halaga na 47, kailangan mong sumangguni sa elemento ng matrix sa [4][2].

int number = matrix[4][2];

Maaaring napansin mo na ang mga coordinate ng matrix ay iba sa klasikal na rectangular coordinate system (Cartesian coordinate system). Kapag na-access mo ang matrix, tinukoy mo muna ang y coordinate at pagkatapos ay ang x coordinate. Sa matematika, kaugalian na tukuyin muna ang x coordinate, ibig sabihin, (x, y). Maaaring nagtataka ka: "Buweno, bakit hindi paikutin ang iyong representasyon ng matrix at pagkatapos ay i-access ang mga elemento sa karaniwang paraan gamit ang (x, y)? Ang paggawa nito ay hindi mababago ang mga nilalaman ng matrix". Oo, walang magbabago. Ngunit sa mundo ng programming, ang tinatanggap na kasanayan ay ang pag-access sa mga matrice "una sa pamamagitan ng y, pagkatapos ay sa pamamagitan ng x". Dapat mong tanggapin ito bilang tamang paraan. Ngayon pag-usapan natin ang tungkol sa pag-project ng matrix sa ating makina (Gameklase). Tulad ng alam mo, ang makina ay may maraming mga pamamaraan na nagbabago sa mga cell ng larangan ng paglalaro sa mga tiyak na coordinate. Halimbawa, ang setCellValue(int x, int y, String value)pamamaraan. Nagtatakda ito ng isang partikular na cell na may mga coordinate (x, y) na katumbas ng value parameter. Maaaring napansin mo na ang pamamaraang ito ay tumatagal ng x muna, tulad ng sa classical coordinate system. Ang iba pang mga pamamaraan ng makina ay gumagana sa katulad na paraan. Kapag nagde-develop ng mga laro, kadalasang kakailanganing kopyahin ang estado ng isang matrix sa screen. Paano natin gagawin iyon? Una, kailangan mong umulit sa lahat ng mga elemento ng matrix sa isang loop. Pangalawa, tawagan ang paraan ng pagpapakita para sa bawat isa sa kanila, gamit ang REVERSED coordinates. Halimbawa:

private void drawScene() {
    for (int i = 0; i < matrix.length; i++) {
        for (int j = 0; j < matrix[i].length; j++) {
            setCellValue(j, i, String.valueOf(matrix[i][j]));
        }
    }
}

Naturally, ang pagbabalik ay gumagana sa parehong direksyon. Maaari mong ipasa ang (i, j) sa setCellValuepamamaraan at sabay-sabay na kumuha ng elemento [j][i] mula sa matrix. Ang pag-reverse ng mga coordinate ay maaaring mukhang medyo mahirap, ngunit kailangan mong tandaan ito. At palagi, kung nakatagpo ka ng anumang mga problema, dapat kang kumuha ng isang piraso ng papel at isang panulat, iguhit ang matrix, at muling gawin ang mga proseso na kinasasangkutan ng matrix.

5. Random na mga numero

Paano ka gumagana sa isang random na generator ng numero? GameTinutukoy ng klase ang getRandomNumber(int)pamamaraan. Sa ilalim ng hood, ginagamit nito ang Randomklase mula sa package ng java.util, ngunit hindi nagbabago ang paraan ng pagtatrabaho mo sa generator ng random na numero. getRandomNumber(int)kumukuha ng integer bilang argumento. Ang numerong ito ang magiging pinakamataas na limitasyon sa kung ano ang maibabalik ng generator. Ang mas mababang limitasyon ay 0. Mahalaga! HINDI ibabalik ng generator ang numero sa itaas na limitasyon. Halimbawa, kung tatawag ka sa getRandomNumber(3), ito ay random na magbabalik ng 0, 1, o 2. Gaya ng nakikita mo, hindi ito makakabalik ng 3. Ang paggamit ng generator sa ganitong paraan ay medyo simple, ngunit lubos na epektibo sa maraming mga kaso. Ipagpalagay na kailangan mong makakuha ng random na numero sa ilang hanay: Isipin na kailangan mo ng tatlong-digit na numero sa hanay [100..999]. Tulad ng alam mo na, ang minimum na numero na ibinalik ay 0. Kaya kakailanganin mong magdagdag ng 100. Ngunit sa kasong ito, kailangan mong mag-ingat na huwag lumampas sa itaas na limitasyon. Upang makakuha ng 999 bilang pinakamataas na random na halaga, tawagan anggetRandomNumber(int)paraan na may argumentong 1000. Ngunit ngayon naaalala namin na nagdaragdag kami ng 100 sa resulta: nangangahulugan ito na ang itaas na hangganan ay dapat bawasan ng 100. Sa madaling salita, ang code upang makuha ang aming random na tatlong-digit na numero ay magiging ganito :

int number = 100 + getRandomNumber(900);

Ngunit upang gawing simple ang pamamaraang ito, ang makina ay nagbibigay ng getRandomNumber(int, int)pamamaraan na ang unang parameter ay ang pinakamababang numero na ibabalik. Gamit ang pamamaraang ito, ang nakaraang halimbawa ay maaaring muling isulat tulad ng sumusunod:

int number = getRandomNumber(100, 1000);

Maaaring gamitin ang mga random na numero upang makakuha ng isang random na elemento ng array:

String [] names = {"Sarah", "Val", "Sergey"};
String randomName = names[getRandomNumber(names.length)]

Pagbuo ng ilang partikular na kaganapan na may ilang posibilidad. Para sa mga tao, nagsisimula ang umaga sa ilang posibleng mga sitwasyon: Overslept – 50% na pagkakataon; Nagising sa oras - 40% na pagkakataon; Nagising ng isang oras nang maaga - 10% ang pagkakataon. Isipin na nagsusulat ka ng isang generator ng kinalabasan sa umaga. Kailangan mong bumuo ng mga kaganapan na may tiyak na posibilidad. Upang gawin ito, kailangan mong gumamit muli ng isang random na generator ng numero. Posible ang iba't ibang pagpapatupad, ngunit ang pinakasimpleng dapat ay batay sa sumusunod na algorithm:

1. itakda ang mga limitasyon na ginamit upang makabuo ng isang numero;
2. bumuo ng isang random na numero;
3. iproseso ang nakuhang numero.

Sa kasong ito, ang maximum ay magiging 10. Tawagan anggetRandomNumber(10)pamamaraan at pag-aralan na ito ay maaari nating ibalik. Maaari itong magbalik ng 10 numero (mula 0 hanggang 9), bawat isa ay may parehong posibilidad - 10%. Ngayon ay kailangan nating pagsamahin ang lahat ng posibleng resulta at imapa ang mga ito sa ating mga posibleng kaganapan. Ang iyong imahinasyon ay maaaring mag-isip ng maraming posibleng kumbinasyon, ngunit narito ang pinaka-halata: "Kung ang random na numero ay nasa hanay [0..4], mayroon kaming kaganapang "Overslept"; kung ang numero ay nasa hanay [5]. ..8], mayroon tayong event na "Woke up on time"; at kung 9 ang numero, mayroon tayong event na "Woke up an hour early." Napakasimple ng lahat. Mayroong 5 numero sa hanay [0 ..4], ang bawat isa ay maaaring ibalik na may posibilidad na 10%, para sa kabuuang 50%; mayroong 4 na numero sa hanay [5..8], mabuti, at ang 9 ay isang numero lamang na lumalabas na may isang posibilidad na 10%.

int randomNumber = getRandomNumber(10);
if (randomNumber < 5) {
    System.out.println("Overslept");
} else if (randomNumber < 9) {
    System.out.println("Woke up on time");
} else {
    System.out.println("Woke up an hour early");
}

Sa pangkalahatan, maraming paraan para gumamit ng mga random na numero. Ikaw ay limitado lamang sa pamamagitan ng iyong imahinasyon. Ngunit ang mga ito ay pinaka-epektibong ginagamit kung kailangan mong paulit-ulit na makakuha ng ilang resulta. Kung gayon ang bagong resulta ay magiging iba sa nauna. May ilang posibilidad, siyempre. Yun lang muna! Kung gusto mong matuto nang higit pa tungkol sa seksyong "Mga Laro," narito ang ilang kapaki-pakinabang na dokumentasyon na makakatulong: