压缩纹理的主要目的是为了节省空间，缩短加载时间。针对不同的需求和平台需要不同的压缩格式，有的需要高性能，有的需要高质量，Unity本身提供了多种压缩格式供选择。

ETC

Ericsson Texture Compression，是由 Khronos 支持的开放标准，在移动平台中广泛采用。它是一种为感知质量设计的有损算法，其依据是人眼对亮度改变的反应要高于色度改变。类似于DXT，ETC也是把4×4的像素块压缩成一个64或128位的数据块，也是有损压缩。

ETC又分为ETC1和ETC2，通常用于Android平台。其中ETC2是较新的标准，也是Unity官方推荐的格式（虽然我还不太理解）。

相对于ETC1，ETC2向前兼容，不强制要求贴图大小为2的整数次幂，且对RGB的压缩质量更好，支持透明通道。唯一的缺点是需要设备支持OpenGL ES 3.0标准。不过该标准诞生于2012年，目前不支持它的设备非常少，因此不用担心。

注意：可对具有 Alpha 通道的纹理使用 ETC1 格式，但仅当构建目标为 Android 且纹理放置在图集上（通过指定打包标签）时才适用。要启用此功能，请勾选纹理的 Compress using ETC1 复选框。Unity 会将生成的图集拆分为两个纹理，每个纹理都没有 Alpha 通道，然后将它们组合在渲染管线的最后部分中。

PVRTC

PowerVR Texture Compression，PVRTC格式与基于块的压缩格式，比如S3TC、ETC的不同之处是，它使用2张双线性放大的低分辨率图，根据精度和每个像素的权重，融合到一起来呈现纹理，并且2-bpp和4-bpp都支持ARGB数据。PVRTC格式压缩比高，也是有损压缩。

PVRTC格式一般用于iOS平台，可以用在所有的iOS设备上。缺点是要求纹理的高、宽必须都是2的整数次幂（POT），最小为8，并且必须是正方形。

注意：使用该格式，极端情况下会让内存占用变得更大。比如原先300*300的贴图，因为要求尺寸为2的整数次幂，所以变成512*512 . 这种情况下还不如使用RGBA16 .

RGBA16

RGBA16，即RGBA4444，每个像素2个字节，RGBA通道各占4位。

相比以上压缩格式，贴图质量相对较好，缺点是内存占用大，且相对于RGBA32来说会有色彩断层问题。

RGBA32

RGBA32，即RGBA8888，每个像素4个字节，RGBA通道各占8位。

原图无压缩，质量最好 ，缺点是内存占用极大。除非美术要求极高才会使用。

假如贴图没有透明通道则使用RGB24格式，少占用一个字节的空间。

ASTC

ASTC 是在 OpenGL ES3.0 出现后在 2012 年中产生的一种业界领先的纹理压缩格式，它的压缩分块从 4×4 到 12×12 最终可以压缩到每个像素占用 1bit 以下，压缩比例有多种可选。ASTC 格式支持 RGBA，且适用于 2 的幂次方长宽等比尺寸和无尺寸要求的 NPOT（非 2 的幂次方）纹理。

目前我最推荐使用的一种压缩格式，优点是压缩质量高，显示质量好，且Android和iOS平台都可以使用，比较省心。压缩质量从4×4到12×12，按需选择。

缺点和ETC2差不多，老设备不支持。其中iOS设备从iPhone 5s才开始支持，Android主流压缩格式也正在从ETC2转向ASTC（这也是我不太理解Unity还在推荐ETC2的原因）。另一个小缺点是压缩时间稍长，不过也不是问题。

所以长期来看，ASTC将一统江湖！

结论

综上来看，新项目的贴图基本可以无脑使用ASTC，这里有张图，有个大佬总结出来的。

不过尽管ASTC支持非二次幂纹理，但在时机开发中还是建议UI及美术尽量制作二次幂纹理。

具体可参考：https://www.zhihu.com/question/376921536/answer/1063272336

Unity 3D 纹理压缩格式指南最先出现在初晴神社。

服务器：海外服

平台：iOS

项目临近发布前测试发现的，具体表现为在iOS设备上，使用TapTap登录，输入完账号密码后点击登录游戏无反应，再次点击需要再次登录。

排查过程

查找过程中发现成功拉起TapTap登录没有异常，但是在TapTap上点击登录后游戏没有收到任何回调。

正常情况下，点击登录之后SDK会调用对应的回调方法，包括：

登录成功（OnLoginSuccess）

登录失败（OnLoginError）

登录取消（OnLoginCancel）

最终在TapSDK的同学帮助下定位了问题，本应由TapSDK传给客户端的消息被AppsFlyer拦截了。。

相关AppsFlyer代码如下：

//  AppsFlyerAppController.mm
//  Unity-iPhone
//
//  Created by Jonathan Wesfield on 30/07/2019.
//
 
#import <Foundation/Foundation.h>
#import "UnityAppController.h"
#import "AppDelegateListener.h"
#import "AppsFlyeriOSWrapper.h"
#if __has_include(<AppsFlyerLib/AppsFlyerLib.h>)
#import <AppsFlyerLib/AppsFlyerLib.h>
#else
#import "AppsFlyerLib.h"
#endif
#import <objc/message.h>
 
/**
 Note if you would like to use method swizzeling see AppsFlyer+AppController.m
 If you are using swizzeling then comment out the method that is being swizzeled in AppsFlyerAppController.mm
 Only use swizzeling if there are conflicts with other plugins that needs to be resolved.
*/
 
 
@interface AppsFlyerAppController : UnityAppController <AppDelegateListener>
{
    BOOL didEnteredBackGround;
}
@end
 
@implementation AppsFlyerAppController
 
