原文是YoYo官网的教程，共有两篇，这是第一篇：Realtime 2D Lighting In GameMaker Studio 2 - Part 1

第二篇可能要再等等，这两天有点事儿orz

——————————

var lx = mouse_x;       // 光源坐标，基于鼠标的位置
var ly = mouse_y;
var rad = 96            // 发光半径
var tile_size = 32;     // 瓷片的尺寸
var tilemap = layer_tilemap_get_id("walls");    //获取摆放墙的 tilemap id

//定位待检测矩形区域顶点坐标
var startx = floor((lx-rad)/tile_size);
var endx = floor((lx+rad)/tile_size);
var starty = floor((ly-rad)/tile_size);
var endy = floor((ly+rad)/tile_size);

//绘制黄色矩形区域
draw_set_color(c_yellow);
draw_rectangle(startx*tile_size,starty*tile_size, endx*tile_size,endy*tile_size,true);  

for(var yy=starty;yy<=endy;yy++)
{
    for(var xx=startx;xx<=endx;xx++)
    {
        var tile = tilemap_get(tilemap,xx,yy);
        if( tile!=0 ){
        }
    }
}

/// @description 初始化阴影构成
vertex_format_begin();
vertex_format_add_position();
vertex_format_add_color();
VertexFormat = vertex_format_end();

VBuffer = vertex_create_buffer();

vertex_begin(VBuffer, VertexFormat);
for(var yy=starty;yy<=endy;yy++)
{
    for(var xx=startx;xx<=endx;xx++)
    {
        var tile = tilemap_get(tilemap,xx,yy);
        if( tile!=0 )
        {
            // get corners of the 
            var px1 = xx*tile_size;     // top left
            var py1 = yy*tile_size;
            var px2 = px1+tile_size;    // bottom right
            var py2 = py1+tile_size;


            ProjectShadow(VBuffer,  px1,py1, px2,py1, lx,ly );
            ProjectShadow(VBuffer,  px2,py1, px2,py2, lx,ly );
            ProjectShadow(VBuffer,  px2,py2, px1,py2, lx,ly );
            ProjectShadow(VBuffer,  px1,py2, px1,py1, lx,ly );                      
        }
    }
}
vertex_end(VBuffer);    
vertex_submit(VBuffer,pr_trianglelist,-1);

Adx = PointX-LightX;        
Ady = PointY-LightY;        
len = sqrt( (Adx*Adx)+(Ady*Ady) );
Adx = Adx / len;    
Ady = Ady / len;    

/// @description 根据光源位置投射某线段的阴影
/// @param VB Vertex buffer
/// @param Ax  x1
/// @param Ay  y1
/// @param Bx  x2
/// @param By  y2
/// @param Lx  Light x
/// @param Ly  Light Y

var _vb = argument0;
var _Ax = argument1;
var _Ay = argument2;
var _Bx = argument3;
var _By = argument4;
var _Lx = argument5;
var _Ly = argument6;

// 阴影是无限的——至少要完全覆盖整个屏幕
var SHADOW_LENGTH = 20000;

var Adx,Ady,Bdx,Bdy,len

// 获取点 1 的单元向量长度
Adx = _Ax-_Lx;      
Ady = _Ay-_Ly;      
len = (1.0*SHADOW_LENGTH)/sqrt( (Adx*Adx)+(Ady*Ady) );      // unit length scaler * Shadow length
Adx = _Ax + Adx * len;
Ady = _Ay + Ady * len;

// 获取点 2 的单元向量长度
Bdx = _Bx-_Lx;      
Bdy = _By-_Ly;      
len = (1.0*SHADOW_LENGTH) / sqrt( (Bdx*Bdx)+(Bdy*Bdy) );    // unit length scaler * Shadow length
Bdx = _Bx + Bdx * len;
Bdy = _By + Bdy * len;


// 构造 QUAD（即投影本体）
vertex_position(_vb, _Ax,_Ay);
vertex_argb(_vb, $ff000000);
vertex_position(_vb, _Bx,_By);
vertex_argb(_vb, $ff000000);
vertex_position(_vb, Adx,Ady);
vertex_argb(_vb, $ff000000);

vertex_position(_vb, _Bx,_By);
vertex_argb(_vb, $ff000000);
vertex_position(_vb, Adx,Ady);
vertex_argb(_vb, $ff000000);
vertex_position(_vb, Bdx,Bdy);
vertex_argb(_vb, $ff000000);

  if( !SignTest( px1,py1, px2,py1, lx,ly) ){
        ProjectShadow(VBuffer,  px1,py1, px2,py1, lx,ly );
    }
    if( !SignTest( px2,py1, px2,py2, lx,ly) ){
        ProjectShadow(VBuffer,  px2,py1, px2,py2, lx,ly );
    }
    if( !SignTest( px2,py2, px1,py2, lx,ly) ){
        ProjectShadow(VBuffer,  px2,py2, px1,py2, lx,ly );
    }
    if( !SignTest( px1,py2, px1,py1, lx,ly) ){
        ProjectShadow(VBuffer,  px1,py2, px1,py1, lx,ly );                      
    }

/// @description 检测点位于线条哪一侧
/// @param Ax 
/// @param Ay 
/// @param Bx
/// @param By
/// @param Lx
/// @param Ly

var _Ax = argument0;
var _Ay = argument1;
var _Bx = argument2;
var _By = argument3;
var _Lx = argument4;
var _Ly = argument5;

return ((_Bx - _Ax) * (_Ly - _Ay) - (_By - _Ay) * (_Lx - _Ax));

原文地址：[Tutorial/Example] Finite State Machines: The most awesome thing in the history of ever.
原作者：PixelatedPope
译者注：之前HeartBeast的2D横版教程里曾经有一集介绍过简单的状态机，之前FC妹子也做过状态机的视频，我搬了生肉其实自己也没仔细看，这两天因为自己想尝试一下，而且群里之前也有好几个朋友都问过状态机的原理和机制，恰好找到了这篇教程，虽然是前两年的老文章，示例也是GMS1.4的，但对状态机介绍还是蛮清楚的，希望大家喜欢

嗨～诸位，也许有些人还记得我之前一篇关于状态机的教程，但考虑到状态机的使用恰好是本月挑战中的“专家级挑战”，我觉得是时候再写一篇更正式的教程了。在这个教程里，我们会简单复刻一些马里奥世界的内容。

最终效果的演示：状态机效果演示

项目文件：网盘下载

我不会逐行去介绍代码，但是应该足够让大家明白基本原理并实践操作了。让我们正式开始吧。

有限状态机：这是个啥？

如果你有关注YoYo Games的官方技术博客，也许你曾经见过这篇文章，这篇文章很好的解释了什么事状态机，强烈对此有兴趣的朋友仔细阅读，不过我会先简单定义一下。

一个有限状态机（后文以状态机缩写指代）是一种特殊的组织代码的方式，用这种方式你能确保你的对象随时都知道自己所处的状态以及所能做的操作。其中每一个状态都是独立的代码块，与其他不同的状态分开独立运行，这么做可以使得游戏的调试变得更加方便，同时也更易于增加新的功能（比如一些特殊的能力和动画之类）。玩家角色在跳跃的时候看起来有点奇怪？那就直接去“跳跃”的状态里找问题吧！

同样这个机制也可以用于给敌人实现基本的AI逻辑，让敌人可以根据状态做出不同的决策。

恰好状态机机制是本月挑战里的“专家级”难度，但我十分希望当我刚开始学习编程时就能了解这个知识点，正确运用状态机可以为你免去很多不必要的麻烦。接下来我们就来看一下如何使用吧。

有限状态机适合我的项目吗？

这个问题俨然是“世上没有愚蠢的问题”这句话的最佳反证。状态机系统永远适合你的项目，这个问题可以修改成这样“状态机是否适合我这个对象？”确实，并不是所有的对象都需要用上状态机机制，但你可能会惊讶地发现有那么多对象都适合使用状态机去进行管理。

显然，可控的角色和敌人都需要使用状态机，但实际上我的游戏控制器对象也采用了这一机制，用来区分在主菜单、设置菜单和关卡选择等不同的场景的用途，甚至我的镜头控制器也用了状态机，比方说“跟随玩家状态”，“过场动画状态”和“显示特定对象状态”等等。

那么如何才能确认某个对象需要使用状态机呢？其实非常简单，对于每个对象都要问一问自己：“这个对象可以做些什么？”

如果这个对象需要处理超过2件事情以上的功能，那你就应该考虑去做一个状态机。让我们来试着问一下这个问题，比如马里奥，尤其是在超级马里奥世界里，马里奥可以做什么呢？

他可以：

• 站立
• 行走/跑
• 躲闪
• 跳
• 爬墙

显然上面这个列表还有更多没列出来的，但这是个好的开始。因此，显然马里奥有很多事情可做，而且几乎所有这些事情都是独立的状态，那你现在就已经有了一个对象应该要做的功能列表了，现在是时候画一个流程图了。

认真脸：流程图。

不开玩笑，港真，流程图是你的好伙伴。下面是几个示例（从最上面那个链接里借用的）

