Cum să faci un joc Pong - hyperPong

Notă: Un fișier de proiect complet pentru acest tutorial poate fi găsit la sfârșitul acestui articol.

Introducere

În acest tutorial, vom crea un joc asemănător Pong de la zero. Vom acoperi unele caracteristici și comportamente mai avansate în hyperPad, așa că acest tutorial presupune o cunoștință de bază cu editorul hyperPad. Dacă credeți că trebuie să vă familiarizați mai mult cu crearea unui joc de la zero, puteți verifica Ghidul Complet - Crearea unui Joc de Tip Platformă în primul rând.

Pong este un joc simplu pentru două persoane care constă doar din două palete și o minge și poate fi considerat o versiune digitală simplă a tenisului de masă. Fiecare jucător controlează o paletă, ambele pe părți opuse ale mesei. Paletele se pot mișca doar înainte și înapoi, lovind mingea către jucătorul advers. Dacă un jucător ratează mingea, celălalt jucător câștigă un punct. Primul jucător care ajunge la 11 puncte câștigă!

Pentru jocul nostru Pong, vom include opțiunea de a juca în modul 1 Jucător (Jucător vs. AI), modul 2 Jucători (Jucător vs. Jucător) sau modul 0 Jucători „Privire” (AI vs. AI).

Partea 1: Configurarea Proiectului și Meniul Principal

Să începem prin a crea un proiect nou.

Deschideți meniul Proiecte în hyperPad și atingeți Proiect Nou. Acordați-i un nume proiectului dvs. și atingeți Următor. Orientarea poate rămâne implicită în modul peisaj. Pentru acest tutorial, Suportul pentru Dispozitive este setat pe iPad 4:3. Pe următorul ecran, selectați "Vedere de Pasăre" și lăsați restul ca implicit.

Acum că avem un proiect nou gata de lucru, să începem rapid să configurăm un meniu principal înainte de a trece direct la jocul propriu-zis. Primul lucru pe care îl vom face este să redenumim scena noastră în "Meniu Principal".

Atingeți butonul Meniu Proiect/Scenă și atingeți butonul cu rotiță de unelte de lângă "Scena 1".

Atingeți opțiunea Setări și redenumiți scena noastră în "Meniu Principal". Atingeți Salvați pentru a salva și a închide fereastra de setări.

În continuare, pentru a rămâne tradiționali față de jocurile retro timpurii precum Pong-ul arcade, putem să facem culoarea fundalului neagră.