- (instancetype)init
{
    self = [super init];
    if (self) {
         
        id swizzleFlag = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"AppsFlyerShouldSwizzle"];
        BOOL shouldSwizzle = swizzleFlag ? [swizzleFlag boolValue] : NO;
         
        if(!shouldSwizzle){
            UnityRegisterAppDelegateListener(self);
        }
    }
    return self;
}
 
- (void)didFinishLaunching:(NSNotification*)notification {
    NSLog(@"got didFinishLaunching = %@",notification.userInfo);
 
 
    if (_AppsFlyerdelegate == nil) {
        _AppsFlyerdelegate = [[AppsFlyeriOSWarpper alloc] init];
    }
    [[AppsFlyerLib shared] setDelegate:_AppsFlyerdelegate];
 
    if (notification.userInfo[@"url"]) {
        [self onOpenURL:notification];
    }
}
 
-(void)didBecomeActive:(NSNotification*)notification {
    NSLog(@"got didBecomeActive(out) = %@", notification.userInfo);
    if (didEnteredBackGround == YES && AppsFlyeriOSWarpper.didCallStart == YES) {
        [[AppsFlyerLib shared] start];
        didEnteredBackGround = NO;
    }
}
 
- (void)didEnterBackground:(NSNotification*)notification {
    NSLog(@"got didEnterBackground = %@", notification.userInfo);
    didEnteredBackGround = YES;
}
 
- (BOOL)application:(UIApplication *)application continueUserActivity:(NSUserActivity *)userActivity restorationHandler:(void (^)(NSArray *))restorationHandler {
    [super application:application continueUserActivity:userActivity restorationHandler:restorationHandler];
    [[AppsFlyerAttribution shared] continueUserActivity:userActivity restorationHandler:restorationHandler];
    return YES;
}
 
-(BOOL) application:(UIApplication *)application openURL:(NSURL *)url options:(NSDictionary *)options {
    NSLog(@"got openUrl: %@",url);
    [super application:application openURL:url options:options];
    [[AppsFlyerAttribution shared] handleOpenUrl:url options:options];
    return NO;
}
 
- (void)onOpenURL:(NSNotification*)notification {
    NSLog(@"got onOpenURL = %@", notification.userInfo);
    NSURL *url = notification.userInfo[@"url"];
    NSString *sourceApplication = notification.userInfo[@"sourceApplication"];
     
    if (sourceApplication == nil) {
        sourceApplication = @"";
    }
     
    if (url != nil) {
        [[AppsFlyerAttribution shared] handleOpenUrl:url sourceApplication:sourceApplication annotation:nil];
    }
     
}
 
- (void)didReceiveRemoteNotification:(NSNotification*)notification {
    NSLog(@"got didReceiveRemoteNotification = %@", notification.userInfo);
    [[AppsFlyerLib shared] handlePushNotification:notification.userInfo];
}
 
@end
 
IMPL_APP_CONTROLLER_SUBCLASS(AppsFlyerAppController)
 
 
/**
Note if you would not like to use IMPL_APP_CONTROLLER_SUBCLASS you can replace it with the code below.
 <code>
 +(void)load
 {
 [AppsFlyerAppController plugin];
 }
  
 // Singleton accessor.
 + (AppsFlyerAppController *)plugin
 {
 static AppsFlyerAppController *sharedInstance = nil;
 static dispatch_once_t onceToken;
  
 dispatch_once(&onceToken, ^{
  
 sharedInstance = [[AppsFlyerAppController alloc] init];
 });
  
 return sharedInstance;
 }
</code>
 **/

首先TapTap的跳转登录是通过修改UnityAppController中的openURL等相关函数实现的；

而该SDK通过 IMPL_APP_CONTROLLER_SUBCLASS(AppsFlyerAppController) 将自己的AppController文件替换掉了原本的UnityAppController，导致原先TapTap SDK的代码没有生效，以至于无法接收到登录回调，最后无法登录。。

解决方法

1. 删除AppsFlyer；
2. 在AppsFlyer的AppController中调用原UnityAppController的函数；

这两种方法都可以，国内版不需要AppsFlyer所以可以删掉。但是海外版还是需要该SDK的。

考虑到该AppController类继承自UnityAppController，最终采用了方法2，以openURL函数为例：

-(BOOL) application:(UIApplication *)application openURL:(NSURL *)url options:(NSDictionary *)options {
NSLog(@"got openUrl: %@",url);
[super application:application openURL:url options:options];
[[AppsFlyerAttribution shared] handleOpenUrl:url options:options];
return NO;
}

增加 [super application:application openURL:url options:options]; 语句，重新调用了父类UnityAppController的openURL函数，使得游戏可以正常接受来自TapSDK的信息，成功登录。

同时，假如以后不需要该SDK了，可以直接删除而不用修改代码（删除之后会默认使用原有的UnityAppController）。

反思

我的锅。。其实以我的计划来说，AppsFlyer已经接入游戏，但还没有经过测试，这次出版本来不及，所以我加了开关给关掉了。

可是万万没想到AppsFlyer SDK还有替换AppController这一手，我接了那么多SDK第一次见，还是我太naive了。。。

辛苦几位同事大半夜还在找bug，这里说声抱歉 Orz

记一次由接入AppsFlyer导致海外iOS无法登录的问题最先出现在初晴神社。

问题场景：某游戏在播放视频时闪退。连接 pc 后使用 XCode 运行，最终停在代码段：

并且提示 XXX must be used from main thread only.

该错误会导致 app 闪退，如题，应该将语句放到主线程中执行。

这里使用 dispatch_async 分发线程：

dispatch_async(dispatch_get_main_queue(), ^{
        // 代码放这里。
    });

最终代码：

// 自動消灯を無効にする
void UI_SetIdleTimerDisabled(bool b)
{
    dispatch_async(dispatch_get_main_queue(), ^{
        // 主线程执行。
        [[UIApplication sharedApplication] setIdleTimerDisabled:b];
    });
}

经过 Apple Developer Enterprise Program 重签的 app 闪退