设计好流程图并梳理好你所有需要处理的状态是非常重要的第一步。在你正式开始编码之前，你需要制定出基本的状态和各自的规则。你不需要彻底搞清楚你的角色能做到每一个操作，这是状态机最棒的特性，它总是易于扩展，但是基本的设计是非常重要的。

OK，设计好了。怎么实现呢？

最好的办法当然是一头扎进去然后直接动手了，是吧？为了让这个过程变得更轻松简单，我做了一个小脚本可供使用

点击前往网盘下载脚本

让我们来看一下这个脚本并了解一下它是怎么工作的：

state_machine_init()

当你在创建需要使用状态机的对象时，可以在Create事件中调用这个脚本。它会创建一对数据结构和一系列十分有用的变量。现在我们先来看看这些变量

• state - 这个变量是当前状态的标志位。这个脚本中将会包含在对象step事件中执行的代码。
• state_next - 当我们切换状态时，我们希望在切换之前当前状态能执行完毕，因此我们调用这个脚本来切换状态，同时更新这个值，然后上述"state"变量将在"End Step"事件中发生变化。
• state_name - 这个变量用于获取保存当前状态的名称（创建时设定的名称）
• state_timer - 这个变量用于记录当前状态持续的“step”数（即运行了多少帧），实用程度绝对超乎想象
• state_map - 一个ds_map数据结构，把你设定的状态名称作为键名保存进来，
• state_stack - 一个用来记录你历史状态的数据结构。可以用来实现一些状态机的进阶功能，比如变回到之前的状态。
• state_new - 这是个非常有用的变量，当你切换到某个状态时，有可能你希望该状态处于初始化状态，比如速度设为0，或者更新精灵等等，这些情况十分常见。这时候你只需要在状态的最开始将这个值设为“true”即可完成这一切操作。
• state_var[0] - state_var 这个变量比较特别。这是一个用来存储某个状态的持续时间的数组。因为我发现我自己经常会有这样的需求——“我想要清楚地跟踪并记录这个状态下的一些信息……但是别的状态没这种需求”那我该怎么办？每次有这种需求的时候都新建一个变量？这不是很荒谬嘛？所以，我用“state_var”来作为替代品，把这个数组作为针对该状态的一个便笺本，或是剪贴板，取决于你的用法。这个数组可以记录我所需要的值，因此我不必新建变量来进行记录，可能有点说不太清楚，但这个非常有用。

如果你下载并仔细看了我提供的脚本，你可能会注意懂我在里面放了一些建议性的变量（也许你的游戏用得着）。比如，通常情况下"state_can_interrupt"或"state_is_invincible" 这些变量都会派得上用场。

State_create("state name",state_script)

当状态机引擎实例化以后，我们需要创建我们自己的状态。比如说，我们要创建几个马里奥的状态，那我们就可以像下面这样操作

state_create("Stand",state_mario_stand);    //调用"state_mario_stand"脚本处理“站立”状态
state_create("Walk",state_mario_walk);        //调用"state_mario_walk"脚本处理“行走”状态
state_create("Air",state_mario_air);            //调用"state_mario_air"脚本处理“空中”状态
state_create("Crouch",state_mario_crouch);    //调用"state_mario_crouch"脚本处理“蹲下”状态

一个对象可以创建任意多的状态，尽可能根据你的需求去随意创建即可

state_init("State Name")

一旦创建好所有的状态，现在就可以来设置对象初始的默认状态了，对于马里奥而言，这应该是站立状态

state_init("Stand");     //把“站立”状态设置为默认初始状态

非常简单

state_execute()

这是状态机的核心，在“step”事件中调用这个方法就可以调用你当前状态的脚本

state_update()

这个脚本应当放在“end step”事件中调用，用于处理不同状态之间的切换

state_cleanup()

这个脚本调用最好放在“destroy”事件里。因为之前我们在处理状态机的过程中会创建一些数据结构，因此当对象实例被销毁时应当彻底销毁那些数据结构来释放内存。重要提醒 也许你还不知道，当你切换“room”时，如果你的非持久化对象（没有勾选“persistant”）具备“destory”事件，那在切换场景的时候这个对象会直接消失但是并不触发“destory”事件里的代码，因此，如果你的游戏中会出现这种情况，请务必谨慎处理。

state_switch("State Name" or state_script)

这个方法是用来在不同状态间进行切换的。你可以把创建状态时起的名字或状态的脚本名作为参数（推荐使用名字更直观）。比如当马里奥在站立状态下，我可能会按下方向键来控制他下蹲：

if(keyboard_check_pressed(vk_down))
    switch_state("Crouch");

你也可以用相同的方法去利用左右方向键来控制走动状态，或用跳跃键来使他执行跳跃状态的脚本。

state_switch_previous()

之前提过，这是状态机的进阶功能。在某些情况下，你可能需要对象恢复到上一阶段的状态。比如我有一个角色拥有施放咒语的状态，并且有另一个状态是击中时被击退，他有可能在任何状态下被击中：站立、行走、下蹲甚至丢道具等等，但当他被“击退”后不能总是让他恢复成站立状态，我希望他能恢复到被击退之前的状态。那在这种情况下，这个脚本就能派上用场了，这个利用了"state_stack"这一数据结构

好吧，也许用说的还不够清楚，下面这个图可以简要的说明具体的使用情况

你可看到"create"、"step"、"end step"、"destory"等不同的事件中的代码，这是状态机系统的基础设置，这其实非常容易，其复杂程度取决于你的状态到底有多复杂。

动手编写一个状态

让我们从最简单的状态开始：“站力状态”. 打开文章开头的那个工程链接并下载下来打开，然后找到“ Scripts>Platform Boy States>pb_state_stand”。

然后你会发现我写了一行"if(state_new)". 让我们来看一下这个状态里都做了些什么. 我把所有的速度变量都设为0，并确保对象处于默认精灵下（马里奥步行精灵的第一帧就是站立状态），为了确保他确实显示的是第一帧海拔image_index设为了0。只要我处于站立状态，所有这些值都应当保持如此，这样就没必要反复去设置了。

在第12行，你会看到我正在检测输入操作，看马里奥是不是马上就要撞墙，我倾向于在状态脚本运行之前先检测用户的输入操作。这不是100%必要的，但是做一次检测然后去调用状态脚本中的内容是个很好的习惯。

为什么我要在12-13行检测碰撞呢？因为如果我不检测碰撞只单纯运行控制事件，那当我们向左或向右朝着墙走过去就会走到墙里去，我不希望马里奥钻进墙里去，所以必须时刻检测，当你试图操作马里奥钻进墙壁时立刻进行切换，因此这个检测在你切换到“行走”状态前是必须完成的。

接下来，我会检测是否按下了跳跃按钮。如果按下了跳跃键，那就会切换到“state_air”空中状态，并将y速度设置为“jump_strength”。因为我的空中状态没有区分下落和跳跃，仅仅是在空中，所以要跳起来的话我需要设置跳跃的力度。

你可能会注意到，在这里我用了两个“if”来处理“state_switch”（嗯，你注意到这点了吗？）没错，设想一下如果现在我们冲着没有墙的方向走去，同时按下了跳跃键……会发生什么呢？所以，当这种情况发生时最后被下达的指令优先级应当更高。因此在这种情况下我会执行跳跃的操作而不是向左走。你可以简单的按照你代码中的顺序来排列不同状态的优先级，25行就是一个示例。

在这里，我正在检测马里奥的脚底的地面。比如当我站在地面上时，也许因为一些原因下面的地面突然消失了，那现在他就要掉下来，而此时应当切换到“空中”状态，迫使他掉下去，并且优先级要高于跳跃或落下。

当然，在同一时间任意组合所有的操作可能性也不大，但是正确梳理不同状态之间的优先级和关系是十分必要的，可以避免很多不必要的意外状况。

这就是我的站立状态中所需要的全部功能，但想一想我们还可以在里面加些什么东西？比如我们可以检测马里奥当前是不是站在一个移动的平台或者传送带上。如果是，那我会获取这个对象的速度，并根据实际情况将这个速度设到马里奥的x轴或y轴的速度上，以便他可以跟着平台运动。而当我处于“空中”状态时则完全不用操心这些问题，甚至我都用不着做相关的判断和检测。但是在“行走”状态下还是需要考虑这种情况的，所以也许你也要考虑在行走状态的脚本中添加相应的检测代码。

尾声

这篇文章写得有点长，我也不确定你是否能从我的代码中得到更多启发（我的碰撞检测有一点疯狂，并）。所以，自己试玩一下范例工程，然后尝试建立自己的状态机角色，如果有任何问题欢迎私信或给我留言。

当你第一次开始使用状态机时，你可能觉得你之前学编程知识都要被丢掉了。因为不再需要像“on_ground”或“can_jump”这样的变量了。 如果你处于站立状态，你就能确认自己正在地面上并一定能进行跳跃操作......其他状态下则肯定不是站立状态，没错吧？ 请务必信我这一次，状态机机制十分有用，值得你学习和尝试去根据自己的需求实现一个定制版的状态机系统，请相信我，这是一个令人难以置信的有价值的东西。 不要放弃，不断续尝试，不断改进，最后你一定会实现你想要的效果。

希望这些内容能派得上用场，而不是单纯耗费了你的时间。再次声明，如果有任何问题可以私信或给我留言。