Atingeți butonul Setări Scenă și selectați Fundal. Atingeți butonul "Schimbați Culoarea" și setați-l pe negru (#000000FF).

Acum să adăugăm o etichetă de titlu la meniul nostru principal. Atingeți butonul Obiecte Speciale și selectați Etichetă.

Introduceți numele jocului dvs. în câmpul de text ("hyperPong" a fost introdus pentru acest tutorial), setați dimensiunea fontului pe ceva mare, dar nu prea mare. Pentru un titlu "hyperPong", 72 de puncte este o dimensiune bună. Schimbați culoarea în alb (#FFFFFFFF) și așezați-o în centrul meniului aproape de sus.

Acum avem o scenă de meniu principal pe care să o populăm cu butoane pentru toate modurile noastre de joc. Vom lăsa meniul așa cum este pentru moment, și îi vom termina după ce avem un joc jucabil.

Partea 2: Configurarea Scenei de Joc și Paleta

Atingeți butonul Meniu Proiect și atingeți "Adăugați Scenă". Numiți-o "Joc" și atingeți Creați. Acum, în scena Joc, ar trebui să vedeți o pânză goală. Așa cum am făcut cu scena Meniului Principal, mergeți și atingeți din nou butonul Setări Scenă și schimbați fundalul în negru (#000000FF).

Să ne apucăm de lucru la crearea paletelor noastre. Creați un obiect gol accesând butonul Obiecte Speciale și selectând "Obiect Gol". Schimbați culoarea în alb (#FFFFFFFF) și asigurați-vă că glisorul de opacitate este complet activat.

Renumiți obiectul în "Jucător-1" și setați modul său fizic pe Fizică, și lăsați Pasabil activat.

Motivul pentru care vom păstra Pasabil activat este pentru a avea un control mai bun asupra felului în care mingea va interacționa cu paleta atunci când o lovește. Vrem să fim capabili să controlăm viteza și direcția în care mingea merge manual.

În proprietățile obiectului Jucător-1, mergeți la tab-ul Transformare și setați scala X la 25% și mutați-l în partea stângă a terenului de joc.

În continuare, vom adăuga niște controale la paleta noastră pentru a putea să se miște. Cu paleta selectată, mergeți la editorul său de comportamente, revenind la tab-ul Fizică.

Plasați o comportare Joystick Analog, care se găsește sub secțiunea Interacțiune (dacă nu o găsiți, s-ar putea să fie nevoie să atingeți tab-ul Avansat). Aceasta va crea automat un joystick pentru dvs. în editorul de scenă.

Dar nu vrem să permitem doar paletei să se miște prin mișcarea joystick-ului. De asemenea, vrem ca un AI să poată efectua mișcări, de asemenea.

Sub secțiunea Personalizată, plasați un Containere Box. Acesta va stoca în ce direcție paleta se va mișca. În acest fel, atât un jucător controlând un joystick cât și un AI efectuând calcule pot să se miște prin schimbarea acestui singur valoare. Valoarea sa implicită ar trebui să fie setată la 0. Este o idee bună să-i dați un nume bun pentru a lucra mai ușor, "Direcția de Mișcare" pare potrivit.

Cu Containere Box selectat, apăsați butonul "Schimbați Câmpul de Intrare" și atingeți Da. Aceasta va crea un comportament Set Input Field pentru containerul box, astfel încât să putem schimba valoarea sa când avem nevoie. Conectați Set Input Field la Joystick Analog.

Cu comportamentul Set Input Field selectat, trageți valoarea de ieșire din Joystick Analog în câmpul Noua Valoare. Selectați proprietatea "y". Acum, box-ul Direcția de Mișcare va urmări cât de mult se mișcă jucătorul joystick-ul în sus sau în jos (axa y).

Acum că urmărim cât de mult se mișcă joystick-ul în sus sau în jos, trebuie să îl resetăm la zero dacă jucătorul cedează joystick-ul. Altfel, paleta va continua să se miște în direcția în care își amintește ultima dată.

Sub secțiunea Interacțiune, adăugați un comportament Stopped Touching și atingeți-l pentru a deschide proprietățile sale. În mod implicit, urmărește atunci când jucătorul încetează să atingă paleta, dar vrem să urmărim atunci când jucătorul încetează să atingă joystick-ul.

Atingeți proprietatea obiectului pentru a o schimba și selectați joystick-ul. Este posibil să fie nevoie să selectați stratul UI Global pentru a putea alege una. Când a fost selectat, atingeți butonul de verificare. Comportamentul ar trebui acum să arate joystick-ul ca obiectul urmărit.

Atingeți Set Input Field pe care l-am făcut anterior și duplează-l. Cu Set Input Field duplicat, conectați-l la comportamentul Stopped Touching și setați proprietatea sa Noua Valoare la 0.

Acum variabila box-ului Direcția de Mișcare va urmări mișcările în sus și în jos ale joystick-ului și se va reinițializa la 0 când joystick-ul este eliberat. Acesta ne oferă un mod excelent de a spune paletei noastre cum să se miște, așa că să continuăm și să dăm paletei noastre puțină mișcare.

Sub secțiunea Personalizată, plasați un comportament Timer. În proprietățile sale, setați intervalul la 0. Acest timer se va executa cât mai des posibil (odată pe cadru), ceea ce ne oferă ocazia de a actualiza mișcarea paletei foarte frecvent.

Înainte de a seta viteza paletei, vrem să ne asigurăm că valoarea pentru containerul Direcție de Mișcare este limitată într-un interval rezonabil, în caz că devine prea mare sau prea mic. Altfel, paleta noastră se va mișca prea repede în unele cazuri.

Sub secțiunea Logică, plasați un comportament Minim și un comportament Maxim. Conectați comportamentul Minim la timer și comportamentul Maxim la Minim. Ar trebui să arate ceva de genul acesta:

În proprietățile comportamentului Minim, setați prima valoare la valoarea de ieșire a comportamentului Direcție de Mișcare și setați a doua valoare la 1.

Comportamentul Minim va oferi cea mai mică valoare primită. Deci, dacă valoarea Direcție de Mișcare devine mai mare decât 1, va ieși 1. Altfel, va oferi pur și simplu valoarea Direcție de Mișcare.

În proprietățile comportamentului Maxim, setați prima valoare la rezultatul lui Minim și setați a doua valoare la -1.

Comportamentul Maxim va oferi cea mai mare valoare primită. Deci, dacă valoarea Direcție de Mișcare devine mai mică decât -1, va ieși -1. Altfel, va oferi valoarea lui Minim (care este fie 1, fie Direcția de Mișcare, care oricum este mai mică).

Ce înseamnă tot acesta este că valoarea rezultată a lui Maxim este efectiv valoarea lui Direcție de Mișcare limitată între -1 și +1. Acest lucru ne oferă control total asupra cât de repede poate să se miște paleta!

Un interval de la -1 la +1 este ușor de gestionat, dar va fi prea lent dacă folosim acesta direct ca viteză a paletei.

Sub secțiunea Logică din nou, plasați un comportament Înmulțiți Valoarea și conectați-l la comportamentul Maxim. La prima valoare, setați-o pe rezultatul ieșirii comportamentului Maxim. La a doua valoare, o putem seta pe o bună valoare "maximală de viteză".

Deocamdată, setați-o la 20. Dacă credeți că mai târziu că paleta se mișcă prea încet sau prea repede, pur și simplu puteți seta acest număr la o valoare mai mare sau mai mică.

Comportamentul Înmulțiți Valoarea ne oferă acum un bun interval de viteză de lucru, de la -20 la +20.

Acum este un moment bun să setăm viteza paletei. Sub secțiunea Fizică, adăugați un comportament Setează Viteza și conectați-l la comportamentul Înmulțiți Valoarea. Setați câmpul "x" la 0 și câmpul "y" la rezultatul ieșirii comportamentului Înmulțiți Valoarea.

Încercați! Când jucați jocul, paleta ar trebui să se miște în timp ce mișcați joystick-ul în sus și în jos.

Așa cum ați probabil observat în timpul testării, nimic nu oprește paleta să părăsească ecranul. În următoarea parte, vom adăuga câteva limite pentru a păstra totul în vedere.

Partea 3: Limite de Joc

Înainte de a continua, să folosim puțină previziune și să luăm în considerare un bun design de joc. Paleta jucătorului nu va fi în centrul ecranului, ci mai aproape de margini pe măsură ce ne adunăm jocul. Acest lucru va deveni o problemă, deoarece avem elemente UI (de exemplu, joystick-uri) care se vor suprapune cu elementele noastre de joc (de exemplu, paletele).

În loc să folosim întregul ecran ca zonă jucabilă, ar trebui să înseriem limitele astfel încât paleta noastră să nu meargă sub joystick, unde degetele noastre sunt, unde nu putem să o vedem ușor. În acest fel, nu vom pierde din vedere paleta noastră aproape de partea de jos a zonei jucabile. Putem, de asemenea, să folosim această inserție ca o limită strictă pentru a menține obiectele noastre în câmpul jucabil.

Atingeți butonul Obiecte Speciale și creați un nou Obiect Gol. Atingeți noul obiect gol pentru a deschide proprietățile sale.

Mențineți modul său fizic setat pe Perete, și dezactivați Pasabil. Setați culoarea pentru a o putea vedea vizual, un gri închis opac (#1F1F1FFF) se potrivește frumos. Setați frecarea la 0% și sărăcia la 100%.

Acum, în tab-ul Transformare al peretelui, setați scala Y la 200% și mutați-l în partea de sus a zonei de ecran. Acum întindeți-l pentru a se potrivi întreaga lățime a zonei de ecran. Puteți activa, de asemenea, modul de aliniere la grilă pentru a vă ajuta să îl așezați precis.

Acum duplicați peretele și deplasați copia la partea de jos.

Duplicați din nou și setați scala X la 200% în schimb. Apoi întindeți înălțimea pentru a se potrivi cu ecranul și puneți-l la stânga ecranului.

Și din nou, duplicați peretele vertical și mutați-l la dreapta ecranului. Ar trebui să aveți acum un câmp de joc complet închis:

Când jucați acum jocul, probabil că veți observa imediat că puteți trece prin pereți ca și cum nu ar fi acolo. Acest lucru se datorează a două motive; am setat paleta să fie "Pasabilă" și forțăm viteza paletei în fiecare cadru. Acest lucru este în regulă, va trebui doar să implementăm un mod de a opri paleta să se miște în perete.

Ce vom facepentru a implementa acel comportament este să verificăm poziția jucătorului față de poziția peretelui. Dacă acesta este adevărat, atunci vom muta jucătorul înapoi în câmpul jucabil.

Pentru a face acest proces puțin mai ușor de implementat, atingeți peretele superior și schimbați punctul de ancorare Y la 0%. Acesta va ancora poziția peretelui la partea de jos a acestuia. Este posibil să fie nevoie să deblocați câmpurile de ancorare apăsând pe pictograma de blocare.

Similar cu peretele de jos, schimbați punctul de ancorare Y al pereților inferior la 100% de această dată. Acesta va ancora poziția peretelui de jos la partea de sus a acestuia.

Acum suntem pregătiți să implementăm comportamentele de verificare a limitelor. Atingeți paleta și deschideți editorul ei de comportamente.

Începând cu plasarea unui Obțineți Pachet Comportamental din secțiunea Logică. Ar trebui să fie setat să utilizeze paleta în mod implicit. Acest comportament ne va oferi coordonatele de jos/stânga și dimensiunea paletei.

Următoare, plasați un Adăugați Valori sub secțiunea Logică și conectați-l la comportamentul Obțineți Pachet Comportamental. În proprietățile Adăugați Valori, setați prima valoare pe rezultatul Obțineți Pachet Comportamental "y" și a doua valoare pe rezultatul "height".

Rezultatul acestei adunări va fi poziția de sus a paletei noastre. Pentru lizibilitate, puteți redenumi comportamentul într-un mod util, cum ar fi "Adăugați Valori - Sus Paletă", pentru a vedea clar ce realizează.

Acum vom verifica dacă paleta se mișcă înspre pereții superior sau inferior. Sub secțiunea Transformare, plasați două Obțineți Comportamente de Poziție pe care le conectați la comportamentul Adăugați Valori în paralel.

Setați primul comportament Obțineți Poziție pentru a urmări peretele de jos și setați al doilea Obțineți Comportare pentru a urmări peretele superior. De asemenea, puteți redenumi aceste comportamente pentru o mai bună lizibilitate. Ar trebui să arate acum asemănător cu asta:

Pentru fiecare comportament Obțineți Poziție, lăsați și conectați un Subtrați Valori din secțiunea Logică.

În proprietățile Subtrați Valori conectate la Obțineți Poziția pentru peretele inferior, setați prima valoare la rezultatul Obțineți Poziția pentru Peretele de Jos "position_y". Apoi, setați a doua valoare la Obțineți Pachet Comportamental "y".

Acum pentru proprietățile din celelalte subtracții de valori care sunt conectate la Obțineți Poziția pentru peretele superior, setați prima valoare la Obțineți Poziție pentru Peretele Superior "position_y". Apoi, setați a doua valoare la Adăugați Valori - Sus rezultat.

Aceste subtracții ne vor spune cât de mult trebuie să "împingem" paleta înapoi pentru a o menține în câmpul de joc. Acum trebuie doar să verificăm dacă trebuie să facem sau nu.

Sub secțiunea logică, plasați și conectați un comportament Dacă pentru fiecare ramură de comportament.

Pentru comportamentul Dacă conectat la ramura Perete Inferior, setați prima valoare la rezultatul comportamentului Subtrageți Valori conectat. Setați condiția la > ("Este Mai Mare Decât") și a doua valoare la 0.

Pentru comportamentul Dacă conectat la ramura Perete Superior, setați prima valoare la rezultatul comportamentului Subtrați Valori conectat. Setați condiția la < ("Este Mai Mic Decât") și a doua valoare la 0.

Ambele declarații If vor continua execuția dacă paleta depășește fiecare perete respectiv.

Dacă paleta depășește un perete, dorim să o oprim forțat din a se mișca mai departe resetând viteza paletei la 0, și apoi să o împingem înapoi în câmp.

Sub secțiunea Fizică, plasați și conectați un Setează Viteza pentru fiecare ramură. Pe ambele, setați valorile Viteza X/Y la 0.

Acum putem împinge paleta înapoi în joc. Sub secțiunea Transformare, plasați un Muvează Prin comportamente pentru fiecare ramură.

În fiecare comportament Muvează Prin, lăsați valorile Muvează Prin X la 0 și setați valorile Muvează Prin Y la rezultatul în comportamentele Subtrați Valori în ramurile lor respective. Apoi setați lungimea duratei la 0 secunde (instantaneu).

Întreaga această secțiune, atunci când este executată, va verifica acum dacă paleta este în interiorul unui perete, cât de departe este, și să o împingă afară, dacă e nevoie. Acum trebuie doar să executăm această lanț de comportamente atunci când paleta se mișcă.

Pentru simplitate, în partea de sus a acestui lanț de comportamente, adăugați un Pachet de Comportamente din secțiunea Personalizată și conectați-l deasupra Obțineți Pachet Comportamental. Puteți redenumi acest lucru într-un mod util, cum ar fi "Verifică Limitele".

Notă:"Pachetul de Comportamente" nu face nimic în sine și este folosit aici doar pentru a marca un "punct de început" pentru a verifica dacă paleta este în afara limitelor.

Apoi, sub secțiunea Personalizată, plasați un Comportament Executare. În proprietățile sale, atingeți câmpul "Selectați Comportamentul" și alegeți comportamentul "Verifică Limitele" pe care tocmai l-am creat. Acum mutați comportamentul Executare sub locul unde am setat original viteza paletei pentru mișcarea paletei. Conectați comportamentul Executare la Setează Viteza comportamentul din lanțul original de mișcare al paletei.

Acum, de fiecare dată când paleta își actualizează viteza de mișcare, comportamentul Executare va "sări" execuția la noul nostru lanț de comportamente Verifică Limitele, unde va verifica dacă paleta a ieșit din limite!

Testați și observați cum funcționează!

Un ultim lucru de făcut acum înainte de a merge mai departe, haideți să mutăm paleta în stânga câmpului.

Acum că avem ceva spațiu, să construim o minge!

Partea 4: Crearea Mingii

Înapoi în editorul de scenă, creați un obiect gol. Setați modul său fizic la Fizică și dezactivați Pasabil, astfel încât mingea să se poată mișca și să se ciocnească fizic cu pereții limitei. Setați frecarea la 0% și sărăcia la 100%. Setați culoarea în alb (#FFFFFFFF). Pentru simplitate, puteți redenumi și acest obiect în "Minge".

În tab-ul de transformare, setați scala la X=25% și Y=25%, și poziția la X=50% și Y=50%.

În continuare, deschideți editorul de comportamente pentru minge și îi vom da puțină mișcare. Sub secțiunea Personalizată, plasați un comportament Întârziați și setați-l la 3 secunde.

Apoi, plasați un comportament Număr Aleatoriu din secțiunea Logică și conectați-l la comportarea Întârziați. Pentru prima valoare puneți -1.0 și pentru a doua valoare puneți 1.0. Asigurați-vă că includeți „.0”, astfel încât să aleagă aleatoriu un număr între -1.0 și 1.0 incluzând zecimale, altfel va alege doar întregi. Acesta va servi ca direcția aleatoare de „servire” atunci când mingea este lansată prima dată.

În continuare, plasați și conectați un comportament Aplică Forță din tab-ul Fizică. Setați Forța X=-1 și setați Forța Y la rezultatul comportamentului Număr Aleatoriu. Aceasta va servi ca direcția în care mingea se va mișca, dar 1 newton nu este o forță mare, așa că ar trebui să schimbăm și multiplierul. Setați multiplierul la 150 și testați jocul pentru a vedea dacă este prea rapid sau prea lent. Dacă da, puteți schimba acest multiplier după preferințe. Mingea ar trebui să înceapă să se miște după 3 secunde când jucați, ca și cum a fost servită.

Când testați, mingea ar trebui să sară în jurul pereților, dar să treacă prin paletă. Asta este normal, deoarece încă nu am implementat comportamentele de coliziune ale paletei pe minge. Ați putea observa, de asemenea, că mingea poate începe uneori să se rotească, ceea ce nu vrem să se întâmple, așa că să rezolvăm asta.

Înapoi în editorul comportamentului mingii, plasați un comportament Blocați Rotția sub secțiunea Transformare și testați din nou. Acum, mingea nu se va roti afară de control.

Înainte de a începe să adăugăm comportamente pentru a se ciocni cu paleta, întoarceți-vă în editorul de scenă și atingeți paleta și în proprietățile paletei mergeți la tab-ul etichete. În câmpul de text, tastați "Paletă" și apăsați butonul + pentru a adăuga eticheta la paletă.

Acum întoarceți-vă în editorul de comportamente al mingii. Sub secțiunea Obiect, plasați un comportament Coliziune. În proprietățile acelui comportament, atingeți tab-ul Etichete și selectați eticheta Paletă pe care am creat-o. Acum, de fiecare dată când mingea lovește orice obiect cu eticheta "Paletă", acest eveniment se va executa.

Ce vrem să facem este să luăm viteza curentă a mingii și să-i inversăm viteza pe axa X. Astfel, dacă mingea se mișca spre stânga, va începe să se miște spre dreapta, și viceversa. Vrem să facem, de asemenea, mingea puțin mai repede decât înainte, pentru a face ca runda să devină mai rapidă.

Conectat la comportamentul Coliziune, plasați un comportament Obțineți Viteza din secțiunea Fizică. Apoi, conectați un comportament Înmulțiți Valori din tab-ul Logic. Setați prima valoare pe rezultatul "velocity_x" din Obțineți Viteza. La a doua valoare, setați valoarea la -1.03. Rezultatul acestui comportament de valori multiplicate va fi viteza negativă pe axa X a mingii, precum și o creștere de 3% a vitezei. Așa că să aplicăm această schimbare în continuare.

Conectat la comportamentul Înmulțiți Valori, plasați un comportament Setează Viteza din secțiunea Fizică. Setați viteza sa X la rezultatul Înmulțiți Valori și lăsați viteza sa Y la viteza curentă.

Acum, când jucați, mingea ar trebui acum să sare, să lovească paleta și să inverseze direcția cu o mică, aproape imperceptibilă creștere a vitezei.

Totul începe să se contureze acum! Mingea și paleta se mișcă bine, dar direcția din care mingea este servită nu se schimbă. Când mingea lovește o paletă ar trebui să schimbe direcția mingii, de asemenea; dacă mingea lovește mai aproape de partea de sus a paletei, atunci ar trebui să se ridice, iar dacă mingea lovește mai aproape de partea de jos a paletei, atunci ar trebui să se coboare. Acest lucru va adăuga un strat de complexitate, precum și abilități, deoarece jucătorul(s) vor avea un control asupra locului unde va merge mingea.

Pentru a afla cât de puternic ar trebui să servim mingea, va trebui să obținem diferența de poziție între mingea și paletă. Sub secțiunea Transformare, plasați două Obțineți Poziție și conectați-le în serie sub comportamentul Setează Viteza. Prima Obțineți Poziție va continua să urmărească Mingea în mod implicit. Schimbați a doua Obțineți Poziție în output-ul "ObjectB_ID" din comportamentul de Coliziune.

Notă:"ObjectB" în acest caz ar fi paleta care se ciocnește, deoarece este al doilea obiect legat de evenimentul de coliziune, în vreme ce primul obiect ("ObjectA") ar fi mingea.

Plasați și conectați un comportament Subtrageți Valori din secțiunea Logică. Setați prima valoare pe rezultatul "position_y" al primei Obțineți Poziție care urmărește mingea. Setați a doua valoare pe rezultatul "position_y" al celei de-a doua Obțineți Poziție care urmărește paleta care se ciocnește.

În continuare, plasați și conectați un comportament Aplică Forță din secțiunea Fizică. Setați valorile forței X la 0 și Y la rezultatul comportamentului Subtrageți Valori. Diferența de poziție în sine nu va fi foarte puternică, așa că va trebui să modificăm și multiplierul. Încercați un multiplier de 50 și verificați cum se simte în joc.

În timpul testării, mingea ar trebui să își schimbe direcția în funcție de locul în care loviți mingea pe paleta dvs. Mingea ar trebui să se ridice mai sus dacă lovește aproape de vârful paletei și ar trebui să coboare dacă lovește aproape de fundul paletei. Dacă mingea dvs. se servește în direcția greșită, încercați să schimbați valorile în comportamentul Subtrați Valori și acest lucru ar trebui să rezolve problema.

Suntem aproape de implementarea completă a mișcării mingii! Există încă o problemă minoră; nu există limită pentru cât de repede poate merge mingea! De fapt, după ce ați jucat o vreme fără a reseta, mingea poate merge atât de repede încât efectiv poate trece prin obiecte. Ar trebui să implementăm o limită asupra vitezei mingii astfel încât să nu ajungă la această viteză extrem de rapidă.

După comportamentul Aplică Forță, plasați și conectați un comportament Obțineți Viteza din secțiunea Fizică pentru a obține noua viteză a mingii. Sub aceasta, plasați și conectați un comportament Maxim și un comportament Minim în serie din secțiunea Logică.

În proprietățile lui Maxim, setați prima valoare pe rezultatul "velocity_x" din Obțineți Viteza, apoi setați a doua valoare la -25. Aceasta va rezulta în ceea ce este mai mare dintre aceste valori.

În proprietățile lui Minim, setați prima valoare pe rezultatul Maxim și a doua valoare la 25. Aceasta va rezulta în ceea ce este mai mic, oferind efectiv o valoare limitată a vitezei mingii pe axa X între -25 și 25. Nimic mai sus și nimic mai jos!

Apoi trebuie să facem la fel pentru viteza pe axa Y a mingii. Plasați și conectați un nou set de comportamente Maxim și Minim în serie. În noile proprietăți ale lui Maxim, setați prima valoare pe rezultatul "velocity_y" din Obțineți Viteza, și apoi setați a doua valoare la -10.

În noile proprietăți ale lui Minim, setați prima valoare pe rezultatul noului Maxim și a doua valoare la 10. Aceasta va rezultă în o viteză limitată pe axa Y între -10 și 10. Simțiți-vă liber să schimbați aceste valori mai târziu dacă preferați!

Acum, când avem valorile limitate ale vitezei mingii, să le aplicăm acum. Plasați și conectați un comportament Setează Viteza din tab-ul Fizică. În proprietățile sale, setați viteza X la rezultatul primului Minim care limitează viteza pe axa X, apoi setați viteza Y la rezultatul celui de-al doilea Minim care limitează viteza pe axa Y.

Acum, indiferent cât de mult durează un meci, mingea nu va ajunge la viteze extreme. Viteza pe axa Y este, de asemenea, limitată astfel încât mingea să nu se servească prea mult.

Partea 5: Inteligența Artificială a Paletei

Deși ar fi în regulă să duplicăm paleta și să creăm o a doua paletă jucabilă, nu ar fi mai cool să avem opțiunea de a lupta împotriva unui AI în loc de 2 jucători? Sigur că ar fi! În această parte, ne vom uita la oferirea paletei AI și la oferirea utilizatorului opțiunea de a juca fie în modul 2-jucători, fie împotriva unui AI.

Folosind sistemul pe care l-am setat pentru mișcarea jucătorului - adică modificând containerul Direcție de Mișcare - implementarea unui AI este destul de simplă. În loc să folosească un joystick, paleta își va schimba Direcția de Mișcare în funcție de faptul dacă mingea se află deasupra sau dedesubtul ei.

De asemenea, vom adăuga puțină entropie și Direcția de Mișcare, sau cu alte cuvinte, un pic de randomizare. Facând acest lucru, vom da un pic de caracteristica umană AI-ului. AI-ul nu va părea atât de robotic și nu va juca jocul perfect.

Iată cum vom defini AI-ul nostru:

• AI-ul se va mișca doar dacă mingea vine către el.
• Direcția de Mișcare este pur și simplu diferența dintre mingea și paleta pe axa Y (verticală), plus un pic de entropie.
• De fiecare dată când mingea lovește ceva (o paletă, un perete, sau altceva), entropia paletei AI se va schimba.
• Entropia se bazează pe viteza mingii; cu cât mingea se mișcă mai repede, cu atât valoarea entropiei va fi mai mare și, prin urmare, cu atât mai inexactă va fi paleta.

Sounnds simplu, să ne apucăm de lucru.

Atingeți paleta și intrați în editorul său de comportamente. Găsiți un loc gol și plasați un nou comportament Timer din secțiunea Personalizată. Setați timer-ul la 0 secunde. Pentru lizibilitate, puteți schimba numele în ceva util precum "AI Gândire".

Notă: Dacă primiți un mesaj aici sau în viitor despre prea multe temporizări cu 0 secunde, îl puteți ignora. Nu vom avea prea multe în proiectul nostru.

În primul rând, dorim să setăm Direcția de Mișcare pe 0, astfel încât paleta să se oprească din mișcare când nu ar trebui să se miște deloc. Atingeți comportamentul Direcția de Mișcare pe care l-am realizat în Partea 2, și atingeți butonul Schimbați Câmpul de Intrare pentru a crea un nou comportament Setează Câmpul de Intrare. Conectați comportamentul Setează Câmpul de Intrare la Timer-ul AI Think și setați proprietatea sa nouă Valoare la 0.

Sub secțiunea Transformare, plasați două comportamente Obțineți Poziție și conectați-le în serie în execuția a doua a Timer-ului AI Think. Setați una să urmărească Mingea, iar cealaltă să urmărească paleta. Pentru a îmbunătăți lizibilitatea, puteți redenumi aceste comportamente, de asemenea. Ar trebui să arate acum așa:

Astfel, valoarea Direcției de Mișcare este setată pe 0 mai întâi, înainte de a continua la comportamentele restul AI-ului.

Următorul, plasați și conectați un comportament Obțineți Viteza din secțiunea Fizică și urmăriți Mingea. Cu aceste trei comportamente, avem toate datele de care avem nevoie pentru a verifica dacă mingea vine spre paleta.

Plasați un comportament Dacă din secțiunea Logică și conectați-l. Setați prima valoare la rezultatul "position_x" din comportamentul Obțineți Poziție pentru paletă. Setați condiția la "Este Mai Mic Decât" (<) și setați a doua valoare la rezultatul "position_x" din comportamentul Obțineți Poziție pentru mingea.

Dacă această condiție este adevărată, înseamnă că paleta se află la stânga mingii. Cu alte cuvinte, mingea se află la dreapta paletei.

De asemenea, avem nevoie unei ramuri pentru când mingea este la dreapta paletei. Plasați și conectați un nou comportament Dacă pe partea dreaptă a comportamentului Dacă. Aceasta va transforma în comportament Else If și se va executa dacă primul comportament Dacă este fals. Proprietățile sale pot rămâne așa cum sunt.

Acum că avem două ramuri pentru fie mingea este la stânga fie la dreapta paletei, trebuie să verificăm dacă mingea se mișcă spre paletă.

Plasați un alt comportament Dacă și conectați-l la prima ramură. Setați prima valoare la rezultatul "velocity_x" din comportamentul Obțineți Viteza pentru mingea. Setați condiția la "Este Mai Mic Decât" (<) și setați a doua valoare la 0. Acest comportament va fi adevărat dacă mingea se îndreaptă spre stânga, care este exact ceea ce dorim, deoarece comportamentul Dacă dinainte este adevărat atunci când mingea este la dreapta paletei! Deci, mingea trebuie să vină spre paletă.

Acum trebuie să facem același lucru pentru ramura