Apple Developer Enterprise Program 可让大型组织开发内部专属的 app 并向其员工部署。此计划仅适用于需要使用安全的内部系统或经由移动设备管理解决方案，向员工私密地直接分发的特例情况。

一般游戏公司都会使用这个服务，绕过 APP Store 来给测试设备安装 app。我们公司也是，某天发现一个游戏上传到该平台重签后，在手机上出现闪退情况，但是使用 PC 连接真机安装没有问题。

// 报错如下。
Bootstrapping failed for <FBApplicationProcess: 0x10a253640; application<com.xd.collections>:<invalid>> with error: <NSError: 0x28071d920; domain: RBSRequestErrorDomain; code: 5; reason: "Launch failed."> {
    underlyingError = <NSError: 0x28071d140; domain: NSPOSIXErrorDomain; code: 88>;
}

解决方法：关闭 bitcode …

说实话，我确实没往这方面想。。我以为 Apple Developer Enterprise Program 只是单纯的换个证书重签名，就像 apk 重签那样。

iOS 开发踩坑日记最先出现在初晴神社。

运行环境

网站基于WordPress搭建，WordPress需要PHP，MySQL以及Apache（或者Nginx）。

旧服务器使用CentOS加宝塔面板，使用简单方便，堪称傻瓜式操作。。缺点就是占用资源，还会可能出现漏洞，推荐小白或者不喜欢折腾的用户使用。

相较于旧的，新服务器移除了宝塔面板，系统和服务更加精简，且使用了CDN加速，缺点就是大陆服务器需要备案，一套流程走下来费时费力。。

安装Nginx

注意：以下内容基于Aliyun Linux系统，不过CenOS应该也能用。

老规矩，先更新软件。

yum update

自带的yum源就有nginx，直接安装即可。

yum -y install nginx

安装完成之后使用以下命令添加到开机启动项。

systemctl enable nginx

然后启动nginx服务。

systemctl start nginx

其他命令：

// 关闭Nginx
systemctl stop nginx

// 重启Nginx
systemctl restart nginx

启动Nginx之后，打开浏览器，地址栏输入服务器的IP并回车，不出意外就能看到成功安装Nginx的提示了。

安装PHP

这一步稍显麻烦，首先查看是否有适合的php版本：

yum list php

然后发现只有5.4的版本，这肯定是不行的，推荐使用php 7以上。

安装remi

yum install http://rpms.remirepo.net/enterprise/remi-release-7.rpm

重建yum缓存，可以提高检索速度。

yum clean all
yum makecache

进入正题，安装php全家桶。

yum install -y php74-php-fpm php74-php-cli php74-php-bcmath php74-php-gd php74-php-json php74-php-mbstring php74-php-mcrypt php74-php-mysqlnd php74-php-opcache php74-php-pdo php74-php-pecl-crypto php74-php-pecl-mcrypt php74-php-pecl-geoip php74-php-recode php74-php-snmp php74-php-soap php74-php-xmll

注意，这行是安装php7.4的。如果想安装7.3版本，将上述命令中的74替换成73即可。然后

然后开机启动。

systemctl enable php74-php-fpm

启动php服务。

systemctl start php74-php-fpm

这里面最坑的就是php74-php-fpm这个服务名。。特么的试了好多次才试出来，不知道是不是系统是阿里云的原因。

如果是CentOS，这个服务名应该是php-fpm.service

配置Nginx

到这一部，已经装好了Nginx和PHP，但是还有一些问题。

新建一个名为info.php的文件，内容如下：

<?php 
    phpinfo(); 
?>

将该文件上传到网站根目录/usr/share/nginx/html，然后使用浏览器打开 服务器IP/info.php ，正常情况下会显示php的详细信息，但是现在会发现浏览器把info.php文件下载下来了。。

原因是Nginx配置错误。