很荣幸你能读到这里，现在亲自去试试看吧！

原作者：Madde Michael

译者：highway★ 

译注：由于gms1的view已经被干掉，新接触2代的用户对摄像机系统并不太熟悉。在游戏的前期（prototype或demo）开发中，摄像机处于3C（Character, Control, Camera）中一个非常重要的核心位置，一个设计合理的摄像机系统会让您的游戏体验起来更juicy，我觉得花些时间翻译一下这篇指南很值得，希望能帮助到更多GMS2用户更了解新的摄像机系统。话了，请您继续看。

版本: IDE: 2.0.2.44

RUNTIME: 2.0.1.27

导出平台: ALL

工程下载: Built Project

译注：部分图片由于原文是beta版，IDE有些命名与现版本不同，已经修正为现有版本。

概要

这篇指南提供了有关新的摄像机系统的基本信息，以及views的使用方法。由于摄像机系统跟GMS1时相比是全新的，这篇指南面向那些对gml有基本了解并对views有点儿懵逼的初学者。

项目工程示意：

效果没那么屌，但是实现了摄像机创建、分配，view的移动、缩放、和插值。对应操作：“点击聚焦”和“滚轮缩放”。

相关链接：

• Cameras/Views

教程

首先，我要说明一下 - 实际上你不用摄像机也能获取一个视图（view） - 场景（Room）编辑器的视图（view）跟GMS1的工作方式基本一样。但是……它现在可没原来那么灵活了 - 你不能像以前那样在代码里修改view_[x,y,h,w]view了（译注：如果你没接触过GMS1，那么请不要在意这段） - 除非你先设置一个摄像机才能进行高级的操作。

注意：

• Gamemaker Studio 2缩写为GMS2
• 请用GML，英雄！
• 困了惑了，请随时按F1查手册，英雄！
• 发现了错误，或者有什么问题请email我，英雄！（去这里找原作者）
• 译注：视图对应view，摄像机对应camera，视图端口对应viewport，加括号有点恶心……sry，mate

这篇指南会讲到这些内容：

• 设置一个视图（用来使用摄像机）
• 创建/删除摄像机并分配给视图
• 通过代码设置摄像机跟随对象（object）
• 除了绑定视图之外，用其他方法绘制摄像机
• 摄像机脚本 - 更新、开始和结束
• 比较简单的摄像机位置插值
• 比较简单的摄像机缩放
• 根据场景边界限定摄像机位置
• 其余的摄像机函数和功能

设置一个视图（用来使用摄像机）

OKay，你可能想跳过这里……我知道，你要是知道这玩意的话就跳过吧。实际上就是在一个Room内，通过编辑器或者代码来启用视图。

在你的游戏里有两种方法可以设置视图，一个是用Room编辑器里的视图工具，第二就是用代码。嗯……我又重复了一遍。

我个人推荐后者，这意味着你无须在每个单独的Room里设置视图（译注：如果你的关卡很多，肯定很烦人，而且说不定哪一个room就忘了）。你只需要在Room start的时候运行代码，完事儿~ 但是，代码并不会改变游戏的窗口（基于视图端口），但是Room编辑器里就可以改变游戏窗口，假如它是游戏中的第一个房间 - 有时候称为“启动房间”。如果之后出于一些原因需要改变窗口的尺寸的话，windows_*函数可以帮你搞定。

两种方法，我们都可以设置： 视图0对应的视图端口尺寸为640*480，跟GMS一样。

这里是在Room编辑器中设置视图的方法：首先，在Resource树窗口打开你的房间，GMS2在默认情况下就为你创建好了一个名为room0的房间。可以双击，也可以拖到工作区来打开。

然后在左侧下方，找到"Viewports and Cameras"。来进行设置：

接下来，在“Enable Viewports”前打钩

打开Viewport 0的设置区，向下面这样填：

OK，我们搞定了基本的视图设置。

注意我们并没有改变视图边界（border）、视图速度（speed）还有跟随对象（Object Following）。这里解释一下他们的功能：

• 跟随对象（Object Following）：如字面意思，让摄像机跟随选中的对象。
• 视图边界（View Border）：摄像机跟随对象之前，需要靠近视图边界的距离（以像素为单位）。
• 视图速度（Camera Speed）：当越过边界时，摄像机跟随对象移动的速度。速度设为-1会让视图即时移动来显示跟随对象。

下面是以代码来设置View的方法：这段代码最好写在“Room Start”事件中。你也可以把它放到创建房间的代码中（room creation code，在room编辑器里可以找到），但你可以把代码写在一个永久存在（persistent）的实例中，来节省一些时间。（尽管使用新的房间父子系统，在Room编辑器中创建默认视图要比以前更容易）。

这里我没有写整段代码，只是展示注释过的部分

代码：

//启用视图
view_enabled = true;

//设置view 0为可见
view_set_visible(0, true);

//设置view 0的视图端口尺寸为640x480，边界为0
view_set_wport(0, 640);
view_set_hport(0, 480);

在这里设置这些边界不会自适应游戏窗口尺寸 - 即使是在启动房间。启动房间（或者有一个启用的视图）的尺寸要和你希望你的游戏的显示窗口尺寸一样，这样才会自动适应。

你也可以手动调整窗口尺寸来适应，用window_set函数。但是，在同一个事件中调用window_set_size()和window_center()是无效的，因为窗口调整要在当前的事件结束之后才能工作。

如果你想要同时调整游戏窗口并居中，看一下下面的示例：

代码：

//调整尺寸并居中
window_set_rectangle((display_get_width() - view_wport[0]) * 0.5, (display_get_height() - view_hport[0]) * 0.5, view_wport[0], view_hport[0]);
surface_resize(application_surface,view_wport[0],view_hport[0]);

这样就可以调整view 0对应的视图端口的窗口尺寸，并将"application_surface"的尺寸设为相同。

我们还没有通过代码来设置视图的尺寸、位置、目标对象、边界或者速度 - 因为我们要通过摄像机来进行设置，在后面我会解释如何操作。

从这里开始，开始全是代码了，英雄！

创建和删除摄像机并分配给视图

如果你习惯了GMS1的视图，那么GMS2的摄像机会有些不同。你可以将其理解为……嗯，有点像实例（instance） - 你要创建一个摄像机，然后赋予它一些信息，当你用过之后可以删了它。

这一部分将帮助你通过代码来设置视图的参数，从这开始这些属性就都由摄像机来管理了。

当创建摄像机时候，有两个函数我们要了解：

"camera_create()" 和 "camera_create_view()"两个函数都返回唯一的摄像机ID，通过ID我们可以用来使用其他所有的摄像机相关函数。

"camera_create()"用来创建一个实际上是空白画布的摄像机 - 你需要手动指定位置和尺寸，然后才能在2D中正确使用 - 我这样说是因为你可以在3D中使用它而无需指定这些参数。"camera_create_view()"更适合2D开发来使用，因为它强制你在创建时就要指定所有的视图参数。

我们将使用“camera_create_view()”，因为这篇指南的目的是帮助那些意图开发2D游戏的英雄们~如果你要关于3D方面的“camera_create”，那可以看我另一篇文章 "Getting Started with 3D in GMS2"。

下面是创建摄像机的方法。再磨叽一遍，640x480的尺寸，位置是0，然后跟随对象参数设为默认：

代码：

//创建摄像机
//在（0,0）的位置创建一个摄像机，640x480，角度为0，没有跟随实例，摄像机水平和垂直速度为即时跳转，边界为32像素
camera = camera_create_view(0, 0, 640, 480, 0, -1, -1, -1, 32, 32);

上面代码中我们指定一个角度，这里取代了GMS1的view_angle[0..7]。其余关于视图角度的函数为 "camera_get_view_angle" 和 "camera_set_view_angle"。

这就是摄像机创建了，用完摄像机要销毁的话：

代码：

camera_destroy(camera);

下面我们要将摄像机绑定到视图，比较简单：

代码：

//设置view0来使用摄像机 "camera"
view_set_camera(0, camera);

从这开始，当我们要更新视图时，我们就要使用"view_camera[view_index]"引用一个绑定的摄像机实例（本例中为view_camera[0]）。这是因为我们要保证我们正在更新的摄像机是分配给视图的那个。

用view_camera[x] = camera也可以正常工作，但我感觉用view_set_camera()更安全更可靠。

我们实际上并不需要将摄像机绑定到视图来使用它 - 我会简单的介绍它的工作原理 - 但绑定会更方便，因为它可以访问自动摄像机“更新/开始/结束”脚本，我将对此进行介绍。

你可以通过这两个函数"view_camera[0..7]"和"view_get_camera(view)"，来获取视图正在使用的摄像机的ID。

通过代码设置摄像机跟随对象（object）

如果你用Room编辑器来设置视图，就不用管这个了。但是，如果用代码的话，你有2个选择：第一，在camera_create_view()里设置标准参数，比如：

代码：

//创建一个摄像机，位置(0,0), 尺寸640x480, 角度0, 跟随的目标实例"objPlayer", 即时跳转的水平垂直速度，边界为32像素
camera = camera_create_view(0, 0, 640, 480, 0, objPlayer, -1, -1, 32, 32);

