Transform维持物体之间的父子级

获取位置

获取世界空间中的位置: transform.position
相对父物体位置: transform.localPosition

获取旋转

获取物体在世界空间旋转值(四元素)：transform.rotation
获取物体相对父物体旋转值(四元素)：transform.localRotation
获取物体在世界空间旋转值(Euler 度为单位): transform.eulerAngles
获取物体相对父物体旋转值(Euler 度为单位): transform.localEulerAngles

获取缩放

获取物体相对父物体缩放比： transform.localScale

向量

前方(Z轴方向)：transform.forward
右方(X轴方向)：transform.right
上方(Y轴方向)：transform.up

父子关系

父物体: transform.parent.gameObject
子物体数量: transform.childCount
通过子物体名称找子物体: transform.Find("childObjName").gameObject
通过索引位置找子物体: transform.GetChild(0).gameObject

常用方法

在 Update() 方法中调用

- 时刻看向指定位置

transform.LookAt(Vector3.zero)

- 旋转

按自身Y轴方向，每侦1度进行旋转(自转)：transform.Rotate(Vector3.up,1)

- 围绕某个物体旋转

围绕某个物体旋转(世界坐标(0,0,0)的点的Y轴): transform.RotateAround(Vector3.zero,Vector3.up,5)

场景类 Scene

- 获取当前活动场景

Scene scene = SceneManager.GetActiveScene();

- 场景名称

Debug.Log(scene.name);

- 是否加载

Debug.Log(scene.isLoaded);

- 场景路径

Debug.Log(scene.path);

- 场景索引

Debug.Log(scene.buildIndex);

- 获取场景内物体数量

GameObject[] objs = scene.GetRootGameObjects();
Debug.Log(objs.Length);

场景管理类 SceneManager

- 创建场景

SceneManager.CreateScene("NewScene");

- 加载场景（同步/异步）

1. 同步加载场景

   SceneManager.LoadSceneAsync(“Scene2”,LoadSceneMode.Additive);

2. 异步加载场景 协程

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class SceneTest : MonoBehaviour
{
	float timer = 0;
	AsyncOperation operation;
	
	// Start is called before the first frame update
	void Start()
	{
		//异步加载场景 协程
		StartCoroutine(LoadScene());
	}
	
	IEnumerator LoadScene()
	{
		operation = SceneManager.LoadSceneAsync("Scene2",LoadSceneMode.Additive);
		//场景是否立即激活
		operation.allowSceneActivation = false;
		yield return operation;
	}
	
	// Update is called once per frame
	void Update()
	{
		Debug.Log(operation.progress);
		timer += Time.deltaTime;
		if (timer > 5)
		{
			//5秒后激活加载的场景
			operation.allowSceneActivation = true;
		}
	}
}

Application

- 游戏数据文件夹路径(只读，打包加密压缩)

Debug.Log(Application.dataPath);  
D:/UnityTest/TestUnity2021Project/New Unity Project/Assets

- 持久化文件夹路径

Debug.Log(Application.persistentDataPath);
C:/Users/gongrenjun/AppData/LocalLow/DefaultCompany/New Unity Project

- StreamingAssets文件夹路径(只读，配置文件,打包后不会加密压缩)

Debug.Log(Application.streamingAssetsPath);
D:/UnityTest/TestUnity2021Project/New Unity Project/Assets/StreamingAssets

- 临时文件夹

Debug.Log(Application.temporaryCachePath);
C:/Users/GONGRE~1/AppData/Local/Temp/DefaultCompany/New Unity Project

- 是否在后台运行 可在Projectt Settins -> Player 选项中设置

Debug.Log(Application.runInBackground);

- 打开URL

Application.OpenURL("http://www.bytefisher.top");

- 退出游戏

Application.Quit();

2月24日，星期六

元宵节，气温骤降。在这样的日子里，我选择前往三一水库挑战红尾。为了应对可能的挑战，跟据以往的经验，由于水库红尾比较小，我准备选择软竿，搭配小钩，细线，希望能提高鱼儿的咬钩。于是我携带了特作伊吹12尺钓竿，搭配0.6主线，0.3子线以及2号无倒刺轻口袖进行作钓。

虽然降温，但鱼口异常的好，仿佛在庆祝元宵节的热闹。到达水库开始作钓不久，就开始上鱼。红尾虽然小，但数量众多，鱼情爆躁。然而，特作伊吹钓竿在这个时候却显得有些不适应，小鱼刺鱼过程中手感模糊，虽然是胴调钓竿，但鱼太小又发挥不了鱼竿的腰力，轻轻发力就变成了飞磕，体现不出伊吹的特性。然而，尽管有这些不足，我依然享受着双飞，连竿上鱼的快感，这正是钓鱼的魅力所在。

Lua实现Unity堆叠消除小游戏，游戏功能每次随机生成四个不同形状的方块，将方块拖入10*10的格子棋盘，如果放入的棋盘格都有空格则可以放入方块，当放满一行或者一列时，消除满行满列的放入格。

- 创建拼图地图格数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
---拼图地图格数据
---@class ROPuzzleMapTileData
local m = {
    ---@type number 位置标记
    index = 0,
    ---@type number 所在行
    x = 0,
    ---@type number 所在列
    y = 0,
    ---@type number 地图格上放置的方块ID  为0 表示空格
    blockId = 0,
}