打开nginx的配置文件 /etc/nginx/ngin.conf，里面有如下配置：

    server {
        listen       80 default_server;
        listen       [::]:80 default_server;
        server_name  _;
        root         /usr/share/nginx/html;

        # Load configuration files for the default server block.
        include /etc/nginx/default.d/*.conf;

        location / {
        }

        error_page 404 /404.html;
        location = /404.html {
        }

        error_page 500 502 503 504 /50x.html;
        location = /50x.html {
        }
    }

其中root         /usr/share/nginx/html; 就是指网站的根目录。

在server { } 区块内添加如下代码：

location ~ .*\.php$ {
  fastcgi_pass 127.0.0.1:9000;
  fastcgi_index index.php;
  fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
  include fastcgi_params;
  }

这段代码意思是让php后缀的文件传入后端php服务处理，添加之后重启nginx服务。

systemctl restart nginx

再次访问 IP/info.php，页面也正常显示。

其中Loaded Configuration File是php的配置信息目录，以后修改WordPress的文件上传大小限制会用得到。

配置MySQL数据库

为了追求安全和性能，这次不再在本地搭建MySQL，转而使用阿里云的数据库服务。

登录阿里云RDS，创建完用户和数据库之后登陆DMS后台，将备份的sql文件进行导入。

（如果是第一次搭建网站，这一步可以略过）

如果新网站的域名和旧的不一样，或者域名还未解析（比如我的还在备案，无法解析到大陆服务器），就要手动改一下数据库里存储的网站地址，不然打开新网站会自动跳转到旧网站。

在DMS后台使用以下命令查询：

SELECT * FROM `wp_options`

点击开启编辑，将siteurl和home字段改为新的服务器地址。

如果用的其他数据库管理a系统没有可视化界面，也可以使用命令行修改：

UPDATE `数据库名`.`wp_options` SET `option_value`='新网站地址' WHERE `option_id`=1;
UPDATE `数据库名`.`wp_options` SET `option_value`='新网站地址' WHERE `option_id`=2;

另外记得将服务器IP地址加入白名单，否则无法访问。

设置完毕之后可以在服务器上ping一下数据库地址，如果能ping通，代表能正常访问。

导入WordPress

打开备份好的WordPress目录里的wp-config.php文件，修改数据库配置。

// ** MySQL settings - You can get this info from your web host ** //
/** The name of the database for WordPress */
define( 'DB_NAME', '数据库名' );

/** MySQL database username */
define( 'DB_USER', '用户名' );

/** MySQL database password */
define( 'DB_PASSWORD', '密码' );

/** MySQL hostname */
define( 'DB_HOST', '数据库地址' );

/** Database Charset to use in creating database tables. */
define( 'DB_CHARSET', 'utf8mb4' );

/** The Database Collate type. Don't change this if in doubt. */
define( 'DB_COLLATE', '' );

然后将所有文件上传到服务器根目录。

（如果是第一次搭建网站，直接使用WordPress官网下载的文件即可）

上传完毕后使用浏览器打开网址，可能会出现403错误，这个时候需要继续修改nginx配置。

打开nginx.conf，在location / { } 区块内添加代码如下：

location / {
    index index.php index.html index.htm;
}

然后重启nginx，再次打开网址就正常了。

如果什么都看不到，可能是数据库配置出了问题，建议删除网站根目录的wp-config.php文件，重新打开网址一步步配置。

其他的坑

WordPress-设置-固定链接只能只用朴素类型，其他其他的类型时打开文章或分类出现403，404错误。

这个也是因为nginx配置问题，

打开nginx.conf，在location / { } 区块内添加代码如下：

location / {
    index index.php index.html index.htm;
  try_files $uri $uri/ /index.php?$args;
}

然后重启nginx就可以了。

更新插件/系统或上传文件提示没有权限，要输入FTP账号。

这个就更坑了。。本质上是Linux系统的权限问题，WordPress没有访问自身文件夹的权限，解决方法有两个：

1.将网站根目录权限改为777；

网上很多教程都是这么建议的，讲道理，但凡有点安全方面的尝试，就不会这么做。

2.创建FTP服务和账号；

这个可以用，但是太麻烦了。。

2.将网站根目录所有者改为WordPress

简单好用，就它了。蛋疼的事情来了，我需要知道WordPress的user名是什么，但这个user名既不是WordPress又不是root，更不是nginx，也不是网上说的www，www-data。

最终试了一圈，嘿！居然是 apache

apache？？？我不是用的nginx吗？？

结果就是，使用chown命令赋予权限。

chown -R apache:apache 网站根目录

设置完成后可使用ll命令查看：

​使用www.域名方式访问网站报403错误

比如我的网站域名是 vki.cc，本意是想使用 www.vki.cc 也能访问网站。于是在域名解析那里使用 cname 将 www.vki.cc 指向 vki.cc，就有了403错误。

尝试了下，将解析方式改为A记录指向服务器IP就能访问了。

虽然可能造成CDN无法加速，不过问题不大。

主机记录为@时，记录类型 cname 与邮箱解析 MX 冲突

​换句话说，如果我使用CDN服务，就不能同时以 vki.cc 访问网站和使用 vki.cc 域名邮箱。

这是我没有料到的，以前没有用CDN的时候，域名直接A记录指向服务器IP，同时使用域名邮箱没有问题。现在这两个冲突，只能选一个，只好放弃邮箱了Orz

搜了一下，有些域名服务商使用link表什么的骚操作可以避免冲突，不过我邮箱用得少，而且转出域名太麻烦，就懒得折腾了，有兴趣可以了解下。

CDN加速

这个有空写个文章详细说，先放两张结构图吧，一个前，一个后。

未使用CDN

使用CDN

网站迁移笔记最先出现在初晴神社。

内存交换

标准交换在内存与备份存储之间移动进程，备份存储通常是快速磁盘，它应足够大，以容纳所有用户的所有内存映像的副本，并且它应提供对这些存储器映像的直接访问。

移动设备不支持任何形式的内存交换。

• 移动设备通常采用闪存，而不是空间更大的硬盘作为它的永久存储。导致的空间约束是移动操作系统设计者避免交换的原因之一；
• 闪存写入次数的限制；
• 内存与闪存之间的吞吐量差；

当空闲内存降低到一定阈值以下时：

• iOS：不釆用交换，而是要求应用程序自愿放弃分配的内存。只读数据（如代码）可从系统中删除，以后如有必要再从闪存重新加载。已修改的数据（如堆栈）不会被删除。然而，操作系统可以终止任何未能释放足够内存的应用程序。
• Android：不支持交换，釆用类似 iOS 使用的策略。如果没有足够可用的空闲内存，则它可以终止进程。然而，在终止进程之前，Android 将其应用程序状态写到闪存，以便它能快速重新启动。

iOS支持内存压缩，Android不可以。

Android 内存单位为Page，大小一般为4k，以分配单位回收，分为用户态和内核态，不可越界访问。

Low Memory Killier：内存杀手。

Android服务优先级（从高到低），当内存不够时从优先级低的开始销毁：

• Native
• System 当杀到这一层级的时候手机重启
• Persistent
• Foreground 前台应用，具体表现为APP闪退
• Perceptible
• Service
• Home 桌面
• Previous 上一个使用的APP
• Cached 后台APP

Unity内存

按类型分为 Native Memory 和 Managed Memory

Editor与Runtime不同

• Editor模式会尽可能的加载资源（启动较慢）
• Runtime按需加载

Unity封装了C++中与申请内存相关的函数，并添加了Label用于统计。

Audio

DSP Buffer

• 过大会导致声音有延迟
• 过小会使CPU负担上升

Force to mono

双声道改单声道（尽量，绝大多数声音不需要双声道）

Compress Format

Code Size

慎用模板泛型，

AssetBundle

Type Tree

当Unity版本与APP版本一致时可以关掉

• • 减小内存
  • 减小包大小
  • Build和Runtime变快

压缩方式

LZ4 推荐

LZMA 弃用

extra

不建议每个文件打一个AssetBundle包

因为它们有相同的“头”，仅数据部分不同，容易浪费空间。

Resources

通过红黑树进行索引，每次启动游戏都要分析加载红黑树，拖慢启动时间。其次整个游戏生命周期都会存在与内存中。

Texture

Upload Buffer

Read&Write

没有特殊需求就关掉write

Mipmap

同样没有特殊需求就关掉

Mesh

Read&Write

Compresssion

Managed内存

VM内存池

VM会返还内存给OS

条件：一个block连续6次GC没被访问到

Unity GC 算法

貌似不采用CLR的GC机制_(:з」∠)_（参见另一篇文章，传送门）

Boehm GC

旧版垃圾回收方式，新版Unity已弃用。

不分代（速度更快）

不压缩（因为一些历史原因。。跟mono有关）

Incremental GC（渐进式GC）

Unity2019.3之后使用，新一代垃圾回收算法。

主要目的为了解决旧版GC导致主线程卡顿（旧版GC时会暂停主线程）的问题，分帧解决，且分代

GC机制考量

• 回收能力
• 暂停时长
• 碎片化
• 额外消耗
• 可扩展性
• 可移植性

内存碎片化

内存碎片通常分为内部碎片和外部碎片：

1. 内部碎片是由于采用固定大小的内存分区，当一个进程不能完全使用分给它的固定内存区域时就产生了内部碎片，通常内部碎片难以完全避免；
2. 外部碎片是由于某些未分配的连续内存区域太小，以至于不能满足任意进程的内存分配请求，从而不能被进程利用的内存区域。

先加载消耗大内存的资源，再加载小内存

僵尸内存

• 无用内存
• 没有释放
• 可通过代码管理和性能工具分析

SetActive

TODO。。。

都说要少用，但是不清楚机制，有机会看一下Unity源码 Orz

优化建议

• 使用Destroy，别用null
  
• Class/Struct

• 少于8个字节的数据可用Struct代替Class（存疑）

• 池中池
• 闭包和匿名函数

• 少用，在IL2CPP里这些都会new class
• 协程

• 用的时候再产生，不用的时候及时终止
• 不要当线程使用
• 配置表

• excel、json等，按需加载，不然会很占用内存空间
• 单例模式 Singleton

• 慎用，生命周期较长，占用内存

Unity 内存管理最先出现在初晴神社。

if (this.dramaEndBuildMapCallback != null)
{
	this.dramaEndBuildMapCallback();
	this.dramaEndBuildMapCallback = null;
}

可以看出，该块代码想表达的意思是执行完委托就清空。事实上在Unity5.6的时候它确实可以正常工作，但是随着Unity升级，.Net版本也升级到4.x，这种方式失效了。

经过查询，找到了一个可以正常清空委托列表的方法，首先通过GetInvocationList()方法获取委托列表，然后遍历，删掉。。

/// <summary>
/// 清除委托列表。
/// </summary>
/// <param name="action"></param>
public static void ClearDelegage(Action action)
{
	if (action != null)
	{
		Delegate[] delegates = action.GetInvocationList();
		for (int i = 0; i < delegates.Length; i++)
		{
			action -= delegates[i] as Action;
		}
	}
}

好想吐槽一下，为什么C#没提供一个像链表Clear()那样的方法来清除委托列表呢_(:з」∠)_

C#清除委托列表的正确用法最先出现在初晴神社。

最近在研究游戏在安卓平台的打包，遇到了不少坑，特此写个文章记录下~

1.Unity与安卓的交互

虽然Unity可以直接导出apk安装包，但由于有些方法，比如读取手机相册图片，获取权限等，或者是添加SDK都不能直接通过Unity实现。我们一般用Unity导出安卓工程，再通过Android Studio修改之后打出apk包。

通常情况下每次打包都需要修改，为了偷懒~

这里提供个堪称一劳永逸的解决办法，请看文章~

Unity与Android交互方案优化版

https://www.jianshu.com/p/86b275da600e

2.Android aar文件修改

今天刚踩得坑，麻蛋！

不同于jar包只能包含java代码，aar包还可以保存贴图等资源，相当于一个后缀是aar的压缩包。有时候第三方sdk提供的也是aar文件，当需要修改里面的东西时，比如删掉里面一个jar。切记不能采取先解压，删除完毕再压缩回去，后缀改成aar的操作。这样修改后Android Studio用不了！！！

正确方法是以解压的形式打开（不是解压压缩包），一般Windows平台的压缩软件都可以，然后在压缩软件里增加或删除文件操作。

3.Android aar文件读取

同上，又是个巨坑，匪夷所思！

我目前的项目在安卓端是这样的，把用到的sdk和需要在安卓端才能调用的方法打成aar包，然后添加到Unity导出的安卓工程里，但是不知道为什么在运行的时候会报以下的错误;

说的是BGPlayerService类重复，可是我的找遍了真个项目和aar包也只有一个类，根本没有重复的地方。研究了很久都无解，就在准备放弃治疗的时候顺便改了下build.gradle的dependencies里的语句，从

dependencies {
    implementation fileTree(include: ['*.jar'], dir: 'libs')
    implementation project(':localizedappnamelib')
    implementation 'com.android.support:support-core-utils:24.2.0'
    implementation (name:'findingparadiselib-debug',ext:'aar')
}

改成了

dependencies {
    implementation (name:'findingparadiselib-debug',ext:'aar')
    implementation fileTree(include: ['*.jar'], dir: 'libs')
    implementation project(':localizedappnamelib')
    implementation 'com.android.support:support-core-utils:24.2.0'
}

然后特么问题解决了！

？？？

我怀疑可能是implementation fileTree(include: [‘*.jar’], dir: ‘libs’)把aar包里的jar也算进去了_(:з」∠)_

4.生成签名安装包的时候报错

在第一次生成签名安装包的时候可能提示缺少xxx.pom（忘了是不是pom后缀了，反正差不多）和xxx.jar组件，这个报错在生成debug包的时候是不出现的。具体原因我不清楚，我猜是打包的时候需要这样依赖包，但是谷歌的官方站点没有（Android Studio提供的链接点进去404）。

两个解决办法，一是手动下载这些依赖包并放到指定的目录中去，不过不建议这样做，一个一个下载再放到指定目录太麻烦了。

第二中解决方法是使用阿里提供的站点，具体操作是将以下的代码方放到安卓工程的build.gradle文件的repositories代码块中去：

maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }
maven { url 'http://maven.aliyun.com/nexus/content/repositories/jcenter' }
maven { url 'http://maven.aliyun.com/nexus/content/repositories/google' }
maven { url 'http://maven.aliyun.com/nexus/content/repositories/gradle-plugin' }