另一个选择是手动的创建每一个参数 - 这允许动态的改变属性，比如增加边界尺寸、聚焦在敌人身上等等。

就像这样设置：

代码：

//基础设置
camera_set_view_pos(view_camera[0], 0, 0);
camera_set_view_size(view_camera[0], 640, 480);

//设置目标对象的信息
camera_set_view_target(objPlayer);
camera_set_view_speed(view_camera[0], -1, -1);
camera_set_view_border(view_camera[0], 32, 32);

搞定！

除了绑定视图之外，用其他方法绘制摄像机

如果，你不想将摄像机指定给某个视图（或者想使用摄像机，但不创建视图的话），我们就要用到camera_apply函数了。

代码：

//应用摄像机并以此来绘制
camera_apply(camera);

如果你只想要将摄像机应用于某些视图（无需绑定），只需要将其包装在view_current测试中，就像这样写：

代码：

if(view_current == 0)
{
camera_apply(camera);
...
}
...

这样弄之后，照常允许绘制代码。

之后要将摄像机重置为默认值，只要这样调用：

代码：

camera_apply(camera_get_default());

这会将摄像机视图重置为GMS2默认的摄像机 - 当没有视图启用的情况下所使用的默认摄像机。注意你要用camera_set_default来操作，虽然我还没想到过合理的使用案例，也没测过。

当使用camera_apply时有个比较大的问题是，并不会自动调用摄像机“更新/开始/结束”脚本 - 这个脚本非常好用，后面我会详细解释。当然，如果你自己写脚本来配合apply方法来使用的话，你要分开调用它们。

摄像机脚本 - 更新、开始和结束

好了，终于到了新摄像机函数里有趣的地方之一了，脚本！请看手册，英雄！这里有三种摄像机脚本，更新/开始/结束。信息如下：

所有可见和活跃视图端口的摄像机都会调用其更新脚本。

然后对于每个独立的视图：

视图对应的摄像机会调用开始脚本绘制事件为该视图执行（包括绘制开始draw begin和绘制结束draw end事件）调用摄像机的结束脚本

那么，这有什么好处呢？嗯，首先，脚本只会被分配给视图的可见摄像机调用 - 这意味着你可以把代码放到这些脚本中，如果视图没开始绘制，它不会浪费时间来运行 - 当跳帧时这就很好。你也不必在绘制开始时使用高深度对象运行设置代码。

这些脚本好像只能自动为绑定到视图的摄像机运行。如果你的脚本没有运行，检查一下是不是没有正确绑定！

OK，这些函数都可以正常工作，并以类似的方式使用 - 你可以告诉它们什么时候开始工作。在这里，我要将脚本赋予视图0的摄像机的开始函数。

这个名为Update_script的脚本，包含下面的内容 - 简单但是比较挫的震屏效果：

代码：

//对分配给当前视图的摄像机进行震动
camera_set_view_pos(view_camera[view_current], random_range(-6,6), random_range(-6,6));

我们用view_camera[view_current]来确保我们将此脚本绑定到任意视图摄像机。

这是震屏功能，现在我们将其绑定到一个视图，用下面的代码绑定到camera_begin：

代码：

//将很挫的震屏脚本update_script绑定到所需的摄像机"begin"
camera_set_begin_script(view_camera[target_view],update_script);

为了绑定到其他摄像机事件，我们可以使用以下两种之一：

代码：

camera_set_end_script(view_camera[target_view],update_script);
camera_set_update_script(view_camera[target_view],update_script);

注意：在写代码的时候，无法从脚本中获知哪台摄像机正在运行当前的更新脚本（只使用view_camera[view_current] 或camera_get_active()来标识"开始"和"结束"脚本），除非你严格的设置所有的变量连接。我已经提交了一个bug报告，但我不知道它是否会被yoyo看做是个bug，因为绘制实际上还没有开始。（译注：由于作者写指南的时候是BETA版，现在这个问题是否存在我还没有测试过）

要清除摄像机中的脚本，只需按照正常运行函数，而不是使用脚本参数中的“-1”。每个脚本设置函数都有一个“getter”equivelant（我不确定这玩意汉语到底该叫什么=_= sry~），它返回当前绑定到摄像机的脚本内容。

再注意：你不能在摄像机脚本中执行任何绘制。这些玩意必须在绘制事件中完成（或者在surface上）。

OK，脚本内容先聊到这儿。

比较简单的摄像机位置插值

对于这一点，我们只是将摄像机从当前位置插入到用户点击的任意位置。这个代码适合...比如，追踪一个对象，这很简单，从简单的东西开始做，是个好选择~

假设 - 你已经创建了一个2D摄像机，分配给了视图0。如果你忘了怎么操作，翻到上面重新看看。

首先：我们在create事件中初始化2个变量：

代码：

click_x = 0;
click_y = 0;

它们用来存储鼠标最后一次点击的位置。因此，我们首次启动项目时，它会将摄像机对准原点，因为我们已经将其赋值为0了。

下面这些代码都写在step事件（在同一个object里，命名叫什么随你，英雄）

代码：

//检测鼠标左键是否点击，是的话，更新点击位置
if(mouse_check_button_pressed(mb_left))
{
click_x = mouse_x;
click_y = mouse_y;
}

//获取目标视图位置和尺寸，尺寸减半所以视图将聚焦在中心
var vpos_x = camera_get_view_x(view_camera[0]);
var vpos_y = camera_get_view_y(view_camera[0]);
var vpos_w = camera_get_view_width(view_camera[0]) * 0.5;
var vpos_h = camera_get_view_height(view_camera[0]) * 0.5;

//插值率
var rate = 0.2;

//将视图位置插入新的对应位置
var new_x = lerp(vpos_x, click_x - vpos_w, rate);
var new_y = lerp(vpos_y, click_y - vpos_h, rate);

//更新视图位置
camera_set_view_pos(view_camera[0], new_x, new_y);

总结一下，这段代码检测是否按下鼠标左键，是的话，更新摄像机到“点击位置”。 然后不管任何情况，视图都会插入到鼠标按下的最后位置的中心。

这是如何完成的？

• 我们获取当前位置（即左上角）和视图的尺寸
• 将视图尺寸减半
• 我们建的变量rate，用来指定插值的速率（这样后面改起效果来会方便一些）
• 我们用lerp函数将当前视图的位置定位到新的点击位置，视图的宽高减半会从点击位置移除，让视图聚焦在 中心
• 将新的位置坐标赋予视图，过程结束

一个简单的视图插值demo完成了~

摄像机缩放

这跟之前的工作原理类似 - 你要修改视图的宽和高，但保持视图端口的尺寸。唯一的区别是你需要一个摄像机才能使用一些函数。

假设 - 你已经创建了一个2D摄像机，分配给了视图0。如果不幸你又忘了怎么操作，翻到上面重新看看。

我们要在create事件中创建一些缩放相关的变量（在摄像机创建之后）：

代码：

zoom_level = 1;
//获取初始视图尺寸，后面要用于插值
default_zoom_width = camera_get_view_width(view_camera[0]);
default_zoom_height = camera_get_view_height(view_camera[0]);

下面这些代码都写在step事件（在同一个object里，命名叫什么随你，英雄）

代码：

//根据鼠标滚轮来缩放，用clamp函数可以让效果看起来没那么蠢
zoom_level = clamp(zoom_level + (((mouse_wheel_down() - mouse_wheel_up())) * 0.1), 0.1, 5);

//获取当前视图尺寸
var view_w = camera_get_view_width(view_camera[0]);
var view_h = camera_get_view_height(view_camera[0]);

//设置插值率
var rate = 0.2;

//通过插值计算当前和目标缩放尺寸获取新视图尺寸
var new_w = lerp(view_w, zoom_level * default_zoom_width, rate);
var new_h = lerp(view_h, zoom_level * default_zoom_height, rate);

//应用新尺寸
camera_set_view_size(view_camera[0], new_w, new_h);

这些是干嘛的? 我们一步步拆开来看：

• 根据鼠标滚轮当前的滚动方式调整缩放级别 - 向上放大向下缩小。缩放级别也用clamp函数处理，防止过度缩放
• 获取当前的视图尺寸
• 设定插值率（这样后面改起效果来会方便一些）
• 通过当前视图尺寸插入到原始尺寸乘以缩放级别来确定新尺寸的大小
• 更新新的视图尺寸

这就是缩放的处理。请记住，视图尺寸从左上角开始变化，而不是中心。如果你想让视图保持居中，需要加上这些：

代码：

//获取重新对齐视图所需的位移值
var shift_x = camera_get_view_x(view_camera[0]) - (new_w - view_w) * 0.5;
var shift_y = camera_get_view_y(view_camera[0]) - (new_h - view_h) * 0.5;

//更新视图位置
camera_set_view_pos(view_camera[0],shift_x, shift_y);
这将使用视图的宽高的差异来确定如何移动视图以此来重新居中，然后再应用新的位置。

这一章节结束~

根据场景边界限定摄像机位置

我在twitter上被问到过这个问题，所以我觉得下面这段代码有必要讲一下：

代码：

camera_set_view_pos(Camera_ID,
clamp( camera_get_view_x(Camera_ID), 0, room_width - camera_get_view_width(Camera_ID) ),
clamp( camera_get_view_y(Camera_ID), 0, room_height - camera_get_view_height(Camera_ID) ));

