Unity3D脚本：Unity制作连连看脚本

Unity3D教程：Unity制作连连看教程

GameManager.cs 游戏的核心代码，产生图片，判断是否可以销毁等。

[color=#008ef1][font=宋体]using UnityEngine;[/font][/color]

using System.Collections;

using System.Collections.Generic;

public class GameManager : MonoBehaviour

{

public DrawLine drawLine;//画线

public GameObject tilePrefab;//tile的预制

public List<Tile> tiles;//开始实例化的时候存放tile

public List<Tile> _tiles;//存放随机摆放的tile

public List<Tile> tilesEdge;//为了边界处可以有拐点，把棋盘四周的tile放在这里，这里的tile看不到

public int x, y;//棋牌的大小，两个数必须是偶数

private Tile tileA;

private Tile tileB;

private bool destroy;

private Vector3 mousePos;

private enum stepType//控制游戏的状态

{

one,

two,

three

}

private stepType _stepType;

void Start ()

{

this.gameObject.transform.position = Vector3.zero;

Spawn ();

_stepType = stepType.one;

}private void Spawn ()//实例化tile

{

float num = (x * y - (2 * x + 2 * y - 4)) * 0.5f;

for (int i = 0; i <num; i ++) {

int idTex = Random.Range (20, 45);

GameObject obj = Instantiate (tilePrefab) as GameObject;

GameObject obj2 = Instantiate (tilePrefab) as GameObject;

Tile tile = obj.GetComponent<Tile> ();

Tile tile2 = obj2.GetComponent<Tile> ();

tile.Init (idTex);

tile2.Init (idTex);

tiles.Add (tile);

tiles.Add (tile2);

}

for (int i = 0; i<((2*x+2*y) -4); i++) {//实例化边缘的tile

GameObject obj = Instantiate (tilePrefab) as GameObject;

obj.name = "edage";

Tile tile = obj.GetComponent<Tile> ();

tilesEdge.Add (tile);

}

CreatTile ();

for (int i = 0; i < _tiles.Count; i++) {

_tiles [i].transform.name = i.ToString ();

_tiles [i].id = i;

}

this.transform.position = new Vector3 (-(x / 2.0f - 0.5f), -(y / 2.0f - 0.5f), 0);

}private void CreatTile ()//随机摆放tile，如果是边缘的就放在边缘位置

{

int idTex = 0;

float _y = 0.0f;

for (int i = 0; i < y; i ++) {

float _x = 0.0f;

for (int j = 0; j < x; j ++) {

if (i == 0 || j == 0 || i == y - 1 || j == x - 1) {

tilesEdge [0].transform.position = new Vector3 (_x, _y, 0);

tilesEdge [0].pos = new Vector2 (_x, _y);

tilesEdge [0].transform.rotation = new Quaternion (0, 0, 180, 0);

tilesEdge [0].transform.parent = this.gameObject.transform;

_tiles.Add (tilesEdge [0]);

tilesEdge [0].transform.localScale = Vector3.zero;

tilesEdge [0].type = false;

tilesEdge.RemoveAt (0);

} else {

int id = Mathf.FloorToInt (Random.Range (0, tiles.Count));

tiles [id].transform.position = new Vector3 (_x, _y, 0);

tiles [id].pos = new Vector2 (_x, _y);

tiles [id].transform.rotation = new Quaternion (0, 0, 180, 0);

tiles [id].transform.parent = this.gameObject.transform;

_tiles.Add (tiles [id]);

tiles.RemoveAt (id);

}

_x += 1;

}

_y += 1;

}

}private void SelectTile ()//开始选择图片，通过射线方式选中，如果tileA和tileB不相同，则tileA等于tileB开始下一个检测

{

Ray ray = Camera.mainCamera.ScreenPointToRay (mousePos);

RaycastHit hit;

int mask = 1 << 8;

if (Physics.Raycast (ray, out hit, mask)) {

if (tileA == null) {

tileA = hit.transform.GetComponent<Tile> ();

tileA.SetTileTexture (1);

// print ("tileA = hit.transform.GetComponent<Tile> ();" + tileA.transform.name);

} else {

tileB = hit.transform.GetComponent<Tile> ();

tileB.SetTileTexture (1);

// print ("tileB = hit.transform.GetComponent<Tile> ();" + tileB.transform.name);

Compare (tileA, tileB);

if (tileA == null && tileB == null) {// print ("a and b is null");

}

}

// hit.transform.GetComponent

}

}
private void Compare (Tile tile1, Tile tile2)//比较两个点是否可以连接到一起
{
// same card
_stepType = stepType.one;
drawLine.waypoints.Add (tile1.transform); //第一个选择的tile是画线的起始位置，
drawLine.transform.position = tile1.transform.position;
destroy = false;
print ("compare");
if (tile1.pos.x == tile2.pos.x && tile1.pos.y == tile2.pos.y) {如果选中的是同一个图片返回
tileA.SetTileTexture (0);
// tileB.SetTileTexture (0);
tileA = tileB;
tileB = null;
// tileA.SetTileTexture (1);
return;
} else if (tile1.pos.x == tile2.pos.x && tile1.pos.y != tile2.pos.y) {//如果两点的x相等，竖向检测
print ("check y");
destroy = CheckY (tile1, tile2);
if (destroy)
drawLine.waypoints.Add (tile2.transform);
} else if (tile1.pos.x != tile2.pos.x && tile1.pos.y == tile2.pos.y) {//如果两点的y相等，横向检测
print ("check x");
destroy = CheckX (tile1, tile2);
if (destroy)
drawLine.waypoints.Add (tile2.transform);
}
if (!destroy) {//不符合直线连接方式的开始进行一个拐点的检测
_stepType = stepType.two;
destroy = CheckTwoStep (tile1, tile2);
// print ("destroy = CheckTwoStep (tile1, tile1);:" + destroy);
print ("check two step");
if (!destroy) {//不符合直线和一个拐点检测的开始进行两个拐点的检测
_stepType = stepType.three;
destroy = CheckThreeStep (tile1, tile2);
print ("check three:" + destroy);
print ("tile1.idTex:" + tile1.idTex + "tile1.idTex:" + tile1.idTex);
}
}
if (destroy) {//如果符合销毁条件销毁图片，并开始画线
tile1.transform.localScale = Vector3.zero;
tile2.transform.localScale = Vector3.zero;
tile1.type = false;
tile2.type = false;
tileA = null;
tileB = null;
drawLine.MoveToWaypoint ();
} else {//不符合的话，清除画线中的路径
drawLine.ClearPath ();
tileA.SetTileTexture (0);
// tileB.SetTileTexture (0);
tileA = tileB;
tileB = null;
return;
}
}
// one step横向检测
private bool CheckX (Tile a, Tile b)
{
bool compare = true;
int _min, _max;
if (a.idTex == b.idTex) {
CompareID (a, b, out _min, out _max);
_min += 1;
if (_min == _max)
return true;
for (int i = _min; i < _max; i++) {
if (_tiles [i].type == true) {
compare = false;
break;
}
}
return compare;
} else
return false;
}
//竖向检测
private bool CheckY (Tile a, Tile b)
{
bool compare = true;
int _min, _max;
// int idA = (int)(a.x * x + a.y);
// int idB = (int)(b.x * x + b.y);
// print (_tiles [idA].id.ToString () + "idA:" + idA);
// print (_tiles [idB].id.ToString () + "idB:" + idB);
// print ("a.idtex:" + a.idTex + "b.idtex:" + b.idTex);
if (a.idTex == b.idTex) {
CompareID (a, b, out _min, out _max);
_min += x;
if (_min == _max)
return true;
for (int i = _min; i < _max; i+=x) {
// print ("1step");
if (_tiles [i].type == true) {
compare = false;
break;
}
}
// if (compare) {
// print ("2step");
// a.type = false;
// b.type = false;
// }
return compare;
} else
return false;
}
// two step一个拐点的检测
private bool CheckTwoStep (Tile a, Tile b)
{
if (a.pos.x == b.pos.x || a.pos.y == b.pos.y)
return false;
int id1 = (int)(a.pos.y * x + b.pos.x);
if (_tiles [id1].type == false) {
_tiles [id1].idTex = a.idTex;

if (CheckY (_tiles [id1], b)) {
if (CheckX (a, _tiles [id1])) {
if (_stepType == stepType.two) {
drawLine.waypoints.Add (_tiles [id1].transform);
drawLine.waypoints.Add (b.transform);
} else if (_stepType == stepType.three) {
drawLine.waypoints.Add (_tiles [id1].transform);
print ("=====================:" + 1);
}
return true;
}
// else
// return false;
}
}
int id2 = (int)(b.pos.y * x + a.pos.x);
if (_tiles [id2].type == false) {
_tiles [id2].idTex = b.idTex;

if (CheckY (a, _tiles [id2])) {
if (CheckX (b, _tiles [id2])) {
if (_stepType == stepType.two) {
drawLine.waypoints.Add (_tiles [id2].transform);
drawLine.waypoints.Add (b.transform);
} else if (_stepType == stepType.three) {
drawLine.waypoints.Add (_tiles [id2].transform);
print ("=====================:" + 2);
}
return true;
}
// else
// return false;
}
}
return false;
}
// three step两个拐点的检测
private bool CheckThreeStep (Tile a, Tile b)
{
print ("a:" + a.idTex + "b:" + b.idTex);
// if (a.pos.x == b.pos.x || a.pos.y == b.pos.y) return false;
bool returnValue = false;
print ("returnValue:" + returnValue);
List<Tile> _comparrPointsB;
ComparePoints (b, out _comparrPointsB);//返回b点可以横竖直线相连的点
for (int i =0; i<_comparrPointsB.Count; i++) {
returnValue = CheckTwoStep (a, _comparrPointsB [i]);
if (returnValue) {
drawLine.waypoints.Add (_comparrPointsB [i].transform);
drawLine.waypoints.Add (b.transform);
return returnValue;
}
}
if (!returnValue) {
List<Tile> _comparrPointsA;
ComparePoints (a, out _comparrPointsA);
print (a.name);
print (b.name);
for (int i =0; i<_comparrPointsA.Count; i++) {
print ("--------------" + b.idTex);
returnValue = CheckTwoStep (b, _comparrPointsA [i]);
if (returnValue) {
drawLine.waypoints.Add (_comparrPointsA [i].transform);
drawLine.waypoints.Add (b.transform);
return returnValue;
}
}

}
return returnValue;
}
//两个拐点的时候返回可以与a横竖直线相连的点
private void ComparePoints (Tile a, out List<Tile> comparePoints)
{
print ("a.idtex" + a.idTex);
comparePoints = new List<Tile> ();
comparePoints.Clear ();
// for (int i = 0; i < y; i ++) {
// if (i != a.y) {
// int id = (int)(i * x + a.pos.x);
// if (_tiles [id].type == false) {
// comparePoints.Add (_tiles [id]);
// _tiles [id].idTex = a.idTex;
// }
// }
// }
for (int i = (int)a.pos.y - 1; i >-1; i--) {
int id = (int)(i * x + a.pos.x);
// print ("three step :" + id);
if (_tiles [id].type == false) {
comparePoints.Add (_tiles [id]);
_tiles [id].idTex = a.idTex;
print ("_tiles [id].idTex = a.idTex; " + _tiles [id].idTex);
} else
break;
}
for (int i = (int)a.pos.y + 1; i < y; i++) {
int id = (int)(i * x + a.pos.x);
// print ("three step :" + id);
if (_tiles [id].type == false) {
comparePoints.Add (_tiles [id]);
_tiles [id].idTex = a.idTex;
print ("_tiles [id].idTex = a.idTex; " + _tiles [id].idTex);
} else
break;
}
for (int i = (int)a.pos.x -1; i >-1; i --) {
int id = (int)(a.pos.y * x + i);
if (_tiles [id].type == false) {
comparePoints.Add (_tiles [id]);
_tiles [id].idTex = a.idTex;
print ("_tiles [id].idTex = a.idTex; " + _tiles [id].idTex);
} else
break;
}
for (int i = (int)a.pos.x +1; i < x; i ++) {
int id = (int)(a.pos.y * x + i);
if (_tiles [id].type == false) {
comparePoints.Add (_tiles [id]);
_tiles [id].idTex = a.idTex;
print ("_tiles [id].idTex = a.idTex; " + _tiles [id].idTex);
} else
break;
}
// for (int i = 0; i < x; i ++) {
// if (i != a.x) {
// int id = (int)(a.pos.y * x + i);
// if (_tiles [id].type == false) {
// comparePoints.Add (_tiles [id]);
// _tiles [id].idTex = a.idTex;
// }
// }
// }
}
private void CompareID (Tile a, Tile b, out int min, out int max)
{

if (a.id < b.id) {
min = a.id;
max = b.id;
} else {
min = b.id;
max = a.id;
}
}
Vector2 TexSize ()
{
Vector2 size = new Vector2 (1 / x, 1 / y);
return size;
}
Vector2 TexOffset (int _idTex)
{
int a = (int)(_idTex / x);
// print (a + "a:" + _idTex);
int b = (int)(_idTex % x);
// print (b + "b:" + _idTex);
Vector2 offset = new Vector2 (b / x, (y - 1 - a) / y);
return offset;
}
void Update ()
{

if (Input.GetMouseButtonUp (0)) {
mousePos = Input.mousePosition;
SelectTile ();
}

}
private void ClearTiles (List<Tile> tiles)
{

tiles.Clear ();
// this.gameObject.transform.DetachChildren();
}
}
// ari

DrawLine.cs，画线脚本，用的itween。

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

public class DrawLine : MonoBehaviour

{

public List<Transform> waypoints = new List<Transform> ();

public float rate = 1;

private int currentWaypoint = 1;

public void MoveToWaypoint ()

{

print ("public void MoveToWaypoint (): " + waypoints.Count);

StartCoroutine ("move");

}

public void ClearPath ()

{

waypoints.Clear ();

print ("path.Clear ();");

}

IEnumerator move ()

{

for (int i = 0; i < waypoints.Count; i++) {

iTween.MoveTo (this.gameObject, waypoints [i].position, rate);

print ("now id:" + i);

yield return new WaitForSeconds(rate);

}

waypoints.Clear ();

}

}

Tile.cs

using UnityEngine;

using System.Collections;

public class Tile : MonoBehaviour

{

public int id;

public int idTex; //通过这个判断两个图片是否相同

public Vector2 pos ;

public bool type = true;//控制图片的状态，当销毁的时候为false，其他判断的时候可以通过该点

public float x, y;

public Texture texA, texB;//鼠标选中的时候可以换贴图

public GameObject mask;//鼠标选中的时候上边显示的框框

public void Init (int _idTex)

{

idTex = _idTex;

Vector2 offset = TexOffset (_idTex);

this.renderer.material.SetTextureOffset ("_MainTex", offset);

this.renderer.material.SetTextureScale ("_MainTex", new Vector2 (0.2f, 0.1f));}

//设置tile显示的贴图和大小

public void SetTileTexture (int i)

{

if (i == 0) {

this.renderer.material.mainTexture = texA;

mask.transform.localScale = Vector3.zero;

}if (i == 1) {

this.renderer.material.mainTexture = texB;

mask.transform.localScale = new Vector3 (0.1380835f, 0.1380835f, 0.1380835f);

}

}

//这个就是裁剪一张大图，变成一个个小的，贴到tile上

Vector2 TexOffset (int _idTex)

{

int a = (int)(_idTex / x);

int b = (int)(_idTex % x);

Vector2 offset = new Vector2 (b / x, (y - 1 - a) / y);

return offset;

}

Vector2 TexSize ()

{

Vector2 size = new Vector2 (1 / x, 1 / y);

return size;

}

}

Menu.cs，添加两个按钮。

using UnityEngine;

using System.Collections;

public class Menu : MonoBehaviour

{

public GameManager gameManager;

private GameManager _gameManger;

private bool start = true;void OnGUI ()

{

if (start) {

if (GUI.Button (new Rect (10, 10, 100, 50), "start")) {

start = false;

_gameManger = Instantiate (gameManager) as GameManager;

}

}

if (GUI.Button (new Rect (10, 70, 100, 50), "restart")) {

if (_gameManger != null) {

Destroy (_gameManger.gameObject);

print ("Destroy(_gameManger.gameObject);");

}

_gameManger = Instantiate (gameManager) as GameManager;

}}

}