这样打包的时候Android Studio会自动去这些站点下载需要的依赖包，问题解决。

5.Execution failed for task ‘:app:ndkBuild’.

该问题是在对一个老游戏升级的时候出现的，表现为无法打包，报错：

Process 'command 'D:\SDK\***/ndk-build.cmd'' finished with non-zero exit value 2

上网搜索，普遍的解决方式是使用低版本的NDK，又或者是删除src/main/obj文件夹里的内容，尝试无果。

最终发现是build.gradle版本较老，且使用ndkBuild的方式打包，不适用于新版的Android Studio，修改之后问题解决

修改前：

android {
    signingConfigs {
    }
    compileSdkVersion 26
    buildToolsVersion '23.0.3'
    defaultConfig {
        applicationId "com.xd.swords.and"
        minSdkVersion 19
        targetSdkVersion 26
        versionCode 18
        versionName "1.1.7"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }

    sourceSets.main.jni.srcDirs = []
    // disable automatic ndk-build call, which ignore our Android.mk
    sourceSets.main.jniLibs.srcDir 'src/main/libs'
    // call regular ndk-build(.cmd) script from app directory
    task ndkBuild(type: Exec) {
        workingDir file('src/main')
        commandLine getNdkBuildCmd()
    }
    tasks.withType(JavaCompile) {
        compileTask -> compileTask.dependsOn ndkBuild
    }
    task cleanNative(type: Exec) {
        workingDir file('src/main')
        commandLine getNdkBuildCmd(), 'clean'
    }
    clean.dependsOn cleanNative
}