function m.New(index,x,y,id)
    local o = Clone(m)
    o:Init(index,x,y,id)
    return o
end

function m:Init(index,x,y,id)
    self.index = index
    self.x = x
    self.y = y
    self.blockId = id
end

return m

- 创建拼图游戏数据结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
---@class ROPuzzleGameData
local m = {
    ---@type CfgRestaurantOperationPuzzleControlData
    cfgPuzzleGameControlData = nil,
    ---@type number 当前积分
    score = 0,
    ---@type ROPuzzleMapTileData[]
    tileMaps = {},
    ---@type number 最大行数
    maxLine = 10,
    ---@type number 最大列数
    maxColumn = 10,
    ---@type number 单次生成的方块数量(上限为4)
    randomBlock = {},
    ---@type boolean 游戏是否已经开始（点了开始按钮视为游戏开始）
    isGameStart = false,
}

local ROPuzzleMapTileData = require("IQIGame.Module.CommonActivity.RestaurantOperation.ROPuzzleGame.ROPuzzleMapTileData")

function m.New(cfgData)
    local o = Clone(m)
    o:Init(cfgData)
    return o
end

function m:Init(cfgData)
    self.score = 0
    self.cfgPuzzleGameControlData = cfgData
    self.tileMaps = self:CreateTiles()
    self.isGameStart = true
end

---开始新游戏，创建拼图地图
function m:CreateTiles()
    local tab = {}
    local index = 0
    for line = 1, self.maxLine do
        for column = 1, self.maxColumn do
            index = index + 1
            local tileData = ROPuzzleMapTileData.New(index,line,column,0)
            tab[index] = tileData
        end
    end
    return tab
end

---随机生成四个方块
function m:RefreshRandomBlock()
    self.randomBlock = {}
    local blockGroup = table.clone(self.cfgPuzzleGameControlData.BlockGroup)
    ---洗牌操作
    for i = #blockGroup, 2, -1 do
        local random_index = math.random(i)
        blockGroup[i], blockGroup[random_index] = blockGroup[random_index],blockGroup[i]
    end
    ---根据配置数据取方块
    for i = 1, self.cfgPuzzleGameControlData.BlockNum do
        local id = blockGroup[i]
        table.insert(self.randomBlock,id)
    end
end

---消除满行满列，并返回消除的行列
---@return number, number[],number[] 消除的总行数，同时消除的行和列
function m:Eliminate()
    local lines = {}
    local columns = {}
    ---行检测
    for i = 1, self.maxLine do
        local isFull = true
        for j = 1, self.maxColumn do
            local pos = (i-1) * self.maxLine + j
            if self.tileMaps[pos].blockId == 0 then
                isFull = false
                break
            end
        end
        if isFull then
            table.insert(lines,i)
        end
    end
    ---列检测
    for j = 1, self.maxColumn do
        local isFull = true
        for i = 1, self.maxLine do
            local pos = (i-1) * self.maxLine + j
            if self.tileMaps[pos].blockId == 0 then
                isFull = false
                break
            end
        end
        if isFull then
            table.insert(columns,j)
        end
    end
    local totalNum = #lines + #columns
    return totalNum,lines,columns
end

---增加积分
---@param score number
function m:AddScore(score)
    self.score = self.score + score
end

---检测方块还有没有空地能放下
---@param blockCell PuzzleGameBlockCell
---@return boolean
function m:CheckBlockCellCanPutDown(blockCell)
    local posTab = blockCell.blockData
    for i, tileData in pairs(self.tileMaps) do
        ---找到了一个空格子
        local canPutDown = false
        if tileData.blockId == 0 then
            ---所有检测点都满足返回true
            for j, pos in pairs(posTab) do

            end
        end
    end
    return false
end

return m

通过调用RefreshRandomBlock()方法，每次随机生成不重复的四个方块

用Lua实现Unity连连看游戏要点记录：

游戏功能描述，通过游戏关卡配置从水果类型中，生成指定类型水果及其数量，位置随机。连线要求最多支持两个拐点，三段线相连通才能消除。

- 创建游戏关卡数据结构

创建关卡水果数据结构 ROFruitData

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
---水果连连看水果数据
---@class ROFruitData
local m = {
    ---@type number 配置ID
    cid = nil,
    ---@type boolean 是否消除
    isClean = false,
    ---@type number 所在位置
    pos = 0,
    ---@type number 行
    x = 0,
    ---@type number 列
    y = 0,
}

function m.New(cid,clean)
    local o = Clone(m)
    o:Init(cid,clean)
    return o
end

function m:Init(cid,clean)
    self.cid = cid
    self.isClean = clean
end

---@param pos number
function m:SetPos(pos)
    self.pos = pos
    local x,y = self:GetX_Y()
    self.x = x
    self.y = y
end

---@return CfgRestaurantOperationFruitListData
function m:GetCfgData()
    if self.cid > 0 then
        return CfgRestaurantOperationFruitListTable[self.cid]
    end
    return nil
end

---通过Pos获取格子位置 (每行10个格子)
---@return number,number  行，列
function m:GetX_Y()
    local x = math.ceil(self.pos / 10)
    local y = self.pos - 10 * (x-1)
    return x,y
end

return m