自由学习记录（25）

🕗 发布于 2024-11-27 07:41 学习 Lua

只要有修改，子表就不用元表的参数了，用自己的参数（只不过和元表里的那个同名）

子表用__index“继承”了父表的值，此时子表仍然是空表

一定是创建这样一个同名的变量在原本空空的子表里，

传参要传具体的变量

__index

这样会报错

local obj = {}
x=1
setmetatable(obj, { __index = x}) 
print(obj.health)

Lua 对于 __index 元方法有严格要求，它必须是一个表或一个函数。

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

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 时是强制要求的，不提供这两个参数会导致错误

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 value

setmetatable（）

通过特殊的元方法来改变表的行为（延伸），实现默认的操作逻辑，比如算术运算、比较、索引、函数调用等。Lua 会在对应的情况下自动调用它们。

以下是元表里常用的内容：

索引相关

`__index`：自定义键的访问行为

__index接受的是一个访问对象，可以是表可以是函数，但不可以是单个的变量

当访问表中不存在的键时，Lua 会去元表里的 __index 方法找值，表里有值就拿表，有方法可以返回值就接收这个返回值

示例 1：使用表提供默认值

local defaults = { health = 100, mana = 50 }
local t = {}
setmetatable(t, { __index = defaults })

print(t.health) -- 输出: 100（默认值）
print(t.attack) -- 输出: nil（没有定义）

示例 2：使用函数动态生成值

local t = {}
setmetatable(t, {
    __index = function(_, key)
        return "键 " .. key .. " 不存在"
    end
})

print(t.unknown) -- 输出: 键 unknown 不存在

`__newindex`：自定义键的赋值行为

当试图给表中不存在的键赋值时，Lua 会调用 __newindex 方法。

可以拦截并自定义赋值逻辑。

示例：限制某些键的赋值

local t = {}
setmetatable(t, {
    __newindex = function(_, key, value)
        print("你不能直接添加新键 " .. key .. "，但我记录下来了！")
    end
})

t.newKey = 123 -- 输出: 你不能直接添加新键 newKey，但我记录下来了！
print(t.newKey) -- 输出: nil

算术操作

元表可以通过定义算术相关的元方法，改变表在算术操作中的行为。以下是常用的元方法：

`__add`：加法

定义两个表相加时的行为：

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`

这些方法分别用于减法、乘法、除法、取模、幂运算。例如：

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`：等于

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`：小于和小于等于

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：

local t = { name = "test" }

setmetatable(t, {
    __tostring = function(table)
        return "表的名字是：" .. table.name
    end
})

print(t) -- 输出: 表的名字是：test

`__len`：自定义表的长度

控制 # 操作符的行为：

local t = { a = 1, b = 2 }

setmetatable(t, {
    __len = function()
        return 100
    end
})

print(#t) -- 输出: 100

`__call`：使表可以被调用

让表像函数一样调用：

local t = {}

setmetatable(t, {
    __call = function(_, a, b)
        return a + b
    end
})

print(t(3, 5)) -- 输出: 8

实际使用场景

元表的功能非常强大，常见的使用场景包括：

默认值表：使用 __index 为表提供默认值。
运算符重载：让自定义类型支持算术或比较运算。
面向对象编程：通过 __index 和元表实现类与对象。
只读表：使用 __newindex 拦截赋值行为，防止表被修改。
代理表：通过 __index 或 __call 动态生成数据。

修正语法思路

关于元表绑定父表的一个小细节

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对参数的规定

-- 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 脚本。例如：

public class Player
{
    public int health = 100;
    public int mana = 50;
}

策划如何知道哪些变量可以用？

程序员一般要提供一份脚本文档或模板，列出策划可以操作的变量、数据结构和接口。

文档需要详细说明：
- player.health 表示角色当前血量，类型是整数；
- enemy.attackPower 表示敌人的攻击力。
- ...

程序员和策划需要约定数据和逻辑的名称

-- Lua 脚本
local tasks = {
    { id = 1, name = "收集苹果", required = 10, reward = 100 },
    { id = 2, name = "击败敌人", required = 5, reward = 200 }
}

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 脚本中编写逻辑，修改数据即可。
工具和约定的作用：策划只需了解绑定的变量和接口，配合文档和自动生成的工具，可以轻松完成任务配置或逻辑调整。

原文地址：https://blog.csdn.net/red_redemption/article/details/144033033

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

金铲铲S13双城之战自动拿牌助手
金铲铲S13双城之战自动拿牌助手基于python和pyautogui实现
阅读更多2024-11-27
OSPTrack：一个包含多个生态系统中软件包执行时生成的静态和动态特征的标记数据集，用于识别开源软件中的恶意行为。
2024-11-22 ，由格拉斯哥大学创建的OSPTrack数据集，目的是通过捕获在隔离环境中执行包和库时生成的特征，包括静态和动态特征，来识别开源软件（OSS）中的恶意指标，特别是在源代码访问受限时
阅读更多2024-11-27
STM32中I2C总线中，允许从机控制SCL总线吗？
在I2C总线中，不允许从机控制SCL总线。
阅读更多2024-11-27
C/C++ 每日一练：在矩阵中查找特定值
本次练习将解决一个经典问题——在一个二维矩阵中查找特定的值。通过这个练习，可以更好地掌握二维数组的操作，以及优化算法的设计。给定一个二维矩阵 matrix，每行从左到右递增排序，每列从上到下递增排序，
阅读更多2024-11-27
【Zookeeper 和 Kafka】为什么 Zookeeper 不用域名？
如果是容器化部署或者 IP 动态变化，给 Zookeeper 配域名也不是不行，但大部分情况下，直接用 IP 地址就够啦！Zookeeper 通信是高频、低延迟的，域名解析（DNS）会增加额外开销，直
阅读更多2024-11-27
解决SpringBoot连接Websocket报：请求路径 404 No static resource websocket.
解决SpringBoot连接Websocket报：请求路径 404 No static resource websocket.
阅读更多2024-11-27
Android 11 三方应用监听关机广播ACTION_SHUTDOWN
关机广播监听
阅读更多2024-11-27
二分查找-02-搜索插入位置
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。输入: nums = [1,3,5,6], target = 5。输入: num
阅读更多2024-11-27
【计网笔记】网络层
无连接服务，即数据报服务有连接服务，即虚电路服务。
阅读更多2024-11-27
C语言中const char *字符进行切割实现
【代码】C语言中const char *字符进行切割实现。
阅读更多2024-11-27