修改后：

android {
    signingConfigs {
    }
    compileSdkVersion 26
    buildToolsVersion '23.0.3'
    defaultConfig {
        applicationId "com.xd.swords.and"
        minSdkVersion 19
        targetSdkVersion 26
        versionCode 18
        versionName "1.1.7"
        ndk {
            abiFilters 'armeabi-v7a'
        }
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
    externalNativeBuild {
        ndkBuild {
            path "src/main/jni/Android.mk"
        }
    }

    // 下面部分代码应该也可以删掉。
    sourceSets.main.jni.srcDirs = []
    // disable automatic ndk-build call, which ignore our Android.mk
    sourceSets.main.jniLibs.srcDir 'src/main/libs'
    // call regular ndk-build(.cmd) script from app directory
}

对比前后，主要是删除了旧的ndkBuild代码，然后设置abiFilters等。

Unity安卓项目踩坑日记最先出现在初晴神社。

工厂模式，顾名思义，主要用在“大量生产某个东西”的地方，并且是有组织，有规律的进行生产。在程序开发中，会遇到大量生成某个对象的情况。比如游戏中，需要生成若干敌人，这些敌人既可以是相同的，也可以是有差别的，像模型，属性等。如果每次生成的时候，都对其进行手动初始化，改下属性啦，位置什么的，肯定很麻烦，还容易出错~

那么有没有一种可以将这些生成行为规范化的方法呢？

那就是工厂模式~

简单工厂模式

举个栗子，巧克力和香子兰肚子饿了，她们要吃好吃的。巧克力说她要吃蛋糕，香子兰说她只要一杯奶茶就够了。以编程的角度看，我们需要生成蛋糕和奶茶。常规思路代码如下:

首先定义蛋糕类和奶茶类;

public class Cake
{
    public Cake()
    {
        Console.WriteLine("生成蛋糕。");
    }
}

public class MilkTea
{
    public MilkTea()
    {
        Console.WriteLine("生成奶茶。");
    }
}

然后在Main方法里生成;

public static void Main(string[] args)
{
    string str = Console.ReadLine();

    Cake cake;
    MilkTea milkTea;
            
    if (str == "蛋糕")
    {
        cake = new Cake();
    }
    else if (str == "奶茶")
    {
        milkTea = new MilkTea();
    }
}

可以看到，这样的代码存在不小的问题，首先是即便是生成一种，我们也要把其他所有食物进行声明，不然无法获得引用，当然这个可以通过定义一个食物父类来解决。另外如果要增加别的食物，需要修改main方法。如果食物种类少了还好，但是当达到成百上千时，结构会非常臃肿，而且违反了开闭原则。

接下来我们使用简单工厂模式改写下：

首先定义一个食物基类Food，并让蛋糕和奶茶继承：

public abstract class Food
{
        
}

public class Cake : Food
{
    public Cake()
    {
        Console.WriteLine("生成蛋糕。");
    }
}

public class MilkTea : Food
{
    public MilkTea()
    {
        Console.WriteLine("生成奶茶。");
    }
}

然后定义工厂类用来产生食物：

public class FoodFactory
{
    public Food CreateFood(string foodName)
    {
        if (String.IsNullOrEmpty(foodName))
        {
            return null;
        }

        Food food = null;
        switch (foodName)
        {
            case "蛋糕":
                food = new Cake();
                break;
            case "奶茶":
                food = new MilkTea();
                break;
                
            default:
                break;
        }

        return food;
    }
}

最后在Main方法里调用：

public static void Main(string[] args)
{
    FoodFactory factory = new FoodFactory();
                
    string str = Console.ReadLine();
    Food food = factory.CreateFood(str);
}

可以看到，这次Main方法简洁了许多，通过使用简单工厂模式，成功的将“生成”和“使用”进行分离，极大的降低了耦合度。前台只需要知道通过传参获得想要的对象就够了。至于怎么生成那是后台工厂类的事。之后如果想增加新的食物，只需要改一下新建一个类并继承自Food，再switch里的参数就行了。

工厂方法模式

看过了简单工厂模式，是不是觉得已经没问题了呢？然而以上只是为了演示，并没有多少功能性的代码。试想一下，在实际开发中，如果需要很多与对象创建有关的代码，而且需要创建很多对象，是不是意味着要在这个简单工厂类里编写很多方法。比如说蛋糕要调整大小，奶茶要调整甜度等等。这样的话每次都需要打开这个简单工厂类进行修改。。

接下来研究工厂方法模式：向上代码：

这次对工厂类进行了抽象：

public interface IFoodFactory
{
    Food Create();
}

public class CakeFactory : IFoodFactory
{
    public Food Create()
    {
        return new Cake();
    }
}
    
public class MilkTeaFactory : IFoodFactory
{
    public Food Create()
    {
        return new MilkTea();
    }
}

Main里调用，这次取消了判断代码。

public static void Main(string[] args)
{
    IFoodFactory cakeFactory = new CakeFactory();
    IFoodFactory milkFactory = new MilkTeaFactory();
    
    Food cake = cakeFactory.Create();
    Food milkTea = milkFactory.Create();
}

这个模式是对简单工厂模式的解耦，在工厂方法模式中一个子类对应一个工厂类，而这些工厂类都实现于一个抽象接口。相当于把原来的一个简单工厂类进行了拆分。降低了耦合度。

抽象工厂模式

其实绝大多数情况下使用以上的模式就可以了，不过还有种情况，巧克力除了要吃蛋糕还要喝奶茶，香子兰除了喝奶茶还要吃蛋糕。这种情况利用上面的方法也不是不可以，可以如果她们还要冰淇淋，饼干，薯片等等一大堆的东西呢。总不能在main方法里写一大堆调用方法吧。

接下来介绍另一种工厂模式：抽象工厂模式。先上代码：

这次对工厂和单个种类的食物进行了抽象~

public abstract class Cake
{
        
}

public class StrawberryCake : Cake
{
    public StrawberryCake()
    {
        Console.WriteLine("生成草莓蛋糕。");
    }
}

public abstract class MilkTea 
{
        
}

public class RedBeanMilkTea : MilkTea
{
    public RedBeanMilkTea()
    {
        Console.WriteLine("生成红豆奶茶。");
    }
}

将巧克力与香子兰当做工厂：

public abstract class IFoodFactory
{
    public abstract Cake CreateCake();
    public abstract MilkTea CreateMilkTea();

    public virtual void Create()
    {
        CreateCake();
        CreateMilkTea();
    }
}

/// <summary>
/// 巧克力。
/// </summary>
public class ChocolatFactory : IFoodFactory
{
    public override Cake CreateCake()
    {
        // 此处可以增加条件，生成不同的对象
        return new StrawberryCake();
    }

    public override MilkTea CreateMilkTea()
    {
        // 此处可以增加条件，生成不同的对象
        return new RedBeanMilkTea();
    }
}
    
/// <summary>
/// 香子兰
/// </summary>
public class VanillaFactory : IFoodFactory
{
    public override Cake CreateCake()
    {
        // 此处可以增加条件，生成不同的对象
        return new StrawberryCake();
    }

    public override MilkTea CreateMilkTea()
    {
        // 此处可以增加条件，生成不同的对象
        return new RedBeanMilkTea();
    }
}

然后调用：

public static void Main(string[] args)
{
    IFoodFactory chocolat = new ChocolatFactory();
    IFoodFactory vanilla = new VanillaFactory();
                
    chocolat.Create();
    vanilla.Create();
}

【设计模式】06 – 工厂模式最先出现在初晴神社。

之前给一个大佬做有赞应用时候遇到了post收发的问题，其实实现起来很简单的。无奈网上关于这方面的资料很少，特此整理一下，希望帮助有需要的人_(:з」∠)_

发送

直接上代码了，关键的地方我加了注释，应该不难理解。

C#提供了相关的API，很方便。这段代码可以直接拿去用_(:з」∠)_

大致步骤就是创建Request-填充信息-发送。

/// <summary>
/// Post提交数据
/// </summary>
/// <param name="postUrl">URL</param>
/// <param name="paramData">参数</param>
/// <returns></returns>
string PostWebRequest(string postUrl, string paramData)
{
    string ret = string.Empty;
    try
    {
        byte[] byteArray = Encoding.UTF8.GetBytes(paramData);
        HttpWebRequest webReq = (HttpWebRequest)WebRequest.Create(new Uri(postUrl));
        // 提交方法，POST/GET等
        webReq.Method = "POST";
        // ContentType
        webReq.ContentType = "application/x-www-form-urlencoded";
        webReq.ContentLength = byteArray.Length;

        Stream newStream = webReq.GetRequestStream();
        //写入参数
        newStream.Write(byteArray, 0, byteArray.Length);
        newStream.Close();
        HttpWebResponse response = (HttpWebResponse)webReq.GetResponse();
        StreamReader sr = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
        ret = sr.ReadToEnd();

        sr.Close();
        response.Close();
        newStream.Close();
    }
    catch (Exception ex)
    {
        return ex.Message;
    }
    return ret;
}

接收

接收消息模块我分了两部分，一是主体，如何调用api进行监听。这部分需要另开一个线程来处理。

/// <summary>
/// 监听post消息，在收到消息后发送响应消息。
/// 建议使用死循环反复监听，且开启一个线程执行该方法。
/// </summary>
void ListenWebRequest()
{
    // string url= "需要监听的url范围";
    // 示例：(这里有个坑，见下文)
    string url = "http://127.0.0.1:2333";
    try
    {
        HttpListener listener = new HttpListener();
        listener.Prefixes.Add(url);

        // 开始监听端口，接收客户端请求
        listener.Start();

        // 阻塞主函数至接收到一个客户端请求为止
        // 也可以使用listener.BeginGetContext()异步监听
        HttpListenerContext context = listener.GetContext();
        HttpListenerRequest request = context.Request;
        HttpListenerResponse response = context.Response;

        // msg即为body内容
        string msg = GetBodyString(request);

        // 通过QueryString索引获取post参数
        string sample = request.QueryString["sample"];

        // 收到信息后返回数据
        string responseString = "响应数据";
        response.StatusCode = 200;
        // header头信息
        response.Headers.Add("Access-Control-Allow-Origin", "*");
        // contentType 类型
        response.ContentType = "application/json";
        response.ContentEncoding = System.Text.Encoding.UTF8;
        byte[] buffer = System.Text.Encoding.UTF8.GetBytes(responseString);
        response.ContentLength64 = buffer.Length;
        Stream output = response.OutputStream;
        output.Write(buffer, 0, buffer.Length);

        output.Close();
        listener.Stop();
        listener.Close();
    }
    catch (Exception ex)
    {
        // TODO
    }
}

第二部分，由于接收到的post消息中body内容是以流格式的，还需要将其转换为string。

/// <summary>
/// 将body内容解析为String。
/// </summary>
/// <returns>The body string.</returns>
/// <param name="request">Request.</param>
string GetBodyString(HttpListenerRequest request)
{
    string result = null;
    using (System.IO.Stream body = request.InputStream) // here we have data
    {
        using (System.IO.StreamReader reader = new System.IO.StreamReader(body, request.ContentEncoding))
        {
            result = reader.ReadToEnd();
        }
    }

    if (string.IsNullOrEmpty(result))
    {
        // TODO 读取到空消息
    }
    else
    {
        // TODO 成功读取消息
    }

    return result;
}

推荐一个post测试工具

Restlet Client – REST API Testing

谷歌浏览器插件：下载链接（需要翻墙）

炒鸡好用！

碎碎念

就是在接收方法那绑定的url，我当时用的腾讯云的服务器（window系统）测试的。是这样的，

如果url是localhost或127.0.0.1，在服务器本机测试一切正常。但如果从外网向其post数据，会报400或405错误。

如果url是服务器外网IP呢，干脆直接抛异常，好像是无法绑定。

最后尝试了下将url改成内网IP，一切OK。不过我还是不知道是什么原因_(:з」∠)_

使用C#实现POST消息发送和读取最先出现在初晴神社。

举个栗子，现在巧克力和香子兰两个人肚子饿了，要吃饭。吃饭的过程有三个步骤：

1.吃配菜；

2.吃主食；

3.喝饮料；

虽然吃饭步骤一样，可是两个人吃的东西却不同。巧克力配菜要吃西红柿炒鸡蛋，主食要吃馒头，饮料要喝可乐；而香子兰要吃麻婆豆腐，米饭和牛奶。

如果用程序表示的话，可以看出二者使用相同的验算流程，且实现的内容不一样。一般情况下我们会分别给二者写一套代码，这样做没有什么问题。可是如果后续开发需要添加新的功能呢，比如说红豆，时雨也要吃饭饭。或者她们想改变下吃饭的流程，先吃主食再吃配菜呢？是不是要为每套代码做出修改？显而易见这样的实现不太好，那么有没有一种好的实现方法呢？

答案就是使用模板方法模式（Template）

偷来的结构图_(:з」∠)_

1.定义一个算法的流程，即是很明确的定义算法的每一个步骤，并写在父类的方法中，而每一个步骤都可以是一个方法的调用。

2.某些步骤由子类完成。

代码实现

算法定义类：

由一个主方法和三个步骤方法组成，主方法不可重写，步骤方法必须在子类实现：

abstract class IEat
{
    public void Eat()
    {
        EatDishes();
        EatStaple();
        Drink();
    }

    protected abstract void EatDishes();
    protected abstract void EatStaple();
    protected abstract void Drink();
}

算法步骤的实现类：

巧克力：

class ChocolatEat : IEat
{
    protected override void EatDishes()
    {
        Console.WriteLine("配菜：西红柿炒鸡蛋");
    }

    protected override void EatStaple()
    {
        Console.WriteLine("主食：馒头");
    }
    protected override void Drink()
    {
        Console.WriteLine("饮料：可乐");
    }
}

香子兰：

class VinillaEat : IEat
{
    protected override void EatDishes()
    {
        Console.WriteLine("配菜：麻婆豆腐");
    }

    protected override void EatStaple()
    {
        Console.WriteLine("主食：米饭");
    }
    protected override void Drink()
    {
        Console.WriteLine("饮料：牛奶");
    }
}

在Main中调用：

static void Main(string[] args)
{
    ChocolatEat chocolat = new ChocolatEat();
    VinillaEat vinilla = new VinillaEat();

    Console.WriteLine("巧克力吃了：");
    chocolat.Eat();

    Console.WriteLine("-------------");
    Console.WriteLine("香子兰吃了：");
    vinilla.Eat();
}

结果：

结论

模板方法模式将可能出现重复的“算法流程”从子类提升到父类中，减少重复的发生，并且也开放子类参与算法中各个步骤的执行或优化。但如果“算法流程”开放太多的步骤，并要求子类必须全部重新实现的话，反而会造成实现的困难，也不容易维护。

【设计模式】05 – 模板方法模式最先出现在初晴神社。