პროგრამირეთ თქვენი საკუთარი 2048 თამაში W/Java!: 8 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:15

ავტორი PranP1 ჩემი (არასრული) საიტის შემდგომი ავტორის მიერ:

მე მიყვარს თამაში 2048. და ამიტომ გადავწყვიტე დამეპროგრამებინა საკუთარი ვერსია.

ის ძალიან ჰგავს რეალურ თამაშს, მაგრამ მისი პროგრამირება მე მაძლევს თავისუფლებას შევიცვალო ის, რაც მსურს, როცა მინდა. თუ მე მინდა 5x5 თამაში ტიპიური 4x4- ის ნაცვლად, "დაფის" კონსტრუქტორის გამოყენებით მარტივი ცვლილება ამის საშუალებას მომცემს. თქვით, რომ მინდა თამაში გავართულო და დავამატო ისეთ პოზიციებზე დარტყმები, რომლებიც მოთამაშეს უფრო რთულს გახდის და არა შემთხვევით. მარტივი ალგორითმის გამოყენებით, მე შემიძლია ამის გაკეთება. მიუხედავად იმისა, რომ მე არ განვიხილავ ყველა ამ ცვლილებას ამ ინსტრუქციაში, მე ვგეგმავ დამატებით დამატებას.

ჯერჯერობით, ჩვენ დავპროგრამებთ თქვენს ჩვეულებრივ თამაშს 2048 წელს.

Დავიწყოთ!

(გვერდითი შენიშვნა: ეს ინსტრუქცია მოითხოვს პროგრამირების ზომიერ ცოდნას - კონკრეტულად ჯავასთან)

ნაბიჯი 1: მასალები

თქვენ არ დაგჭირდებათ ბევრი ამ პროექტისთვის, რადგან ეს მხოლოდ პროგრამირების გზაა.

მასალები:

• Ლეპტოპი
• დაბნელება (ან თქვენი არჩევანის ნებისმიერი IDE)

Კი. Ის არის.

ნაბიჯი 2: გაეცანით პროგრამას - დაფა

მთელი ჩემი კოდი ავტვირთე GitHub– ზე - შეამოწმეთ აქ:

თამაში დავყავი 3 კლასად: დაფა, კრამიტი და თამაში.

დაფა:

აღწერა: დაფის კლასი ეხება სათამაშო დაფას, ადგენს "კრამიტის" ელემენტების მასივს, იღებს მიმდინარე ქულას და ყველაზე მაღალ კრამიტს და მასივს ათავსებს სტრიქონში (მოგვიანებით გამოიყენება "თამაშში"). ლოგიკის უმეტესი ნაწილი ასევე აქ არის, კლასი უზრუნველყოფს მეთოდებს 2 და 4 კომბინაციების წარმოსადგენად შემთხვევით ადგილას, მოძრაობისას ზემოთ, ქვემოთ, მარცხნივ და მარჯვნივ და აცნობებს მოთამაშეებს თამაშის დასრულების შემდეგ.

კონსტრუქტორები:

/ * დაფის ნაგულისხმევი კონსტრუქტორი - ადგენს 4x4 მატრიქსს */

საჯარო საბჭო () {…}

/ * დაფის კონსტრუქტორი - ადგენს მატრიცას ქსელის განსაზღვრული ზომით */

საჯარო საბჭო (შიდა ბადეები) {…}

მეთოდები:

/ * მიმღები მეთოდი, რომელიც აბრუნებს დაფას */

საჯარო კრამიტი getBoard () {…}

/ * მიმღები მეთოდი, რომელიც აბრუნებს ქულას */

public int getScore () {…}

/ * პოულობს დაფაზე ყველაზე მაღალ ფილას და აბრუნებს მას */

public int getHighTile () {…}

/ * ბეჭდავს დაფას კონსოლზე - ტესტირების მიზნით */

საჯარო ბათილი ბეჭდვა () {…}

/ * აბრუნებს დაფას როგორც სიმებიანი - გამოიყენება GUI– ში */

public String toString () {…}

/ * ქვირითობს 2 (ან 4) ცარიელ სივრცეში ძალიან სწრაფად ხდება ნაბიჯი */

public void spawn () {…}