这行代码通过存储在Camera_ID变量中的ID来获取摄像机的位置，然后将其位置控制在（0,0）和房间界限减去摄像机尺寸之间。

如果你已经计算好或者已经知道摄像机尺寸和位置，你可以不用camera_get_view_*这个函数，直接用值就可以（译注：如果能用变量的话，后期查阅或者修改代码的时候会比单纯用值来写的可读性更好）。

其余的摄像机函数和其功能

上面说了那么多之后，我想你应该对新的摄像机系统有了一定的了解，用它们来创造奇迹吧~英雄！当然，还有点东西最好说一下，很方便的几个函数：

• 我们可以用view_set_[x,y,w,h]port()函数来改变视图端口相关的东西
• 可以通过view_set_surface_id()告诉视图绘制到surface
• camera_get_active()返回当前活跃摄像机的唯一ID（正在绘制的摄像机）
• 有两个函数使用了矩阵 - camera_set_view_mat()和camera_set_proj_mat()。这些主要用于设置3D投影（译注：如果你有兴趣扩展学习，可以去Shaun Spaulding的youtube频道看看，他比较喜欢用这个，有几个视频专门讲了GMS2的摄像机）
• camera_set_proj_mat()采用投影矩阵，通常用三个矩阵函数之一 - matrix_build_projection_ortho，matrix_build_projection_perspective或matrix_build_projection_perspective_fov
• camera_set_view_mat()采用视图矩阵，通常用matrix_build_lookat构建
• 我在另一篇指南“GMS2的3D开发起步”讲了这些矩阵函数的基本用法
• 本指南中讨论的所有setter函数都对应的有getter函数

值得一提的是，你可以用"camera_get_view_[x/y/width/height]()"来绘制与摄像机视图相关的东西，尽管使用Draw GUI事件来绘制HUD会好的多。译注：HUD，即head-up display，西方游戏行业对游戏界面的定义，从飞机的抬头显示系统拿来的名词，国内游戏业更喜欢叫UI，如果你希望查阅国外游戏的资料，建议还是更改习惯，称之为HUD。

就写到这吧，你现在应该可以去玩这个新的摄像机系统了，如果还有什么你想了解的，或者有什么问题，需要什么帮助的话，联系我，我看看能不能帮到你~

*译注：阿西吧，真tm长………

扩展阅读 : [GDC2015] Scroll Back - 2D卷轴游戏的摄像机理论与实例

这篇文章是Itay Keren（Mushroom11的开发者，IGN9分游戏，貌似IOS上过推荐）在2015年的游戏开发者大会上的演讲的图文版，超长超屌，理论研究+实例分析~ 如果你在开发2D卷轴游戏，那你一定要精读精读精读这篇文章，里面涉及到很多行业前辈带来的超级精彩精心设计的摄像机系统。在看过文章之后，再去回顾以前玩过的游戏，或者新玩到的游戏，就会更加体会到摄像机系统对游戏体验的强力加分或者……折扣……。废话不多说了，请去GMS2实验吧~ 期待您的新成果~~~~~ 一起加油！

脚本说明

这是在reddit发现的一个脚本，作者为“CptLeafBlower ”

原帖地址：Super Easy Tile Collision - GMS2

跟内置函数“place_meeting”的用法十分类似，只是这个检测的不是对象而是瓷片地图只需传入要检测的坐标点以及需要检测的瓷片地图ID即可

参数说明

代码正文

///@description tiles_collision(x , y , tilemap)
///@arg x
///@arg y
///@arg tilemap

var xx, yy, tilemap, xp, yp, meeting;

xx = argument0;
yy = argument1;
tilemap = argument2;

//save our current position
xp = x;
yp = y;

//move to the position where we wanna check for a tile collision
x = xx;
y = yy;

//check for collision on all four corners of the collision mask
meeting =       tilemap_get_at_pixel(tilemap, bbox_right, bbox_top)
                ||
                tilemap_get_at_pixel(tilemap, bbox_right, bbox_bottom)
                ||
                tilemap_get_at_pixel(tilemap, bbox_left, bbox_top)
                ||
                tilemap_get_at_pixel(tilemap, bbox_left, bbox_bottom);

//Move back to the original position
x = xp;
y = yp;

//Return wether or not there was a collision
return(meeting);

使用范例

var tile_solid = layer_tilemap_get_id("tiles_ground")
if(!tiles_collision(x, y + 1, tile_solid))                            
{
    speed_down  += gravity_;
}

以上代码首先使用"layer_tilemap_get_id"的方法获取了"tiles_ground"图层中设置的瓷片地图的ID，然后将该ID保存到临时变量"tile_solid"中，然后检测在当前对象向下一个像素的位置有没有"tile_solid"对应的瓷片地图，如果没有则受重力加速度影响下落。

这一篇是之前曾经就说过的冷却时间的实现方式，废话不说我们先看效果:

上图左边的柱形动画是之前在QA里就介绍过的，今天我们要实现的就是右侧那种钟形的冷却时间动画，其实这个方法也是借花献佛，主要借用了Yellowafterlife的这篇文章——GameMaker: Circular cooldown rectangle 中的脚本，严格来说，本文只算个简单的脚本使用说明，原文详细的解释了脚本实现的思路和原理，推荐喜欢研究的同学深入阅读～

这个脚本利用了绘制基本几何体的方法来绘制这个动画，同时使用了扇形图元，基本的原理就是先绘制一个矩形蒙版图像，然后根据冷却时间的变化（时间进度）来逐步缩小绘制的区域，期间需要根据进度值来不断计算绘制的角度变化。

在使用这个脚本时有一些注意事项：

• 可以在调用方法前使用draw_set_alpha和draw_set_colour来定义绘制的不透明度和颜色（用完记得要恢复）
• 原方法绘制了一个矩形，如果你想绘制圆形，可以使用纹理贴图来实现
• 对调x1和x2的传入顺序可以切换顺时针/逆时针动画方向
• 传入的value并不是冷却时间而应当是当前剩余的冷却进度（百分比）

/// draw_rectangle_cd(x1, y1, x2, y2, value)
///@param x1
///@param y1
///@param x2
///@param y2
///@param value

var v, x1, y1, x2, y2, xm, ym, vd, vx, vy, vl;
v = argument4
if (v <= 0) return 0 // 进度为0则不绘制
x1 = argument0; y1 = argument1; // 定义左上角
x2 = argument2; y2 = argument3; // 定义右下角
if (v >= 1) return draw_rectangle(x1, y1, x2, y2, false) // 填满冷却区域
xm = (x1 + x2) / 2; ym = (y1 + y2) / 2; // 定义中心点
draw_primitive_begin(pr_trianglefan)
draw_vertex(xm, ym); draw_vertex(xm, y1)
// 绘制不同的角:
if (v >= 0.125) draw_vertex(x2, y1)
if (v >= 0.375) draw_vertex(x2, y2)
if (v >= 0.625) draw_vertex(x1, y2)
if (v >= 0.875) draw_vertex(x1, y1)
// 计算角度:
vd = pi * (v * 2 - 0.5)
vx = cos(vd)
vy = sin(vd)
// 向量控制
vl = max(abs(vx), abs(vy))
if (vl < 1) {
    vx /= vl
    vy /= vl
}
draw_vertex(xm + vx * (x2 - x1) / 2, ym + vy * (y2 - y1) / 2)
draw_primitive_end()

第一张图中的例子放在网盘了欢迎下载，包含了这个CD时间的脚本以及很粗糙的一个技能拖拽的实现orz

链接:https://pan.baidu.com/s/1bqf44Th 密码:y022

前几天有朋友在后台问我如何能让文字移动，以及缩放大小，经过一番沟通确认了他的目的是想要做那种人物受到伤害时头顶飘出的伤害数字，想了一下原理并不复杂，于是有了这篇简单的教程，下面先看下效果：

其中使用的最重要的一个函数是

draw_text_transformed_color(x,y,string,xscale,yscale,angle,c1,c2,c3,c4,alpha)

通过这个函数我们可以控制绘制文字的绘制属性

• x,y——文字绘制坐标
• string——需要绘制的文字内容
• xscale,yscale——文字的横纵向缩放比
• angle——文字绘制角度
• c1,c2,c3,c4——左上左下右上右下四个顶点的颜色值，中间的颜色会自动过渡
• alpha——透明度

之前的文字放大就是通过xscale和yscale的设定实现的，文字淡出的效果则是调整了alpha值。

当然这样的效果需要根据实际使用场景来进行具体的调整才会达到最佳。

下面我们说一下这样的文字具体的实现方式

首先我们需要一个对象来绘制文字内容，并且我们希望这个文字有一个位移，然后在位移的过程中逐渐变淡同时略微放大，最后直接消失

首先是位移，在draw事件中我们可以指定绘制文字的坐标，理论上直接修改绘制文字的坐标也可以达到这个目的，为了方便我选择直接修改绘制文字的对象本身的坐标，然后把绘制坐标跟对象的坐标绑定关联，同样可以让文字移动。

