只要有修改，子表就不用元表的参数了，用自己的参数（只不过和元表里的那个同名）
子表用__index"继承"了父表的值，此时子表仍然是空表
一定是创建这样一个同名的变量在原本空空的子表里，
传参要传具体的变量
__index
这样会报错
Lua
local obj = {}
x=1
setmetatable(obj, { __index = x})
print(obj.health)
Lua 对于 __index 元方法有严格要求，它必须是一个表 或一个函数。
Lua
local obj = {}
setmetatable(obj, { __index = 42 }) -- 错误：尝试访问时 Lua 会报错
print(obj.health) -- 报错：bad argument #2 to 'setmetatable' (index must be table or function)在 Lua 中，当 __index 被设置为 nil 时，Lua 的行为是将其视为没有定义 __index 元方法 。这不会引发错误，而是简单地返回 nil
Lua 不强制要求 __index 必须被定义或赋值，只在查找键失败时才会检查是否存在有效的 __index
Lua
local obj = {}
setmetatable(obj, { __index = nil })
print(obj.health) -- 输出: nil当 Lua 查找一个表中不存在的键时：
- 如果该表的元表中定义了
__index：- 如果
__index是表，Lua 会在这个表中继续查找键。 - 如果
__index是函数 ，Lua 会调用该函数，并将原表和键作为参数传递（重点在先找到，再传入参数，而且这时候的参数的self什么的也是自己此时传入的参数）
- 如果
- 如果该表的元表存在，但
__index为nil或未定义或者有但是里面没找到 ，Lua 会直接返回nil，不会报错。
__index 的函数可以没有返回值
Lua 将该返回空的值也视为 nil
__index 的函数在被调用时，会自动接受两个参数（调用的表，缺失的键）
这两个参数是自动传入的，并且在实现 __index 时是强制要求的，不提供这两个参数会导致错误
Lua
local obj = {}
setmetatable(obj, {
__index = function(table, key)
print("Table is:", table)
print("Key is:", key)
return "Default value" -- 显式返回一个值
end
})
print(obj.health) -- 输出:
-- Table is: <table: 0x...>
-- Key is: health
-- Default valuesetmetatable（）
通过特殊的元方法来改变表的行为（延伸） ，实现默认的操作逻辑 ，比如++算术运算++ 、++比较++ 、索引、++函数++调用等。Lua 会在对应的情况下自动调用它们。
以下是元表里常用的内容：
索引相关
__index：自定义键的访问行为
**__index**接受的是一个访问对象，可以是表可以是函数，但不可以是单个的变量
当访问表中不存在的键时，Lua 会去元表里的 __index 方法找值，表里有值就拿表，有方法可以返回值就接收这个返回值
示例 1：使用表提供默认值
Lua
local defaults = { health = 100, mana = 50 }
local t = {}
setmetatable(t, { __index = defaults })
print(t.health) -- 输出: 100（默认值）
print(t.attack) -- 输出: nil（没有定义）示例 2：使用函数动态生成值
Lua
local t = {}
setmetatable(t, {
__index = function(_, key)
return "键 " .. key .. " 不存在"
end
})
print(t.unknown) -- 输出: 键 unknown 不存在__newindex：自定义键的赋值行为
当试图给表中不存在的键赋值时，Lua 会调用 __newindex 方法。
- 可以拦截并自定义赋值逻辑。
示例：限制某些键的赋值
Lua
local t = {}
setmetatable(t, {
__newindex = function(_, key, value)
print("你不能直接添加新键 " .. key .. "，但我记录下来了！")
end
})
t.newKey = 123 -- 输出: 你不能直接添加新键 newKey，但我记录下来了！
print(t.newKey) -- 输出: nil算术操作
元表可以通过定义算术相关的元方法，改变表在算术操作中的行为。以下是常用的元方法：
__add：加法
定义两个表相加时的行为：
Lua
local t1 = { value = 5 }
local t2 = { value = 10 }
setmetatable(t1, {
__add = function(a, b)
return { value = a.value + b.value }
end
})
local result = t1 + t2
print(result.value) -- 输出: 15__sub、__mul、__div、__mod、__pow
这些方法分别用于减法、乘法、除法、取模、幂运算。例如：
Lua
local t1 = { value = 2 }
local t2 = { value = 3 }
setmetatable(t1, {
__mul = function(a, b)
return { value = a.value * b.value }
end
})
local result = t1 * t2
print(result.value) -- 输出: 6比较操作
元表还可以控制比较操作的行为：
__eq：等于
Lua
local t1 = { id = 1 }
local t2 = { id = 1 }
setmetatable(t1, {
__eq = function(a, b)
return a.id == b.id
end
})
print(t1 == t2) -- 输出: true__lt 和 __le：小于和小于等于
Lua
local t1 = { value = 5 }
local t2 = { value = 10 }
setmetatable(t1, {
__lt = function(a, b)
return a.value < b.value
end
})
print(t1 < t2) -- 输出: true表的行为
__tostring：自定义表的字符串表示
用于定义表被转换为字符串时的行为，例如 print：
Lua
local t = { name = "test" }
setmetatable(t, {
__tostring = function(table)
return "表的名字是：" .. table.name
end
})
print(t) -- 输出: 表的名字是：test__len：自定义表的长度
控制 # 操作符的行为：
Lua
local t = { a = 1, b = 2 }
setmetatable(t, {
__len = function()
return 100
end
})
print(#t) -- 输出: 100__call：使表可以被调用
让表像函数一样调用：
Lua
local t = {}
setmetatable(t, {
__call = function(_, a, b)
return a + b
end
})
print(t(3, 5)) -- 输出: 8实际使用场景
元表的功能非常强大，常见的使用场景包括：
- 默认值表 ：使用
__index为表提供默认值。 - 运算符重载：让自定义类型支持算术或比较运算。
- 面向对象编程 ：通过
__index和元表实现类与对象。 - 只读表 ：使用
__newindex拦截赋值行为，防止表被修改。 - 代理表 ：通过
__index或__call动态生成数据。
修正语法思路
关于元表绑定父表的一个小细节
Lua
local base = {
name = "base",
speak = function(self)
print("Name is " .. self.name)
end
}
local derived = {}
setmetatable(derived, { __index = base })
-- 调用方法
derived:speak() -- 输出: Name is nil解释：
derived没有name属性，speak是从元表base中继承的。self绑定到调用者derived，所以self.name为nil。
如果在 derived 中添加属性，行为会改变：
derived.name = "derived"
derived:speak() -- 输出: Name is derived
当使用 : 调用方法时，Lua 会自动将表作为第一个参数传入函数，并绑定到变量 self
self 完全取决于调用者传入的第一个参数
同一个函数，被别的表继承之后，：如果要执行这个函数，self指的就是那个新的继承的表对象
这个self是动态的
这里看上去是在给Object这个表对象写新方法，但这个表对象会被作为元表去被别的表继承，
function这个东西写哪都一样，只是一种简写，对于{}调用自己的方法，然后会有一个self指代自己（这个自己不是真的要是自己，而是使用这个方法时的自己，self的功能重点不在是定义在谁的{}，而在对表之间的"继承"关系的强调）
现在再看这个继承的代码看着简单，但是通用性很强，里面的确有很多知识点
把Object声明在全局，突出class的感觉
new和subClass方法也写成全局的
不用:语法糖实现Object万物之父
所有的方法都要传入参数，这个参数不会
参数能不能传入，只靠local对参数的规定
Lua
-- Object 万物之父类
local Object = {}
-- 创建新对象方法
function Object.new(self)
local instance = {}
setmetatable(instance, { __index = self }) -- 设置元表，继承父类的方法
return instance
end
-- 添加一个通用的方法
function Object.say(self, message)
print("[" .. tostring(self) .. "] says: " .. message)
end
-- 返回 Object 类
return Object要实现一个万物之父的Object，
首先创建这个大表{}，因为是万物之父，所以这个表里包含了new一个新的自己的能力
在这体现为function Object:new()
.....
end
封装
然后是对这个自我实例化的函数的实现，也就是给这个万物之父Object表{}对象，写一个可以创建出新的独立的{}表的方法（这个创建的新{}对象，里面还要实现和Object{}对象里一模一样的功能）
那问题就来到了这个新{}对象的创建，以及这个新{}要怎么复制Object对象里的各种方法和数据
这里巧妙的运用了闭包，即Object{}对象里的new方法，里面存在的各种变量，也是有生命周期的
这一点同c#
所以在这个Object{}对象里的new函数里
local obj={}
...
return obj
这个return的值在外部用变量接了就可以用了
二次强调，这个new的方法是属于Object这个{}的
lua创建一个对象的流程：先写好一个实实在在的{}，然后想有新的"实例"，就通过元表setmetatable（）把新的"实例"去引用上已经存在的{}里的各种...，这个部分是__index在发挥作用
换句话说，这个功能本是setmetatable（）设置元表的一个小分支，
但意外的是这个小分支是实现面向对象的继承和创建新对象的关键
setmetatable()先写元表再写上面的self.__index=self
Lua热更新
Lua 是 Unity 热更新的一种常见选择，但并不是唯一的方案。
以下是详细的解释和 Lua 在 Unity 热更新中的应用场景：
Lua 热更新的核心原理
热更新的目标是在不重新发布客户端版本的情况下更新游戏逻辑。Lua 作为脚本语言，可以加载和运行外部脚本文件，更新逻辑时只需替换脚本资源，而无需重新打包整个应用。
在 Unity 中，Lua 热更新通常通过以下方式实现：
- 将++核心逻辑（如主角行为、UI 逻辑）写在 Lua 脚本++中。
- 在 C# 程序中++嵌入 Lua 虚拟机（通常使用 LuaBridge 、SLua 或 XLua 等工具）++。
- 在运行时动态加载和执行 Lua 脚本文件，达到热更新的效果。
为什么 Lua 是热门选择
- 游戏行业传统 ：Lua 广泛应用于 Cocos2d、Corona、Roblox 等游戏引擎，因此在游戏行业中++积累了丰富的生态和成熟的实践经验++。
- Unity 插件支持 ：Unity 中有多个成熟的 Lua 框架（如 XLua 、SLua 、ToLua），可以快速上手，降低实现热更新的技术门槛。
- 适配热更新需求：Lua 支持动态加载脚本，结合 Unity 的 AssetBundle 等机制，可以在运行时替换特定逻辑，满足热更新需求。
热更新的其他方案（非 Lua）
-
ILRuntime（C# 热更新）：
- ILRuntime 是一个开源的 .NET 运行时框架，可以让游戏逻辑以 C# 写成的 DLL 文件形式热更新。
- 优点：无需学习新的语言，直接使用 C# 编写代码；性能接近原生逻辑。
- 缺点：复杂度较高，调试和配置成本稍高于 Lua。
-
HybridCLR：
- Unity 原生不支持代码热更新，但使用 HybridCLR（开源的 AOT+Interpreter 混合运行时），可以实现类似 Lua 的热更新效果。
- 优点：完全基于 C#，不需要引入额外语言；性能优越。
- 缺点：配置复杂，需要对 Unity 和 CLR 有深入理解。
-
AssetBundle 热更新：
- 通过资源的动态加载更新 UI、关卡、角色等内容，而不是直接更新逻辑。
- 优点：简单易用，适合仅更新资源的场景。
- 缺点：无法更新游戏逻辑。
-
Python 或其他脚本语言：
- 某些项目可能会选择 Python 或其他轻量脚本语言（如 JavaScript）作为热更新脚本语言，但使用较少，生态不如 Lua 完善。
如果更倾向于使用 C# 完成所有开发任务，也可以探索 ILRuntime 或 HybridCLR 等更贴近 Unity 原生的热更新方案。
Lua的实现流程
eg：活动与任务系统
-
实际场景 ：
游戏中的限时活动、节日任务等需要随时调整或增加，比如：
-
在春节期间增加一个"新年集福活动"。
-
在万圣节期间添加"收集南瓜"的任务，完成后奖励独特皮肤。
-
-
为何需要热更新 ：
这些任务的规则（比如"收集多少南瓜"、"奖励什么物品"）可能需要动态调整。如果每次都通过重新发布客户端更新，这会导致玩家需要频繁下载新版本，影响体验。
-
热更新解决方案 ：
开发者只需++通过服务器发送新的 Lua 脚本，定义任务逻辑，客户端运行时加载这些脚本++即可完成更新。
如果开发者对游戏代码进行了加密或封装，玩家无法随意加载和替换脚本内容。否则，恶意脚本可能造成数据泄露或作弊行为
++游戏需要内置一个脚本虚拟机（比如 Lua VM），支持动态加载和执行外部脚本。如果没有这种机制，热更新就无法通过脚本实现。++
热更新的限制
游戏逻辑中哪些部分允许用 Lua 控制，哪些是固定在 C# 或引擎层（Unity 原生）中，通常是++预先定义好的++。
一些核心机制（如图形渲染、网络通信）往往不会交给 Lua 脚本，而是保留在底层代码中。
++游戏服务器通常会校验客户端发来的逻辑更新（如活动配置、技能参数）。如果玩家任意替换脚本但未通过服务器校验，可能无法生效。++
策划使用Lua
程序员需要预先用框架（如 Unity 的 XLua 、ToLua 或自研绑定系统）把 Lua 与游戏的核心逻辑或数据结构连接起来，让 Lua 脚本中的变量和程序代码的数据能够互相访问。以下是常见的绑定机制：
通过 Lua 表映射游戏数据
程序员定义一个数据表（如角色属性、任务数据），并通过接口将其暴露给 Lua 脚本。例如：
cs
public class Player
{
public int health = 100;
public int mana = 50;
}
策划如何知道哪些变量可以用？
程序员一般要提供一份脚本文档或模板，列出策划可以操作的变量、数据结构和接口。
- 文档需要详细说明：
player.health表示角色当前血量，类型是整数；enemy.attackPower表示敌人的攻击力。- ...
程序员和策划需要约定数据和逻辑的名称
Lua
-- Lua 脚本
local tasks = {
{ id = 1, name = "收集苹果", required = 10, reward = 100 },
{ id = 2, name = "击败敌人", required = 5, reward = 200 }
}
cs
public void LoadTaskData(LuaTable tasks)
{
foreach (var task in tasks)
{
Debug.Log($"任务 {task.name}: 收集 {task.required} 件物品，奖励 {task.reward} 金币");
}
}也可以通过工具自动生成绑定
存在一些框架（如 XLua、ToLua）支持自动生成 Lua 脚本的 API 文档和绑定代码
程序员在 Unity 中使用 XLua，会自动生成可以在 Lua 中调用的 C# 函数和变量清单。策划直接查阅清单即可知道哪些数据可以修改。
- 程序员的职责：通过绑定框架（如 XLua）将游戏数据和 Lua 脚本连接起来，并定义清晰的接口。
- 策划的职责：按照约定好的变量名和函数名，在 Lua 脚本中编写逻辑，修改数据即可。
- 工具和约定的作用：策划只需了解绑定的变量和接口，配合文档和自动生成的工具，可以轻松完成任务配置或逻辑调整。