/ * ამოწმებს, არის თუ არა დაფა მთლიანად ჩაბნელებული და თუ არა, ის მოთამაშეებს აიძულებს გადატვირთონ */

საჯარო ლოგიკური blackOut () {…}

/ * ამოწმებს, დასრულდა თუ არა თამაში - როდესაც დაფა გაშავებულია და ვერცერთ ფილს არ შეუძლია გაერთიანება */

საჯარო ლოგიკური თამაში Over () {…}

/ * იძახება 'w' ან ზემოთ ისრის დაჭერისას - იძახება 'verticalMove' დაფაზე ყველა ფილაზე პარამეტრით 'up' */

საჯარო სიცარიელე () {…}

/ * იძახება 's' ან ქვემოთ ისრის დაჭერისას - იძახება 'verticalMove' დაფაზე ყველა ფილაზე პარამეტრით 'down' */public void down () {…}

/ * იძახება 'd' ან მარჯვენა ისრის დაჭერისას - იძახება 'horizontalMove' დაფაზე ყველა ფილაზე პარამეტრით 'right' */public void right () {…}

/ * იძახება 'a' ან მარცხენა ისრის დაჭერისას - იძახება 'horizontalMove' დაფაზე ყველა ფილაზე პარამეტრით 'left' */

საჯარო სიცარიელე დარჩა () {…}

/* ადარებს ორი კრამიტის მნიშვნელობას ერთად და თუ ისინი ერთნაირია თუ ერთი უდრის 0 -ს (უბრალო კრამიტი) - მათი მნიშვნელობები ემატება (იმ პირობით, რომ ფილები, რომლებსაც ჩვენ ვადარებთ, არის ორი განსხვავებული კრამიტი და ისინი მოძრაობენ შესაბამისი მიმართულებით) - რეკურსიულად მოძრაობს მწკრივში */

public void horizontalMove (int row, int col, სიმებიანი მიმართულება) {…}

/* ადარებს ორი კრამიტის მნიშვნელობას ერთად და თუ ისინი ერთნაირია თუ ერთი უდრის 0 -ს (უბრალო კრამიტი) - მათი მნიშვნელობები ემატება (იმ პირობით, რომ ჩვენ შედარების ფილები არის ორი განსხვავებული კრამიტი და ისინი მოძრაობენ შესაბამისი მიმართულებით) - რეკურსიულად გადადის სვეტში */

public void verticalMove (int row, int col, სიმებიანი მიმართულება) {…}

დიახ, ეს ბევრი მეთოდია - მაგრამ არ ინერვიულოთ, უმეტესობა ძალიან ადვილად გასაგებია. გარდა ამისა, "დაფის" კლასი არის ყველაზე რთული, ასე რომ ყველაფერი ამის შემდეგ იქნება შედარებით მარტივი.

ნაბიჯი 3: გაეცანით პროგრამას - კრამიტი

კრამიტი:

აღწერა: კრამიტის კლასი ეხება ცალკეულ ფილებს და არის ყველაზე პატარა ყველა კლასს შორის. თითოეულ ფილას აქვს მთელი მნიშვნელობა და ფერი. მას აქვს ორი კონსტრუქტორი, რომლებიც ქმნიან ფილებს 0 ღირებულებით (ნაგულისხმევი) ან #მნიშვნელობით. მეთოდები უმეტესად თვითგამოხსნილია, ხოლო „მიმღები“და „სეტერის“მეთოდები შეადგენს მთლიანი მასის დიდ ნაწილს.

კონსტრუქტორები:

/ * აშენებს ძირითად კრამიტს 0 * მნიშვნელობით/

საჯარო კრამიტი () {…}

/ * აშენებს კრამიტს ნომრის მნიშვნელობით */

საჯარო კრამიტი (int ნომერი) {…}

მეთოდები:

/ * იღებს კრამიტის მნიშვნელობას */

public int getValue () {…}

/ * ადგენს კრამიტის მნიშვნელობას - გამოიყენება ორი კრამიტის ერთად დამატებისას */

public void setValue (int value) {…}

/ * წარმოადგენს კრამიტს როგორც სიმებიანი - გამოიყენება GUI– ში */

public String toString () {…}

/ * ადგენს კრამიტის ფერს მისი ღირებულებიდან გამომდინარე */

public void setColor () {…}

/ * იღებს კრამიტის ფერს */