然后在对象的step事件中把对象自身的image_xscale和image_yscale进行递增操作，同时将image_alpha进行递减操作，最后把文字绘制方法中的xscale、yscale和alpha跟与之对应关联，这里其实也可以直接设定三个递增/减的自定义变量而不使用内置属性。

最后是设定如果alpha小于等于0即完全透明不见时自动销毁该对象，避免冗余的对象消耗性能。

首先创建一个对象

然后在create事件中添加了一个随机数值的代码，这部分是为了演示用的，在实际应用时需要根据自己的需求去定义

然后在step事件中是如下内容

第一部分就是设定对象的y坐标递减以达到向上飘升的效果

第二部分是设定了自身的横纵图像缩放比以每帧0.05的速率递增

第三部分是设定自身的图像透明度以每帧0.05的速率递减

最后第四部则是设定当图像透明度小于等于0以后直接销毁当前实例

最后是文字绘制的方法

这就是最关键的文字绘制，我这里用step中修改的image_xscale和image_yscale来约束了文字的缩放比，同时用image_alpha约束了文字的透明度

不过如果只按照以上方法绘制的效果会有一些问题，最主要是当文字放大以后会出现锯齿而不清晰。

为了解决文字放大锯齿的问题，我们首先需要自定义一个足够大的字体，然后在平时使用时可以缩小显示，之后放大显示就会平滑一些。

然后我们会尝试调整角度和颜色的变化来使文字更有动感，大概效果如下：

这部分优化代码直接放出，不截图了，代码里会做一些注释

//Create事件
//随机获取四个顶点的颜色
color = [c_green,c_white,c_red,c_purple,c_yellow,c_blue,c_lime,c_maroon,c_orange]
color1_to_draw = color[random(7)];//c1 
color2_to_draw = color[random(7)];//c2
color3_to_draw = color[random(7)];//c3
color4_to_draw = color[random(7)];//c4
//随机设定显示的数字
text_to_draw = floor(random(150));//String

//Step事件
//up
y -= 5 ;

//scale
image_xscale += 0.05;
image_yscale += 0.05;

//fade out
image_alpha -= 0.05;

//destroy
if (image_alpha <= 0 ) instance_destroy();

//Draw事件
//设定自定义字体，这个字体的字号我设置了100
draw_set_font(fnt_test);       
//文字居中排版 
draw_set_halign(fa_center)  
//绘制文字，角度用了wave脚本，这个脚本以前介绍过
draw_text_transformed_color(x,y,string(text_to_draw),image_xscale/10,image_yscale/10,wave(-10,10,5,0),color1_to_draw,color2_to_draw,color3_to_draw,color4_to_draw,image_alpha)

链接:http://pan.baidu.com/s/1kUBddAZ 密码:htvt

这么个简单的功能都能水一整篇也是蛮佩服我自己的XDDD

这是翻译的YoYo官方博客里的一篇教程——DYNAMIC RENDERING MASKS

这是一篇小教程，内容不多，但是效果很酷而且十分实用。当我们在屏幕上绘制内容时，大多数人都只考虑颜色，即红、绿、蓝三个颜色通道，但其实还有一个Alpha通道，但如果你想要借此来构建精灵或处理画面上的内容时可能会遇到很多问题，但是有一件事用Alpha通道绝对合适，那就是制作蒙板遮罩。

因为玩家只会看到处理过的最终结果画面，所以我们可以使用Alpha通道来处理画面以获取我们想要的效果。首先我们要知道有这样一个命令——“gpu_set_colorwriteenable()”——这个方法可以用来打开或关闭颜色和Alpha通道是否允许写入。

首先，我们在屏幕上取任意像素点，每个像素点都具有4个通道——红、绿、蓝以及Alpha，你可以任意启用或关闭其中的任何通道。然后我们要定义一个“特殊”的遮罩，然后把精灵图像写入这个“特殊”的遮罩。这样一来这个RGB通道就会变成这个样子——比如说，一个有趣的按钮，我们可以正常渲染这个按钮图像，然后我们用屏幕上的Alpha通道来“遮”住按钮外面的内容，这样我们就只绘制按钮内部的画面了。

我们现创建两个精灵，一个按钮，以及一个我们希望绘制的“遮罩”的造型精灵。

现在我们的思路是这样的，我们先按照常规的方式把所有内容绘制出来，包括背景、按钮以及按钮的阴影等等，然后要来限制整个按钮绿色区域内部的内容。当然要实现这个目标也有很多其他的方法，比如使用着色器等等，但哪些方法更复杂。接下来我们还要准备一个背景和用来绘制按钮的精灵。

一切准备就绪，如果我们此时来创建测试对象和绘制事件，我们只需要按部就班，首先是背景，接着是按钮阴影，最后是按钮本身，一切照旧。

draw_sprite(sBackground,0, 0,0);
draw_sprite_ext(sButton,0, 32+4,32+4,1,1,0,c_black,0.5);
draw_sprite(sButton,0, 32,32);

接下来的操作才是重点！我们要禁用所有的颜色通道和混合模式，然后在alpha通道写入“0”，如果混合模式是开启状态，这个0会被混合模式按正常的数值进行处理（即完全透明）就不会被正确写入——或者说不是我们希望的样子。而关闭混合模式以后，0就可以被写入alpha通道，而此时其他颜色通道中的图像则不会受影响。

gpu_set_blendenable(false)
gpu_set_colorwriteenable(false,false,false,true);
draw_set_alpha(0);
draw_rectangle(0,0, room_width,room_height, false);

如上，我们禁用了混合模式和颜色通道，并将alpha设置为0，然后绘制了一个全屏的矩形——当然这个矩形只会填充alpha通道。接下来，我们要来实现“遮罩”，遮罩即整个屏幕内我们希望展示的区域。这可以是任何形状或区域，不过在本文中，特制按钮中的绿色区域。

draw_set_alpha(1);
draw_sprite(sMask,0, 32,32);
gpu_set_blendenable(true);
gpu_set_colorwriteenable(true,true,true,true);

这里我们把alpha值设回了1，并且绘制了“sMask”这个遮罩精灵——同样是关闭了混合模式的，因此。

现在我们画面上是这样的：正常的背景画面上有一个按钮，然后上面被一个alpha值是0的矩形覆盖，但按钮的绿色区域哪一块的alpha值是1。接下来我们要打开alpha模式，但并不是读取精灵的alpha通道，而是去读取整个屏幕画面的alpha通道。因为精灵中并没有alpha值因此我们需要打开alphatest模式，这样会尝试从精灵中读取alpha值，然后在最后要记得再把这个测试模式关闭。

gpu_set_blendmode_ext(bm_dest_alpha,bm_inv_dest_alpha);
gpu_set_alphatestenable(true);
draw_sprite(sPlayer,0, mouse_x,mouse_y);
gpu_set_alphatestenable(false);
gpu_set_blendmode(bm_normal);

然后最后我们再把混合模式设置好，启用alpha通道来进行测试，然后我们设置以鼠标所在位置来绘制这个精灵，把所有的设置恢复到正常模式。最后我们点击运行，就会看到以下画面。

我们可以用类似的机制去实现许多类似上图的效果，比如高亮标记游戏中的一些元素等。甚至可以用来实现水的效果。

最后两段因为跟教程没什么关系就不翻了，不过这个教程确实蛮有意思，我尝试了一个移动遮罩的效果，感觉如果在一些解谜游戏中使用也是蛮有趣的。

这个挑战是Reddit的GameMaker版块的每月挑战，有兴趣的朋友可以一起参与一下:-)

原帖——Monthly Challenge 30 - November 2017

————————————————————————

各位游戏开发者大家好，本月是第三十期月度挑战！这个挑战系列是希望通过一些有趣的小任务，刺激大家运用自己的知识来挑战特定主题的游戏开发。

说到有趣，什么最有趣呢？当然是玩游戏！那比玩游戏更有趣的呢？那就是跟朋友一起玩游戏！

没错，本次的月度挑战是要挑战双人游戏，不过这里不涉及网络联机，而是单纯的本地多人游戏，如果你想尝试多人联机，那就自己去尝试一下，不过本次的挑战任务并不包含网络联机的内容。

通常来说，本地多人游戏至少需要为两名（或更多）玩家设计单独的控制器，另外游戏的玩法上需要有一定的竞争性或合作趣味，另外需要显示不同玩家的进度或者得分情况。游戏类型当然是可以任意的，但请注意要控制规模，不然很容易失控。如果你一下子想不到适合的游戏类型，可以试试看传统的双人游戏，比如Pong、双人青蛙跳等～

你可以通过以下方式来参与这次挑战：

• 在你正在做的游戏里实现这个功能
• 做一个小的Demo演示
• 把相关的代码直接发出来
• 任何方式，你喜欢就好！

完成这些挑战后直接回复来展现你的成果即表示完成挑战:)

GameMaker Studio 2的移动版可以支持iOS和Android双平台的导出，之前我曾经写过Android平台的真机调试的配置方式，前阵子有朋友在后台问我怎么导出iOS版本，因此今天就来介绍一下。

注：GameMaker Studio 2导出iOS版本必须有一台Mac用于编译，并且必须拥有苹果开发账号，本文不涉及注册账号的内容，假定有这需求的朋友自己已经搞定账号和证书了

