MSYS2 是一个 Windows 下的 Linux-like 环境，提供 g++ 编译器和 gdb 调试器。
C:\msys64（默认路径）ms-vscode.cpptoolsC:\msys64在 MSYS2 UCRT64 终端中执行以下命令：
1 | # 更新包数据库 |
Ctrl+Shift+X 打开扩展面板C/C++ 并安装 Microsoft 的 C/C++ 扩展在你的 C++ 项目根目录（例如 C:\Dev\leetcode）创建 .vscode 文件夹，并添加以下配置文件：
1 | { |
1 | { |
1 | { |
1 | { |
在 VS Code 用户设置中添加快捷键绑定（Ctrl+Shift+P -> Preferences: Open Keyboard Shortcuts (JSON)）：
1 | [ |
Ctrl+Shift+B 或打开命令面板运行 “Tasks: Run Build Task”F5，会启动 gdb 调试器F6，会打开 cmd 黑框窗口运行程序C:\msys64\ucrt64\binbuild/Debug/outDebug.exeterminal.external.windowsExec 设置1 |
|
1 | int gcd(int a,int b) // 最大公约数 |
1 | int prime(int b) // 素数 |
1 | int c[N][N]; |
1 | int Fast(int x,int n) { |
1 | int pow(int a,int x) { |
1 | string trans(int num,int base) { |
1 | 等差数列求和公式： |
1 | sort（起始地址，终点地址，比较方法）； |
Android 15 的 16KB page 检测主要看三件事：
对于aab 来说，上面的三个要求，一般只用关注PT_LOAD。因为aab 有压缩率，所以关于压缩的两项检验直接计算是不准确的。Google Play 在分发时会自动处理。
官方文档：
https://developer.android.com/guide/practices/page-sizes?utm_source=chatgpt.com&hl=zh-cn
关于so 文件是否合规的检测，主要有以下几种方法：
可以解压出so文件，然后使用ndk 工具检测（一定使用PowerShell，cmd无法运行）：
1 | llvm-objdump.exe -p E:\Test\so\arm64-v8a\libanogs.so | Select-String -Pattern "LOAD" |
运行结果可以看LOAD off 类型行尾是不是带有212、213。
低于2**14的so文件都不符合。
工具的路径在：
1 | {YourNDKPath}\toolchains\llvm\prebuilt\windows-x86_64\bin |
但是这里只检查了PT_LOAD。
Google 官方提供了检测工具：
可以直接使用这个脚本进行检测。
1 | check_elf_alignment.sh APK_NAME.apk |
最后，如果将Android Studio 更到最新版本，即可使用Apk Analyze 功能进行检测。
前者报错为：1
4 KB LOAD section alignment, but 16 KB is required
后者报错为：1
RELRO is not a suffix and its end is not 16 KB aligned
Unity相关的so，需要通过提升Unity 编辑器版本号的方式进行解决。
第三方SDK 相关的so，需要联系相关提供商进行SDK 升级。
如果无法完成合规，应该考虑取消对该插件的接入。
如果是自己使用NDK 编译的so，需要升级NDK工具并在编译中指定相关参数。
1 | ({NDK Path}/ndk-build ^ |
对于Android.mk 文件和Application.mk 文件也有内容需要修改：
如果旧内容涉及cmd-strip，在打包时会报错。这是因为NDK r23+中，strip 工具路径变成 LLVM 版本。最简单的解决方式是删掉这一行，新版本不需要手动调用strip，会自动调用。
如果文件中存在：APP_STL := gnustl_static，也需要进行修改。
修改为：APP_STL := c++_static
为了兼容RELRO 必须在 segment 末尾（suffix）和 RELRO end 必须 16KB 对齐，需要在Android.mk 中增加：
1 | LOCAL_LDFLAGS += -Wl,-z,max-page-size=16384 |
最后，在旧的代码中，如果使用了PAGE_SIZE / PAGE_MASK 宏，这会报错，在新版本中，NDK 不再提供。
需要增加以下内容：
1 | #ifndef PAGE_SIZE |
升级到新版Unity之后，如果不修改代码，可能不会让C++代码重新导出。
也可以删除Library目录下的Bee目录和所有的il2cpp_*目录的缓存，强制生成。
]]>捡起了好久没有更新的博客。
在AI 的帮助下，我完成了整个环境的重新搭建。
由于我使用的hexo 框架和版本都比较老了，所以有些地方可能不适应于新版本的主题，在接入时还请注意。
参考视频： https://www.bilibili.com/video/BV1xTgTemEDU/
视频文档： https://xiamu-ssr.github.io/Hexo/2024/06/19/2024-H1/2024-06-19-12-31-52/
使用Github Actions 服务，将hexo 部署到 Github Pages。
与参考内容不同的是，我使用了两个仓库来实现。
参考内容中，使用了同一个项目，两个分支。其中一个分支用于提交博客源文件，另一个分支用于存放生成的静态网页文件。
考虑到将博客源文件内容暴露出来会有一定的风险，于是我的方案是使用两个仓库来实现。其中，Private 的仓库用于存放博客源文件，Public 的仓库用于存放页面。
我之前是有hexo 环境的，会和从头开始实现有所区别，在接下来的内容中，我将会分别说明。
关于Github Actions 服务的用量，Public 仓库可以免费使用，但是Private 的仓库会有一定的限制。但是如果只是作为hexo的资源站，免费的额度也是可以覆盖的。
安装并初始化hexo，如果已有hexo环境，可跳过这一步。
1 | npm install -g hexo-cli |
如果是已有hexo环境，在其他地方做过备份的。可以删除node_modules目录和package-lock.json，然后重新安装：
1 | cd blog |
在github上新建两个仓库，一个Private的blog_base，一个Public 的username.github.io；
已有Github Pages 的，可以不用重新创建username.github.io，只创建博客源文件仓库。
使用Github Actions ，需要生成Personal access tokens，而且至少要包含repo 权限。把这个Token 配置给Github Action， 它才有权限去执行自动部署。
首先是Token 的创建：
单击头像 -> Settings -> Developer Settings -> Personal access tokens -> Tokens (classic)
这里是所有Tokens的列表，下面我们继续创建：
Generate new token -> Generate new token (classic)
新打开的界面中，我们需要给这个token 命名，随便命名即可，比如blog_base。
在下面的权限列表中，勾选repo，workflow 两项。
记录token的有效期，有效期到期后需要给Github Actions 配置新的token。
完成创建后，去到blog_base 仓库进行配置。首先打开该仓库，点击上方的Settings -> Secrets and variables -> Actions
点击 New repository secret 创建，Name设置为：GH_TOKEN（可随意设置，后面保持一致即可），Secret 粘贴刚才生成出来的token内容，就是一串以ghp_为开头的字符串。
为了设置推送的地址，需要在_config.yml 中配置推送地址。这里选择Public 的Github pages 仓库地址：
1 | deploy: |
在blog_base 目录创建.github文件夹，再在.github文件夹下创建workflows文件夹，然后创建deploy.yml，内容如下：
1 | name: Deploy Hexo to GitHub Pages |
这里最后一步是将生成的内容，推送到你配置的仓库的master 分支，我的Github Pages就是设置的这个分支。
配置里的node-version 这个参数需要注意。旧版的hexo 使用新版的node 可能会生成失败。我的主题使用的hexo 版本比较老，使用12版本是可以生成的，最新的24 反而无法生成，这里可以按需修改版本。
这个工作流的意思就是，使用ubuntu-latest作为基础环境，然后安装各种依赖，随后hexo generate生成博客网站静态文件夹，最后再推送到设定的仓库和分支。
到Github Pages 仓库，点击Settings，设置page来源的分支。
推送并查看是否能够生效。
在这里，介绍一下我的.gitignore文件:
1 | .DS_Store |
.DS_Store文件和Thumbs.db文件。这两个文件分别是Mac系统和Win系统生成的垃圾。
public 目录存放的是本地生成的静态页面，这个也不必上传。Github Actions 会自动生成。
node_modules 目录一定不能上传，需要排除掉。因为它太大了，不方便版本控制。而且不同平台需求的可能都不同。本地环境和运行Github Actions 的虚拟机环境不可能保证一致的。
如果你之前是有Github Pages的，需要做好备份，防止文件丢失。
我就出现了CNAME文件和其他文件丢失的情况，这里需要注意。
如果嫌username.github.io 的网址不够优雅，可以注册域名，然后配置解析。
在购买域名后，进行以下设置：
进入Github Pages 仓库，单击Settings 切页。
在左侧边栏点击Pages。
Custom domain 配置为：
1 | www.yourdomin.xxx |
然后勾选Enforce HTTPS
在域名解析中，做出以下设置：
1 | www CNAME yourusername.github.io |
需要在Github Pages 网站的根目录创建CNAME文件，内容是在第一步中配置的www.yourdomin.xxx
]]>使用LuaEnv中的DoString方法来执行Lua脚本。
因为创建一个LuaEnv相当于创建了一个lua虚拟机，所以一个游戏最好只有一个LuaEnv。
1 | // 执行lua代码 |
官方建议的加载Lua脚本方式是：整个程序就一个DoString(“require ‘main’”)，然后在main.lua加载其它脚本（类似lua脚本的命令行执行：lua main.lua）。
先加载lua脚本，再通过LuaEnv.Global.Get获取变量。
1 | TextAsset ta = Resources.Load<TextAsset>("Lua/variable.lua"); |
需要注意的是，在构建C#中对应的结构时，接口一定要是public修饰，否则会报错。类最好也是，但是经测试，没有报错。
映射到普通class或struct
table的属性可以多于或者少于class的属性，也就是不一定都需要做映射。这个过程是值拷贝，如果class比较复杂代价会比较大。而且修改class的字段值不会同步到table，反过来也不会。1
2
3
4
5
6
7public class Person
{
public string name;
public int age;
}
Person p = env.Global.Get<Person>("g_tbl");
映射到接口
一定要加[CSharpCallLua]和public，否则会报错。1
2
3
4
5
6
7g_int = 1
g_str = "Hello World Variable"
g_bool = false
g_tbl = {name = "Juhnny", age = 12}
g_tbl.say = function(this, str)
print(str)
end
1 | [] |
映射到Dictionary和List
这种方法较方法2更为轻量级，但是要求table下key和value类型一致。1
2g_dic = {apple = "iPhone", flower = "Huawei"}
g_list = {1, 3, 5, 7, 9}
1 | Dictionary<string, string> dic = env.Global.Get<Dictionary<string, string>>("g_dic"); |
映射到LuaTable
这种方法比较慢，而且没有类型检查，不推荐使用。1
2
3
4
5
6
7
8LuaTable tab = env.Global.Get<LuaTable>("g_tbl");
string name = tab.Get<string>("name");
int age = tab.Get<int>("age");
print(string.Format("Name is {0}, age is {1}", name, age));
foreach (string key in tab.GetKeys())
{
print(tab.Get<object>(key));
}
使用delegate映射
这种是建议的方式，性能好很多，而且类型安全，但是要生成代码。支持带返回值，多返回值，甚至返回值都可以是delegate。1
2
3
4
5
6
7
8g_func1 = function()
print("FF")
end
g_func2 = function(num)
print(num)
return num, "Yoshida", "SE"
end
1 | [] |
在过去的一些版本中，需要在不使用后，将接收到的函数销毁，否则会在LuaEnv.Dispose的时候报错。
使用LuaFunction
与上一种方法优缺点相反，不推荐使用。1
2LuaFunction func = env.Global.Get<LuaFunction>("g_func2");
object[] res = func.Call(14);
1 | // 读静态属性 |
方法的参数处理
Lua调用侧的参数处理规则：C#的普通参数算一个输入形参，ref修饰的算一个输入形参，out不算，然后从左往右对应lua 调用侧的实参列表。
Lua调用侧的返回值处理规则：C#函数的返回值（如果有的话）算一个返回值，out算一个返回值，ref算一个返回值，然后从左往右对应lua的多返回值。
可变参数的处理1
2
3
4
5// 对于C#的如下方法：
void VariableParamsFunc(int a, params string[] strs)
// 可以在lua里头这样调用：
testobj:VariableParamsFunc(5, 'hello', 'john')
枚举1
2
3
4
5
6
7
8
9
10// 枚举值就像枚举类型下的静态属性一样。
testobj:EnumTestFunc(CS.Tutorial.TestEnum.E1)
上面的EnumTestFunc函数参数是Tutorial.TestEnum类型的。
枚举类支持__CastFrom方法，可以实现从一个整数或者字符串到枚举值的转换，例如：
CS.Tutorial.TestEnum.__CastFrom(1)
CS.Tutorial.TestEnum.__CastFrom('E1')
委托
1 | -- 使用+-号来实现委托 |
如果直接使用默认的–[[和–]]来进行多行注释的时候,如果遇到table包table的情况会直接结束注释:1
2
3
4
5
6--[[
a = [];
b = [a];
a[b[1]]
a = 1
--]]
可以使用另一种方法来进行多行注释,避免这个问题:1
2
3
4
5
6--[=[
a = [];
b = [a];
a[b[1]]
a = 1
]=]
当然,最安全的方法还是使用IDE的快捷键进行注释.IDE会在每行的前面加单行注释,避免错误的发生.
多行字符串,也会出现类似于上面的情况:1
2
3
4
5
6
7
8
9
10str =
[[
话说
这个东西
好像打印不出来
就是这个
table[table[idx]]
咋办啊
]]
print(str)
#运算符取的是最大索引的值，如果删除了中间的值，获得的结果不会改变：1
2
3
4
5tb_a = {1, 2, 3}
print (#tb_a)
tb_a[2] = nil
print (#tb_a)
但是这种情况仅限于Lua 5.1 ，Lua5.3和Lua5.4结果是1。
模拟三目运算符的and…or…，在第二个参数为false时，始终返回c，会出现问题：1
2a = true
print (a and false or true)
输出结果会是true 而不是三目运算符应该返回的false。
这时候，可以将三目运算符的后面两个部分转换成table，运算结束后再取第一个元素，即可实现：1
2
3
4
5
6
7a = true
b = (a and {false} or {true})[1]
if b then
print("true")
else
print("false")
end
自定义迭代器的格式：1
2
3for 变量列表 in 迭代函数, 状态变量, 控制变量 do
-- 循环体
end
自定义无状态迭代器1
2
3
4
5
6
7
8
9
10
11function square(iteratorMaxCount, currentNumber)
if currentNumber < iteratorMaxCount then
currentNumber = currentNumber + 1
return currentNumber, currentNumber * currentNumber
end
end
for i, n in square, 3, 0
do
print(i, n)
end
多状态迭代器：
多个状态可以存放在table，因此只需要一个参数即可：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18array = {"Google", "Runoob"}
function elementIterator (collection)
local index = 0
local count = #collection
-- 闭包函数
return function ()
index = index + 1
if index <= count then
-- 返回迭代器的当前元素
return collection[index]
end
end
end
for element in elementIterator(array) do
print(element)
end
可以使用goto语句来实现continue：1
2
3
4
5
6
7
8
9for i=1, 3 do
if i <= 2 then
print(i, "yes continue")
goto continue
end
print(i, " no continue")
::continue::
print([[i'm end]])
end
Lua可以通过设置元表，定义元方法的方式，改变table的一些行为：
index元方法，可以修改按索引取值的逻辑。
若index内容是一个表的话，如果table里没有值，会从元表中对应的索引去取：1
2
3
4
5
6
7
8
9
10
11t_table = setmetatable({k1 = "v1"}, {__index = {k2 = "v2"}})
print(t_table["k1"])
print(t_table["k2"])
t_table["k2"] = "v3"
print(t_table["k2"])
--[[
输出是：
v1
v2
v3
--]]
若__index内容是一个函数，则可以定义返回逻辑：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
28t_table = setmetatable({}, {__index =
function(t_table, key)
if key == 1 then
return "true"
else
return "false"
end
end
})
print(t_table[1])
print(t_table[2])
print(t_table[3])
t_table = {1, 2, 3}
print(t_table[1])
print(t_table[2])
print(t_table[3])
--[[
输出是：
true
false
false
1
2
3
--]]
__newindex元方法，可以修改追加索引时的逻辑1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17t_table = setmetatable({k1 = "v1"}, {
__newindex =
function(t_table, key, value)
rawset(t_table, key, "\"v" .. value .. "\"")
end
})
t_table["k2"] = 2
print(t_table["k1"])
print(t_table["k2"])
--[[
输出是：
v1
"v2"
--]]
其它的规则：
|元表|运算符|
|:–:|:–:|
|add|+|
|sub|-|
|mul|*|
|div|/|
|mod|%|
|unm|-(相反数)|
|concat|..|
|eq|==|
|lt|<|
|le|<=|
add和tostring:1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21t_table = setmetatable({1, 2, 3}, {__add =
function(t_table, data)
t_table[#t_table + 1] = data
return t_table
end,
__tostring =
function(t_table)
local res = ""
for _, v in pairs(t_table) do
res = res .. v
end
return res
end
})
print(t_table)
print(t_table + 4)
--[[
输出：
123
1234
--]]
需要注意的是，关系运算符，比较的两端，元表必须相同。如果只有一方有元表，另一方没有，又或者是两方拥有不同的元表，会导致比较报错：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25a_metatable =
{
__gt = function(a_table, b_table)
return a_table[1] > b_table[1]
end,
__lt = function(a_table, b_table)
return a_table[1] < b_table[1]
end
}
b_metatable =
{
__gt = function(a_table, b_table)
return b_table[1] > a_table[1]
end,
__lt = function(a_table, b_table)
return b_table[1] < a_table[1]
end
}
a_table = setmetatable({0}, a_metatable)
b_table = setmetatable({1}, b_metatable)
print(a_table<b_table)
--[[
报错内容是：
attempt to compare two table values
--]]
重写取反操作1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24a_metatable =
{
__unm = function(a_table)
local _temp_table = {}
for i = #a_table, 1, -1 do
_temp_table[#a_table + 1 - i] = a_table[i]
end
return _temp_table
end
}
p_metatable =
{
__tostring =
function(a_table)
local res = ""
for _, v in pairs(a_table) do
res = res .. v
end
return res
end
}
a_table = setmetatable({1, 2, 3}, a_metatable)
b_table = setmetatable(-a_table, p_metatable)
print(b_table)
__call比较有意思，可以让table可以变得和函数一样可以执行。因此可以写成如下的极其过分的形式：1
2
3
4
5
6
7
8
9
10function_content =
{
__call = function(a_table, a_data)
print(a_data)
end
}
func_print = setmetatable({}, function_content)
b = func_print(4)
1 | function sleep(n) |
用table实现了类与继承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-- 类
-- 类管理器
CClassManager = {}
function CClassManager.ctor(cls, ...)
local this = {}
setmetatable(this, cls)
cls.__index = cls -- 将元表的__index设为自身，访问表的属性不存在时会搜索元表
cls.init(this, ...)
return this
end
function CClassManager.VInit(self, ...)
end
function CClassManager.init(self, ...)
self:VInit(...)
end
function CClassManager.dtor(cls)
-- do sth
end
-- 通过继承实现的类的定义
ClassT = CClassManager:ctor()
function ClassT.VInit(self, word)
self.word = word
end
function ClassT.say(self)
print(self.word)
end
test = ClassT:ctor("B")
test:say()
test:dtor()
test:say()
EFK 是三个开源软件的缩写，Elasticsearch，FileBeat，Kibana。其中 ELasticsearch 负责日志分析和存储，FileBeat 负责日志收集，Kibana 负责界面展示。它们之间互相配合使用，完美衔接，高效的满足了很多场合的应用，是目前主流的一种日志分析系统解决方案。
EFK 和 ELK 只有一个区别， 收集日志的组件由 Logstash 替换成了 FileBeat，因为 Filebeat 相对于 Logstash 来说有2个好处:
1.侵入低，无需修改 elasticsearch 和 kibana 的配置；
2.性能高，IO 占用率比 logstash 小太多
当然 Logstash 相比于 FileBeat 也有一定的优势，比如 Logstash 对于日志的格式化处理能力，FileBeat 只是将日志从日志文件中读取出来，当然如果收集的日志本身是有一定格式的，FileBeat 也可以格式化，但是相对于Logstash 来说，效果差很多。
1 . 安装Docker
2 . 下载所需镜像
1 | docker pull elasticsearch:7.12.0 |
3 . 创建自定义网络
1 | docker network create elk_net |
4 . 启动Elasticsearch和Kibana
1 | docker run -d --name elasticsearch --net elk_net -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.12.0 |
如果希望使用中文界面（中文化不完全，不推荐使用），可以进入kibana的容器里，修改排至文件，在现有配置文件中加一行中文相关的配置即可：
1 | server.name: kibana |
进入docker容器的指令为：
1 | docker exec -it kibana /bin/bash |
5 . 配置日志解析规则
日志解析的规则，是存放在Elasticsearch中的。只要通过curl命令即可实现向es中插入数据。
新建json文件：
1 | { |
patterns部分为解析每行日志的正则表达式，pattern_definitions是处理换行标志。
测试可以使用kibana自带的grok测试工具，在设置界面会有。
下方的date部分，是通过对上方产生的Time字段，存放到默认的时间戳上，用于处理排序。
处理完成后，把多余的字段删除，特别是输入的message，有利于缩减入库数据的量。
需要注意的是，json文件里的反斜杠一定要进行转义。
执行命令：
1 | curl -H "Content-Type: application/json" -XPUT 'http://192.168.3.67:9200/_ingest/pipeline/lmyzpip' -d@/home/docker/pipline/pip.json |
除此之外，可以登录Kibana界面，通过可视化界面配置解析。
右侧Add documents可以填写测试用例，测试相关配置是否正确（通过直接写入ES的配置也可以在此测试）。
测试数据的格式为：
1 | [ |
6 . 安装filebeat
新增配置文件filebeat.docker.yml：
1 | #=========================== Filebeat inputs ============== |
其中需要注意的是，如果filebeat和前面的EK两个东西，没有部署在同一台机器上，需要把容器名改成对应的ip地址。
运行Filebeat：
1 | docker run -d --net elk_net -v /home/docker/filebeat/filebeat.docker.yml:/usr/share/filebeat/filebeat.yml -v /home/docker/logs/:/home/docker/logs/ --link elasticsearch:elasticsearch --link kibana:kibana --name filebeat docker.io/store/elastic/filebeat:7.12.0 |
这里只讨论货币飞行路线的问题。
贝塞尔曲线(Bézier curve)，又称贝兹曲线或贝济埃曲线，是应用于二维图形应用程序的数学曲线。PS中的钢笔工具就是使用贝塞尔曲线来绘制矢量曲线的。
这里使用简单的，四个点确定的贝塞尔曲线来实现飞行轨迹。首先p0和p3分别是移动的起点和终点。为了模拟爆炸效果，可以通过随机选取以p0为圆心，长度为R的圆上的点，调整曲线的第一次弯折位置实现。这一点定为P1。最后，根据P1点和P0点之间的关系，进行x轴或者y轴的修正，实现曲线平滑延申到p3，这一点是p2点。
p1点（爆炸点）的获取方式：1
2
3
4
5private static Vector3 GetRandomPosition(Vector3 vec)
{
float sita = UnityEngine.Random.Range(-Mathf.PI, Mathf.PI);
return new Vector3(vec.x + Mathf.Cos(sita) * Screen.width / 8, vec.y + Mathf.Sin(sita) * Screen.width / 8);
}
p2点（修正点）的获取方式：1
2
3
4private static Vector3 GetFixedPoint(Vector3 start, Vector3 end)
{
return new Vector3(start.x + 3*(end.x - start.x)/4, start.y + 3 * (end.y - start.y) / 4 + p1.y > start.y ? Screen.height / 15 : - Screen.height / 15);
}
根据已知的四个点，实现物体延贝塞尔曲线移动的效果。
1 | /// <summary> |
不卖关子了，这个错误是多返回值函数造成了对上一句值的影响。下面举个例子：
1 | function func() { |
运行的结果将会是这样:
a is :1,2
b is :0 c is :0
很容易看到，我们函数的返回值给了上一行的a。这是因为我们的编译器将代码认为了：
1 | let a = 3 ,[b, c] = func(); |
避免这种情况，还是要多加分号吧——虽然它并不会报错。
]]>和买了新的电脑或者做了新系统一样，得先把生产环境搞好。
距离Python2.x停止维护大概只有5个月了吧，所以第一要务是升级Python的版本。但是yum是依赖Python2的，所以升级还是会有一些顾虑的。下面是升级的过程：
1 | wget https://www.python.org/ftp/python/3.8.0/Python-3.8.0.tgz |
1 | yum install make build-essential libssl-dev zlib1g-dev libbz2-dev |
1 | yum install -y make build-essential libssl-dev zlib1g-dev libbz2-dev |
1 | mv /usr/bin/python /usr/bin/python.bak |
将下面文件中的配置修改为Python2.x版本的路径。
1 | /usr/bin/yum |
pip需要依赖setuptools，所以要先安装setuptools。
1 | wget https://files.pythonhosted.org/packages/ce/1d/96320b9784b04943c924a9f1c6fa49124a1542039ce098a5f9a369227bad/setuptools-42.0.1.zip |
https://www.cnblogs.com/zhangym/p/6226435.html
https://www.cnblogs.com/fjping0606/p/9156344.html
https://www.cnblogs.com/fyly/p/11112169.html
需要注意的是，因为图床需要一个git目录，同时代码也需要。在使用部分git管理工具时会禁止这种目录的嵌套。因此最好将代码独立运行。可以自己打包，也可以使用我打好的可执行程序。
在这里需要提一句，一般如果只想要下载github上项目的一个目录或者一个文件，可以使用svn进行下载。将文件路径中的文件名/master替换为trunk即可使用下载。
经过配置之后，以后只需要将图片放到todo目录下，执行脚本即可。
编译时需要安装以下运行库
1 | pip install pyyaml |
Ver.0.2 2019-11-17 提交编译的可执行程序；增加配置文件
Ver.0.1 2019-11-12 提交项目
]]>但是在刷库的过程中，我发现，我总不能一次处理完所有的数据。后来发现是JavaScript的Replace函数的问题，这个函数默认只能替换第一个匹配到的项目。如果需要处理全部的，需要使用正则表达式：
1 | string.replace(/\\n/g, "\n") |
除此之外，下面是一些处理爬取内容常用操作，包含了html的转义：
1 | string.replace(/ /g, ' ') |
下面的方法主要是使用下标进行操作。如果是用值的话，可以通过indexOf()函数来获取下标。若不存在则返回-1。
值交换
1 | function swap_arr(a_list, index1, index2) { |
置顶
1 | function up_arr(a_list, index){ |
下移
1 | function down_arr(a_list, index) { |
插入
1 | function ins_arr(a_list, index, a_data) { |
在顶部插入
1 | function topins_arr(a_list, a_data) { |
删除元素
1 | function del_arr(a_list, a_data_list) { |
但是最近我在写另一个工具时，遇到了一个奇怪的问题，就是：tick总在27000多左右的时候崩溃。
我进行了一系列的猜测，比如tick的代码，或者是逻辑有问题，最后我把思路放在了之前遇到的这个错误上。查阅资料后发现，MySQL数据库在连接之后，如果超过一个设定的时间戳之后，会断开。这个值叫WAIT_TIMEOUT，默认值是28800，也就是说如果连上MySQL数据库之后，8小时内没有进行操作，这个连接便会断开。
网上很多连接MySQL数据库的代码没有处理过超时连接的问题，就连JS的官方代码好像也是在17年之后才更新的。以往这个问题，大家都是通过修改这个值来进行规避的。比如改成300天。修改有两种方式，一种是修改配置文件，这样在启动时便会使用这个配置；另一种是修改这个值，或者全局，或者当次生效。
下面是我在使用JavaScript语言链接MySQL数据库时，处理超时重连问题的代码：
1 | this.config = { |
很好的例子：
https://www.jianshu.com/p/a609f510b19a
https://blog.csdn.net/l799069596/article/details/47094731
安卓动画：https://blog.csdn.net/IO_Field/article/details/53101499
除去游戏本身的闪屏之外，有的渠道会要求，有额外的渠道闪屏。为了使用一套资源出不同渠道包，我们可以对接渠道的AS工程进行处理，单独设置闪屏。
首先，创建一个闪屏Activity，为你的主Activity，这样在游戏的一开始你就可以看到闪屏了。
这里需要注意的是，你原先的Activit也需要在Manifest中注册打开日志，否则在打包的时候会找不到，报错：
https://blog.csdn.net/qq_28301007/article/details/52265775
1 | <activity android:name="...Activity"/> |
下面是主Activity，也就是闪屏Activity的代码，需要根据AS的提示import缺少的部分。
1 | import android.animation.ObjectAnimator; |
1 |
|
在上面控制闪屏格式的style.xml中，可以看到闪屏的背景色设置为了白色。这里有一些常用的颜色xml：https://blog.csdn.net/sundaysunshine/article/details/53509854
除了这两处之外，还需要根据style.xml中的配置，放好闪屏图片，设置闪屏背景。
整个闪屏的原理就是创建一个动画，在动画播放完成之后，去执行一个新的activity。在补全报错的部分之后，还是有一些细节部分需要注意的。
首先是结束时间的判定。判定时机总共有两种，一种是获取动画的进度，就像这里的例子，使用(int)animation.getAnimatedFraction()进行获取一个从0~1的数，来表示目前的动画的播放进度。除此之外还可以获取播放的时间，这个函数是：getAnimatedValue()，它可以获取属性的当前值。使用这两个函数可以很方便地控制动画的时间和动作。
除此之外，在调起另一个Activity之后，我结束了这个Activity。这是因为如果使用默认的LaunchMode，在重新唤醒应用时，闪屏会再次启动，然后走完动画，应用重启。这就造成了应用无法关闭的状况，只能后台强制杀掉。解决办法就是让闪屏只执行一次。
]]>1.酷派
充值之后，服务器收不到消息，对接也没有人。
现在看来很明显，已然黄了。
2.应用宝
传说中的5000人大群只有2个技术的大渠道。每天上午问问题会施舍你两句，下午是肯定不会回答问题的，团建能团建半个月。这个渠道我是使用聚合sdk接入的。需要注意的是，接入时有测试阶段，和正式阶段之分，游戏货币名不能修改，同时还必须接入腾讯的信鸽推送SDK，否则无法过审，手动接入成本极高。
3.金立
高版本会造成初次进入闪退，主动获取权限也不行，必须低版本编译。
华为手机会出现渲染错误，游戏变成紫红色。
需要安装支付插件。
现在也应该没有接入的必要了。
4.华为
相当棒的渠道，文档详细，对接起来体验也很不错。充值错误的时候，每一步骤，原因都会有显示。
但是不支持第三方工具接入。
需要安装支付插件。
5.魅族
商品id配置不明，会出现莫名的变动，很不靠谱。
支付回调生效需要1天的时间，需要对商品进行映射，对接很麻烦的渠道。
需要安装支付插件。
6.360
包体最大，足足有50多k的方法数，不分包就是死。
7.百度
方法数排名第二，仅次于360。
高版本编译会无法使用闪屏。
提审体验极差。说好的SDK不强用更，但是等到提审后告诉你不合格。
8.联想
商品id为自动生成，需要做好映射。
AnySDK接入需要注意参数顺序。
9.UC
无法使用第三方工具进行接入。
闪屏比较蛋疼，在sdk初始化时自动播放。首次运行时无法正常显示，时机不一定，容易和应用闪屏覆盖。
10.OPPO、VIVO
无法使用第三方工具进行接入。
需要安装支付插件。
11.小七
文档描述不明确，注意对登陆回调的处理方式，注重切换账号的测试。
SDK的Manifest中，最高宽高比设置为2.2。如果游戏中有对这个参数进行修改，需要进行统一。
12.拇指玩
sdk默认背景为透明，会造成有些版本的手机唤起sdk时会显示桌面为背景。或者是切换到主屏后，再回来，只有单独的sdk页面。
解决方式是把style.xml中的windowIsTranslucent值置为为false。
回调处理方式与其他sdk略有不同,Log与执行功能部分的代码进行了分离。
目前版本，无法使用qq登陆等方式，在登陆界面仍没有去掉该入口。
其他:
在运营过程中，小米、UC、应用宝和魅族会不同频率出现无法登录的问题，属正常现象，是他们的SDK服务器抽风了，会报一些很可怕的错误，比如应用不存在，应用id无效之类的。这时候只需要稳定好用户的心态即可，没有任何解决办法。
]]>最近，微信针对文章历史接口做了调整：PC版限制了爬取的次数，访问间隔应该控制在8分钟以上，移动端则是在两个月前直接干掉了这个功能。文章评论则没有改变。因此，这个工具目前最好的使用方式就是多开，分别爬不同的文章，再单开一个用来爬需要爬的评论。
工具的具体使用方法在原工程中都有提到，这里就不再赘述了。
在工具的使用方法中，我们知道，作者是使用全局代理，将所有的https消息都强制走了本机的8080端口，然后通过Python的mitmproxy来截取消息内容来实现的这个工具。那么，我可以使用局部代理，将制定的微信客户端，走制定端口，即可实现工具的多开。
有了这个思路，那么我们就只需要解决两个问题：
这里先说一下，我们无法使用微信PC客户端自带的代理功能。因为一旦这个功能开启，微信的所有链接都将进行加密，你得到的只会是一个格式如：<code>https://xxx.xxx.xx.xx/mmtls/xxxxxx``的加密链接。
微信多开的实现比较简单，直接使用bat脚本打开多个微信即可。需要注意的是，要以管理员模式运行。
1 | @echo off |
这样虽然可以打开多个微信，但是在设置局部代理时，工具无法区相同路径下的相同可执行文件。因此，我们需要把微信客户端拷贝多份，以应对后面的步骤。
1 | @echo off |
需要注意的是，这样配置之后的脚本将不一定百分百执行成功，可能只打开一个客户端。一般第二次即可执行成功。
这里，我使用了Proxifier工具，进行局部代理。这个工具很容易获取，x度上很容易就可以获取到免费破解汉化的版本。
安装之后，我们开始配置工作。
1.配置文件->代理服务器 这里地址填本机127.0.0.1，端口填你想要转发的端口，比如8080，8081，协议类型是HTTPS。你想开多少，就填多少个。
2.配置文件->代理规则 这里我们把默认的全局代理给关闭，双击条目，将“是否有效”取消勾选即可。然后添加微信的代理规则，点击添加，名称随意，应用程序浏览到微信的exe文件，目标主机清空，端口清空，然后在最下方的动作中选择你上一步配置的一个端口。那么这个路径下的客户端执行时，便会代理到这个端口下了。
微信多开之后，我们会发现多开的这几个的微信的进程名是一样的，无法进行区分。这时候可以在任务管理器中使用切换到、最小化等功能确定哪个窗口是哪个进程，转到本地文件来确定他是哪个目录下的。在开多个的时候，一定要注意区分，以防登错账号，影响爬取。
爬虫的配置文件中，我们最好使用不同的mysql数据库，以免产影响。当然，如果你修改了原工具的代码，那就另当别论了。
]]>GC回收堆上的内存
避免：1.减少new产生对象的次数
2.使用公用的对象（静态成员）
3.将String换为StringBuilder
1.压缩自带类库；
2.将暂时不用的以后还需要使用的物体隐藏起来而不是直接Destroy掉；
3.释放AssetBundle占用的资源；
4.降低模型的片面数，降低模型的骨骼数量，降低贴图的大小；
5.使用光照贴图，使用多层次细节(LOD)，使用着色器(Shader)，使用预设(Prefab)。
6.代码中少产生临时变量
1.使用assetbundle，实现资源分离和共享，将内存控制到200m之内，同时也可以实现资源的在线更新
2.顶点数对渲染无论是cpu还是gpu都是压力最大的贡献者，降低顶点数到8万以下，fps稳定到了30帧左右
3.只使用一盏动态光，不是用阴影，不使用光照探头
粒子系统是cpu上的大头
4.剪裁粒子系统
5.合并同时出现的粒子系统
6.自己实现轻量级的粒子系统
animator也是一个效率奇差的地方
7.把不需要跟骨骼动画和动作过渡的地方全部使用animation，控制骨骼数量在30根以下
8.animator出视野不更新
9.删除无意义的animator
10.animator的初始化很耗时（粒子上能不能尽量不用animator）
11.除主角外都不要跟骨骼运动apply root motion
12.绝对禁止掉那些不带刚体带包围盒的物体（static collider ）运动
NUGI的代码效率很差，基本上runtime的时候对cpu的贡献和render不相上下
13每帧递归的计算finalalpha改为只有初始化和变动时计算
14去掉法线计算
15不要每帧计算viewsize 和windowsize
16filldrawcall时构建顶点缓存使用array.copy
17.代码剪裁：使用strip level ，使用.net2.0 subset
18.尽量减少smooth group
19.给美术定一个严格的经过科学验证的美术标准，并在U3D里面配以相应的检查工具
1.遮挡剔除（Occlusion Culling） 不显示被遮挡住的物体
2.LOD 根据相机距离远近显示不同精细程度的模型
3.大场景可以调节相机可视距离
4.小物体可以适当隐藏掉
5.使用光照贴图 避免动态实时的进行光照计算，提高效率
1.将同一画面图片放到同一图集中
2.图片和文字尽量不要交叉，会产生多余drawcall（相同材质和纹理的UI元素是可以合并的）
3.UI层级尽量不要重叠太多
4.取消勾选不必要的射线检测RaycastTarget
5.将动态的UI元素和静态的UI元素放在不同的Canvas中，减少canvas网格重构频率
]]>1.字符串使用StringBuilder而不是string，stringBuilder在创建时会自动获取一个容量存储并逐渐扩充，string每一次改变都会创建一个新的对象。
2.访问物体tag的时候尽量使用Gameobject.CompareTag()，因为访问物体的tag属性会在堆上额外的分配空间
3.使用对象池缓存大量创建的物体
4.用for代替foreach，foreach每次迭代产生24字节垃圾内存
是指在显示器上为了显示出图像而经过的一系列必要操作。 渲染管道中的很多步骤，都要将几何物体从一个坐标系中变换到另一个坐标系中去。主要步骤有：
本地坐标->视图坐标->背面裁剪->光照->裁剪->投影->视图变换->光栅化
渲染流水线流程：
1.应用阶段（由CPU负责，输出是渲染所需要的几何信息，即渲染图元。然后发起Draw Call，进入GPU流水线）
2.几何阶段（由GPU负责，处理渲染图元，这阶段中最重要的就是把顶点坐标变换屏幕空间中，交给光栅器处理
这阶段输出的是屏幕空间中二维顶点坐标、每个顶点对应的深度值、着色等相关信息）
3.光栅化阶段（由GPU，负责这一阶段会使用上个阶段传递的数据来产生屏幕上的像素，并渲染出最终的图像）
细节过程https://zhuanlan.zhihu.com/p/97498781
Unity中，每次引擎准备数据并通知GPU的过程称为一次Draw Call。DrawCall越高对显卡的消耗就越大。降低DrawCall的方法：
- Dynamic Batching
- Static Batching
- 高级特性Shader降级为统一的低级特性的Shader。
CPU通过调用绘制命令来告诉GPU开始进行一个渲染过程(一次DrawCall)。
CPU方面减少DrawCall：
1、使用Draw Call Batching 、Dynamic Batching动态批处理
2、纹理打包成图集减少材质使用
3、少用反光、阴影
4、设置一个合适的Fixed Timestep
5、不要使用网格碰撞器(Mesh Collider)
6、大量或频繁的字符串连接操作一定要用StringBuilder
7、某些可能情况，使用结构体代替类
8、使用对象池重复利用空间
9、尽量不要用foreach，用for
10、不要直接访问GameObjcet的tag属性
11、不要频繁使用GetComponent，访问一次后保留其引用
12、使用OnBecameVisible()和OnBecameInVisible()，控制物体update()函数的执行减少开销
13、使用内建数组，如Vector3.zero而不是new Vector3(0,0,0)
14、使用ref关键字对方法的参数进行优化
15、关闭所有update中的log操作
16、不在update中调用GetComponent、SendMessage、FindWithTag等方法
17、不在update中使用临时变量
1、使用纹理图集代替一系列单独小贴图
2、保持材质数目尽可能少
3、如果使用纹理图集和共享材质，用Renderer.sharedMaterial代替Renderer.material
4、使用光照纹理(lightmap)而非实时灯光
5、使用LOD
6、使用mobile版的shader
7、尽可能减少顶点数、背面删减
8、压缩图片，减少显存带宽压力
材质系统定义了如何渲染物件表面信息。shader里面使用材质信息加自身操作，最终呈现物体渲染。shader是material一部分，是根据计算即时演算生成贴图的程序，叫着色器。常用处理无法用固定贴图表现的模型。material是模型的材质，包含贴图、shader、顶点、凹凸等信息。
在Game视图右上角点击Stats。降低Draw Call 的技术是Draw Call Batching
这个在5.0以后在window-》Profiler下面，快捷键是cmd + 7（ctl + 7
DrawCall：meshes网格绘制应用批处理后的总数。请注意，在多次呈现对象(例如，由像素灯照明的对象)，每个在一个单独的渲染结果绘制调用。
SetPass Call：渲染改变（ passes）次数。每个改变 需要Unity运行时绑定一个新的渲染器（shader），它可能会引入 CPU 开销。
表面着色器的抽象层次比较高，它可以轻松地以简洁方式实现复杂着色。表面着色器可同时在前向渲染及延迟渲染模式下正常工作。
顶点片段着色器可以非常灵活地实现需要的效果，但是需要编写更多的代码，并且很难与Unity的渲染管线完美集成。
固定功能管线着色器可以作为前两种着色器的备用选择，当硬件无法运行那些酷炫Shader的时，还可以通过固定功能管线着色器来绘制出一些基本的内容。
把A组物体的渲染队列大于B物体的渲染队列，通过shader里面的渲染队列来渲染
没有区别，因为不管几张贴图只渲染一次。
LOD(Level of detail)多层次细节，是最常用的游戏优化技术。它按照模型的位置和重要程度决定物体渲染的资源分配，降低非重要物体的面数和细节度，从而获得高效率的渲染运算。缺点是增加了内存。
MipMapping：在三维计算机图形的贴图渲染中有常用的技术，为加快渲染进度和减少图像锯齿，贴图被处理成由一系列被预先计算和优化过的图片组成的文件，这样的贴图被称为MipMap。
LightMap:就是指在三维软件里实现打好光，然后渲染把场景各表面的光照输出到贴图上，最后又通过引擎贴到场景上，这样就使物体有了光照的感觉。
Alpha Blend 实现透明效果，不过只能针对某块区域进行alpha操作，透明度可设。
alpha blend 用于做半透明效果。Color = (源颜色 源系数) OP ( 目标颜色 目标系数);其中OP（混合方式）有加，减，反减，取最小，取最大
作用就是Alpha混合。公式：最终颜色 = 源颜色 x 源透明值 + 目标颜色 x（1 - 源透明值）
Alpha Test ,中文就是透明度测试。简而言之就是V&F shader中最后fragment函数输出的该点颜色值（即上一讲frag的输出half4）的alpha值与固定值进行比较。AlphaTest语句通常于Pass{}中的起始位置。Alpha Test产生的效果也很极端，要么完全透明，即看不到，要么完全不透明。
顶点着色器是一段执行在GPU上的程序，用来取代fixed pipeline中的transformation和lighting，Vertex Shader主要操作顶点。
Vertex Shader对输入顶点完成了从local space到homogeneous space（齐次空间）的变换过程，homogeneous space即projection space的下一个space。在这其间共有world transformation, view transformation和projection transformation及lighting几个过程。
diffuse = Kd x colorLight x max(N*L,0)；
Kd 漫反射系数、colorLight 光的颜色、N 单位法线向量、L 由点指向光源的单位向量、其中N与L点乘，如果结果小于等于0，则漫反射为0。
1 | 答：漫反射光(diffuse)计算公式为：Idiffuse = Dintensity*Dcolor*N.L ; (Dintensity表示漫反射强度，Dcolor表示漫反射光颜色，N为该点的法向量，L为光源向量) |
修改sharedMaterial将改变所有物体使用这个材质的外观，并且也改变储存在工程里的材质设置。不推荐修改由sharedMaterial返回的材质。如果你想修改渲染器的材质，使用material替代。
原理就是对水面的贴图纹理进行扰动，以产生波光玲玲的效果。用shader可以通过GPU在像素级别作扰动，效果细腻，需要的顶点少，速度快
如果动态物体共用着相同的材质，那么Unity会自动对这些物体进行批处理。动态批处理操作是自动完成的，并不需要你进行额外的操作。
区别：动态批处理一切都是自动的，不需要做任何操作，而且物体是可以移动的，但是限制很多。静态批处理：自由度很高，限制很少，缺点可能会占用更多的内存，而且经过静态批处理后的所有物体都不可以再移动了。
本影：景物表面上那些没有被光源直接照射的区域（全黑的轮廓分明的区域）。
半影：景物表面上那些被某些特定光源直接照射但并非被所有特定光源直接照射的区域（半明半暗区域）
工作原理：从光源处向物体的所有可见面投射光线，将这些面投影到场景中得到投影面，再将这些投影面与场景中的其他平面求交得出阴影多边形，保存这些阴影多边形信息，然后再按视点位置对场景进行相应处理得到所要求的视图（利用空间换时间，每次只需依据视点位置进行一次阴影计算即可，省去了一次消隐过程）
四种。
平行光：Directional Light
点光源：Point Light
聚光灯：Spot Light
区域光源：Area Light
可以有cookies – 带有 alpha通道的立方图(Cubemap )纹理。点光源是最耗费资源的。
简而言之，GPU的图形（处理）流水线完成如下的工作：（并不一定是按照如下顺序） 顶点处理：这阶段GPU读取描述3D图形外观的顶点数据并根据顶点数据确定3D图形的形状及位置关系，建立起3D图形的骨架。在支持DX8和DX9规格的GPU中，这些工作由硬件实现的Vertex Shader（定点着色器）完成。 光栅化计算：显示器实际显示的图像是由像素组成的，我们需要将上面生成的图形上的点和线通过一定的算法转换到相应的像素点。把一个矢量图形转换为一系列像素点的过程就称为光栅化。例如，一条数学表示的斜线段，最终被转化成阶梯状的连续像素点。 纹理帖图：顶点单元生成的多边形只构成了3D物体的轮廓，而纹理映射（texture mapping）工作完成对多变形表面的帖图，通俗的说，就是将多边形的表面贴上相应的图片，从而生成“真实”的图形。TMU（Texture mapping unit）即是用来完成此项工作。 像素处理：这阶段（在对每个像素进行光栅化处理期间）GPU完成对像素的计算和处理，从而确定每个像素的最终属性。在支持DX8和DX9规格的GPU中，这些工作由硬件实现的Pixel Shader（像素着色器）完成。 最终输出：由ROP（光栅化引擎）最终完成像素的输出，1帧渲染完毕后，被送到显存帧缓冲区。
总结：GPU的工作通俗的来说就是完成3D图形的生成，将图形映射到相应的像素点上，对每个像素进行计算确定最终颜色并完成输出。
Mesh