public void getColor () {…}

ნაბიჯი 4: გაიცანით პროგრამა - თამაში

თამაში

აღწერა: თამაშის კლასში არის ძირითადი მეთოდი, GUI მეთოდების უმეტესობა და ძირითადი ურთიერთქმედება. ის გადის როგორც კრამიტის, ასევე გამგეობის კლასებს და აძლევს მათ ერთად მუშაობის საშუალებას.

კონსტრუქტორები:

არცერთი

მეთოდები:

/ * ადგენს GUI- ს შესაბამისი ზომებით და ამატებს საკვანძო მსმენელს */

საჯარო სტატიკური სიცარიელე setUpGUI () {…}

/ * ამოწმებს, არის თუ არა დაჭერილი wasd ან ისრის ღილაკები და ასრულებს შესაბამის მოქმედებებს - განაახლებს JFrame ყოველ ნაბიჯს */

public void keyPressed (KeyEvent e) {…}

/ * ხატავს GUI– ს რიგი სიმებით, დაფით, ფილებით და უზრუნველყოფს მათ ხატვას თამაშის დასრულებისას */

საჯარო ბათილი საღებავი (გრაფიკა g) {…}

/ * ხატავს ინდივიდუალურ კრამიტს - ეწოდება საღებავის მეთოდით */

public void drawTiles (გრაფიკა g, Tile tile, int x, int y) {…}

/ * ძირითადი მეთოდი - აყენებს GUI- ს და იწყებს თამაშს */

საჯარო სტატიკური სიცარიელე მთავარი (სიმებიანი args) {…}

ნაბიჯი 5: მნიშვნელოვანი მეთოდები - მოძრაობა

მოძრაობის მეთოდები ყველაზე მნიშვნელოვანია გასაგები, მაგრამ კარგი ამბავია მას შემდეგ რაც გაიგებთ ვერტიკალურ მოძრაობებს, შეგიძლიათ ეს გაგება გამოიყენოთ ჰორიზონტალურ მოძრაობებზე. სინამდვილეში, სამი ვერტიკალური მოძრაობის მეთოდი ზუსტად იგივეა, რაც სამი ჰორიზონტალური მეთოდის მოძრაობა, გარდა იმისა, რომ ერთი მოძრაობს მწკრივზე და მეორე სვეტზე. ამ მიზეზით, მოდით გავამახვილოთ ყურადღება მხოლოდ ვერტიკალური მოძრაობის მეთოდებზე.

პირადი სიცარიელე verticalMove (int row, int col, სიმებიანი მიმართულება)

{კრამიტის საწყისი = დაფა [საზღვარი] [სვეტი]; კრამიტის შედარება = დაფა [რიგი] [სვეტი]; if (initial.getValue () == 0 || initial.getValue () == compare.getValue ()) {if (row> border || (direction.equals ("down") && (row <border))) {int addScore = initial.getValue () + compare.getValue (); if (initial.getValue ()! = 0) {ანგარიში += addScore; } initial.setValue (addScore); შეადარეთ. setValue (0); }} სხვა {if (direction.equals ("down")) {border--; } else {საზღვარი ++; } verticalMove (მწკრივი, სვეტი, მიმართულება); }}

ზემოაღნიშნულ მეთოდს verticalMove ეწოდება "ზემოთ" და "ქვემოთ" მეთოდებით. მოდით შევხედოთ "up" მეთოდს.

საზოგადოებრივი სიცარიელე ()

{for (int i = 0; i <ბადეები; i ++) {საზღვარი = 0; for (int j = 0; j <grids; j ++) {if (board [j] .getValue ()! = 0) {if (border <= j) {verticalMove (j, i, "up"); }}}}}

ეს მეთოდი გადის მთელ დაფაზე და მოუწოდებს verticalMove ყველა ფილაზე პარამეტრით "up". verticalMove შემდეგ ადარებს ფილას 'j' და 'i' კრამიტს პოზიციასთან 'საზღვარი' და 'i'. თუ ორივე ტოლია, ისინი გაერთიანებულია. თუ ისინი არ არიან, სასაზღვრო ფილა იზრდება 1 -ით (რადგან პარამეტრი ადგილზე არის „ზემოთ“) და verticalMove კვლავ იძახება.