首先，在IDE的右上角可以切换编译和调试用的平台，选择iOS即可，同样这里有VM和YYC两个选项，这里稍微说明一下这两种编译方式的区别：

VM模式是通过一个叫“YOYO Runner”的特殊运行器直接运行你的代码，而YYC模式则是完全编译成对应平台的原生代码再执行，前者可以理解成是使用GMS2自带的一个万能模拟器来运行你的游戏。

VM模式的运行效率稍微低一些，但是编译速度更快，并且可以使用调试模式（Debugger），而在YYC模式下是无法调试游戏的，当然YYC模式的运行效率更高性能更可靠，不过如果游戏比较大逻辑比较复杂的话编译的时间可能会比较长，各位可以自行权衡取舍。

如果你是用Windows开发的游戏，想要最终输出iOS版的话，也务必需要准备一台Mac电脑，因为GMS2只会导出Xcode的工程文件，还是要在Mac中使用Xcode来最终打包编译游戏的，而且官方说必须是真机，Mac虚拟机用不了。

在YYC模式中点击笔形图标即可管理用来运行和调试的设备，跟之前Android设备的管理类似。

在设备列表中默认会同步Xcode中的设备列表进行展示，而进入设备管理界面后如下图：

点击“Detect Device”可以重新检测设备的连接情况，如果你的设备没有显示出来可以检查一下数据线有没有问题并重新插拔一下设备，也有可能是Xcode的同步有问题，可以先启动Xcode然后等几分钟再尝试检测设备。

另外，这里的列表不仅会显示已连接的iOS设备，在Xcode中创建的各个iOS模拟器也都会显示出来，并同样可以用于游戏调试，不过如果使用模拟器调试游戏，最好现在Xcode中把模拟器打开，因为临时启动模拟器耗时较长，另外如果你的Mac内存不够的话，可能会在这个过程中出错导致编译失败。

在GMS2的设置项中可以设置输出Xcode工程的路径以及默认的证书信息

如果你的Mac尚未完成开发环境的配置，可能会导致后续的编译工作出问题，另外图中的复选框如果勾选上，在后续调试时项目会自动编译并打开，如果没有勾上，则项目只会被发送到Xcode中需要你手动编译运行。

当完成以上所有配置以后，无论使用VM或YYC模式，只要点击“运行”按钮就可以编译游戏，项目会被编译成Xcode工程发送到Xcode中。

如果这是第一次测试该项目，还需要在项目的配置项中做一些调整，如下图所示：

你会发现在“Status”处有红色感叹号，这就意味着配置有问题无法正确编译执行，此处需要修改对应的“Bundle Identifier”。

你需要修改默认配置的包名“com.company.game”为你自定义的游戏包名，这个包名可在此处手动修改，在GMS2中也可事先定义，当修改完成后正常显示应该如下图所示：

当所有的警告信息消失后就可以开始运行游戏了，当你点击Xcode的运行按钮时，游戏将在你选择的设备(或模拟器)上运行起来。

以上最后关于Xcode的使用部分未进行太过详细的说明，相信准备编译iOS版本的同学自己应该已经从其它渠道对iOS的开发和编译有一定程度的了解了：）

前两天因为GMS2更新，又在首次更新runtime的时候无限卡了，这次似乎特别严重，以前等一会儿多试几次总能成功，这次却怎么也不行，昨天在公众号稍稍吐槽了一下，就有朋友来介绍手动更新的方法了，推荐给所有卡屏的朋友～

本文系知乎的爱德华所写，原文地址：每次版本更新都卡住？如何手动下载GMS2的runtime工具

前言

GMS2每次版本更新时都会卡住很久，而且因为更新界面比较简陋，用户无法通过界面信息及时了解到更新究竟是卡在了哪里，只能干瞪眼，让人无名火起。

实际上，版本更新所花费的时间，主要都耗在了下载上，因为国内链接yoyogames的服务器的速度很慢，所以每次更新都会花费巨量的时间来下载并不算大的文件。因此，如果你有VPN或者海外加速网络服务的，可以开启这类功能，也许会大幅加快你的更新速度。

而没有科学上网条件的朋友，我们也可以手动下载更新文件，通过下载工具，同样可以提高GMS的版本更新速度。

操作

• step1

打开yoyogames官网runtimes页面（需登陆你的账号）

https://account.yoyogames.com/runtimes

• step2

点击最新的runtime

• step3

根据提示，下载右侧的文件（建议用支持断点续传的下载工具，不然你懂的），并根据页面提示拷贝到指定文件夹

上图为下载区，download按钮即指向对应文件的下载地址

上图为手动操作提示，红框内文字意思是：

如果你是windows，就拷贝到C盘的%programdata%\GameMakerStudio2\Cache\runtimes\runtime-2.1.1.158\downloads

如果你是mac，就拷贝到/Users/Shared/GameMakerStudio2/Cache/runtimes/runtime-2.1.1.158/downloads

如果没有这个文件夹的话，你需要手动创建下（不过如果你已在下载前开启GMS2进行了自动更新的话，GMS2应该已经创建这个文件夹）

注：我在实际操作过程中发现也可能是download，所以如果发现复制到地址栏打不开的话把末尾的downloads换成download试试，可能是官网打错了

注2：文件夹地址中的runtime-2.1.1.158这个是根据tuntime版本号来的，不同版本也会有相应的改变

• step4

还没有结束，因为我在操作时发现，更新系统可能还会下载其他的文件，我们在将这些runtime文件复制到指定目录后，可以打开GMS2，看到软件还在更新后，刷新下指定目录，会发现文件夹内又有了新的文件，然而runtime页面并没有，怎么办？

没关系，其实这个更新的文件的地址就是，http://gm2016.yoyogames.com/xxxxx.zip （末尾为文件名），所以你只要复制这个文件名，加个http://gm2016.yoyogames.com/地址，复制到浏览器或者下载工具中，同样可以手动下载。下载完后复制到step3中提示的文件夹里即可。

如果打开GMS2后发现还有新文件要下载，重复本操作即可。

注：亦可通过官网的runtime RSS订阅地址下载最新runtime的所有RSS，地址如下：

http://gms.yoyogames.com/Zeus-Runtime.rss

（请留意版本号，其中后缀为zip的文档即是runtime文件）

把这些下载的文件都复制到指定的文件夹后，你会惊喜地发现更新只需数秒就完事了……

真是的是下载几小时，安装几秒钟。

本文完。

亦可参考官方指导：How To Manually Download GMS2 "Runtime" Build Tools

https://help.yoyogames.com/hc/en-us/articles/115001342672-How-To-Manually-Download-GMS2-Runtime-Build-Tools

不知道还有没有人记得我曾经说过自己在做一个FlappyBird用来练手，当时的进度是完成了基本的开始游戏、计分和死亡检测之类，但是后来就没再继续，这两天想了想还是准备捡一捡，然后就想先做一个暂停的功能。

Flappy Bird的暂停界面属于现在手机游戏特别典型那种，当玩家按下暂停按钮以后在当前的画面至上浮出一个暂停菜单，菜单里一般有“继续”，“重新开始”，“退出游戏”等一些基本的选项操作，如果玩家按下“继续”那就要回到游戏界面可以继续操作。

说起来并不复杂，而原理其实同样简单，通常来说有两种思路：

• 制作一个专门的“暂停菜单”的游戏场景（room），当用户点击暂停以后跳转到那个场景
• 在用户按下暂停按钮的同时把当前画面截屏并设置为背景画面，同时把场景中所有的对象全部禁用（deactivate），然后创建一个新的暂停菜单的对象供用户操作

今天先介绍第一种方法（才不是因为这种方法比较简单orz）

在介绍这之前，我们首先要了解游戏场景的一个自身属性"persistence"——持久化，当把这个属性设置为Ture并离开该场景后，场景中的所有数据都会保存为你离开时的状态，并会以该状态被直接带入下一个场景，之后你再回到这个场景就可以继续所有刚才未完成的操作。

了解了这个属性以后就很容易了，我们首先需要制作一个没有背景的暂停菜单的游戏场景

然后当我们在游戏场景中按下暂停按键后只需要简单的两行即可

room_persistent = true;     //把持久化属性设置为true
room_goto(room_pause);  //跳转去暂停菜单场景
global.current_room = room //把当前场景保存到一个全局变量中

如果我们要继续游戏，只需要给“Continue”按钮的对象中增加一个点击事件

room_goto(global.current_room);   //返回暂停前的游戏场景

这里我们用了一个全局变量来记录暂停前的游戏场景，这个操作是针对于一些拥有多个游戏场景的游戏而设置的，如果你的游戏十分简单，像FlappyBird一样只有一个固定的游戏场景，完全也可以写死跳转的roomid也能达到相同效果，不过为了培养良好的习惯最好还是不要用写死的方法。

今天介绍的方法真的很简单，不过可能会相对稍微多占用一些内存。

毕竟要把暂停前的游戏数据都临时存起来，但是对于一些小游戏而言也基本够用了：）

之前介绍了在GameMaker Studio中使用自带函数和ini文件进行存/读档的方法，其实还有另一种方法，即采用GMS中的几种数据结构来保存数据——ds_map、ds_list、ds_grid等并且在GMS中自带了十分方便的方法可以直接把这些数据结构保存成物理文件（对应也有方法可以读取这些文件），今天以ds_map为例介绍一下这种方法，希望能有帮助。而保存和读取文件主要会使用到的方法是：

