Mai întâi creați blocurile. Pentru a face acest lucru, folosim un cub simplu cu culori diferite (am luat 4 culori) și am setat cuburile scalate la (0,8, 0,8, 0,8).
Apoi creați un script C #, numiți Match3
Ce trebuie să facem:
1) Generarea câmpului de joc (tablă).
2) Selectarea a două blocuri.
3) Verificați dacă sunt aproape.
4) Schimbul de poziții și date.
5) Compararea blocurilor.
6) Distrugerea și distrugerea obiectelor.
200? '200px': '' + (this.scrollHeight + 5) + 'px'); ">
// Consiliul
public int # 91;,] bord;
// blocuri
blocul public de transformare # 91;];
void Start (# 41;<
blocuri = nou int # 91; 10,10];
// generarea consiliului
GenBoard (# 41 ;;
>
void GenBoard (# 41;<
// 10x10 = 100blocuri
pentru (int x = 0; x
// blocuri spawn
Transformarea obj = (Transform # 41; instantierea (bloc # 91; randomNumber] .transform, noi Vector3 (x, y, 0 # 41;, Quaternion.identity # 41; ca Transformare;
// atribuie părinte
obj.parent = transform;
// atribuiți un nume
obj.name = "Blocul # 91; X:" + x + "Y:" + y + "] ID:" + randomNumber;
/ / setați ID-ul pe placă în această poziție
bord # 91; x, y] = randomNumber;
>
>
>
Transmitem fiecare bloc pe tablă și obținem un număr aleatoriu pentru acesta (aceasta va fi culoarea). Creste blocul.
Nu uitați să alocați fiecare prefab la fiecare bloc din matricea bloc.
Acum creați un script nou. Să numim Bloc. Atribuiți acest script fiecărui bloc nou creat. Adăugați unele variabile pentru poziție și ID, vom avea nevoie de ele mai târziu.
200? '200px': '' + (this.scrollHeight + 5) + 'px'); ">
// blochează pozițiile
public ID int;
public int x;
public int.
privat Vector3 myScale;
private float startTime;
statică publică Transformați selectați;
statică publică Transformare movTo;
void Start (# 41;<
myScale = transform.localScale;
startTime = Time.time;
>
Acum trebuie să adăugați acest script la fiecare bloc, să atribuiți o poziție și un ID. În scriptul Match3, adăugați funcția GenBoard
200? '200px': '' + (this.scrollHeight + 5) + 'px'); ">
// Atașați scriptul la fiecare bloc
Blochează b = obj.gameObject.AddComponent
// atribuiți variabilele
b.x = x;
b.y = y;
b.ID = randomNumber;
Selectarea a două blocuri.
Pentru a selecta două blocuri, trebuie să verificăm dacă playerul a apăsat butonul stâng al mouse-ului. Apoi trebuie să verificați blocul pe care este activ cursorul.
În scriptul bloc, putem folosi funcția OnMouseOver, care se numește atunci când cursorul se află peste bloc.
Apoi, dacă nu este selectat nimic și playerul apasă butonul din stânga, selectați acest bloc. Și dacă acest bloc este deja selectat - selectați-l din nou.
Pentru aceasta trebuie să definim două variabile statice.
200? '200px': '' + (this.scrollHeight + 5) + 'px'); ">
statică publică Transformați selectați;
statică publică Transformare movTo;
void OnMouseExit (# 41;<
// resetați cântarele blocului
transform.localScale = MyScale;
>
Verificați blocurile din apropiere
Pentru a verifica dacă blocurile sunt una lângă alta, trebuie să știți pozițiile lor.
Utilizați bloc.select pentru a accesa o variabilă statică. Obținem transformarea blocului selectat.
În scriptul Match3, în funcția Actualizare, trebuie să verificăm dacă sunt selectate două blocuri. Dacă este cazul, trebuie să apelați funcția CheckIfNear, care returnează true sau false.
200? '200px': '' + (this.scrollHeight + 5) + 'px'); ">
void Update (# 41;<
dacă (Block.select Block.moveTo # 41; // Verificați dacă sunt aproape
dacă (CheckIfNear (# 41; == true # 41;
200? '200px': '' + (this.scrollHeight + 5) + 'px'); ">
bool CheckIfNear (# 41;<
Blocare sel = Block.select.gameObject.GetComponent
Blocare mov = Block.moveTo.gameObject.GetComponent
// Verificați lângă mine
dacă (sel.x-1 == mov.x sel.y == mov.y # 41;<
// Stânga
return true;
>
dacă (sel.x + 1 == mov.x sel.y == mov.y # 41;<
Bine
return true;
>
dacă (sel.x == mov.x sel.y + 1 == mov.y # 41;<
// Sus
return true;
>
dacă (sel.x == mov.x sel.y-1 == mov.y # 41;<
// Jos
return true;
>
Debug.Log ("Ce încerci să selectezi?" # 41 ;;
return false;
>
Schimbul de schimb și schimbarea poziției
Pentru a face acest lucru, avem din nou nevoie de acces la componenta Block a blocului selectat și de a schimba variabilele sale.
200? '200px': '' + (this.scrollHeight + 5) + 'px'); ">
void Swap (# 41;<
Blocare sel = Block.select.gameObject.GetComponent
Blocare mov = Block.moveTo.gameObject.GetComponent
Vector3 tempPos = sel.transform.position;
int tempX = sel.x;
int tempY = sel.y;
Schimbul de funcții
sel.transform.position = mov.transform.position;
mov.transform.position = tempPos;
// Schimbul de date
sel.x = mov.x;
sel.y = mov.y;
mov.x = tempX;
mov.y = tempY;
// Schimbați ID-ul pe tablă
bord # 91; sel.x, sel.y] = sel.ID;
bord # 91; mov.x, mov.y] = mov.ID;
Verificați pentru comparație este după cum urmează.
Știm blocul evidențiat. Care, de exemplu, este negru. Știm poziția blocului (avem acces la o variabilă statică). Dar nu știm, așa că este vorba dacă există 3 aceleași blocuri lângă cel selectat.
Pentru a afla, noi:
1) Din poziția blocului selectat, mergeți la dreapta.
2) Dacă acest bloc are aceeași culoare ca cel selectat, mergeți din nou în dreapta și rețineți că am găsit blocul +1.
3) Dacă culoarea blocului este diferită de cea selectată, opriți, nu mai mergem spre dreapta.
Aproape la fel cu alte direcții, cu excepția faptului că în acest caz începem să verificăm nu din poziția blocului alocat. Începem să numărăm din poziția în fața blocului selectat. Nu vrem să verificăm aceeași unitate de două ori.
Același principiu pentru direcțiile superioare și inferioare.
După aceasta, trebuie să verificăm dacă avem un număr de blocuri identice. Dacă countL + countR => 3, distrugem blocurile și le marchem ca goale.
200? '200px': '' + (this.scrollHeight + 5) + 'px'); ">
bool CheckMatch (# 41;<
// accesați toate blocurile din scenă
Blocare # 91;] allb = FindObjectsOfType (typeof (Bloc # 41; # 41; ca Bloc # 91;];
Blocare sel = Block.select.gameObject.GetComponent
int countU = 0; // contracție
int countD = 0; // contra-jos
int countL = 0; // contra stânga
int countR = 0; // contra drept
// Sus
pentru (int u = sel.y; u
countU ++;
>
// Verificați dacă există un rând de trei blocuri
dacă (countL + countR> = 3 || countD + countU> = 3 # 41;<
dacă (countL + countR> = 3 # 41;<
// distrugeți și marcați blocurile goale
pentru (int cl = 0; cl<=countL; cl++)<
foreach (Blocul b in allb # 41;<
dacă (b.x == sel.x-cl b.y == sel.y # 41;<
Distruge (b.gameObject # 41 ;;
bord # 91; b.x, b.y] = 500; // marcați blocul gol
>
>
>
pentru (int cr = 0; cr
dacă (b.x == sel.x + cr b.y == sel.y # 41;<
Distruge (b.gameObject # 41 ;;
bord # 91; b.x, b.y] = 500;
>
>
>
>
dacă (countD + countU> = 3 # 41;<
pentru (int cd = 0; cd<=countD; cd++)<
foreach (blocați blc în allb # 41;<
dacă (blc.x == sel.x blc.y == sel.y - cd # 41;<
bord # 91; blc.x, blc.y] = 500;
Distruge (blc.gameObject # 41 ;;
>
>
>
pentru (int cu = 0; cu
dacă (blc.x == sel.x blc.y == sel.y + cu # 41;<
bord # 91; blc.x, blc.y] = 500;
Distruge (blc.gameObject # 41 ;;
>
>
>
>
Respawn (# 41;
return true;
Acum putem crea noi blocuri pe pozițiile marcate ale câmpului. Aproape același lucru am făcut și în funcția GenBoard
200? '200px': '' + (this.scrollHeight + 5) + 'px'); ">
void Respawn (# 41;<
pentru (int x = 0; x
Transformatei obj = (Transform # 41; instanțiați (blocuri # 91; randomNumber] .transform, noi Vector3 (x, y, 0 # 41;, Quaternion.identity # 41 ;;
obj.parent = transform;
Blochează b = obj.gameObject.AddComponent
// atribuiți variabilele
b.ID = randomNumber;
b.x = x;
b.y = y;
// atribuiți ID plăcii o nouă valoare
bord # 91; x, y] = randomNumber;
>
>
>
>
Și, deja în funcția Actualizare
200? '200px': '' + (this.scrollHeight + 5) + 'px'); ">
void Update (# 41;<
dacă (Block.select Block.moveTo # 41; // Verificați dacă sunt aproape
dacă (CheckIfNear (# 41; == true # 41;<
// Aproape
Schimbați (# 41;; // Schimbați poziția și datele acestora
// Verificați pentru meci3
dacă (CheckMatch (# 41; == true # 41;<
// Există un meci
Block.select = null;
Block.moveTo = null;
>
altfel<
// Nu există nici o potrivire, returnați-le în poziția lor implicită
Schimbați (# 41 ;;
Block.select = null;
Block.moveTo = null;
>
>
altfel<
// Nu în apropiere
Block.select = null;
Block.moveTo = null;
// Putem selecta din nou blocuri noi
>
>
>