• ds_map_secure_save
• ds_map_secure_load

而要使用ds_map来保存数据，首先我们要对这种数据结构有一个大致的了解：

如上图，我们可以把ds_map想像成这样一个数据集合，其实它的数据结构跟ini配置文件十分类似，只是少了一个"section"的分类，其中的数据同样是由一对对"key"、"value"构成。而GMS中针对ds_map也有大量内置函数可以用于数据的增删改查：

• ds_map_exists
• ds_map_create
• ds_map_add
• ds_map_clear
• ds_map_copy
• ds_map_replace
• ds_map_delete
• ds_map_empty
• ds_map_size
• ds_map_find_first
• ds_map_find_last
• ds_map_find_next
• ds_map_find_previous
• ds_map_find_value
• ds_map_read
• ds_map_write
• ds_map_destroy

有关ds_map的相关函数可以看这里——映射表（DS Map）

接下来，我们用一个实际的例子来说明一下如何用ds_map来保存游戏信息：

假设我们现在有一个简单的RPG游戏，现在要保存游戏进度，我们需要保存的内容有英雄的等级、血量、攻击力，以及英雄身上的装备的信息

save_1 = ds_map_create(); //创建一个ds_map保存到save_1变量中

//
ds_map_add(save_1,"Head",hero_head);// 在save_1中增加一个key为"Head"的数据，值为hero_head
ds_map_add(save_1,"Right Hand",hero_right_hand);//同上
ds_map_add(save_1,"Left Hand",hero_left_hand);//同上
ds_map_add(save_1,"Level",hero_level);//在save_1中增加一个key为“Level”的数据，值取hero_level对应的值
ds_map_add(save_1,"HP",hero_hp);//同上
ds_map_add(save_1,"Attack",hero_attack);//同上

ds_map_secure_save(save_1, "save1.dat" ) ;//把save_1中的ds_map保存为一个名为"save1.dat"的物理文件
ds_map_destroy(save1.dat);//释放内存

通过以上操作我们就可以完成我们之前的目标，将需要保存的信息通过ds_map进行储存并加密保存为一个物理文件，由于这种保存方式自带加密操作，因此存档文件的安全性较ini配置文件要更高。而当游戏中执行加载存档的方法时我们可以这么做：

load_save = ds_map_secure_load("save1.dat")//加载"save1.dat"文件中的ds_map保存到"load_save"中

//加载ds_map中的数据保存到游戏变量中
hero_head = ds_map_find_value(load_save, "Head");
hero_right_hand = ds_map_find_value(load_save, "Right Hand");
hero_left_hand = ds_map_find_value(load_save, "Left Hand");
hero_level = ds_map_find_value(load_save, "Level");
hero_hp = ds_map_find_value(load_save, "HP");
hero_attack  = ds_map_find_value(load_save, "Attack");

ds_map_destroy(load_save);//释放内存

以上，其实从原理上来说跟ini配置文件的使用方式是十分类似的，但是个人更推崇这种方式

• 加密性更好
• ds_map的数据结构也更好与ds_list和ds_grid等联动
• ini配置文件同时只能开启一个，ds_map只要内存不炸理论上可以多个同时操作

在写这篇教程的时候找到了几篇详细介绍数据结构的教程，好像很棒，过几天找时间翻译一下：）

除了Flappy Bird之类的小游戏，许多游戏都需要保存和载入进度，以便玩家可以随时中断游戏，之后又能继续玩下去，在GameMaker Studio中有几种方法都可以实现类似的功能，常用的有以下几种方法：

• 自带函数game_save()
• ini配置文件保存
• ds_map/ds_list存储

大家可以根据自己游戏的复杂程度和自己的喜好来选用，今天先介绍前两种。

在GameMaker Studio中自带两个存档和读档的方法：

• game_save()
• game_load()

这两个方法在调用时都只需要在括号中填入字符串格式的文件名作为参数即可

game_save("save.dat")
game_load("save.dat")

如上的代码就是将当前游戏的一些静态内容保存到一个名为"save.dat"的文件中（或从中读取），如各种变量等，但这个方法无法指定哪些内容需要保存，而哪些又需要排除，并且无法保存游戏中创建的动态资源，诸如数据结构（ds_list、ds_map等）。并且当你开启了某个场景（room）自带的物理特性以后这个方法就会失效无法使用。另外好像这种方法保存的文件在重新编译更新游戏版本时是无法继承的。所以这个方法其实还是十分有局限性的，只有当游戏非常简单对保存的数据内容非常有限时可以考虑用一下。

这可能是最普遍的一种方法，可以自定义需要保存的值，而且不算复杂，但是使用这种方法首先要对ini配置文件有基本的理解，不清楚的可以先去了解一下——INI文件

使用ini配置文件保存数据的方法如下：

ini_open("saveData.ini"); //打开ini文件，如果不存在则新建
ini_write_real("Variables", "score", score); //第一个值是section，第二个值是key，第三个值是对应要写入的value
ini_write_string("Variables","string",string); //同上，不过这是写入字符串的方法
ini_close(); //用完记得关闭文件否则容易内存溢出

在使用ini_open的方法打开/新建了一个ini配置文件以后，就可以将你所需要的值全部存入这个文件，比如血量、分数、人物等级等等，甚至可以把每一个对象的坐标都保存到文件里，方便下次载入时能让画面完全恢复原装。而当你载入游戏时就需要用以下方法进行读取：

ini_open("saveData.ini");
score = ini_read_real("Variables","score",0); //如果文件中没有对应的值则会将第三个参数保存到文件里
string = ini_read_string("Variables","string","Hello world"); //同上，只是字符串的方法而已
ini_close();

用这个方法你可以把你之前保存的数据依次读取出来，然后加载到你当前的游戏中来，这里要注意的是如果在存档文件中没有获取到对应的值时，会将此处第三个参数的内容作为默认值写入存档文件，切记。

刚发现介绍脚本的这最后的集合一直留在草稿里没发……抓紧发了orz

Wrap这个脚本是用来做什么的呢？先来看一下这个GIF图其实就是把传入的一个值约束在指定的范围内来回递增/减，并且钟摆循环。

///@description Wrap(value,min,max)
///@function Wrap
///@param value
///@param min
///@param max
//returns the value wrapped

var _val = argument[0];
var _max = argument[1];
var _min = argument[2];

if(_val mod 1==0 )
{
    while(_val > _max) || _val < _min)
    {
        if(_val > _max)
        {
            _val = _min + _val - _max -1 ;
        }
        else if (_val < _min)
        {
            _val = _max + _val - _min + 1 ;
        }
        else
            _val = _val ;
    }
    return(_val);
 }
 else
 {
     var _old = argument[0] + 1 ;
     while(_val != _old)
     {
         _old = _val ;
         if (_val < _min)
                _val = _max - (_min - _val) ;
        else if(_val > _max)
                _val = _min + (_val - _max) ;
        else
                _val = _val ;
     }
     return(_val);
 }

下面这个脚本其实很简单，就是在你指定跳跃的角度和距离后，即可让对象朝着指定的方向移动对应距离的脚本，而脚本中的那两句代码在HeartBeast的横版射击游戏教程中也有使用，就是把官方内置的方法"lengthdir_x"和"lengthdir_y"组合使用，这个脚本只是单纯简化了操作。

/// @description JumpInDirection(length,direction)
/// @param length
/// @param direction
var len = argument0 ;
var dir = argument1;

x += lengthdir_x(len,dir);
y += lengthdir_y(len,dir);

这个脚本更简单，只有一行，理论上来说也完全可以直接把代码写到需要实用的地方去，但是通过脚本可以使得可读性更强，这个脚本的目的是计算概率，下面举个例子

if Chance(0.7)
{
    //写在这里的代码就有70%的概率被触发
}

在参数里只要填入0~1的小数即可直接设定触发代码的概率，从而实现触发概率的功能。而实现机制则异常简单，稍加思考应该就能明白：）

return argument0 > random(1) ;

从这个月开始继续同步更新reddit的每月挑战吧，一个月一个主题压力也不大，有兴趣的朋友也可以一起参与一下，这是第28期了。

本月的主题是关于“系统时间”的运用，很多人可能会觉得奇怪，“系统时间”能用来做什么呢？首先，通过读取系统时间，你的游戏可以模拟真实世界的时间流逝，你可以让你游戏中的太阳随着实际的时间而改变位置，也可以根据实际时间切换白天/黑夜。或者让敌人的力量随着时间的变化而得到调整，也可以随着时间来动态调整游戏的元素以提供更多的趣味性。

你可以用以下不同的方式参与到活动中来：

• 直接在你正在制作的项目中使用该功能
• 制作一个全新的demo
• 提交一份相关的代码
• 以及其他任何你喜欢的形式！

下面的表中有三项不同难度的挑战，可根据自己的实际情况选择挑战：

小Tips: 可以使用以下这些函数

• current_second
• current_minute
• current_hour
• date_current_datetime
• date_get_second
• date_get_minute
• date_get_hour

不用太刻意去迎合示例的要求，只要符合主题，想怎么做都是可以的:)