Game

包含所有游戏信息的主要全局游戏对象。

Game.constructionSitesobject<string, ConstructionSite>

包含你所有施工工地的 hash，并以 id 作为关键字。

Game.cpuobject

包含有关 CPU 使用率信息的对象，具有以下属性：

parameter	type	description
limit	number	你在当前指定 shard 的CPU限制。
tickLimit	number	当前游戏 tick 可用的 CPU 时间。 通常它高于 Game.cpu.limit. 了解更多
bucket	number	在你的 bucket 中累积的未使用的 CPU 数量。
shardLimits	object <string,number>	包含了每个 shard cpu 上限的对象，以 shard 名称为关键字。你可以使用 setShardLimits 方法重设他们。
unlocked	boolean	您的账户是否已经解锁了完整的 CPU。
unlockedTime	number	您账户解锁完整 CPU 时的 UNIX 毫秒时间戳。当您账户的完整 CPU 未解锁或未使用 subscription 时该属性未定义。

Game.creepsobject<string, Creep>

for(const i in Game.creeps) {
    Game.creeps[i].moveTo(flag);
}

包含你所有 creep 的 hash，并以 creep 名作为关键字。

Game.flagsobject<string, Flag>

creep.moveTo(Game.flags.Flag1);

包含你所有 flag 的 hash，以 flag 名作为关键字。

Game.gclobject

你的全局控制等级（Global Control Level）的对象，具有以下属性：

parameter	type	description
level	number	当前的等级。
progress	number	到下一个等级当前的进展。
progressTotal	number	到下一个等级所需的进展。

Game.gplobject

你的全局能量等级（Global Power Level）的对象，具有以下属性：

parameter	type	description
level	number	当前的等级。
progress	number	到下一个等级当前的进展。
progressTotal	number	到下一个等级所需的进展。

Game.mapobject

表示世界地图的全局对象。 请参照此文档。

Game.marketobject

表示游戏内市场的全局对象。 请参照此文档

Game.powerCreepsobject<string, PowerCreep>

Game.powerCreeps['PC1'].moveTo(flag);

包含你所有超能 creep 的 hash，以 creep 名称为键。从这里也可以访问到未孵化的超能 creep。

Game.resourcesobject

表示你账户中全局资源的对象，例如 pixel 或 cpu unlock。每个对象的关键字都是一个资源常量，值是资源量。

Game.roomsobject<string, Room>

包含所有对你可用的房间的 hash，以房间名作为关键字。一个房间在你有一个 creep 或者自有建筑在其中时可见。

Game.shardobject

表示当前正在执行脚本的 shard 的对象。

parameter	type	description
name	string	shard 的名称。
type	string	目前总是等于 normal.
ptr	boolean	这个 shard 是否为 PTR.

Game.spawnsobject<string, StructureSpawn>

for(const i in Game.spawns) {
    Game.spawns[i].createCreep(body);
}

包含你所有 spawn 的 hash，以 spawn 名作为关键字。

Game.structuresobject<string, Structure>

包含你所有 structures 的 hash，以 structures 名作为关键字。

Game.timenumber

console.log(Game.time);

系统游戏 tick 计数。他在每个 tick 自动递增。点此了解更多。

Game.cpu.getHeapStatistics()

let heap = Game.cpu.getHeapStatistics();
console.log(`Used ${heap.total_heap_size} / ${heap.heap_size_limit}`);

这个方法只在虚拟机在你的账户运行时设置中被设为 Isolated 时可用

使用此方法获取虚拟机的堆统计信息。 返回值几乎与 Node.js 函数 v8.getHeapStatistics()相同。 此函数返回一个附加属性： externally_allocated_size，它是当前分配的内存总量，不包含在 v8 堆中，但会计入此隔离的内存限制。 超过一定大小的 ArrayBuffer 实例是外部分配的，将在此计算。

返回值

以下列格式返回具有堆统计信息的对象：

{
  "total_heap_size": 29085696,
  "total_heap_size_executable": 3670016,
  "total_physical_size": 26447928,
  "total_available_size": 319649520,
  "used_heap_size": 17493824,
  "heap_size_limit": 343932928,
  "malloced_memory": 8192,
  "peak_malloced_memory": 1060096,
  "does_zap_garbage": 0,
  "externally_allocated_size": 38430000
}

Game.cpu.getUsed()

if(Game.cpu.getUsed() > Game.cpu.tickLimit / 2) {
    console.log("Used half of CPU already!");
}

for(const name in Game.creeps) {
    const startCpu = Game.cpu.getUsed();

    // creep logic goes here

    const elapsed = Game.cpu.getUsed() - startCpu;
    console.log('Creep '+name+' has used '+elapsed+' CPU time');
}

获取当前游戏开始时使用的 CPU 时间总量。在模拟模式下始终返回 0.

返回值

以浮点数返回当前使用的 CPU 时间。

Game.cpu.halt()

Game.cpu.halt();

这个方法只在虚拟机在你的账户运行时设置中被设为 Isolated 时可用

重置你的运行环境并擦除堆内存中的所有数据。

Game.cpu.setShardLimits(limits)

Game.cpu.setShardLimits({shard0: 20, shard1: 10});

分配 CPU 限制到不同的 shard。CPU总量应保持等于 Game.cpu.shardLimits。此方法每 12 小时只能使用一次。

parameter	type	description
limits	object<string, number>	表示每个 shard 的 CPU 值，与 Game.cpu.shardLimits 格式相同。

返回值

以下代码之一：

constant	value	description
OK	0	该操作已成功安排。
ERR_BUSY	-4	12 小时的冷却时间尚未结束。
ERR_INVALID_ARGS	-10	该参数不是有效的 shard 限制对象。

Game.cpu.unlock()

if(Game.cpu.unlockedTime && ((Game.cpu.unlockedTime - Date.now()) < 1000*60*60*24)) {
    Game.cpu.unlock();
}

为您的账户解锁 24 小时的完整 CPU。该方法将消耗一个您账户中的 CPU unlock（详见 Game.resources）。 如果之前尚未激活过完整 CPU。则可能需要一点时间（5 分钟之内）来为您的账户应用解锁。

返回值

下列返回值之一：

constant	value	description
OK	0	该操作已成功安排。
ERR_NOT_ENOUGH_RESOURCES	-6	您的账户没有足够的 cpuUnlock 资源。
ERR_FULL	-8	您的 CPU 已经使用了 subscription 解锁.

Game.cpu.generatePixel()

if(Game.cpu.bucket == 10000) {
    Game.cpu.generatePixel();
}

从您的 bucket 中取出 10000 CPU 来生成一点 pixel 资源。

constant	value	description
OK	0	该操作已成功安排。
ERR_NOT_ENOUGH_RESOURCES	-6	您的 bucket 中没有足够的 CPU。

Game.getObjectById(id)

creep.memory.sourceId = creep.pos.findClosestByRange(FIND_SOURCES).id;
const source = Game.getObjectById(creep.memory.sourceId);

获取具有唯一指定 ID 的对象。 它可以是任何类型的游戏对象。 只能访问您可见的房间内的物体。

parameter	type	description
id	string	The unique identificator.

返回值

返回一个对象实例，若找不到则返回 null。

Game.notify(message, [groupInterval])

if(creep.hits < creep.memory.lastHits) {
    Game.notify('Creep '+creep+' has been attacked at '+creep.pos+'!');
}
creep.memory.lastHits = creep.hits;

if(Game.spawns['Spawn1'].energy == 0) {
    Game.notify(
        'Spawn1 is out of energy',
        180  // group these notifications for 3 hours
    );
}

向你的个人资料中的邮件发送信息。由此，你可以在游戏中的任何场合为自己设置通知。你最多可以安排 20 个通知。在模拟模式中不可用。

parameter	type	description
message	string	将在消息中发送的自定义文本。最大长度为 1000 个字符。
groupInterval	number	如果被设为 0 (默认), 通知将被立即安排。 否早他将于其他通知编组，并在指定的时间（分钟）寄出。

InterShardMemory

InterShardMemory 对象提供了在不同的 shard 之间通信的接口。你的脚本在不同的 shard 内是单独执行的，并且他们的 Memory 对象对彼此隔离。为了在不同的 shard 之间传递信息，您需要使用 InterShardMemory。

每个 shard 可以拥有能被其他 shard 访问的数据字符串，最长 100 KB。每个数据字符串只有其所属的 shard 才有写权限， 而其他的 shard 只有读权限。

该数据和 Memory 完全不相关，它是一个独立的数据容器。

InterShardMemory.getLocal()

返回当前 shard 的数据字符串内容。

InterShardMemory.setLocal(value)

var data = JSON.parse(InterShardMemory.getLocal() || "{}");
data.message = "hello from another shard!";
InterShardMemory.setLocal(JSON.stringify(data));

将当前 shard 的数据替换为新的值。

parameter	type	description
value	string	格式化为字符串的新数据。

InterShardMemory.getRemote(shard)

var data = JSON.parse(InterShardMemory.getRemote('shard0') || "{}");
console.log(data.message);

返回其他 shard 的数据字符串内容。

parameter	type	description
shard	string	Shard 名称。

Game.map

世界地图对象，用于在房间之间导航。

Game.map.describeExits(roomName)

const exits = Game.map.describeExits('W8N3');

根据给定的房间名列出所有可用的出口。

parameter	type	description
roomName	string	房间名。

返回值

出口信息按照以下格式给出，在房间不存在时返回null。

{
    "1": "W8N4",    // TOP
    "3": "W7N3",    // RIGHT
    "5": "W8N2",    // BOTTOM
    "7": "W9N3"     // LEFT
}

Game.map.findExit(fromRoom, toRoom, [opts])

if(creep.room != anotherRoomName) {
    const exitDir = Game.map.findExit(creep.room, anotherRoomName);
    const exit = creep.pos.findClosestByRange(exitDir);
    creep.moveTo(exit);
}
else {
    // 到另一个房间的某处去
}

creep.moveTo(new RoomPosition(25, 25, anotherRoomName));

查找从给定房间到另一个房间的出口方向。

parameter	type	description
fromRoom	string, Room	起点房间名或房间对象。
toRoom	string, Room	终点房间名或房间对象。
opts (可选)	object	包含寻路选项的对象。参见findRoute。

返回值

房间方向常量，下列之一：

• FIND_EXIT_TOP
• FIND_EXIT_RIGHT
• FIND_EXIT_BOTTOM
• FIND_EXIT_LEFT

或下列错误码：

constant	value	description
ERR_NO_PATH	-2	找不到路径。
ERR_INVALID_ARGS	-10	位置不正确。

Game.map.findRoute(fromRoom, toRoom, [opts])

const route = Game.map.findRoute(creep.room, anotherRoomName);
if(route.length > 0) {
    console.log('Now heading to room '+route[0].room);
    const exit = creep.pos.findClosestByRange(route[0].exit);
    creep.moveTo(exit);
}

const route = Game.map.findRoute(creep.room, anotherRoomName, {
    routeCallback(roomName, fromRoomName) {
        if(roomName == 'W10S10') {    // 回避这个房间
            return Infinity;
        }
        return 1;
    }});

let from = new RoomPosition(25, 25, 'E1N1');
let to = new RoomPosition(25, 25, 'E4N1');

// 使用`findRoute`计算路径的高阶计划，优先选择大路和自有房间
let allowedRooms = { [ from.roomName ]: true };
Game.map.findRoute(from.roomName, to.roomName, {
    routeCallback(roomName) {
        let parsed = /^[WE]([0-9]+)[NS]([0-9]+)$/.exec(roomName);
        let isHighway = (parsed[1] % 10 === 0) || 
                        (parsed[2] % 10 === 0);
        let isMyRoom = Game.rooms[roomName] &&
            Game.rooms[roomName].controller &&
            Game.rooms[roomName].controller.my;
        if (isHighway || isMyRoom) {
            return 1;
        } else {
            return 2.5;
        }
    }
}).forEach(function(info) {
    allowedRooms[info.room] = true;
});

// 调用PathFinder, 只允许访问`findRoute`中的房间
let ret = PathFinder.search(from, to, {
    roomCallback(roomName) {
        if (allowedRooms[roomName] === undefined) {
            return false;
        }
    }
});

console.log(ret.path);

查找从给定房间到另一个房间的路径。

parameter	type	description
fromRoom	string, Room	起点房间名或房间对象。
toRoom	string, Room	终点房间名或房间对象。
opts (可选)	object	包含下列选项的对象： routeCallback function 这个回调函数接受两个参数： function(roomName, fromRoomName)。 它可以用来计算进入一个房间的开销。你可以用它实现优先进入自己的房间或者回避某些房间等功能。你应该返回一个浮点数开销，或者返回Infinity代表不可进入。

返回值

如下格式的路径数组：

[
    { exit: FIND_EXIT_RIGHT, room: 'arena21' },
    { exit: FIND_EXIT_BOTTOM, room: 'arena22' },
    ...
]

或如下错误码之一：

constant	value	description
ERR_NO_PATH	-2	找不到路径。

Game.map.getRoomLinearDistance(roomName1, roomName2, [continuous])

Game.map.getRoomLinearDistance('W1N1', 'W4N2'); // 3
Game.map.getRoomLinearDistance('E65S55','W65S55', false) // 131
Game.map.getRoomLinearDistance('E65S55','W65S55', true) // 11

获取两个房间之间直线距离（房间数）。你可以使用这个函数估算使用终端发送资源的能源开销，或用于使用观察者和核武器。

parameter	type	description
roomName1	string	第一个房间名。
roomName2	string	第二个房间名。
continuous (可选)	boolean	是否视世界地图为在边界连续。 如果要计算交易或终端发送开销，请设置为true。 默认值为false。

返回值

给定两个房间之间的房间数。

Game.map.getRoomTerrain(roomName)

const terrain = Game.map.getRoomTerrain("E2S7");
switch(terrain.get(10,15)) {
    case TERRAIN_MASK_WALL:
        break;
    case TERRAIN_MASK_SWAMP:
        break;
    case 0:
        break;
}

获取Room.Terrain 对象，快捷访问静态地形数据。此方法适用于所有房间，哪怕是无法访问的房间。

parameter	type	description
roomName	string	房间名。

返回值

一个新Room.Terrain对象。

Game.map.getTerrainAt(x, y, roomName)
(pos)

console.log(Game.map.getTerrainAt(25,20,'W10N10'));

console.log(Game.map.getTerrainAt(new RoomPosition(25,20,'W10N10'));

获取指定房间坐标的地形类型。此方法适用于所有房间，哪怕是无法访问的房间。

parameter	type	description
x	number	房间内X坐标。
y	number	房间内Y坐标。
roomName	string	房间名。
pos	RoomPosition	坐标对象。

返回值

下列字符串值：

• plain
• swamp
• wall

Game.map.getWorldSize()

返回世界尺寸，即世界对角之间的房间数。例如对于一个从 W50N50 至 E50S50 的世界这个方法返回102。

Game.map.isRoomAvailable(roomName)

if(Game.map.isRoomAvailable(room.name)) {
    creep.moveTo(room.getPositionAt(25,25));
}

检查一个房间是否可以进入。

parameter	type	description
roomName	string	The room name.

返回值

布尔值

Game.map.getRoomStatus(roomName)

if(Game.map.getRoomStatus(room.name).status == 'normal') {
    nuker.launchNuke(room.getPositionAt(25,25));
}

获取指定房间的开放状态。点击 本文 了解更多起始区域的相关信息。

parameter	type	description
roomName	string	房间名

返回值

包含如下属性的对象：

属性	类型	介绍
status	string	下列字符串之一： normal – 该房间没有限制 closed – 该房间未启用（not available） novice – 该房间是新手区的一部分 respawn – 该房间是重生区的一部分
timestamp	number	状态终止时间 UNIX 毫秒时间戳。如果房间状态没有终止时间，则该属性为 null。

Game.map.visual

地图可视化（Map visual）提供了一种途径来在游戏地图上显示各种可视化的调试信息。您可以使用 Game.map.visual 对象来绘制一些仅对您可见的简单图形。

地图可视化不会被存储在游戏数据库中，它们唯一的作用就是在您的浏览器上显示一些信息。所有的绘制效果只会被保留一个 tick，并且如果下个 tick 没有更新的话它们就会消失。所有的 Game.map.visual 调用都不会产生 CPU 消耗（只会产生一些代码执行的自然成本，并且大多与简单的 JSON.serialize 调用有关）。然而，这里有一条使用限制：您最多只能为每个房间发布 1000 KB 的序列化数据。

所有绘制坐标均等同于全局游戏坐标 (RoomPosition)。

line(pos1, pos2, [style])

Game.map.visual.line(creep.pos, target.pos,
    {color: '#ff0000', lineStyle: 'dashed'});

绘制一条线。

parameter	type	description
pos1	RoomPosition	起始点位置对象。
pos2	RoomPosition	结束点位置对象。
style (可选)	object	包含下列属性的对象： width number 线条的宽度，默认值为 0.1。 color string 线条颜色，使用以下格式：#ffffff（十六进制颜色），默认为 #ffffff。 opacity number 透明度，默认值为 0.5。 lineStyle string undefined (实线)，dashed (虚线) 或者 dotted (点线) 之一。默认值为 undefined。

返回值

MapVisual 对象本身，以便进行链式调用。

circle(pos, [style])

Game.map.visual.circle(new RoomPosition(25,25,'E2S7'));

Game.map.visual.circle(nuker.pos, {fill: 'transparent', radius: NUKE_RANGE*50, stroke: '#ff0000'});

绘制一个圆。

parameter	type	description
pos	RoomPosition	中心点位置对象。
style (可选)	object	包含下列属性的对象： radius number 圆的半径，默认值为 10。 fill string 线条颜色，使用以下格式：#ffffff（十六进制颜色），默认为 #ffffff。 opacity number 透明度，默认值为 0.5。 stroke string 轮廓颜色，使用以下格式：#ffffff（十六进制颜色），默认为 undefined（无轮廓）。 strokeWidth number 轮廓宽度，默认值为 0.5。 lineStyle string undefined (实线)，dashed (虚线) 或者 dotted (点线) 之一。默认值为 undefined。

返回值

MapVisual 对象本身，以便进行链式调用。

rect(topLeftPos, width, height, [style])

// tower 的最佳效果区域
Game.map.visual.rect(new RoomPosition(tower.pos.x - 5, tower.pos.y - 5, tower.pos.roomName), 
    11, 11,
    {fill: 'transparent', stroke: '#ff0000'});

绘制一个矩形。

parameter	type	description
topLeftPos	RoomPosition	左上角的位置对象。
width	number	矩形的宽。
height	number	矩形的高。
style (可选)	object	包含下列属性的对象： fill string 线条颜色，使用以下格式：#ffffff（十六进制颜色），默认为 #ffffff。 opacity number 透明度，默认值为 0.5。 stroke string 轮廓颜色，使用以下格式：#ffffff（十六进制颜色），默认为 undefined（无轮廓）。 strokeWidth number 轮廓宽度，默认值为 0.5。 lineStyle string undefined (实线)，dashed (虚线) 或者 dotted (点线) 之一。默认值为 undefined。

返回值

MapVisual 对象本身，以便进行链式调用。

poly(points, [style])

const points = [];
points.push(creep1.pos);
points.push(Game.rooms.E2S7.storage.pos);
points.push(new RoomPosition(20,21,'W1N1'));
Game.map.visual.poly(points, {fill: 'aqua'}); 

// 将路径可视化
const path = PathFinder.search(creep.pos, creep.room.storage.pos).path;
Game.map.visual.poly(path, {stroke: '#ffffff', strokeWidth: .8, opacity: .2, lineStyle: 'dashed'});

绘制一段折线.

parameter	type	description
points	array	包含了所有拐点的数组。每个数组元素都应是一个 RoomPosition 对象。
style (可选)	object	包含下列属性的对象： fill string 填充颜色，使用以下格式：#ffffff（十六进制颜色），默认为 undefined（无填充）。 opacity number 透明度，默认值为 0.5。 stroke string 轮廓颜色，使用以下格式：#ffffff（十六进制颜色），默认为 #ffffff。 strokeWidth number 轮廓宽度，默认值为 0.5。 lineStyle string undefined (实线)，dashed (虚线) 或者 dotted (点线) 之一。默认值为 undefined。

返回值

MapVisual 对象本身，以便进行链式调用。

text(text, pos, [style])

Game.map.visual.text("Target💥", new RoomPosition(11,14,'E2S7'), {color: '#FF0000', fontSize: 10}); 

绘制一个文本标签。你可以使用任何有效的 Unicode 字符，包括 emoji。

parameter	type	description
text	string	文本信息
pos	RoomPosition	文本基线（baseline）起始点的位置对象。
style (可选)	object	包含下列属性的对象： color string 文本颜色，使用以下格式：#ffffff（十六进制颜色），默认为 #ffffff。 fontFamily string 文本字体，默认为 sans-serif fontSize number 字体大小，基于游戏坐标，默认为 10 fontStyle string 字体风格（'normal', 'italic' 或者 'oblique'） fontVariant string 字体变种（'normal' 或者 'small-caps'） stroke string 轮廓颜色，使用以下格式：#ffffff（十六进制颜色），默认为 undefined（无轮廓）。 strokeWidth number 轮廓宽带，默认为 0.15。 backgroundColor string 背景颜色，使用以下格式：#ffffff（十六进制颜色），默认为 undefined（无背景色）。当启用背景色时，文本的垂直对齐模式将被设置为居中（默认为 baseline）。 backgroundPadding number 背景矩形的内边距（padding），默认为 2。 align string 文本对齐，center、left、right 之一。默认为 center。 opacity number 透明度，默认值为 0.5。

返回值

MapVisual 对象本身，以便进行链式调用。

clear()

Game.map.visual.clear();

移除该房间的所有可视化效果。

返回值

MapVisual 对象本身，以便进行链式调用。

getSize()

if(Game.map.visual.getSize() >= 1024000) {
    // 本 tick 无法添加更多的可视化效果
}

获取本 tick 所有可视化效果的存储大小。最多不能超过 1024,000（1000 KB）。

返回值

可视化效果的大小（单位：字节）。

export()

Memory.MapVisualData = Game.map.visual.export();

返回当前 tick 中添加到地图中的所有可视化效果的紧凑格式。

返回值

代表了可视化数据的字符串。除了将其存储以备后续使用外，您不应该对其进行其他操作。

import(val)

Game.map.visual.import(Memory.MapVisualData);

将先前导出（使用Game.map.visual.export）的地图可视化效果添加到当前 tick。

parameter	type	description
val	string	从 Game.map.visual.export 返回的字符串。

返回值

MapVisual 对象本身，以便进行链式调用。

Game.market

描述游戏内市场的全局变量。您可以使用该对象追踪从您的终端接收/发送的资源交易，以及您的购买/出售订单。

点击 本文 来了解更多关于市场系统的信息。

Game.market.creditsnumber

您当前的 credit 余额。

Game.market.incomingTransactionsarray

[{
    transactionId : "56dec546a180ce641dd65960",
    time : 10390687,
    sender : {username: "Sender"},
    recipient : {username: "Me"},
    resourceType : "U",
    amount : 100,
    from : "W0N0",
    to : "W10N10",
    description : "trade contract #1",
    order: {        // 可选的
        id : "55c34a6b5be41a0a6e80c68b",
        type : "sell",
        price : 2.95
    }
}]

一个数组，内容为您终端接收的最近 100 笔交易，格式详见右侧：

Game.market.outgoingTransactionsarray

[{
    transactionId : "56dec546a180ce641dd65960",
    time : 10390687,
    sender : {username: "Me"},
    recipient : {username: "Recipient"},
    resourceType : "U",
    amount : 100,
    from : "W0N0",
    to : "W10N10",
    description : "trade contract #1",
    order: {        // 可选的
        id : "55c34a6b5be41a0a6e80c68b",
        type : "sell",
        price : 2.95
    }
}]

一个数组，内容为您终端发送的最近 100 笔交易，格式详见右侧：

Game.market.ordersobject

{
    "55c34a6b5be41a0a6e80c68b": {
        id : "55c34a6b5be41a0a6e80c68b",
        created : 13131117,
        active: true,
        type : "sell"
        resourceType : "OH",
        roomName : "W1N1",
        amount : 15821,
        remainingAmount : 30000,
        totalAmount : 50000,
        price : 2.95
    },
    "55c34a6b52411a0a6e80693a": {
        id : "55c34a6b52411a0a6e80693a",
        created : 13134122,
        active: true,
        type : "buy"
        resourceType : "energy",
        roomName : "W1N1",
        amount : 94000,
        remainingAmount : 94000,
        totalAmount : 94000
        price : 0.45
    },
    "55c34a6b5be41a0a6e80c123": {
        id : "55c34a6b5be41a0a6e80c123",
        created : 13105123,
        active: false,
        type : "sell"
        resourceType : "token",
        amount : 0,
        remainingAmount : 10,
        totalAmount : 10,
        price : 50000
    }
}

一个对象，包含了您在市场中活跃 (activated) 和非活跃 (deactivated) 的购买/出售订单。 查看 getAllOrders 来了解其详细说明。

Game.market.calcTransactionCost(amount, roomName1, roomName2)

const cost = Game.market.calcTransactionCost(1000, 'W0N0', 'W10N5');
// -> 284 单位能量

估算 StructureTerminal.send 和 Game.market.deal 方法的能量交易成本。 算法：

Math.ceil( amount * ( 1 - Math.exp(-distanceBetweenRooms/30) ) )

parameter	type	description
amount	number	要发送的资源数量。
roomName1	string	第一个房间的名称。
roomName2	string	第二个房间的名称。

返回值

进行交易所需的能量。

Game.market.cancelOrder(orderId)

for(const id in Game.market.orders) {
    Game.market.cancelOrder(id);
}

取消先前创建的订单。5% 的费用将不予退还。

parameter	type	description
orderId	string	Game.market.orders 中提供的订单 ID。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_INVALID_ARGS	-10	无效的订单 ID。

Game.market.changeOrderPrice(orderId, newPrice)

Game.market.changeOrderPrice('57bec1bf77f4d17c4c011960', 9.95);

修改一个已存在订单的单价。如果 newPrice 大于之前的单价，将向您收取 (newPrice-oldPrice)*remainingAmount*0.05 credit 的费用。

parameter	type	description
orderId	string	Game.market.orders 提供的订单 ID。
newPrice	number	新的订单单价。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	您不是该房间终端的所有者或者该房间没有终端。
ERR_NOT_ENOUGH_RESOURCES	-6	您没有足够的 credit 来缴纳费用。
ERR_INVALID_ARGS	-10	提供了无效的参数。

Game.market.createOrder(params)

Game.market.createOrder({
    type: ORDER_SELL,
    resourceType: RESOURCE_GHODIUM,
    price: 9.95,
    totalAmount: 10000,
    roomName: "W1N1"   
});

从您的终端创建一个市场订单。下单时将向您收取 price*amount*0.05 credit 的费用。每个玩家最多可以拥有 300 个订单。您可以在任意时刻使用任意数量创建一个订单。之后会自动根据其可用资源量和 credit 来将其状态设置为活跃和非活跃。

parameter	type	description
params	object	包含下列参数的对象： type string 订单类型，ORDER_SELL 或者 ORDER_BUY。 resourceType string Either one of the RESOURCE_* constants or one of account-bound resources (See INTERSHARD_RESOURCES constant). If your Terminal doesn't have the specified resource, the order will be temporary inactive. price number 资源的单价（单位: credit）。可以包含小数。 totalAmount number 要交易的资源总量。 roomName (可选) string 在创建订单时指定的房间中必须存在一个属于您的终端（Terminal），否则该订单将暂时无效。当 resourceType 参数的值为账户绑定资源之一（见 INTERSHARD_RESOURCES 常量）时本参数不使用。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	您不是该房间终端的所有者或者该房间没有终端。
ERR_NOT_ENOUGH_RESOURCES	-6	您没有足够的 credit 来缴纳费用。
ERR_FULL	-8	您不能创建超过 300 个订单。
ERR_INVALID_ARGS	-10	提供了无效的参数。

Game.market.deal(orderId, amount, [yourRoomName])

Game.market.deal('57cd2b12cda69a004ae223a3', 1000, "W1N1");

const amountToBuy = 2000, maxTransferEnergyCost = 500;
const orders = Game.market.getAllOrders({type: ORDER_SELL, resourceType: RESOURCE_GHODIUM});

for(let i=0; i<orders.length; i++) {
    const transferEnergyCost = Game.market.calcTransactionCost(
        amountToBuy, 'W1N1', orders[i].roomName);

    if(transferEnergyCost < maxTransferEnergyCost) {
        Game.market.deal(orders[i].id, amountToBuy, "W1N1");
        break;
    }
}

使用 yourRoomName 房间中的终端处理一个贸易订单，根据订单类型(购入/卖出)来和其他玩家的终端进行交易。无论订单类型如何，您的终端都将承担本次资源交易所产生的能量消耗。您可以使用 Game.market.calcTransactionCost 方法估算运输成本。当多个玩家尝试处理同一个订单时，距离更近的玩家优先。您每 tick 不能处理超过 10 笔交易。

parameter	type	description
orderId	string	来自 Game.market.getAllOrders 的订单 ID。
amount	number	要转移的资源数量。
yourRoomName (可选)	string	您某个房间的名称，该房间应该存在一个可用终端且该终端存放了足够的能量。当订单的资源类型为账户绑定资源之一（见 INTERSHARD_RESOURCES 常量）时本参数不使用。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	目标房间中不存在属于您的终端。
ERR_NOT_ENOUGH_RESOURCES	-6	您没有足够的 credit 或者资源。
ERR_FULL	-8	您每 tick 不能处理超过 10 笔交易。
ERR_INVALID_ARGS	-10	提供了无效的参数。
ERR_TIRED	-11	目标终端仍在冷却。

Game.market.extendOrder(orderId, addAmount)

Game.market.extendOrder('57bec1bf77f4d17c4c011960', 10000);

为一个已存在的订单添加容量。它将影响 remainingAmount 和 totalAmount 属性。您将要为此支付 price*addAmount*0.05 credit 的手续费。

parameter	type	description
orderId	string	Game.market.orders 中提供的订单 ID。
addAmount	number	要增加多少容量。不能为负数。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_ENOUGH_RESOURCES	-6	您没有足够的 credit 来缴纳费用。
ERR_INVALID_ARGS	-10	提供了无效的参数。

Game.market.getAllOrders([filter])

Game.market.getAllOrders(); // 更慢

Game.market.getAllOrders({type: ORDER_SELL, resourceType: RESOURCE_GHODIUM}); // 更快

const targetRoom = "W1N1";
Game.market.getAllOrders(order => order.resourceType == RESOURCE_GHODIUM &&
    order.type == ORDER_SELL &&
    Game.market.calcTransactionCost(1000, targetRoom, order.roomName) < 500); // 更慢

// 输出：

[{
    id : "55c34a6b5be41a0a6e80c68b",
    created : 13131117,
    type : "sell",
    resourceType : "OH",
    roomName : "W1N1",
    amount : 15821,
    remainingAmount : 30000,
    price : 2.95
}, {
    createdTimestamp: 1543253147522,
    type: "sell",
    amount: 1000,
    remainingAmount: 1000,
    resourceType: "O",
    price: 1,
    roomName: "E2S7",
    created: 12010056,
    id: "5bfc2c9bd719fb605037c06d"
}, {
    id : "55c34a6b5be41a0a6e80c123",
    createdTimestamp: 1543253155580,
    type : "sell",
    resourceType : "token",
    amount : 3,
    remainingAmount : 10,
    price : 50000
}]

获取当前市场上其他玩家活跃的订单。该方法支持 resourceType 内置索引。

parameter	type	description
filter (可选)	object, function	一个对象或者函数，将使用 lodash.filter 方法对结果列表进行筛选。

返回值

一个订单数组，订单格式如下：

属性	介绍
id	唯一的订单 ID。
created	订单创建时的游戏 tick。inter-shard 市场中的订单不存在该属性。
createdTimestamp	订单创建时的 UNIX 毫秒时间戳。老版本的订单不存在该属性。
type	ORDER_SELL 或 ORDER_BUY。
resourceType	RESOURCE_* 常量之一或者账户绑定资源之一（见 INTERSHARD_RESOURCES 常量）。
roomName	下订单的房间。
amount	当前可用的交易量。
remainingAmount	该订单还可以交易多少资源。(How many resources are left to trade via this order.)
price	当前的交易单价。

Game.market.getHistory([resourceType])

获取最近 14 天以来市场中指定资源的每日价格记录。

parameter	type	description
resourceType (可选)	string	RESOURCE_* 常量之一。如果为 undefined，则返回所有资源的历史数据。

Return value

返回具有以下格式的对象数组：

[{
    "resourceType": "L",
    "date": "2019-06-24",
    "transactions": 4,
    "volume": 400,
    "avgPrice": 3.63,
    "stddevPrice": 0.27
}]    

Game.market.getOrderById(id)

const order = Game.market.getOrderById('55c34a6b5be41a0a6e80c123');

检索指定的市场订单。

parameter	type	description
id	string	订单 ID。

返回值

订单信息对象。查看 getAllOrders 来了解其属性说明。

Memory

一个可以包含任意数据全局白对象。你可以使用API和游戏编辑器中的Memory UI来访问它。 从这篇文章中学习如何使用存储。

PathFinder

包含了在游戏中进行寻路的强大方法。这个模块使用原生的高性能 C++ 代码实现，并支持跨越多个房间的自定义寻路成本及路径。

PathFinder.search(origin, goal, [opts])

  let creep = Game.creeps.John;

  let goals = _.map(creep.room.find(FIND_SOURCES), function(source) {
    // 我们没办法走到 source 上 -- 将 `range` 设置为 1
    // 所以我们将寻路至其旁边
    return { pos: source.pos, range: 1 };
  });

  let ret = PathFinder.search(
    creep.pos, goals,
    {
      // 我们需要把默认的移动成本设置的更高一点
      // 这样我们就可以在 roomCallback 里把道路移动成本设置的更低
      plainCost: 2,
      swampCost: 10,

      roomCallback: function(roomName) {

        let room = Game.rooms[roomName];
        // 在这个示例中，`room` 始终存在
        // 但是由于 PathFinder 支持跨多房间检索
        // 所以你要更加小心！
        if (!room) return;
        let costs = new PathFinder.CostMatrix;

        room.find(FIND_STRUCTURES).forEach(function(struct) {
          if (struct.structureType === STRUCTURE_ROAD) {
            // 相对于平原，寻路时将更倾向于道路
            costs.set(struct.pos.x, struct.pos.y, 1);
          } else if (struct.structureType !== STRUCTURE_CONTAINER &&
                     (struct.structureType !== STRUCTURE_RAMPART ||
                      !struct.my)) {
            // 不能穿过无法行走的建筑
            costs.set(struct.pos.x, struct.pos.y, 0xff);
          }
        });

        // 躲避房间中的 creep
        room.find(FIND_CREEPS).forEach(function(creep) {
          costs.set(creep.pos.x, creep.pos.y, 0xff);
        });

        return costs;
      },
    }
  );

  let pos = ret.path[0];
  creep.move(creep.pos.getDirectionTo(pos));

在 origin 和 goal 之间查找最佳路径。

parameter	type	description
origin	RoomPosition	起始位置。
goal	object	一个或一组目标。如果提供了多个目标，则返回所有目标中移动成本最低的路径。目标可以是一个 RoomPosition 或者包含下列定义的对象： 重要： 请注意，如果您的目标是无法行走的（例如，一个 source），请至少将 range 设置成至少为 1。否则您将浪费很多 CPU 资源来查找一个无法到达的目标。 pos RoomPosition 目标。 range number pos 周围被当作目的地的范围。默认为 0。
opts (可选)	object	一个包含其他寻路选项的对象。 roomCallback function 该回调可以用来生成某些房间的 CostMatrix，并提供给 pathfinder 来增强寻路效果。该回调拥有一个 roomName 参数。在寻路搜索中，每个房间只会被执行一次回调。如果您要在 1 tick 内为单个房间执行多次寻路操作，可以考虑缓存您的 CostMatrix 来提高代码运行效率。请阅读下方的 CostMatrix 文档来了解更多关于 CostMatrix 的信息。如果该回调返回 false，则对应的房间不会被搜索，并且该房间也不会加入到 maxRooms里。 plainCost number 平原上的移动成本，默认为 1。 swampCost number 沼泽上的移动成本，默认为 5。 flee boolean 与其寻找前往目标的道路，不如寻找远离目标的道路。返回远离每个目标 range 的移动成本最低的路径。默认为 false。 maxOps number 寻路所允许的最大消耗。你可以限制用于搜索路径的 CPU 时间，基于 1 op ~ 0.001 CPU 的比例。默认值为 2000。 maxRooms number 寻路所允许的最大房间数。默认值为 16，最大值为 64。 maxCost number 寻路所允许的最大移动成本。如果 pathfinder 发现无论如何都找不到移动成本小于等于 maxCost 的路径时，它将立即停止搜索。默认值为无穷大(Infinity)。 heuristicWeight number 应用于 A* 算法 F = G + weight * H 中的启发式权重(weight)。在使用该选项之前您最好已经了解了 A* 算法的底层实现！默认值为 1.2。

返回值

包含以下属性的对象：

属性	介绍
path	RoomPosition 对象数组。
ops	寻路完成时的 operation 总消耗。
cost	从 plainCost，swampCost 和任何给定的 CostMatrix 实例推导出的移动总成本。
incomplete	如果 pathfinder 找不到完整的路径的话，该值将为 true。注意，path 中依旧会有部分路径，其中的不完整路径代表在当前搜索限制下所能找到的最接近的路径。

PathFinder.use(isEnabled)

PathFinder.use(true);
Game.creeps.John.moveTo(Game.spawns['Spawn1']);

指定是否在游戏中使用新的实验性 pathfinder。该方法应在每个 tick 调用。它将影响以下方法的行为：Room.findPath, RoomPosition.findPathTo, RoomPosition.findClosestByPath, Creep.moveTo.

parameter	type	description
isEnabled	boolean	是否要激活新的 pathfinder。默认值为 true。

RawMemory

RawMemory 对象允许您实现自己的内存序列器来替代内建的基于 JSON.stringify 的序列器。 它还允许使用异步内存分段功能请求最多 10 MB 的额外内存。

您也可以通过下述方法访问其他玩家的内存分段。

RawMemory.segmentsobject

RawMemory.setActiveSegments([0,3]);
// 在下个 tick
console.log(RawMemory.segments[0]);
console.log(RawMemory.segments[3]);
RawMemory.segments[3] = '{"foo": "bar", "counter": 15}';

当前 tick 可用的异步内存分段对象。对象的每个键都是其对应字符串数据的分段 ID。使用 setActiveSegments 来在下个 tick 获取分段。分段数据在 tick 结束时会自动保存。每个分段的最大容量是 100 KB。

RawMemory.foreignSegmentobject

RawMemory.setActiveForeignSegment('player');
// 在下个 tick
console.log(RawMemory.foreignSegment); 
// --> {"username": "player", "id": 40, "data": "Hello!"} 

当前 tick 可用的其他玩家的内存分段对象。使用 setActiveForeignSegment 来在下个 tick 获取分段。 该对象包含以下属性：

parameter	type	description
username	string	其他玩家的名称
id	number	被请求的内存分段 ID。
data	string	分段的内容。

RawMemory.interShardSegmentstring

RawMemory.interShardSegment = JSON.stringify({
    creeps: {
        Bob: {role: 'claimer'}
    }
});

// 在其他 shard
var interShardData = JSON.parse(RawMemory.interShardSegment);
if(interShardData.creeps[creep.name]) {
    creep.memory = interShardData[creep.name];
    delete interShardData.creeps[creep.name];
}
RawMemory.interShardSegment = JSON.stringify(interShardData);

在所有世界 shard 都可以访问的内存分段字符串。字符串的最大长度为 100 KB。

警告: 该分段不能同时使用！所有的 shard 都有同一个数据实例的访问权限。 当分段内容被两个 shard 同时写入时，由于分段字符串写入的原子性，您可能会丢失一些数据。 您必须实现自己的系统来确定何时允许不同的 shard 重写内存分段。例如基于 互斥锁（mutual exclusions）。

RawMemory.get()

const myMemory = JSON.parse(RawMemory.get());

获取 Memory 对象的原始字符串形式。

返回值

返回一个字符串值。

RawMemory.set(value)

RawMemory.set(JSON.stringify(myMemory));

设置新的 Memory 值。

parameter	type	description
value	string	新的字符串形式的 memroy 值。

RawMemory.setActiveSegments(ids)

RawMemory.setActiveSegments([0,3]);

使用多个分段数组的 ID 来请求响应的内存分段。内存分段将在下个 tick 的 segments 对象中可用。

parameter	type	description
ids	array	分段的 ID 数组。每个 ID 都应是从 0 到 99 之间的一个整数。同一时间最多只能启用 10 个分段。后续的 setActiveSegments 调用将覆盖先前的调用。

RawMemory.setActiveForeignSegment(username, [id])

RawMemory.setActiveForeignSegment('player');

RawMemory.setActiveForeignSegment('player', 10);

RawMemory.setActiveForeignSegment(null);

请求其他用户的内存分段。该分段应被其所有者使用 setPublicSegments 标注为公开。 该分段数据将在下个 tick 的 foreignSegment 对象中可用。 您同一时间只能访问一个外部分段。

parameter	type	description
username	string | null	其他用户的名称。传入 null 来清除外部分段。
id (可选)	number	0 到 99 之间的请求分段 ID。如果未定义，将请求该用户通过 setDefaultPublicSegment 设置的默认公开分段。

RawMemory.setDefaultPublicSegment(id)

RawMemory.setPublicSegments([5,20,21]);
RawMemory.setDefaultPublicSegment(5);

RawMemory.setDefaultPublicSegment(null);

将指定的内存分段设置为您的默认公开分段。当其他玩家使用 setActiveForeignSegment 访问您的分段并且没有传入 id 参数时返回该分段。

parameter	type	description
id	number | null	0 到 99 之间的内存分段 ID。传入 null 来移除您的默认公开分段。

RawMemory.setPublicSegments(ids)

RawMemory.setPublicSegments([5,3]);

RawMemory.setPublicSegments([]);

将指定的分段设置为公开。将允许其他用户使用 setActiveForeignSegment 来访问它们。

parameter	type	description
ids	array	分段 ID 数组。每个 ID 都应是从 0 到 99 之间的一个整数。后续的 setPublicSegments 调用将覆盖先前的调用。

Constants

下面所有的常量都全局可用：

Object.assign(exports, {
    OK: 0,
    ERR_NOT_OWNER: -1,
    ERR_NO_PATH: -2,
    ERR_NAME_EXISTS: -3,
    ERR_BUSY: -4,
    ERR_NOT_FOUND: -5,
    ERR_NOT_ENOUGH_ENERGY: -6,
    ERR_NOT_ENOUGH_RESOURCES: -6,
    ERR_INVALID_TARGET: -7,
    ERR_FULL: -8,
    ERR_NOT_IN_RANGE: -9,
    ERR_INVALID_ARGS: -10,
    ERR_TIRED: -11,
    ERR_NO_BODYPART: -12,
    ERR_NOT_ENOUGH_EXTENSIONS: -6,
    ERR_RCL_NOT_ENOUGH: -14,
    ERR_GCL_NOT_ENOUGH: -15,

    FIND_EXIT_TOP: 1,
    FIND_EXIT_RIGHT: 3,
    FIND_EXIT_BOTTOM: 5,
    FIND_EXIT_LEFT: 7,
    FIND_EXIT: 10,
    FIND_CREEPS: 101,
    FIND_MY_CREEPS: 102,
    FIND_HOSTILE_CREEPS: 103,
    FIND_SOURCES_ACTIVE: 104,
    FIND_SOURCES: 105,
    FIND_DROPPED_RESOURCES: 106,
    FIND_STRUCTURES: 107,
    FIND_MY_STRUCTURES: 108,
    FIND_HOSTILE_STRUCTURES: 109,
    FIND_FLAGS: 110,
    FIND_CONSTRUCTION_SITES: 111,
    FIND_MY_SPAWNS: 112,
    FIND_HOSTILE_SPAWNS: 113,
    FIND_MY_CONSTRUCTION_SITES: 114,
    FIND_HOSTILE_CONSTRUCTION_SITES: 115,
    FIND_MINERALS: 116,
    FIND_NUKES: 117,
    FIND_TOMBSTONES: 118,
    FIND_POWER_CREEPS: 119,
    FIND_MY_POWER_CREEPS: 120,
    FIND_HOSTILE_POWER_CREEPS: 121,
    FIND_DEPOSITS: 122,
    FIND_RUINS: 123,

    TOP: 1,
    TOP_RIGHT: 2,
    RIGHT: 3,
    BOTTOM_RIGHT: 4,
    BOTTOM: 5,
    BOTTOM_LEFT: 6,
    LEFT: 7,
    TOP_LEFT: 8,

    COLOR_RED: 1,
    COLOR_PURPLE: 2,
    COLOR_BLUE: 3,
    COLOR_CYAN: 4,
    COLOR_GREEN: 5,
    COLOR_YELLOW: 6,
    COLOR_ORANGE: 7,
    COLOR_BROWN: 8,
    COLOR_GREY: 9,
    COLOR_WHITE: 10,

    LOOK_CREEPS: "creep",
    LOOK_ENERGY: "energy",
    LOOK_RESOURCES: "resource",
    LOOK_SOURCES: "source",
    LOOK_MINERALS: "mineral",
    LOOK_DEPOSITS: "deposit",
    LOOK_STRUCTURES: "structure",
    LOOK_FLAGS: "flag",
    LOOK_CONSTRUCTION_SITES: "constructionSite",
    LOOK_NUKES: "nuke",
    LOOK_TERRAIN: "terrain",
    LOOK_TOMBSTONES: "tombstone",
    LOOK_POWER_CREEPS: "powerCreep",
    LOOK_RUINS: "ruin",

    OBSTACLE_OBJECT_TYPES: ["spawn", "creep", "powerCreep", "source", "mineral", "deposit", "controller", "constructedWall", "extension", "link", "storage", "tower", "observer", "powerSpawn", "powerBank", "lab", "terminal", "nuker", "factory", "invaderCore"],

    MOVE: "move",
    WORK: "work",
    CARRY: "carry",
    ATTACK: "attack",
    RANGED_ATTACK: "ranged_attack",
    TOUGH: "tough",
    HEAL: "heal",
    CLAIM: "claim",

    BODYPART_COST: {
        "move": 50,
        "work": 100,
        "attack": 80,
        "carry": 50,
        "heal": 250,
        "ranged_attack": 150,
        "tough": 10,
        "claim": 600
    },

    // WORLD_WIDTH and WORLD_HEIGHT constants are deprecated, please use Game.map.getWorldSize() instead
    WORLD_WIDTH: 202,
    WORLD_HEIGHT: 202,

    CREEP_LIFE_TIME: 1500,
    CREEP_CLAIM_LIFE_TIME: 600,
    CREEP_CORPSE_RATE: 0.2,
    CREEP_PART_MAX_ENERGY: 125,

    CARRY_CAPACITY: 50,
    HARVEST_POWER: 2,
    HARVEST_MINERAL_POWER: 1,
    HARVEST_DEPOSIT_POWER: 1,
    REPAIR_POWER: 100,
    DISMANTLE_POWER: 50,
    BUILD_POWER: 5,
    ATTACK_POWER: 30,
    UPGRADE_CONTROLLER_POWER: 1,
    RANGED_ATTACK_POWER: 10,
    HEAL_POWER: 12,
    RANGED_HEAL_POWER: 4,
    REPAIR_COST: 0.01,
    DISMANTLE_COST: 0.005,

    RAMPART_DECAY_AMOUNT: 300,
    RAMPART_DECAY_TIME: 100,
    RAMPART_HITS: 1,
    RAMPART_HITS_MAX: {2: 300000, 3: 1000000, 4: 3000000, 5: 10000000, 6: 30000000, 7: 100000000, 8: 300000000},

    ENERGY_REGEN_TIME: 300,
    ENERGY_DECAY: 1000,

    SPAWN_HITS: 5000,
    SPAWN_ENERGY_START: 300,
    SPAWN_ENERGY_CAPACITY: 300,
    CREEP_SPAWN_TIME: 3,
    SPAWN_RENEW_RATIO: 1.2,

    SOURCE_ENERGY_CAPACITY: 3000,
    SOURCE_ENERGY_NEUTRAL_CAPACITY: 1500,
    SOURCE_ENERGY_KEEPER_CAPACITY: 4000,

    WALL_HITS: 1,
    WALL_HITS_MAX: 300000000,

    EXTENSION_HITS: 1000,
    EXTENSION_ENERGY_CAPACITY: {0: 50, 1: 50, 2: 50, 3: 50, 4: 50, 5: 50, 6: 50, 7: 100, 8: 200},

    ROAD_HITS: 5000,
    ROAD_WEAROUT: 1,
    ROAD_WEAROUT_POWER_CREEP: 100,
    ROAD_DECAY_AMOUNT: 100,
    ROAD_DECAY_TIME: 1000,

    LINK_HITS: 1000,
    LINK_HITS_MAX: 1000,
    LINK_CAPACITY: 800,
    LINK_COOLDOWN: 1,
    LINK_LOSS_RATIO: 0.03,

    STORAGE_CAPACITY: 1000000,
    STORAGE_HITS: 10000,

    STRUCTURE_SPAWN: "spawn",
    STRUCTURE_EXTENSION: "extension",
    STRUCTURE_ROAD: "road",
    STRUCTURE_WALL: "constructedWall",
    STRUCTURE_RAMPART: "rampart",
    STRUCTURE_KEEPER_LAIR: "keeperLair",
    STRUCTURE_PORTAL: "portal",
    STRUCTURE_CONTROLLER: "controller",
    STRUCTURE_LINK: "link",
    STRUCTURE_STORAGE: "storage",
    STRUCTURE_TOWER: "tower",
    STRUCTURE_OBSERVER: "observer",
    STRUCTURE_POWER_BANK: "powerBank",
    STRUCTURE_POWER_SPAWN: "powerSpawn",
    STRUCTURE_EXTRACTOR: "extractor",
    STRUCTURE_LAB: "lab",
    STRUCTURE_TERMINAL: "terminal",
    STRUCTURE_CONTAINER: "container",
    STRUCTURE_NUKER: "nuker",
    STRUCTURE_FACTORY: "factory",
    STRUCTURE_INVADER_CORE: "invaderCore",

    CONSTRUCTION_COST: {
        "spawn": 15000,
        "extension": 3000,
        "road": 300,
        "constructedWall": 1,
        "rampart": 1,
        "link": 5000,
        "storage": 30000,
        "tower": 5000,
        "observer": 8000,
        "powerSpawn": 100000,
        "extractor": 5000,
        "lab": 50000,
        "terminal": 100000,
        "container": 5000,
        "nuker": 100000,
        "factory": 100000
    },
    CONSTRUCTION_COST_ROAD_SWAMP_RATIO: 5,
    CONSTRUCTION_COST_ROAD_WALL_RATIO: 150,

    CONTROLLER_LEVELS: {1: 200, 2: 45000, 3: 135000, 4: 405000, 5: 1215000, 6: 3645000, 7: 10935000},
    CONTROLLER_STRUCTURES: {
        "spawn": {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 2, 8: 3},
        "extension": {0: 0, 1: 0, 2: 5, 3: 10, 4: 20, 5: 30, 6: 40, 7: 50, 8: 60},
        "link": {1: 0, 2: 0, 3: 0, 4: 0, 5: 2, 6: 3, 7: 4, 8: 6},
        "road": {0: 2500, 1: 2500, 2: 2500, 3: 2500, 4: 2500, 5: 2500, 6: 2500, 7: 2500, 8: 2500},
        "constructedWall": {1: 0, 2: 2500, 3: 2500, 4: 2500, 5: 2500, 6: 2500, 7: 2500, 8: 2500},
        "rampart": {1: 0, 2: 2500, 3: 2500, 4: 2500, 5: 2500, 6: 2500, 7: 2500, 8: 2500},
        "storage": {1: 0, 2: 0, 3: 0, 4: 1, 5: 1, 6: 1, 7: 1, 8: 1},
        "tower": {1: 0, 2: 0, 3: 1, 4: 1, 5: 2, 6: 2, 7: 3, 8: 6},
        "observer": {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 1},
        "powerSpawn": {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 1},
        "extractor": {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 1, 7: 1, 8: 1},
        "terminal": {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 1, 7: 1, 8: 1},
        "lab": {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 3, 7: 6, 8: 10},
        "container": {0: 5, 1: 5, 2: 5, 3: 5, 4: 5, 5: 5, 6: 5, 7: 5, 8: 5},
        "nuker": {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 1},
        "factory": {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 1, 8: 1}
    },
    CONTROLLER_DOWNGRADE: {1: 20000, 2: 10000, 3: 20000, 4: 40000, 5: 80000, 6: 120000, 7: 150000, 8: 200000},
    CONTROLLER_DOWNGRADE_RESTORE: 100,
    CONTROLLER_DOWNGRADE_SAFEMODE_THRESHOLD: 5000,
    CONTROLLER_CLAIM_DOWNGRADE: 300,
    CONTROLLER_RESERVE: 1,
    CONTROLLER_RESERVE_MAX: 5000,
    CONTROLLER_MAX_UPGRADE_PER_TICK: 15,
    CONTROLLER_ATTACK_BLOCKED_UPGRADE: 1000,
    CONTROLLER_NUKE_BLOCKED_UPGRADE: 200,

    SAFE_MODE_DURATION: 20000,
    SAFE_MODE_COOLDOWN: 50000,
    SAFE_MODE_COST: 1000,

    TOWER_HITS: 3000,
    TOWER_CAPACITY: 1000,
    TOWER_ENERGY_COST: 10,
    TOWER_POWER_ATTACK: 600,
    TOWER_POWER_HEAL: 400,
    TOWER_POWER_REPAIR: 800,
    TOWER_OPTIMAL_RANGE: 5,
    TOWER_FALLOFF_RANGE: 20,
    TOWER_FALLOFF: 0.75,

    OBSERVER_HITS: 500,
    OBSERVER_RANGE: 10,

    POWER_BANK_HITS: 2000000,
    POWER_BANK_CAPACITY_MAX: 5000,
    POWER_BANK_CAPACITY_MIN: 500,
    POWER_BANK_CAPACITY_CRIT: 0.3,
    POWER_BANK_DECAY: 5000,
    POWER_BANK_HIT_BACK: 0.5,

    POWER_SPAWN_HITS: 5000,
    POWER_SPAWN_ENERGY_CAPACITY: 5000,
    POWER_SPAWN_POWER_CAPACITY: 100,
    POWER_SPAWN_ENERGY_RATIO: 50,

    EXTRACTOR_HITS: 500,
    EXTRACTOR_COOLDOWN: 5,

    LAB_HITS: 500,
    LAB_MINERAL_CAPACITY: 3000,
    LAB_ENERGY_CAPACITY: 2000,
    LAB_BOOST_ENERGY: 20,
    LAB_BOOST_MINERAL: 30,
    LAB_COOLDOWN: 10,           // not used
    LAB_REACTION_AMOUNT: 5,
    LAB_UNBOOST_ENERGY: 0,
    LAB_UNBOOST_MINERAL: 15,

    GCL_POW: 2.4,
    GCL_MULTIPLY: 1000000,
    GCL_NOVICE: 3,

    MODE_SIMULATION: null,
    MODE_WORLD: null,

    TERRAIN_MASK_WALL: 1,
    TERRAIN_MASK_SWAMP: 2,
    TERRAIN_MASK_LAVA: 4,

    MAX_CONSTRUCTION_SITES: 100,
    MAX_CREEP_SIZE: 50,

    MINERAL_REGEN_TIME: 50000,
    MINERAL_MIN_AMOUNT: {
        "H": 35000,
        "O": 35000,
        "L": 35000,
        "K": 35000,
        "Z": 35000,
        "U": 35000,
        "X": 35000
    },
    MINERAL_RANDOM_FACTOR: 2,

    MINERAL_DENSITY: {
        1: 15000,
        2: 35000,
        3: 70000,
        4: 100000
    },
    MINERAL_DENSITY_PROBABILITY  : {
        1: 0.1,
        2: 0.5,
        3: 0.9,
        4: 1.0
    },
    MINERAL_DENSITY_CHANGE: 0.05,

    DENSITY_LOW: 1,
    DENSITY_MODERATE: 2,
    DENSITY_HIGH: 3,
    DENSITY_ULTRA: 4,

    DEPOSIT_EXHAUST_MULTIPLY: 0.001,
    DEPOSIT_EXHAUST_POW: 1.2,
    DEPOSIT_DECAY_TIME: 50000,

    TERMINAL_CAPACITY: 300000,
    TERMINAL_HITS: 3000,
    TERMINAL_SEND_COST: 0.1,
    TERMINAL_MIN_SEND: 100,
    TERMINAL_COOLDOWN: 10,

    CONTAINER_HITS: 250000,
    CONTAINER_CAPACITY: 2000,
    CONTAINER_DECAY: 5000,
    CONTAINER_DECAY_TIME: 100,
    CONTAINER_DECAY_TIME_OWNED: 500,

    NUKER_HITS: 1000,
    NUKER_COOLDOWN: 100000,
    NUKER_ENERGY_CAPACITY: 300000,
    NUKER_GHODIUM_CAPACITY: 5000,
    NUKE_LAND_TIME: 50000,
    NUKE_RANGE: 10,
    NUKE_DAMAGE: {
        0: 10000000,
        2: 5000000
    },

    FACTORY_HITS: 1000,
    FACTORY_CAPACITY: 50000,

    TOMBSTONE_DECAY_PER_PART: 5,
    TOMBSTONE_DECAY_POWER_CREEP: 500,

    RUIN_DECAY: 500,
    RUIN_DECAY_STRUCTURES: {
        'powerBank': 10
    },

    PORTAL_DECAY: 30000,

    ORDER_SELL: "sell",
    ORDER_BUY: "buy",

    MARKET_FEE: 0.05,

    MARKET_MAX_ORDERS: 300,
    MARKET_ORDER_LIFE_TIME: 1000*60*60*24*30,

    FLAGS_LIMIT: 10000,

    SUBSCRIPTION_TOKEN: "token",
    CPU_UNLOCK: "cpuUnlock",
    PIXEL: "pixel",
    ACCESS_KEY: "accessKey",

    PIXEL_CPU_COST: 10000,

    RESOURCE_ENERGY: "energy",
    RESOURCE_POWER: "power",

    RESOURCE_HYDROGEN: "H",
    RESOURCE_OXYGEN: "O",
    RESOURCE_UTRIUM: "U",
    RESOURCE_LEMERGIUM: "L",
    RESOURCE_KEANIUM: "K",
    RESOURCE_ZYNTHIUM: "Z",
    RESOURCE_CATALYST: "X",
    RESOURCE_GHODIUM: "G",

    RESOURCE_SILICON: 'silicon',
    RESOURCE_METAL: 'metal',
    RESOURCE_BIOMASS: 'biomass',
    RESOURCE_MIST: 'mist',

    RESOURCE_HYDROXIDE: "OH",
    RESOURCE_ZYNTHIUM_KEANITE: "ZK",
    RESOURCE_UTRIUM_LEMERGITE: "UL",

    RESOURCE_UTRIUM_HYDRIDE: "UH",
    RESOURCE_UTRIUM_OXIDE: "UO",
    RESOURCE_KEANIUM_HYDRIDE: "KH",
    RESOURCE_KEANIUM_OXIDE: "KO",
    RESOURCE_LEMERGIUM_HYDRIDE: "LH",
    RESOURCE_LEMERGIUM_OXIDE: "LO",
    RESOURCE_ZYNTHIUM_HYDRIDE: "ZH",
    RESOURCE_ZYNTHIUM_OXIDE: "ZO",
    RESOURCE_GHODIUM_HYDRIDE: "GH",
    RESOURCE_GHODIUM_OXIDE: "GO",

    RESOURCE_UTRIUM_ACID: "UH2O",
    RESOURCE_UTRIUM_ALKALIDE: "UHO2",
    RESOURCE_KEANIUM_ACID: "KH2O",
    RESOURCE_KEANIUM_ALKALIDE: "KHO2",
    RESOURCE_LEMERGIUM_ACID: "LH2O",
    RESOURCE_LEMERGIUM_ALKALIDE: "LHO2",
    RESOURCE_ZYNTHIUM_ACID: "ZH2O",
    RESOURCE_ZYNTHIUM_ALKALIDE: "ZHO2",
    RESOURCE_GHODIUM_ACID: "GH2O",
    RESOURCE_GHODIUM_ALKALIDE: "GHO2",

    RESOURCE_CATALYZED_UTRIUM_ACID: "XUH2O",
    RESOURCE_CATALYZED_UTRIUM_ALKALIDE: "XUHO2",
    RESOURCE_CATALYZED_KEANIUM_ACID: "XKH2O",
    RESOURCE_CATALYZED_KEANIUM_ALKALIDE: "XKHO2",
    RESOURCE_CATALYZED_LEMERGIUM_ACID: "XLH2O",
    RESOURCE_CATALYZED_LEMERGIUM_ALKALIDE: "XLHO2",
    RESOURCE_CATALYZED_ZYNTHIUM_ACID: "XZH2O",
    RESOURCE_CATALYZED_ZYNTHIUM_ALKALIDE: "XZHO2",
    RESOURCE_CATALYZED_GHODIUM_ACID: "XGH2O",
    RESOURCE_CATALYZED_GHODIUM_ALKALIDE: "XGHO2",

    RESOURCE_OPS: "ops",

    RESOURCE_UTRIUM_BAR: 'utrium_bar',
    RESOURCE_LEMERGIUM_BAR: 'lemergium_bar',
    RESOURCE_ZYNTHIUM_BAR: 'zynthium_bar',
    RESOURCE_KEANIUM_BAR: 'keanium_bar',
    RESOURCE_GHODIUM_MELT: 'ghodium_melt',
    RESOURCE_OXIDANT: 'oxidant',
    RESOURCE_REDUCTANT: 'reductant',
    RESOURCE_PURIFIER: 'purifier',
    RESOURCE_BATTERY: 'battery',

    RESOURCE_COMPOSITE: 'composite',
    RESOURCE_CRYSTAL: 'crystal',
    RESOURCE_LIQUID: 'liquid',

    RESOURCE_WIRE: 'wire',
    RESOURCE_SWITCH: 'switch',
    RESOURCE_TRANSISTOR: 'transistor',
    RESOURCE_MICROCHIP: 'microchip',
    RESOURCE_CIRCUIT: 'circuit',
    RESOURCE_DEVICE: 'device',

    RESOURCE_CELL: 'cell',
    RESOURCE_PHLEGM: 'phlegm',
    RESOURCE_TISSUE: 'tissue',
    RESOURCE_MUSCLE: 'muscle',
    RESOURCE_ORGANOID: 'organoid',
    RESOURCE_ORGANISM: 'organism',

    RESOURCE_ALLOY: 'alloy',
    RESOURCE_TUBE: 'tube',
    RESOURCE_FIXTURES: 'fixtures',
    RESOURCE_FRAME: 'frame',
    RESOURCE_HYDRAULICS: 'hydraulics',
    RESOURCE_MACHINE: 'machine',

    RESOURCE_CONDENSATE: 'condensate',
    RESOURCE_CONCENTRATE: 'concentrate',
    RESOURCE_EXTRACT: 'extract',
    RESOURCE_SPIRIT: 'spirit',
    RESOURCE_EMANATION: 'emanation',
    RESOURCE_ESSENCE: 'essence',

    REACTIONS: {
        H: {
            O: "OH",
            L: "LH",
            K: "KH",
            U: "UH",
            Z: "ZH",
            G: "GH"
        },
        O: {
            H: "OH",
            L: "LO",
            K: "KO",
            U: "UO",
            Z: "ZO",
            G: "GO"
        },
        Z: {
            K: "ZK",
            H: "ZH",
            O: "ZO"
        },
        L: {
            U: "UL",
            H: "LH",
            O: "LO"
        },
        K: {
            Z: "ZK",
            H: "KH",
            O: "KO"
        },
        G: {
            H: "GH",
            O: "GO"
        },
        U: {
            L: "UL",
            H: "UH",
            O: "UO"
        },
        OH: {
            UH: "UH2O",
            UO: "UHO2",
            ZH: "ZH2O",
            ZO: "ZHO2",
            KH: "KH2O",
            KO: "KHO2",
            LH: "LH2O",
            LO: "LHO2",
            GH: "GH2O",
            GO: "GHO2"
        },
        X: {
            UH2O: "XUH2O",
            UHO2: "XUHO2",
            LH2O: "XLH2O",
            LHO2: "XLHO2",
            KH2O: "XKH2O",
            KHO2: "XKHO2",
            ZH2O: "XZH2O",
            ZHO2: "XZHO2",
            GH2O: "XGH2O",
            GHO2: "XGHO2"
        },
        ZK: {
            UL: "G"
        },
        UL: {
            ZK: "G"
        },
        LH: {
            OH: "LH2O"
        },
        ZH: {
            OH: "ZH2O"
        },
        GH: {
            OH: "GH2O"
        },
        KH: {
            OH: "KH2O"
        },
        UH: {
            OH: "UH2O"
        },
        LO: {
            OH: "LHO2"
        },
        ZO: {
            OH: "ZHO2"
        },
        KO: {
            OH: "KHO2"
        },
        UO: {
            OH: "UHO2"
        },
        GO: {
            OH: "GHO2"
        },
        LH2O: {
            X: "XLH2O"
        },
        KH2O: {
            X: "XKH2O"
        },
        ZH2O: {
            X: "XZH2O"
        },
        UH2O: {
            X: "XUH2O"
        },
        GH2O: {
            X: "XGH2O"
        },
        LHO2: {
            X: "XLHO2"
        },
        UHO2: {
            X: "XUHO2"
        },
        KHO2: {
            X: "XKHO2"
        },
        ZHO2: {
            X: "XZHO2"
        },
        GHO2: {
            X: "XGHO2"
        }
    },

    BOOSTS: {
        work: {
            UO: {
                harvest: 3
            },
            UHO2: {
                harvest: 5
            },
            XUHO2: {
                harvest: 7
            },
            LH: {
                build: 1.5,
                repair: 1.5
            },
            LH2O: {
                build: 1.8,
                repair: 1.8
            },
            XLH2O: {
                build: 2,
                repair: 2
            },
            ZH: {
                dismantle: 2
            },
            ZH2O: {
                dismantle: 3
            },
            XZH2O: {
                dismantle: 4
            },
            GH: {
                upgradeController: 1.5
            },
            GH2O: {
                upgradeController: 1.8
            },
            XGH2O: {
                upgradeController: 2
            }
        },
        attack: {
            UH: {
                attack: 2
            },
            UH2O: {
                attack: 3
            },
            XUH2O: {
                attack: 4
            }
        },
        ranged_attack: {
            KO: {
                rangedAttack: 2,
                rangedMassAttack: 2
            },
            KHO2: {
                rangedAttack: 3,
                rangedMassAttack: 3
            },
            XKHO2: {
                rangedAttack: 4,
                rangedMassAttack: 4
            }
        },
        heal: {
            LO: {
                heal: 2,
                rangedHeal: 2
            },
            LHO2: {
                heal: 3,
                rangedHeal: 3
            },
            XLHO2: {
                heal: 4,
                rangedHeal: 4
            }
        },
        carry: {
            KH: {
                capacity: 2
            },
            KH2O: {
                capacity: 3
            },
            XKH2O: {
                capacity: 4
            }
        },
        move: {
            ZO: {
                fatigue: 2
            },
            ZHO2: {
                fatigue: 3
            },
            XZHO2: {
                fatigue: 4
            }
        },
        tough: {
            GO: {
                damage: .7
            },
            GHO2: {
                damage: .5
            },
            XGHO2: {
                damage: .3
            }
        }
    },

    REACTION_TIME: {
        OH: 20,
        ZK: 5,
        UL: 5,
        G: 5,
        UH: 10,
        UH2O: 5,
        XUH2O: 60,
        UO: 10,
        UHO2: 5,
        XUHO2: 60,
        KH: 10,
        KH2O: 5,
        XKH2O: 60,
        KO: 10,
        KHO2: 5,
        XKHO2: 60,
        LH: 15,
        LH2O: 10,
        XLH2O: 65,
        LO: 10,
        LHO2: 5,
        XLHO2: 60,
        ZH: 20,
        ZH2O: 40,
        XZH2O: 160,
        ZO: 10,
        ZHO2: 5,
        XZHO2: 60,
        GH: 10,
        GH2O: 15,
        XGH2O: 80,
        GO: 10,
        GHO2: 30,
        XGHO2: 150,
    },

    PORTAL_UNSTABLE: 10*24*3600*1000,
    PORTAL_MIN_TIMEOUT: 12*24*3600*1000,
    PORTAL_MAX_TIMEOUT: 22*24*3600*1000,

    POWER_BANK_RESPAWN_TIME: 50000,

    INVADERS_ENERGY_GOAL: 100000,

    SYSTEM_USERNAME: 'Screeps',

    // SIGN_NOVICE_AREA and SIGN_RESPAWN_AREA constants are deprecated, please use SIGN_PLANNED_AREA instead
    SIGN_NOVICE_AREA: 'A new Novice or Respawn Area is being planned somewhere in this sector. Please make sure all important rooms are reserved.',
    SIGN_RESPAWN_AREA: 'A new Novice or Respawn Area is being planned somewhere in this sector. Please make sure all important rooms are reserved.',
    SIGN_PLANNED_AREA: 'A new Novice or Respawn Area is being planned somewhere in this sector. Please make sure all important rooms are reserved.',

    EVENT_ATTACK: 1,
    EVENT_OBJECT_DESTROYED: 2,
    EVENT_ATTACK_CONTROLLER: 3,
    EVENT_BUILD: 4,
    EVENT_HARVEST: 5,
    EVENT_HEAL: 6,
    EVENT_REPAIR: 7,
    EVENT_RESERVE_CONTROLLER: 8,
    EVENT_UPGRADE_CONTROLLER: 9,
    EVENT_EXIT: 10,
    EVENT_POWER: 11,
    EVENT_TRANSFER: 12,

    EVENT_ATTACK_TYPE_MELEE: 1,
    EVENT_ATTACK_TYPE_RANGED: 2,
    EVENT_ATTACK_TYPE_RANGED_MASS: 3,
    EVENT_ATTACK_TYPE_DISMANTLE: 4,
    EVENT_ATTACK_TYPE_HIT_BACK: 5,
    EVENT_ATTACK_TYPE_NUKE: 6,

    EVENT_HEAL_TYPE_MELEE: 1,
    EVENT_HEAL_TYPE_RANGED: 2,

    POWER_LEVEL_MULTIPLY: 1000,
    POWER_LEVEL_POW: 2,
    POWER_CREEP_SPAWN_COOLDOWN: 8*3600*1000,
    POWER_CREEP_DELETE_COOLDOWN: 24*3600*1000,
    POWER_CREEP_MAX_LEVEL: 25,
    POWER_CREEP_LIFE_TIME: 5000,

    POWER_CLASS: {
        OPERATOR: 'operator'
    },

    PWR_GENERATE_OPS: 1,
    PWR_OPERATE_SPAWN: 2,
    PWR_OPERATE_TOWER: 3,
    PWR_OPERATE_STORAGE: 4,
    PWR_OPERATE_LAB: 5,
    PWR_OPERATE_EXTENSION: 6,
    PWR_OPERATE_OBSERVER: 7,
    PWR_OPERATE_TERMINAL: 8,
    PWR_DISRUPT_SPAWN: 9,
    PWR_DISRUPT_TOWER: 10,
    PWR_DISRUPT_SOURCE: 11,
    PWR_SHIELD: 12,
    PWR_REGEN_SOURCE: 13,
    PWR_REGEN_MINERAL: 14,
    PWR_DISRUPT_TERMINAL: 15,
    PWR_OPERATE_POWER: 16,
    PWR_FORTIFY: 17,
    PWR_OPERATE_CONTROLLER: 18,
    PWR_OPERATE_FACTORY: 19,

    EFFECT_INVULNERABILITY: 1001,
    EFFECT_COLLAPSE_TIMER: 1002,

    INVADER_CORE_HITS: 100000,
    INVADER_CORE_CREEP_SPAWN_TIME: {
        0: 0, 1: 0, 2: 6, 3: 3, 4: 2, 5: 1
    },
    INVADER_CORE_EXPAND_TIME: { 1: 4000, 2: 3500, 3: 3000, 4: 2500, 5: 2000 },
    INVADER_CORE_CONTROLLER_POWER: 2,
    INVADER_CORE_CONTROLLER_DOWNGRADE: 5000,
    STRONGHOLD_RAMPART_HITS: { 0: 0, 1: 100000, 2: 200000, 3: 500000, 4: 1000000, 5: 2000000 },
    STRONGHOLD_DECAY_TICKS: 75000
});

Object.assign(exports, {
    POWER_INFO: {
        [exports.PWR_GENERATE_OPS]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [0, 2, 7, 14, 22],
            cooldown: 50,
            effect: [1, 2, 4, 6, 8]
        },
        [exports.PWR_OPERATE_SPAWN]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [0, 2, 7, 14, 22],
            cooldown: 300,
            duration: 1000,
            range: 3,
            ops: 100,
            effect: [0.9, 0.7, 0.5, 0.35, 0.2]
        },
        [exports.PWR_OPERATE_TOWER]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [0, 2, 7, 14, 22],
            cooldown: 10,
            duration: 100,
            range: 3,
            ops: 10,
            effect: [1.1, 1.2, 1.3, 1.4, 1.5]
        },
        [exports.PWR_OPERATE_STORAGE]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [0, 2, 7, 14, 22],
            cooldown: 800,
            duration: 1000,
            range: 3,
            ops: 100,
            effect: [500000,1000000,2000000,4000000,7000000]
        },
        [exports.PWR_OPERATE_LAB]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [0, 2, 7, 14, 22],
            cooldown: 50,
            duration: 1000,
            range: 3,
            ops: 10,
            effect: [2,4,6,8,10]
        },
        [exports.PWR_OPERATE_EXTENSION]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [0, 2, 7, 14, 22],
            cooldown: 50,
            range: 3,
            ops: 2,
            effect: [0.2, 0.4, 0.6, 0.8, 1.0]
        },
        [exports.PWR_OPERATE_OBSERVER]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [0, 2, 7, 14, 22],
            cooldown: 400,
            duration: [200,400,600,800,1000],
            range: 3,
            ops: 10,
        },
        [exports.PWR_OPERATE_TERMINAL]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [0, 2, 7, 14, 22],
            cooldown: 500,
            duration: 1000,
            range: 3,
            ops: 100,
            effect: [0.9, 0.8, 0.7, 0.6, 0.5]
        },
        [exports.PWR_DISRUPT_SPAWN]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [0, 2, 7, 14, 22],
            cooldown: 5,
            range: 20,
            ops: 10,
            duration: [1,2,3,4,5]
        },
        [exports.PWR_DISRUPT_TOWER]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [0, 2, 7, 14, 22],
            cooldown: 0,
            duration: 5,
            range: 50,
            ops: 10,
            effect: [0.9, 0.8, 0.7, 0.6, 0.5],
        },
        [exports.PWR_DISRUPT_SOURCE]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [0, 2, 7, 14, 22],
            cooldown: 100,
            range: 3,
            ops: 100,
            duration: [100, 200, 300, 400, 500]
        },
        [exports.PWR_SHIELD]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [0, 2, 7, 14, 22],
            effect: [5000, 10000, 15000, 20000, 25000],
            duration: 50,
            cooldown: 20,
            energy: 100,
        },
        [exports.PWR_REGEN_SOURCE]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [10, 11, 12, 14, 22],
            cooldown: 100,
            duration: 300,
            range: 3,
            effect: [50,100,150,200,250],
            period: 15
        },
        [exports.PWR_REGEN_MINERAL]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [10, 11, 12, 14, 22],
            cooldown: 100,
            duration: 100,
            range: 3,
            effect: [2,4,6,8,10],
            period: 10
        },
        [exports.PWR_DISRUPT_TERMINAL]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [20, 21, 22, 23, 24],
            cooldown: 8,
            duration: 10,
            range: 50,
            ops: [50,40,30,20,10]

        },
        [exports.PWR_FORTIFY]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [0, 2, 7, 14, 22],
            cooldown: 5,
            range: 3,
            ops: 5,
            duration: [1, 2, 3, 4, 5]
        },
        [exports.PWR_OPERATE_POWER]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [10, 11, 12, 14, 22],
            cooldown: 800,
            range: 3,
            duration: 1000,
            ops: 200,
            effect: [1, 2, 3, 4, 5]
        },
        [exports.PWR_OPERATE_CONTROLLER]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [20, 21, 22, 23, 24],
            cooldown: 800,
            range: 3,
            duration: 1000,
            ops: 200,
            effect: [10, 20, 30, 40, 50]
        },
        [exports.PWR_OPERATE_FACTORY]: {
            className: exports.POWER_CLASS.OPERATOR,
            level: [0, 2, 7, 14, 22],
            cooldown: 800,
            range: 3,
            duration: 1000,
            ops: 100
        },
    },

    BODYPARTS_ALL: [
        exports.MOVE,
        exports.WORK,
        exports.CARRY,
        exports.ATTACK,
        exports.RANGED_ATTACK,
        exports.TOUGH,
        exports.HEAL,
        exports.CLAIM
    ],
    RESOURCES_ALL: [
        exports.RESOURCE_ENERGY,
        exports.RESOURCE_POWER,

        exports.RESOURCE_HYDROGEN,
        exports.RESOURCE_OXYGEN,
        exports.RESOURCE_UTRIUM,
        exports.RESOURCE_KEANIUM,
        exports.RESOURCE_LEMERGIUM,
        exports.RESOURCE_ZYNTHIUM,
        exports.RESOURCE_CATALYST,
        exports.RESOURCE_GHODIUM,

        exports.RESOURCE_HYDROXIDE,
        exports.RESOURCE_ZYNTHIUM_KEANITE,
        exports.RESOURCE_UTRIUM_LEMERGITE,

        exports.RESOURCE_UTRIUM_HYDRIDE,
        exports.RESOURCE_UTRIUM_OXIDE,
        exports.RESOURCE_KEANIUM_HYDRIDE,
        exports.RESOURCE_KEANIUM_OXIDE,
        exports.RESOURCE_LEMERGIUM_HYDRIDE,
        exports.RESOURCE_LEMERGIUM_OXIDE,
        exports.RESOURCE_ZYNTHIUM_HYDRIDE,
        exports.RESOURCE_ZYNTHIUM_OXIDE,
        exports.RESOURCE_GHODIUM_HYDRIDE,
        exports.RESOURCE_GHODIUM_OXIDE,

        exports.RESOURCE_UTRIUM_ACID,
        exports.RESOURCE_UTRIUM_ALKALIDE,
        exports.RESOURCE_KEANIUM_ACID,
        exports.RESOURCE_KEANIUM_ALKALIDE,
        exports.RESOURCE_LEMERGIUM_ACID,
        exports.RESOURCE_LEMERGIUM_ALKALIDE,
        exports.RESOURCE_ZYNTHIUM_ACID,
        exports.RESOURCE_ZYNTHIUM_ALKALIDE,
        exports.RESOURCE_GHODIUM_ACID,
        exports.RESOURCE_GHODIUM_ALKALIDE,

        exports.RESOURCE_CATALYZED_UTRIUM_ACID,
        exports.RESOURCE_CATALYZED_UTRIUM_ALKALIDE,
        exports.RESOURCE_CATALYZED_KEANIUM_ACID,
        exports.RESOURCE_CATALYZED_KEANIUM_ALKALIDE,
        exports.RESOURCE_CATALYZED_LEMERGIUM_ACID,
        exports.RESOURCE_CATALYZED_LEMERGIUM_ALKALIDE,
        exports.RESOURCE_CATALYZED_ZYNTHIUM_ACID,
        exports.RESOURCE_CATALYZED_ZYNTHIUM_ALKALIDE,
        exports.RESOURCE_CATALYZED_GHODIUM_ACID,
        exports.RESOURCE_CATALYZED_GHODIUM_ALKALIDE,

        exports.RESOURCE_OPS,

        exports.RESOURCE_SILICON,
        exports.RESOURCE_METAL,
        exports.RESOURCE_BIOMASS,
        exports.RESOURCE_MIST,

        exports.RESOURCE_UTRIUM_BAR,
        exports.RESOURCE_LEMERGIUM_BAR,
        exports.RESOURCE_ZYNTHIUM_BAR,
        exports.RESOURCE_KEANIUM_BAR,
        exports.RESOURCE_GHODIUM_MELT,
        exports.RESOURCE_OXIDANT,
        exports.RESOURCE_REDUCTANT,
        exports.RESOURCE_PURIFIER,
        exports.RESOURCE_BATTERY,
        exports.RESOURCE_COMPOSITE,
        exports.RESOURCE_CRYSTAL,
        exports.RESOURCE_LIQUID,

        exports.RESOURCE_WIRE,
        exports.RESOURCE_SWITCH,
        exports.RESOURCE_TRANSISTOR,
        exports.RESOURCE_MICROCHIP,
        exports.RESOURCE_CIRCUIT,
        exports.RESOURCE_DEVICE,

        exports.RESOURCE_CELL,
        exports.RESOURCE_PHLEGM,
        exports.RESOURCE_TISSUE,
        exports.RESOURCE_MUSCLE,
        exports.RESOURCE_ORGANOID,
        exports.RESOURCE_ORGANISM,

        exports.RESOURCE_ALLOY,
        exports.RESOURCE_TUBE,
        exports.RESOURCE_FIXTURES,
        exports.RESOURCE_FRAME,
        exports.RESOURCE_HYDRAULICS,
        exports.RESOURCE_MACHINE,

        exports.RESOURCE_CONDENSATE,
        exports.RESOURCE_CONCENTRATE,
        exports.RESOURCE_EXTRACT,
        exports.RESOURCE_SPIRIT,
        exports.RESOURCE_EMANATION,
        exports.RESOURCE_ESSENCE
    ],
    COLORS_ALL: [
        exports.COLOR_RED,
        exports.COLOR_PURPLE,
        exports.COLOR_BLUE,
        exports.COLOR_CYAN,
        exports.COLOR_GREEN,
        exports.COLOR_YELLOW,
        exports.COLOR_ORANGE,
        exports.COLOR_BROWN,
        exports.COLOR_GREY,
        exports.COLOR_WHITE
    ],
    INTERSHARD_RESOURCES: [
        exports.SUBSCRIPTION_TOKEN,
        exports.CPU_UNLOCK,
        exports.PIXEL,
        exports.ACCESS_KEY
    ],
    COMMODITIES: {
        [exports.RESOURCE_UTRIUM_BAR]: {
            amount: 100,
            cooldown: 20,
            components: {
                [exports.RESOURCE_UTRIUM]: 500,
                [exports.RESOURCE_ENERGY]: 200
            }
        },
        [exports.RESOURCE_UTRIUM]: {
            amount: 500,
            cooldown: 20,
            components: {
                [exports.RESOURCE_UTRIUM_BAR]: 100,
                [exports.RESOURCE_ENERGY]: 200
            }
        },
        [exports.RESOURCE_LEMERGIUM_BAR]: {
            amount: 100,
            cooldown: 20,
            components: {
                [exports.RESOURCE_LEMERGIUM]: 500,
                [exports.RESOURCE_ENERGY]: 200
            }
        },
        [exports.RESOURCE_LEMERGIUM]: {
            amount: 500,
            cooldown: 20,
            components: {
                [exports.RESOURCE_LEMERGIUM_BAR]: 100,
                [exports.RESOURCE_ENERGY]: 200
            }
        },
        [exports.RESOURCE_ZYNTHIUM_BAR]: {
            amount: 100,
            cooldown: 20,
            components: {
                [exports.RESOURCE_ZYNTHIUM]: 500,
                [exports.RESOURCE_ENERGY]: 200
            }
        },
        [exports.RESOURCE_ZYNTHIUM]: {
            amount: 500,
            cooldown: 20,
            components: {
                [exports.RESOURCE_ZYNTHIUM_BAR]: 100,
                [exports.RESOURCE_ENERGY]: 200
            }
        },
        [exports.RESOURCE_KEANIUM_BAR]: {
            amount: 100,
            cooldown: 20,
            components: {
                [exports.RESOURCE_KEANIUM]: 500,
                [exports.RESOURCE_ENERGY]: 200
            }
        },
        [exports.RESOURCE_KEANIUM]: {
            amount: 500,
            cooldown: 20,
            components: {
                [exports.RESOURCE_KEANIUM_BAR]: 100,
                [exports.RESOURCE_ENERGY]: 200
            }
        },
        [exports.RESOURCE_GHODIUM_MELT]: {
            amount: 100,
            cooldown: 20,
            components: {
                [exports.RESOURCE_GHODIUM]: 500,
                [exports.RESOURCE_ENERGY]: 200
            }
        },
        [exports.RESOURCE_GHODIUM]: {
            amount: 500,
            cooldown: 20,
            components: {
                [exports.RESOURCE_GHODIUM_MELT]: 100,
                [exports.RESOURCE_ENERGY]: 200
            }
        },
        [exports.RESOURCE_OXIDANT]: {
            amount: 100,
            cooldown: 20,
            components: {
                [exports.RESOURCE_OXYGEN]: 500,
                [exports.RESOURCE_ENERGY]: 200
            }
        },
        [exports.RESOURCE_OXYGEN]: {
            amount: 500,
            cooldown: 20,
            components: {
                [exports.RESOURCE_OXIDANT]: 100,
                [exports.RESOURCE_ENERGY]: 200
            }
        },
        [exports.RESOURCE_REDUCTANT]: {
            amount: 100,
            cooldown: 20,
            components: {
                [exports.RESOURCE_HYDROGEN]: 500,
                [exports.RESOURCE_ENERGY]: 200
            }
        },
        [exports.RESOURCE_HYDROGEN]: {
            amount: 500,
            cooldown: 20,
            components: {
                [exports.RESOURCE_REDUCTANT]: 100,
                [exports.RESOURCE_ENERGY]: 200
            }
        },
        [exports.RESOURCE_PURIFIER]: {
            amount: 100,
            cooldown: 20,
            components: {
                [exports.RESOURCE_CATALYST]: 500,
                [exports.RESOURCE_ENERGY]: 200
            }
        },
        [exports.RESOURCE_CATALYST]: {
            amount: 500,
            cooldown: 20,
            components: {
                [exports.RESOURCE_PURIFIER]: 100,
                [exports.RESOURCE_ENERGY]: 200
            }
        },
        [exports.RESOURCE_BATTERY]: {
            amount: 50,
            cooldown: 10,
            components: {
                [exports.RESOURCE_ENERGY]: 600
            }
        },
        [exports.RESOURCE_ENERGY]: {
            amount: 500,
            cooldown: 10,
            components: {
                [exports.RESOURCE_BATTERY]: 50
            }
        },
        [exports.RESOURCE_COMPOSITE]: {
            level: 1,
            amount: 20,
            cooldown: 50,
            components: {
                [exports.RESOURCE_UTRIUM_BAR]: 20,
                [exports.RESOURCE_ZYNTHIUM_BAR]: 20,
                [exports.RESOURCE_ENERGY]: 20
            }
        },
        [exports.RESOURCE_CRYSTAL]: {
            level: 2,
            amount: 6,
            cooldown: 21,
            components: {
                [exports.RESOURCE_LEMERGIUM_BAR]: 6,
                [exports.RESOURCE_KEANIUM_BAR]: 6,
                [exports.RESOURCE_PURIFIER]: 6,
                [exports.RESOURCE_ENERGY]: 45
            }
        },
        [exports.RESOURCE_LIQUID]: {
            level: 3,
            amount: 12,
            cooldown: 60,
            components: {
                [exports.RESOURCE_OXIDANT]: 12,
                [exports.RESOURCE_REDUCTANT]: 12,
                [exports.RESOURCE_GHODIUM_MELT]: 12,
                [exports.RESOURCE_ENERGY]: 90
            }
        },

        [exports.RESOURCE_WIRE]: {
            amount: 20,
            cooldown: 8,
            components: {
                [exports.RESOURCE_UTRIUM_BAR]: 20,
                [exports.RESOURCE_SILICON]: 100,
                [exports.RESOURCE_ENERGY]: 40
            }
        },
        [exports.RESOURCE_SWITCH]: {
            level: 1,
            amount: 5,
            cooldown: 70,
            components: {
                [exports.RESOURCE_WIRE]: 40,
                [exports.RESOURCE_OXIDANT]: 95,
                [exports.RESOURCE_UTRIUM_BAR]: 35,
                [exports.RESOURCE_ENERGY]: 20
            }
        },
        [exports.RESOURCE_TRANSISTOR]: {
            level: 2,
            amount: 1,
            cooldown: 59,
            components: {
                [exports.RESOURCE_SWITCH]: 4,
                [exports.RESOURCE_WIRE]: 15,
                [exports.RESOURCE_REDUCTANT]: 85,
                [exports.RESOURCE_ENERGY]: 8
            }
        },
        [exports.RESOURCE_MICROCHIP]: {
            level: 3,
            amount: 1,
            cooldown: 250,
            components: {
                [exports.RESOURCE_TRANSISTOR]: 2,
                [exports.RESOURCE_COMPOSITE]: 50,
                [exports.RESOURCE_WIRE]: 117,
                [exports.RESOURCE_PURIFIER]: 25,
                [exports.RESOURCE_ENERGY]: 16
            }
        },
        [exports.RESOURCE_CIRCUIT]: {
            level: 4,
            amount: 1,
            cooldown: 800,
            components: {
                [exports.RESOURCE_MICROCHIP]: 1,
                [exports.RESOURCE_TRANSISTOR]: 5,
                [exports.RESOURCE_SWITCH]: 4,
                [exports.RESOURCE_OXIDANT]: 115,
                [exports.RESOURCE_ENERGY]: 32
            }
        },
        [exports.RESOURCE_DEVICE]: {
            level: 5,
            amount: 1,
            cooldown: 600,
            components: {
                [exports.RESOURCE_CIRCUIT]: 1,
                [exports.RESOURCE_MICROCHIP]: 3,
                [exports.RESOURCE_CRYSTAL]: 110,
                [exports.RESOURCE_GHODIUM_MELT]: 150,
                [exports.RESOURCE_ENERGY]: 64
            }
        },

        [exports.RESOURCE_CELL]: {
            amount: 20,
            cooldown: 8,
            components: {
                [exports.RESOURCE_LEMERGIUM_BAR]: 20,
                [exports.RESOURCE_BIOMASS]: 100,
                [exports.RESOURCE_ENERGY]: 40
            }
        },
        [exports.RESOURCE_PHLEGM]: {
            level: 1,
            amount: 2,
            cooldown: 35,
            components: {
                [exports.RESOURCE_CELL]: 20,
                [exports.RESOURCE_OXIDANT]: 36,
                [exports.RESOURCE_LEMERGIUM_BAR]: 16,
                [exports.RESOURCE_ENERGY]: 8
            }
        },
        [exports.RESOURCE_TISSUE]: {
            level: 2,
            amount: 2,
            cooldown: 164,
            components: {
                [exports.RESOURCE_PHLEGM]: 10,
                [exports.RESOURCE_CELL]: 10,
                [exports.RESOURCE_REDUCTANT]: 110,
                [exports.RESOURCE_ENERGY]: 16
            }
        },
        [exports.RESOURCE_MUSCLE]: {
            level: 3,
            amount: 1,
            cooldown: 250,
            components: {
                [exports.RESOURCE_TISSUE]: 3,
                [exports.RESOURCE_PHLEGM]: 3,
                [exports.RESOURCE_ZYNTHIUM_BAR]: 50,
                [exports.RESOURCE_REDUCTANT]: 50,
                [exports.RESOURCE_ENERGY]: 16
            }
        },
        [exports.RESOURCE_ORGANOID]: {
            level: 4,
            amount: 1,
            cooldown: 800,
            components: {
                [exports.RESOURCE_MUSCLE]: 1,
                [exports.RESOURCE_TISSUE]: 5,
                [exports.RESOURCE_PURIFIER]: 208,
                [exports.RESOURCE_OXIDANT]: 256,
                [exports.RESOURCE_ENERGY]: 32
            }
        },
        [exports.RESOURCE_ORGANISM]: {
            level: 5,
            amount: 1,
            cooldown: 600,
            components: {
                [exports.RESOURCE_ORGANOID]: 1,
                [exports.RESOURCE_LIQUID]: 150,
                [exports.RESOURCE_TISSUE]: 6,
                [exports.RESOURCE_CELL]: 310,
                [exports.RESOURCE_ENERGY]: 64
            }
        },

        [exports.RESOURCE_ALLOY]: {
            amount: 20,
            cooldown: 8,
            components: {
                [exports.RESOURCE_ZYNTHIUM_BAR]: 20,
                [exports.RESOURCE_METAL]: 100,
                [exports.RESOURCE_ENERGY]: 40
            }
        },
        [exports.RESOURCE_TUBE]: {
            level: 1,
            amount: 2,
            cooldown: 45,
            components: {
                [exports.RESOURCE_ALLOY]: 40,
                [exports.RESOURCE_ZYNTHIUM_BAR]: 16,
                [exports.RESOURCE_ENERGY]: 8
            }
        },
        [exports.RESOURCE_FIXTURES]: {
            level: 2,
            amount: 1,
            cooldown: 115,
            components: {
                [exports.RESOURCE_COMPOSITE]: 20,
                [exports.RESOURCE_ALLOY]: 41,
                [exports.RESOURCE_OXIDANT]: 161,
                [exports.RESOURCE_ENERGY]: 8
            }
        },
        [exports.RESOURCE_FRAME]: {
            level: 3,
            amount: 1,
            cooldown: 125,
            components: {
                [exports.RESOURCE_FIXTURES]: 2,
                [exports.RESOURCE_TUBE]: 4,
                [exports.RESOURCE_REDUCTANT]: 330,
                [exports.RESOURCE_ZYNTHIUM_BAR]: 31,
                [exports.RESOURCE_ENERGY]: 16
            }
        },
        [exports.RESOURCE_HYDRAULICS]: {
            level: 4,
            amount: 1,
            cooldown: 800,
            components: {
                [exports.RESOURCE_LIQUID]: 150,
                [exports.RESOURCE_FIXTURES]: 3,
                [exports.RESOURCE_TUBE]: 15,
                [exports.RESOURCE_PURIFIER]: 208,
                [exports.RESOURCE_ENERGY]: 32
            }
        },
        [exports.RESOURCE_MACHINE]: {
            level: 5,
            amount: 1,
            cooldown: 600,
            components: {
                [exports.RESOURCE_HYDRAULICS]: 1,
                [exports.RESOURCE_FRAME]: 2,
                [exports.RESOURCE_FIXTURES]: 3,
                [exports.RESOURCE_TUBE]: 12,
                [exports.RESOURCE_ENERGY]: 64
            }
        },

        [exports.RESOURCE_CONDENSATE]: {
            amount: 20,
            cooldown: 8,
            components: {
                [exports.RESOURCE_KEANIUM_BAR]: 20,
                [exports.RESOURCE_MIST]: 100,
                [exports.RESOURCE_ENERGY]: 40
            }
        },
        [exports.RESOURCE_CONCENTRATE]: {
            level: 1,
            amount: 3,
            cooldown: 41,
            components: {
                [exports.RESOURCE_CONDENSATE]: 30,
                [exports.RESOURCE_KEANIUM_BAR]: 15,
                [exports.RESOURCE_REDUCTANT]: 54,
                [exports.RESOURCE_ENERGY]: 12
            }
        },
        [exports.RESOURCE_EXTRACT]: {
            level: 2,
            amount: 2,
            cooldown: 128,
            components: {
                [exports.RESOURCE_CONCENTRATE]: 10,
                [exports.RESOURCE_CONDENSATE]: 30,
                [exports.RESOURCE_OXIDANT]: 60,
                [exports.RESOURCE_ENERGY]: 16
            }
        },
        [exports.RESOURCE_SPIRIT]: {
            level: 3,
            amount: 1,
            cooldown: 200,
            components: {
                [exports.RESOURCE_EXTRACT]: 2,
                [exports.RESOURCE_CONCENTRATE]: 6,
                [exports.RESOURCE_REDUCTANT]: 90,
                [exports.RESOURCE_PURIFIER]: 20,
                [exports.RESOURCE_ENERGY]: 16
            }
        },
        [exports.RESOURCE_EMANATION]: {
            level: 4,
            amount: 1,
            cooldown: 800,
            components: {
                [exports.RESOURCE_SPIRIT]: 2,
                [exports.RESOURCE_EXTRACT]: 2,
                [exports.RESOURCE_CONCENTRATE]: 3,
                [exports.RESOURCE_KEANIUM_BAR]: 112,
                [exports.RESOURCE_ENERGY]: 32
            }
        },
        [exports.RESOURCE_ESSENCE]: {
            level: 5,
            amount: 1,
            cooldown: 600,
            components: {
                [exports.RESOURCE_EMANATION]: 1,
                [exports.RESOURCE_SPIRIT]: 3,
                [exports.RESOURCE_CRYSTAL]: 110,
                [exports.RESOURCE_GHODIUM_MELT]: 150,
                [exports.RESOURCE_ENERGY]: 64
            }
        },
    }
});

ConstructionSite

一个正在建设中的工地。可以使用游戏界面右侧的'Construct'按钮创建工地或Room.createConstructionSite方法。

要在工地建造一个建筑，需要给工人creep一些能量并执行Creep.build动作。

如果想移除敌人的工地，只需让一个creep踩在上面即可。

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

idstring

全局唯一的对象标识。你可以通过调用Game.getObjectById方法取得对象实例。

myboolean

你是否拥有这个工地。

ownerobject

建筑拥有者信息，一个包含如下属性的对象：

parameter	type	description
username	string	拥有者姓名。

progressnumber

当前建造进度。

progressTotalnumber

完成建造所需的建造总进度。

structureTypestring

STRUCTURE_*常量之一。

remove()

删除这个工地。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个工地的拥有者，或者这不是你的房间。

Creep

creep 是你的单位, creep 可以移动、采集能量、建造建筑、攻击其他 creep 以及执行其他动作。每个 creep 都由最多 50 个身体部件构成，身体部件的类型如下：

身体部件	孵化成本	每个部件效果
MOVE	50	每 tick 减少 2 点疲惫值
WORK	100	每 tick 从能量源采集 2 单位能量。 每 tick 从矿区采集 1 单位矿物。 每 tick 增加工地建设进度 5 点，花费 5 单位能量。 每 tick 增加建筑 100 耐久度，花费 1 单位能量。 每 tick 拆减建筑 50 点耐久，并返还 0.25 单位能量。 每 tick 提高控制器升级进度 1 点，花费 1 单位能量。
CARRY	50	携带最多 50 单位资源。
ATTACK	80	对相邻的 creep 或建筑造成 30 点伤害。
RANGED_ATTACK	150	单个目标时，每 tick 对 creep 或建筑造成 10 点伤害，范围为 3 格。 多个目标时，每 tick 对范围内所有 creep 与建筑造成 1-4-10 点伤害，具体伤害取决于距离，范围为 3 格。
HEAL	250	治疗对象可为自己或其它 creep。自愈或治疗相邻 creep 时每 tick 恢复 12 点耐久，一定距离内远程治疗每 tick 恢复 4 点耐久。
CLAIM	600	占领一个中立房间的控制器。 每部件每 tick 使己方对中立房间控制器的预定时间增加 1 tick，或使其他玩家的预定时间减少 1 tick。 每部件每 tick 使其他玩家控制器降级计数器加速 300 tick。 注：拥有该部件的 creep 寿命只有 600 tick，且无法被 renew。
TOUGH	10	无附加效果，唯一作用是增加 creep 的最大耐久值。可被强化以承受更多伤害。

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

bodyarray

一个描述了该 creep 身体部件的数组，每一个数组元素都拥有如下的属性:

parameter	type	description
boost	string | undefined	如果该身体部件被强化(boost)了，则该属性指定了强化所用的化合物类型。化合物为 RESOURCE_* 常量之一。 了解更多
type	string	身体部件常量之一。
hits	number	该身体部件剩余的生命值。

carryobject

Creep.store 的别名。

carryCapacitynumber

Creep.store.getCapacity() 的别名。

fatiguenumber

每次移动的疲劳值指示器，当该值大于零时 creep 无法移动。

hitsnumber

当前的 creep 生命值。

hitsMaxnumber

该 creep 的最大生命值。

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

memoryany

creep.memory.task = 'building';

指向 Memory.creeps[creep.name] 的链接。你可以用它来快速访问该 creep 的特定内存对象。 点此了解更多关于 memory 的信息

myboolean

该 creep 属于您还是其他人。

namestring

creep 的名字。您可以在创建一个新的 creep 时给它取名，名称一旦指定无法更改。此名称是 Game.creeps 对象中指向该 creep 对象的哈希键。你可以使用它来快速访问到该 creep。

ownerobject

该 creep 的所有者信息，包含以下属性：

parameter	type	description
username	string	所有者姓名。

sayingstring

creep 所说的最后一句话。

spawningboolean

该 creep 是否仍在孵化中。

storeStore

if(creep.store[RESOURCE_ENERGY] < creep.store.getCapacity()) {
    goHarvest(creep);
}

一个包含了该建筑中所存储的货物的 Store 对象。

ticksToLivenumber

该 creep 还有多少 tick 死亡。

attack(target)

const target = creep.pos.findClosestByRange(FIND_HOSTILE_CREEPS);
if(target) {
    if(creep.attack(target) == ERR_NOT_IN_RANGE) {
        creep.moveTo(target);
    }
}

使用近战攻击其他 creep、超能(power) creep 或建筑。需要 ATTACK 身体部件。如果目标在 rampart 中，则优先攻击 rampart。目标必须与 creep 相邻，如果目标是一个带有 ATTACK 身体的 creep 并且没有自己没有在 rampart 中，则该目标会自动进行反击。

parameter	type	description
target	Creep, PowerCreep, Structure	要攻击的目标

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_INVALID_TARGET	-7	这个目标不是一个有效的攻击目标。
ERR_NOT_IN_RANGE	-9	目标太远了。
ERR_NO_BODYPART	-12	这个 creep 身上没有 ATTACK 部件。

attackController(target)

if(creep.room.controller && !creep.room.controller.my) {
    if(creep.attackController(creep.room.controller) == ERR_NOT_IN_RANGE) {
        creep.moveTo(creep.room.controller);
    }
}

攻击时，每个 CLAIM 身体部件都能使得房间控制器的降级计时器降低 300 tick，或者将预定计时器降低 1 tick。如果受到攻击的控制器已经有所属者，则接下来的 1000 tick 将无法升级(upgrade)或再次进行攻击。目标必须与 creep 相邻。

parameter	type	description
target	Structure	目标房间控制器对象。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_INVALID_TARGET	-7	该目标不存在有效的所属者或者预订者对象。
ERR_NOT_IN_RANGE	-9	目标太远了。
ERR_TIRED	-11	您必须等待控制器可以被再次攻击。
ERR_NO_BODYPART	-12	这个 creep 身上没有 CLAIM 部件。

build(target)

const target = creep.pos.findClosestByRange(FIND_CONSTRUCTION_SITES);
if(target) {
    if(creep.build(target) == ERR_NOT_IN_RANGE) {
        creep.moveTo(target);
    }
}

使用自己携带的能量来在目标工地上建造一个建筑。需要 WORK 和 CARRY 身体部件。目标必须位于以 creep 为中心的 7*7 正方形区域内。

parameter	type	description
target	ConstructionSite	待建造的目标工地。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_NOT_ENOUGH_RESOURCES	-6	这个creep没有携带任何能量。
ERR_INVALID_TARGET	-7	该目标不是一个有效的建筑工地(construction site)或者此处无法建造建筑(有可能是 creep 站在该地块上导致的)。
ERR_NOT_IN_RANGE	-9	目标太远了。
ERR_NO_BODYPART	-12	这个 creep 身上没有 WORK 部件。

cancelOrder(methodName)

creep.move(LEFT);
creep.cancelOrder('move');
// creep 本 tick 将不会移动

取消当前 tick 中给出的某个指令。

parameter	type	description
methodName	string	需要被取消的 creep 方法名。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作被成功取消了。
ERR_NOT_FOUND	-5	找不到给出的指令名。

claimController(target)

if(creep.room.controller) {
    if(creep.claimController(creep.room.controller) == ERR_NOT_IN_RANGE) {
        creep.moveTo(creep.room.controller);
    }
}

占领一个中立的房间。需要 CLAIM 身体部件。目标必须与 creep 相邻。你需要有对应的全局控制等级(Global Control Level)才能占领新的房间。如果你没有足够的 GCL。请考虑 预定(reserving) 该房间。点击了解更多

parameter	type	description
target	StructureController	目标控制中心对象。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_INVALID_TARGET	-7	目标不是一个有效的中立控制中心对象。
ERR_FULL	-8	你不能在新手区占领超过3个房间。
ERR_NOT_IN_RANGE	-9	目标太远了。
ERR_NO_BODYPART	-12	这个 creep 身上没有 CLAIM 部件。
ERR_GCL_NOT_ENOUGH	-15	你的全局控制等级不足。

dismantle(target)

const target = creep.pos.findClosestByRange(FIND_STRUCTURES,
    {filter: {structureType: STRUCTURE_WALL}});
if(target) {
    if(creep.dismantle(target) == ERR_NOT_IN_RANGE) {
        creep.moveTo(target);
    }
}

拆解任意可以建造的建筑（即使是敌人的）并且返回 50% 其修理所花的能量。需要 WORK 身体部件。如果 creep 有空余的 CARRY 身体部件，则会直接将能量转移进去；否则能量将掉落在地上。目标必须与 creep 相邻。

译者注：拆解效率和 WORK 部件的数量正相关。

parameter	type	description
target	Structure	目标建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_INVALID_TARGET	-7	目标不是一个有效的建筑对象。
ERR_NOT_IN_RANGE	-9	目标太远了。
ERR_NO_BODYPART	-12	这个 creep 身上没有 WORK 部件。

drop(resourceType, [amount])

creep.drop(RESOURCE_ENERGY);

// 丢弃身上所有资源
for(const resourceType in creep.carry) {
    creep.drop(resourceType);
}

将资源丢弃到地上。

parameter	type	description
resourceType	string	RESOURCE_* 常量之一。
amount (可选)	number	丢弃资源的数量。如果没有这个参数，丢弃全部资源。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_NOT_ENOUGH_RESOURCES	-6	这个creep没有足够的资源。
ERR_INVALID_ARGS	-10	resourceType不是一个有效的RESOURCE_*常量。

generateSafeMode(controller)

if(creep.generateSafeMode(creep.room.controller) == ERR_NOT_IN_RANGE) {
    creep.moveTo(creep.room.controller);
}

向房间控制器添加一个新的安全模式激活次数。creep 必须与房间控制器相邻并且带有 1000 ghodium 资源。

parameter	type	description
target	StructureController	目标控制中心。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_NOT_ENOUGH_RESOURCES	-6	这个 creep 没有足够的 ghodium。
ERR_INVALID_TARGET	-7	目标不是一个有效的控制中心对象。
ERR_NOT_IN_RANGE	-9	目标太远了。

getActiveBodyparts(type)

const target = creep.pos.findClosestByRange(FIND_HOSTILE_CREEPS, {
    filter: function(object) {
        return object.getActiveBodyparts(ATTACK) == 0;
    }
});
if(target) {
    creep.moveTo(target);
}

获取指定类型可用的身体部件数量。完全毁坏的部件不会被计算。

parameter	type	description
type	string	一个身体部件类型，下列身体部件类型常量之一： MOVE WORK CARRY ATTACK RANGED_ATTACK HEAL TOUGH

返回值

身体部件的数量。

harvest(target)

const target = creep.pos.findClosestByRange(FIND_SOURCES_ACTIVE);
if(target) {
    if(creep.harvest(target) == ERR_NOT_IN_RANGE) {
        creep.moveTo(target);
    }
}

从 source 中采集能量或者从 mineral 或 deposit 中采集资源。需要 WORK 身体部件。如果 creep 有空余的 CARRY 身体，则会自动将采集到的资源转移进去；否则将会掉落在地上。目标必须与 creep 相邻。

parameter	type	description
target	Source, Mineral, Deposit	要采集的对象。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是该 creep 的所有者，或者其他玩家已经占领或者预定了该房间的控制器。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_NOT_FOUND	-5	未找到 extractor。你必须建造一个 extractor 来开采矿物。了解更多
ERR_NOT_ENOUGH_RESOURCES	-6	目标中已经没有可采集的能量或者矿物。
ERR_INVALID_TARGET	-7	目标不是有效的 source 或者 mineral 对象。
ERR_NOT_IN_RANGE	-9	目标太远了。
ERR_TIRED	-11	extractor 仍在冷却中。
ERR_NO_BODYPART	-12	这个 creep 身上没有 WORK 部件。

heal(target)

const target = creep.pos.findClosestByRange(FIND_MY_CREEPS, {
    filter: function(object) {
        return object.hits < object.hitsMax;
    }
});
if(target) {
    if(creep.heal(target) == ERR_NOT_IN_RANGE) {
        creep.moveTo(target);
    }
}

治疗自己或者其他 creep。这将恢复目标 creep 受损身体部件的功能，并恢复已损失的生命值(hits)。需要 HEAL 身体部件。目标必须与 creep 相邻。

parameter	type	description
target	Creep, PowerCreep	目标 creep 对象。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_INVALID_TARGET	-7	目标不是有效的 creep 对象。
ERR_NOT_IN_RANGE	-9	目标太远了。
ERR_NO_BODYPART	-12	这个 creep 身上没有 HEAL 部件。

move(direction)

creep.move(RIGHT);

const path = creep.pos.findPathTo(Game.flags.Flag1);
if(path.length > 0) {
    creep.move(path[0].direction);
}

creep1.move(TOP);
creep1.pull(creep2);
creep2.move(creep1);

使 creep 朝指定方向移动一个地块。需要 MOVE 身体部件，或者其他 creep 在其附近并拉动该 creep。如果你对着一个相邻 creep 调用了 move 方法，将会使本 creep 跳过 ERR_TIRED 和 ERR_NO_BODYPART 检查; 否则将跳过 ERR_NOT_IN_RANGE 检查。

parameter	type	description
direction	Creep|number	一个相邻的 creep 或者下列常量之一： TOP TOP_RIGHT RIGHT BOTTOM_RIGHT BOTTOM BOTTOM_LEFT LEFT TOP_LEFT

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_NOT_IN_RANGE	-9	目标 creep 距离过远。
ERR_INVALID_ARGS	-10	提供的方向不正确。
ERR_TIRED	-11	该 creep 的疲劳（fatigue）计数器不为零。
ERR_NO_BODYPART	-12	该 creep 没有 MOVE 身体部件。

moveByPath(path)

const path = spawn.room.findPath(spawn, source);
creep.moveByPath(path);

if(!creep.memory.path) {
    creep.memory.path = creep.pos.findPathTo(target);
}
creep.moveByPath(creep.memory.path);

使用预先定义的路径进行移动。需要 MOVE 身体部件。

parameter	type	description
path	array|string	从 Room.findPath, RoomPosition.findPathTo 或 PathFinder.search 方法返回的路径值，数组或序列字符串形式都可接受。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_NOT_FOUND	-5	指定的路径与该 creep 的位置不匹配。
ERR_INVALID_ARGS	-10	path 不是一个有效的路径数组。
ERR_TIRED	-11	该 creep 的疲劳（fatigue）计数器不为零。
ERR_NO_BODYPART	-12	该 creep 没有 MOVE 身体部件。

moveTo(x, y, [opts])
(target, [opts])

creep.moveTo(10, 20);

creep.moveTo(Game.flags.Flag1);

creep.moveTo(new RoomPosition(25, 20, 'W10N5'));

creep.moveTo(pos, {reusePath: 50});

// 优先使用缓存路径进行移动
for(const name in Game.creeps) {
    Game.creeps[name].moveTo(target, {noPathFinding: true});
}

// 仅当有足够 CPU 时才执行寻路
if(Game.cpu.tickLimit - Game.cpu.getUsed() > 20) {
    for(const name in Game.creeps) {
        Game.creeps[name].moveTo(target);
    }
}

在本房间内查询到目标的最佳路径并向目标移动。该方法是 pos.findPathTo( ) move( ) 的调用简写。如果目标在其他房间，则相应的出口将被当做目标(在本房间中)。需要 MOVE 身体部件。

parameter	type	description
x	number	目标在 creep 所在房间中的 x 坐标。
y	number	目标在 creep 所在房间中的 y 坐标。
target	object	可以是 RoomPosition 对象或者任何包含 RoomPosition 属性的对象。该位置不必和 creep 在同一房间。
opts (可选)	object	包含可选项的对象： reusePath number 此选项将缓存前方多个 tick 将要移动的路径。该操作可以节省 cpu 时间，但是会导致 creep 的反应变慢。路径被缓存到 creep 内存中的 _move 属性里。reusePath 的值定义了要缓存前方多少 tick 的移动路径。默认值为 5。增加该值来节省更多的 CPU。减少该值来使移动更加连贯。设置为 0 来禁用路径重用。 serializeMemory boolean 如果 reusePath 启用并且该值设为 true，重用的路径将会使用 Room.serializePath 进行序列化并储存在内存中。默认值为 true。 noPathFinding boolean 如果该选择设为 true 并且内存中没有重用路径时，moveTo 将会返回 ERR_NOT_FOUND。在某些情况下，这会节省大量的 CPU 时间。默认值为 false。 visualizePathStyle object 使用 RoomVisual.poly 来在 creep 的移动路线上画一条线。你可以提供一个空对象或者自定义样式参数。默认的样式如下： { fill: 'transparent', stroke: '#fff', lineStyle: 'dashed', strokeWidth: .15, opacity: .1 } 任何 Room.findPath 方法支持的可选项。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_NO_PATH	-2	没有找到可以抵达目标的路径。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_NOT_FOUND	-5	该 creep 没有找到可重用的路径。
ERR_INVALID_TARGET	-7	提供了无效目标。
ERR_TIRED	-11	该 creep 的疲劳（fatigue）计数器不为零。
ERR_NO_BODYPART	-12	该 creep 没有 MOVE 身体部件。

notifyWhenAttacked(enabled)

if(creep.memory.role == 'scout') {
    creep.notifyWhenAttacked(false);
}
else {
    creep.notifyWhenAttacked(true);
}

当 creep 受到攻击时切换自动通知。通知将发送到您的帐户邮箱。默认情况下启用。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_INVALID_ARGS	-10	enable 参数不是 boolean 值。

pickup(target)

const target = creep.pos.findClosestByRange(FIND_DROPPED_RESOURCES);
if(target) {
    if(creep.pickup(target) == ERR_NOT_IN_RANGE) {
        creep.moveTo(target);
    }
}

捡起一个物品 (如捡起一些能量)。需要 CARRY 身体部件。目标必须与 creep 相邻或者和 creep 在相同位置。

parameter	type	description
target	Resource	要捡起的目标对象。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_INVALID_TARGET	-7	目标不是一个有效的可拾取对象。
ERR_FULL	-8	该 creep 已无法存储更多资源。
ERR_NOT_IN_RANGE	-9	目标太远了。

pull(target)

creep1.move(TOP);
creep1.pull(creep2);
creep2.move(creep1);

const target = creep.pos.findClosestByRange(FIND_MY_CREEPS, {
    filter: function(object) {
        return (object.getActiveBodyparts(MOVE) == 0) && 
            object.memory.destinationId &&
            !object.pos.isNearTo(Game.getObjectById(object.memory.destinationId));
    }
});
if(target) {
    if(creep.pull(target) == ERR_NOT_IN_RANGE) {
        creep.moveTo(target);
    } else {
        target.move(creep);
        if(creep.pos.isNearTo(Game.getObjectById(target.memory.destinationId))) {
            creep.move(creep.pos.getDirectionTo(target));
        } else {
            creep.moveTo(Game.getObjectById(target.memory.destinationId));
        }
    }
}

帮助其他 creep 跟随该 creep。目标 creep 移动产生的疲劳值将由该 creep 承担。需要 MOVE 身体部件。目标必须与 creep 相邻。该 creep 必须移动到其他地方，目标 creep 也必须朝该 creep 移动。

parameter	type	description
target	Creep	目标 creep。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_INVALID_TARGET	-7	提供了无效目标。
ERR_NOT_IN_RANGE	-9	目标太远了。

rangedAttack(target)

const targets = creep.pos.findInRange(FIND_HOSTILE_CREEPS, 3);
if(targets.length > 0) {
    creep.rangedAttack(targets[0]);
}

远程攻击其他 creep 或者建筑。需要 RANGED_ATTACK 身体部件。如果目标在 rampart 中，则 rampart 将被优先攻击。目标必须位于以 creep 为中心的 7*7 正方形区域内。

parameter	type	description
target	Creep, PowerCreep, Structure	要攻击的目标。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_INVALID_TARGET	-7	这个目标不是一个有效的攻击目标。
ERR_NOT_IN_RANGE	-9	目标太远了。
ERR_NO_BODYPART	-12	该 creep 没有 RANGED_ATTACK 身体部件。

rangedHeal(target)

const target = creep.pos.findClosestByRange(FIND_MY_CREEPS, {
    filter: function(object) {
        return object.hits < object.hitsMax;
    }
});
if(target) {
    creep.moveTo(target);
    if(creep.pos.isNearTo(target)) {
        creep.heal(target);
    }
    else {
        creep.rangedHeal(target);
    }
}

远程治疗其他 creep。这将恢复目标 creep 受损身体部件的功能，并恢复已损失的生命值(hits)。需要 HEAL 身体部件。目标必须位于以 creep 为中心的 7*7 正方形区域内。

parameter	type	description
target	Creep, PowerCreep	目标 creep 对象。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_INVALID_TARGET	-7	目标不是一个有效的creep对象。
ERR_NOT_IN_RANGE	-9	目标太远了。
ERR_NO_BODYPART	-12	这个 creep 身上没有 HEAL 部件。

rangedMassAttack()

const targets = creep.pos.findInRange(FIND_HOSTILE_CREEPS, 3);
if(targets.length > 0) {
    creep.rangedMassAttack();
}

对以该 creep 为中心，3 格范围内的所有敌方 creep 和建筑进行攻击。需要 RANGED_ATTACK 身体部件。对目标造成的伤害随距离的增加而衰减。友方单位不会受到影响。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_NO_BODYPART	-12	这个 creep 身上没有 RANGED_ATTACK 部件。

repair(target)

const targets = creep.room.find(FIND_STRUCTURES, {
    filter: object => object.hits < object.hitsMax
});

targets.sort((a,b) => a.hits - b.hits);

if(targets.length > 0) {
    if(creep.repair(targets[0]) == ERR_NOT_IN_RANGE) {
        creep.moveTo(targets[0]);
    }
}

使用携带的能量修复受损建筑。需要 WORK 和 CARRY 身体部件。目标必须位于以 creep 为中心的 7*7 正方形区域内。

parameter	type	description
target	Structure	要修复的目标建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	该 creep 依然在孵化中。
ERR_NOT_ENOUGH_RESOURCES	-6	该 creep 没有携带任何能量。
ERR_INVALID_TARGET	-7	目标不是一个有效的 structure 对象。
ERR_NOT_IN_RANGE	-9	目标太远了。
ERR_NO_BODYPART	-12	该 creep 身上没有 WORK 部件。

reserveController(target)

if(creep.room.controller) {
    if(creep.reserveController(creep.room.controller) == ERR_NOT_IN_RANGE) {
        creep.moveTo(creep.room.controller);
    }
}

暂时阻止其他玩家占领该房间控制器并且将 source 的能量上限恢复至正常容量。每 tick 执行该命令都可以让控制器的不可占领时间增加，增加的 tick 等同于 CLAIM 身体部件的数量。最大的预定时间为 5,000 tick。目标必须与 creep 相邻。

parameter	type	description
target	StructureController	要预定的目标控制器对象。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_INVALID_TARGET	-7	目标不是一个有效的中立房间控制器对象。
ERR_NOT_IN_RANGE	-9	目标太远了。
ERR_NO_BODYPART	-12	这个 creep 身上没有 CLAIM 部件。

say(message, [public])

const hostiles = creep.pos.findInRange(FIND_HOSTILE_CREEPS, 10);
if(hostiles.length > 0) {
    creep.say('OMG!😨');
    creep.moveTo(Game.spawns['Spawn1']);
}
else {
    doWork(creep);
}

在该 creep 上显示带有指定内容的可视对话气泡。此信息只会显示 1 tick。你可以通过 saying 属性获取说过的最后一条信息。允许使用任何有效的 Unicode 字符。包括 emoji。

parameter	type	description
message	string	要显示的信息，最长 10 字符。
public (可选)	boolean	设置为 true 来让其他玩家也能看到该信息。默认为 false。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。

signController(target, text)

if(creep.room.controller) {
    if(creep.signController(creep.room.controller, "I'm going to claim this room in a few days. I warned ya!") == ERR_NOT_IN_RANGE) {
        creep.moveTo(creep.room.controller);
    }
}

用对所有玩家可见的任意文本对控制器进行签名。该文本将显示在世界地图的房间 UI 中。并可通过 api 进行访问。你可以签名无主甚至敌对玩家的控制器。目标必须与 creep 相邻。传递一个空字符串来移除签名。

parameter	type	description
target	StructureController	要签名的目标控制器对象。
text	string	签名文本，最多 100 字符，之后的内容将被截断。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_INVALID_TARGET	-7	目标不是一个有效的控制器对象。
ERR_NOT_IN_RANGE	-9	目标太远了。

suicide()

立刻杀死该 creep。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。

transfer(target, resourceType, [amount])

if(creep.transfer(storage, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
    creep.moveTo(storage);
}

// 转移所有资源
for(const resourceType in creep.carry) {
    creep.transfer(storage, resourceType);
}

将资源从该 creep 转移至其他对象。目标必须与 creep 相邻。

parameter	type	description
target	Creep, PowerCreep, Structure	目标对象。
resourceType	string	RESOURCE_* 常量之一。
amount (可选)	number	要转移的资源数量。如果省略，将转移携带的全部指定资源。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的拥有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_NOT_ENOUGH_RESOURCES	-6	该 creep 没有携带足够的资源。
ERR_INVALID_TARGET	-7	目标不是一个能存放指定资源的有效对象。
ERR_FULL	-8	目标无法携带更多的资源。
ERR_NOT_IN_RANGE	-9	目标太远了。
ERR_INVALID_ARGS	-10	resourceType 不是 RESOURCE_* 常量之一，或者 amount 数量错误。

upgradeController(target)

if(creep.room.controller) {
    if(creep.upgradeController(creep.room.controller) == ERR_NOT_IN_RANGE) {
        creep.moveTo(creep.room.controller);
    }
}

使用携带的能量将您的控制器升级到新的等级。升级控制器将同时提高你的全局控制等级(Global Control Level)。需要 WORK 和 CARRY 身体部件。目标必须位于以 creep 为中心的 7*7 正方形区域内。

一个完全升级的 8 级控制器每 tick 最多接受 15 能量的升级，无论 creep 的能力有没有超过。该值限制了当前 tick 所有 creep 执行 upgradeController 积累的总能量值。可以使用 ghodium 化合物强化 来提高此上限。

升级控制器会把它的 ticksToDowngrade 计时器提高 100 tick。该计时器必须填满才能提升控制器等级。

parameter	type	description
target	StructureController	要进行升级的目标控制器。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是该 creep 或目标控制器的所有者。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_NOT_ENOUGH_RESOURCES	-6	这个creep没有携带任何能量。
ERR_INVALID_TARGET	-7	目标不是有效的控制器对象，或控制器的升级被阻滞了。
ERR_NOT_IN_RANGE	-9	目标太远了。
ERR_NO_BODYPART	-12	这个 creep 身上没有 WORK 部件。

withdraw(target, resourceType, [amount])

if(creep.withdraw(storage, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
    creep.moveTo(storage);
}

从建筑(structure)或是墓碑(tombstone)中拿取资源。目标必须与 creep 相邻。多个 creep 可以在同一 tick 里从相同对象中拿取资源。你的 creep 同样也可以从敌对建筑/墓碑中拿取资源，如果它上面没有敌对的 rampart 的话。

此方法不应该被用来在 creep 之间转移资源。想要在 creep 之间转移，请对携带资源的 creep 执行 transfer 方法。

parameter	type	description
target	Structure, Tombstone, Ruin	目标对象。
resourceType	string	RESOURCE_* 常量之一。
amount (可选)	number	被传递资源的数量。如果没有这个参数，传递全部可用数量的资源。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是此 creep 的所有者，或者目标位于敌方 rampart 之下。
ERR_BUSY	-4	这个 creep 依然在孵化中。
ERR_NOT_ENOUGH_RESOURCES	-6	目标中没有足够数量的资源。
ERR_INVALID_TARGET	-7	目标不是一个能存储指定资源的对象。
ERR_FULL	-8	此 creep 的存储已经满了。
ERR_NOT_IN_RANGE	-9	目标太远了。
ERR_INVALID_ARGS	-10	resourceType 不是 RESOURCE_* 常量之一, 或者 amount 数量错误。

Deposit

生产商品所需的稀有资源储备。 可以通过带有 WORK 身体部位的 creep 来收获。 每次采集操作都会触发冷却时间，冷却时间会随着时间的流逝而越来越长。

点击 本文 了解更多关于 deposits 的信息。

冷却	0.001 * totalHarvested ^ 1.2
老化	50,000 ticks after appearing or last harvest operation

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

cooldownnumber

下一次采集前还要冷却多少 tick。

depositTypestring

deposit 类型, 以下常量之一:

RESOURCE_MIST
RESOURCE_BIOMASS
RESOURCE_METAL
RESOURCE_SILICON

idstring

唯一的对象标识符。您可以使用 Game.getObjectById 方法通过其 id 检索对象实例。 。

lastCooldownnumber

该结构上次采集的冷却时间。

ticksToDecaynumber

该结构还有多少 tick 就要因老化而消失。

Flag

一个旗帜，旗帜可以用来标记房间中的一个特定的地点。旗帜只对其所有者可见。你最多只能拥有 10,000 个旗帜。

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

colornumber

旗帜的主要颜色。COLOR_* 常量之一。

memoryany

指向 Memory.flags[flag.name] 的链接。你可以使用它来快速访问到该旗帜的内存数据对象。

namestring

旗帜的名称。你可以在创建新的旗帜时为其指定名字，名字一旦确定无法修改。创建之后会以该名称为键，旗帜对象为值存放在 Game.flags 对象中。名称最长不能超过 100 字符。

secondaryColornumber

旗帜的次要颜色。COLOR_* 常量之一。

remove()

移除该旗帜。

返回值

永远返回 OK 。

setColor(color, [secondaryColor])

Game.flags.Flag1.setColor(COLOR_GREEN, COLOR_WHITE);

给旗帜设置一个新颜色

parameter	type	description
color	string	旗帜的主要颜色。COLOR_* 常量之一。
secondaryColor (可选)	string	旗帜的次要颜色。COLOR_* 常量之一。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_INVALID_ARGS	-10	color 或者 secondaryColor 不是一个有效的 COLOR_* 常量。

setPosition(x,y)
(pos)

Game.flags.Flag1.setPosition(10,20);

Game.flags.Flag1.setPosition( new RoomPosition(10, 20, 'W3S5') );

给旗帜设置一个新的位置。

parameter	type	description
x	number	相同房间内的 x 坐标。
y	number	相同房间内的 y 坐标。
pos	object	可以是 RoomPosition 对象或者任何包含 RoomPosition 属性的对象。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_INVALID_TARGET	-7	提供了无效的目标。

Mineral

矿床。在建有 extractor 建筑时可以通过带有 WORK 身体部件的 creep 采集。 点击 本文 来了解更多关于 mineral 的信息。

再生容量	DENSITY_LOW: 15,000 DENSITY_MODERATE: 35,000 DENSITY_HIGH: 70,000 DENSITY_ULTRA: 100,000
再生时间	50,000 ticks
丰度(Density)改变机率	DENSITY_LOW: 100% 机率改变 DENSITY_MODERATE: 5% 机率改变 DENSITY_HIGH: 5% 机率改变 DENSITY_ULTRA: 100% 机率改变

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

densitynumber

矿床丰度。丰度越高其容量越大。一旦再生时间 (ticksToRegeneration) 降为 0，该矿床的丰度将被重置为 DENSITY_* 常量之一。

mineralAmountnumber

资源的剩余容量。

mineralTypestring

资源类型， RESOURCE_* 常量之一。

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

ticksToRegenerationnumber

矿床容量将要恢复满额的剩余时间。

Nuke

核弹原爆点，此对象无法被更改或移除。但可以用常数 FIND_NUKES 查找即将抵达房间的核弹。核弹只能由 核弹发射井 发射

着落时间	50,000 ticks
影响	房间里的所有的 creeps 、建筑工地、掉落的资源会在核爆瞬间被移除，无论其是否在堡垒内。对建筑的伤害： 10,000,000 hits 在原爆点; 5,000,000 hits 对周边 5x5 区域内的所有建筑. 注：向同一目标发射多枚核弹可叠加伤害。 Nuke 着落不会产生墓碑（tombstone）和遗迹（ruin），并且会销毁房间中所有存在的墓碑和遗迹。 如果目标房间处与安全模式，则其安全模式会被立即取消，但安全模式的冷却时间会被重置为0。 目标房间的控制器会进入 upgradeBlocked ，这意味着在 200 ticks 内其无法重新开启安全模式。

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

idstring

全局唯一的对象标识。你可以通过调用Game.getObjectById方法取得对象实例。

launchRoomNamestring

发射此核弹的房间名。

timeToLandnumber

着落倒计时。

OwnedStructure

存在拥有者的建筑的基础原型。 这类建筑可以被用FIND_MY_STRUCTURES或FIND_HOSTILE_STRUCTURES找到。

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

myboolean

是否是你拥有的建筑。

ownerobject

建筑拥有者信息，一个包含如下属性的对象：

parameter	type	description
username	string	拥有者姓名。

PathFinder.CostMatrix

存放自定义导航寻路成本的对象。默认情况下，PathFinder 在寻路时只考虑地形 (平原、沼泽、墙壁) —— 如果您需要绕过建筑或者 creep，就需要把他们放进一个 CostMatrix 里。通常情况下，您将在 roomCallback 内部创建 CostMatrix。如果在房间的 CostMatrix 里找到了一个非零值，那么它将替代默认的地形移动成本。您应该避免在 CostMatrix 和地形移动成本标志里使用较大值。例如，使用 { plainCost: 1, swampCost: 5 } 的 PathFinder.search 将比使用 {plainCost: 2, swampCost: 10 } 的运行的更快，并且他们将会寻路出相同的路径。

constructor()

let costs = new PathFinder.CostMatrix;

创建一个新的 CostMatrix，其中所有位置的移动成本都为 0。

set(x, y, cost)

let costs = new PathFinder.CostMatrix;
let pos = Game.spawns['Spawn1'].pos;
costs.set(pos.x, pos.y, 255); // 不能从该建筑上移动

在 CostMatrix 中设置指定位置的移动成本。

parameter	type	description
x	number	位置在房间中的 x 坐标。
y	number	位置在房间中的 y 坐标。
cost	number	该位置的移动成本，必须是整数。值为 0 时将使用该地块默认的地形移动成本。大于或等于 255 的移动成本将视为无法通过。

get(x, y)

获取该 CostMatrix 中指定位置的移动成本。

parameter	type	description
x	number	位置在房间中的 x 坐标。
y	number	位置在房间中的 y 坐标。

clone()

使用当前 CostMatrix 中的相同数据创建一个新的 CostMatrix。

返回值

一个新的 CostMatrix 实例。

serialize()

let costs = new PathFinder.CostMatrix;
Memory.savedMatrix = costs.serialize();

返回该 CostMatrix 的紧凑形式，使其可以使用 JSON.stringify 进行存储。

返回值

一个 number 数组。它除了可以被保存起来以备后续使用之外没有什么作用。

PathFinder.CostMatrix.deserialize(val)

let costs = PathFinder.CostMatrix.deserialize(Memory.savedMatrix)

静态方法，可以将 serialize 方法返回的值反序列化为一个新的 CostMatrix。

parameter	type	description
val	object	任何 serialize 的返回值。

返回值

返回新的 CostMatrix 实例。

PowerCreep

Power Creep 是和您账户绑定的不朽“英雄”单位。其死后可以在任何 PowerSpawn 重生。你可以升级它们的能力（“powers”），可升级的等级取决于您的 Global Power Level。(查看 Game.gpl)。

存活时间	5,000
生命值	1,000 每级
容量	100 每级

可用 power 的完整列表

PowerCreep.create(name, className)

PowerCreep.create('PowerCreep1', POWER_CLASS.OPERATOR);

向您账户中添加新的 Power Creep 实例。在添加之后默认为未孵化状态，使用 spawn 方法在游戏世界中生成它。

您的账户中拥有至少一个可用的 Power Level 才能执行该操作。

parameter	type	description
name	string	新 power creep 的名字。最长不能超过 100 个字符。
className	string	新 power creep 的类型，POWER_CLASS 常量之一。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NAME_EXISTS	-3	指定的 power creep 名称已被使用。
ERR_NOT_ENOUGH_RESOURCES	-6	您的账户中没有足够的 Power Level。
ERR_INVALID_ARGS	-10	指定的 power creep 名称超过长度，或者 power creep 的类型（class）无效。

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

carryobject

Creep.store 的别名。

carryCapacitynumber

Creep.store.getCapacity() 的别名。

classNamestring

该 power creep 的类型，POWER_CLASS 常量之一。

deleteTimenumber

该 creep 被从账户中永久删除的时间戳，否则为 undefined。

hitsnumber

该 creep 当前的 hit 生命值。

hitsMaxnumber

该 creep 当前的最大生命值。

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

levelnumber

该 power creep 的等级。

memoryany

creep.memory.task = 'building';

Memory.powerCreeps[creep.name] 的简写。您可以使用它来快速访问该 creep 的特定内存数据对象。点此了解有关 memory 的更多信息

myboolean

您是否为该 creep 的所有者。

namestring

Power creep 的名字。您可以在创建一个新 power creep 时为其指定名称，一旦指定无法修改（在 creep 存活时无法修改）。此名称是 Game.powerCreeps 对象中指向该 creep 的哈希键。你可以使用它来快速访问到该 creep。

ownerobject

一个代表其拥有者信息的对象，包含以下属性：

parameter	type	description
username	string	拥有者姓名。

storeStore

if(creep.store[RESOURCE_ENERGY] < creep.store.getCapacity()) {
    goHarvest(creep);
}

一个包含了该 creep 所携带资源的 Store 对象。

powersobject

可用的 power，一个使用 power ID 作为键的对象，包含以下属性：

parameter	type	description
level	number	该 power 的等级。
cooldown	number	剩余的冷却时间，当 power creep 还没有出生时为 undefined。

sayingstring

该 creep 在最后一 tick 说过的话。

shardstring

该 power creep 孵化到的 shard 名称，或者为 undefined。

spawnCooldownTimenumber

if(!(Game.powerCreeps['PowerCreep1'].spawnCooldownTime > Date.now())) {
    Game.powerCreeps['PowerCreep1'].spawn(powerSpawn);
}

在生成或者删除 creep 时该时间戳可用。 在该 power creep 已经出生后为 undefined。

ticksToLivenumber

在 creep 死亡并变为未孵化状态前的剩余存活 tick 时长。在 creep 未孵化时该属性为 undefined。

cancelOrder(methodName)

creep.move(LEFT);
creep.cancelOrder('move');
// 该 creep 本 tick 将不会移动。

取消当前 tick 已经调用的操作。

parameter	type	description
methodName	string	要取消的 creep 方法名称。

返回值

如下错误码之一：

constant	value	description
OK	0	该操作已被成功取消。
ERR_NOT_OWNER	-1	你不是该 creep 的所有者。
ERR_BUSY	-4	该 power creep 还没有出生。
ERR_NOT_FOUND	-5	要取消的方法名称未找到。

delete([cancel])

Game.powerCreeps['PowerCreep1'].delete();

从您的账户中永久删除一个 power creep。在删除时 creep 应处于未孵化状态。该 creep 并不会被立刻删除，而是会启动一个 24 小时的删除倒计时 (详见 deleteTime)。你可以通过调用 delete(true) 来取消删除。

parameter	type	description
cancel	boolean	将其设为 true 来取消之前的删除计划。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个 creep 的所有者。
ERR_BUSY	-4	该 power creep 仍然存活在这个世界上。

drop(resourceType, [amount])

creep.drop(RESOURCE_ENERGY);

// 丢弃所有资源
for(const resourceType in creep.carry) {
    creep.drop(resourceType);
}

将资源丢弃到地上。

parameter	type	description
resourceType	string	RESOURCE_*常量之一。
amount (可选)	number	要被丢弃的资源数量。如果为空，则所有该类型资源都会被丢弃。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个creep的拥有者。
ERR_BUSY	-4	该 power creep 还没有出生。
ERR_NOT_ENOUGH_RESOURCES	-6	该 creep 上携带的资源数量小于给定的 amount。
ERR_INVALID_ARGS	-10	resourceType 不是一个有效的 RESOURCE_* 常量。

Game.powerCreeps['PowerCreep1'].usePower(PWR_GENERATE_OPS);

enableRoom(controller)

powerCreep.enableRoom(powerCreep.room.controller);

在该房间启用 power。房间控制器应位于相邻的地块上。

parameter	type	description
controller	StructureController	房间控制器。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个creep的拥有者。
ERR_INVALID_TARGET	-7	目标不是一个控制器建筑。
ERR_NOT_IN_RANGE	-9	目标太远了。

move(direction)

creep.move(RIGHT);

const path = creep.pos.findPathTo(Game.flags.Flag1);
if(path.length > 0) {
    creep.move(path[0].direction);
}

creep1.move(TOP);
creep1.pull(creep2);
creep2.move(creep1);

使 creep 朝指定方向移动一个地块。

parameter	type	description
direction	Creep|number	一个相邻的 creep 或者下列常量之一： TOP TOP_RIGHT RIGHT BOTTOM_RIGHT BOTTOM BOTTOM_LEFT LEFT TOP_LEFT

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个creep的拥有者。
ERR_BUSY	-4	该 power creep 还没有出生。
ERR_NOT_IN_RANGE	-9	目标 creep 距离过远。
ERR_INVALID_ARGS	-10	提供的方向不正确。
ERR_TIRED	-11	该 creep 的疲劳(fatigue)计数器不为零。

moveByPath(path)

const path = spawn.room.findPath(spawn, source);
creep.moveByPath(path);

if(!creep.memory.path) {
    creep.memory.path = creep.pos.findPathTo(target);
}
creep.moveByPath(creep.memory.path);

使用预先定义的路径进行移动。

parameter	type	description
path	array|string	Room.findPath、RoomPosition.findPathTo 或 PathFinder.search 的返回值。数组和序列化的字符串都可以接受。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个creep的拥有者。
ERR_BUSY	-4	该 power creep 还没有出生。
ERR_NOT_FOUND	-5	指定的路径与该 creep 的位置不匹配。
ERR_INVALID_ARGS	-10	path 不是一个有效的路径数组。
ERR_TIRED	-11	该 creep 的疲劳(fatigue)计数器不为零。

moveTo(x, y, [opts])
(target, [opts])

creep.moveTo(10, 20);

creep.moveTo(Game.flags.Flag1);

creep.moveTo(new RoomPosition(25, 20, 'W10N5'));

creep.moveTo(pos, {reusePath: 50});

// 优先使用缓存路径进行移动
for(const name in Game.creeps) {
    Game.creeps[name].moveTo(target, {noPathFinding: true});
}

// 仅当有足够 CPU 时才执行寻路
if(Game.cpu.tickLimit - Game.cpu.getUsed() > 20) {
    for(const name in Game.creeps) {
        Game.creeps[name].moveTo(target);
    }
}

在本房间内查询到目标的最佳路径并向目标移动。该方法是 pos.findPathTo( ) move( ) 的调用简写。如果目标在其他房间，则相应的出口将被当做目标(在本房间中)。

parameter	type	description
x	number	目标在 creep 所在房间中的 x 坐标。
y	number	目标在 creep 所在房间中的 y 坐标。
target	object	可以是 RoomPosition 对象或者任何包含 RoomPosition 属性的对象。 The position doesn't have to be in the same room with the creep.
opts (可选)	object	包含可选项的对象： reusePath number 此选项将缓存前方多个 tick 将要移动的路径。该操作可以节省 cpu 时间，但是会导致 creep 的反应变慢。路径被缓存到 creep 内存中的 _move 属性里。reusePath 的值定义了要缓存前方多少 tick 的移动路径。默认值为 5。增加该值来节省更多的 CPU。减少该值来使移动更加连贯。设置为 0 来禁用路径重用。 serializeMemory boolean 如果 reusePath 启用并且该值设为 true，重用的路径将会使用 Room.serializePath 进行序列化并储存在内存中。默认值为 true。 noPathFinding boolean 如果该选择设为 true 并且内存中没有重用路径时，moveTo 将会返回 ERR_NOT_FOUND。在某些情况下，这会节省大量的 CPU 时间。默认值为 false。 visualizePathStyle object 使用 RoomVisual.poly 来在 creep 的移动路线上画一条线。你可以提供一个空对象或者自定义样式参数。默认的样式如下： { fill: 'transparent', stroke: '#fff', lineStyle: 'dashed', strokeWidth: .15, opacity: .1 } 任何 Room.findPath 方法支持的可选项。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个creep的拥有者。
ERR_NO_PATH	-2	没有找到可以抵达目标的路径。
ERR_BUSY	-4	该 power creep 还没有出生。
ERR_NOT_FOUND	-5	该 creep 没有找到可重用的路径。
ERR_INVALID_TARGET	-7	提供了无效目标。
ERR_TIRED	-11	该 creep 的疲劳(fatigue)计数器不为零。

notifyWhenAttacked(enabled)

Game.powerCreeps['PC1'].notifyWhenAttacked(true);

当 creep 受到攻击时切换自动通知。通知将发送到您的帐户邮箱。默认情况下启用。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个creep的拥有者。
ERR_BUSY	-4	该 power creep 还没有出生。
ERR_INVALID_ARGS	-10	enable 参数不是 boolean 值。

pickup(target)

const target = creep.pos.findClosestByRange(FIND_DROPPED_RESOURCES);
if(target) {
    if(creep.pickup(target) == ERR_NOT_IN_RANGE) {
        creep.moveTo(target);
    }
}

捡起一个物品 (如捡起一些能量)。目标必须在紧邻 creep 的正方形区域中或者和 creep 在相同位置。

parameter	type	description
target	Resource	要捡起的目标对象。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个creep的拥有者。
ERR_BUSY	-4	该 power creep 还没有出生。
ERR_INVALID_TARGET	-7	目标不是一个有效的可拾取对象。
ERR_FULL	-8	该 creep 已无法存储更多资源。
ERR_NOT_IN_RANGE	-9	目标太远了。

rename(name)

Game.powerCreeps['PC1'].rename('PC1X');

重命名 power creep。该 creep 必须尚未出生。

parameter	type	description
name	string	power creep 的新名字。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是该 creep 的所有者。
ERR_NAME_EXISTS	-3	指定的名称已经被已存在的 power creep 使用。
ERR_BUSY	-4	power creep 已经出生。

renew(target)

let powerBank = Game.getObjectById('XXX');
Game.powerCreeps['PowerCreep1'].renew(powerBank);

立刻使用一个 Power Spawn 或者附近的 Power Bank 恢复最大的存活时间。目标必须在相邻的地块上。

parameter	type	description
target	StructurePowerBank | StructurePowerSpawn	目标建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个creep的拥有者。
ERR_BUSY	-4	该 power creep 还没有出生。
ERR_INVALID_TARGET	-7	目标不是一个有效的 power bank 对象。
ERR_NOT_IN_RANGE	-9	目标太远了。

say(message, [public])

const hostiles = creep.pos.findInRange(FIND_HOSTILE_CREEPS, 10);
if(hostiles.length > 0) {
    creep.say('OMG!😨');
    creep.moveTo(Game.spawns['Spawn1']);
}
else {
    doWork(creep);
}

在该 creep 上显示带有指定内容的可视对话气泡。此信息只会显示 1 tick。你可以通过 saying 属性获取说过的最后一条信息。允许使用任何有效的 Unicode 字符。包括 emoji。

parameter	type	description
message	string	要显示的信息，最长 10 字符。
public (可选)	boolean	设置为 true 来让其他玩家也能看到该信息。默认为 false。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个creep的拥有者。
ERR_BUSY	-4	该 power creep 还没有出生。

spawn(powerSpawn)

Game.powerCreeps['PowerCreep1'].spawn(Game.getObjectById('XXX'));

使用指定的 Power Spawn 孵化该 power creep。

parameter	type	description
powerSpawn	StructurePowerSpawn	您的 Power Spawn 建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	您不是该 creep 或者 spawn 的所有者。
ERR_BUSY	-4	该 power creep 已经出生了。
ERR_INVALID_TARGET	-7	指定的对象不是一个 Power Spawn。
ERR_TIRED	-11	由于 power creep 仍在冷却中导致其无法生成。
ERR_RCL_NOT_ENOUGH	-14	房间控制等级（RCL）不足以使用该 spawn。

suicide()

立刻杀死一个 power creep。这不会永久的删除它，而是将其转为未孵化状态， 所以你可以重新 spawn 它。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个creep的拥有者。
ERR_BUSY	-4	该 power creep 还没有出生。

transfer(target, resourceType, [amount])

if(creep.transfer(storage, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
    creep.moveTo(storage);
}

// 转移所有资源
for(const resourceType in creep.carry) {
    creep.transfer(storage, resourceType);
}

将资源从该 creep 转移至其他对象。目标必须在紧邻 creep 的正方形区域中。

parameter	type	description
target	Creep, Structure	The target object.
resourceType	string	RESOURCE_*常量之一。
amount (可选)	number	要转移的资源数量。如果省略，将转移携带的全部指定资源。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个creep的拥有者。
ERR_BUSY	-4	该 power creep 还没有出生。
ERR_NOT_ENOUGH_RESOURCES	-6	该 creep 没有携带足够的资源。
ERR_INVALID_TARGET	-7	目标不是一个能存放指定资源的有效对象。
ERR_FULL	-8	目标无法携带更多的资源。
ERR_NOT_IN_RANGE	-9	目标太远了。
ERR_INVALID_ARGS	-10	resourceType 不是 RESOURCE_* 常量之一，或者 amount 数量错误。

upgrade(power)

Game.powerCreeps['PowerCreep1'].upgrade(PWR_GENERATE_OPS);

升级该 creep，给它添加一个新的 power 能力或者升级已存在的 power 能力。 你账户中需要有一个空闲的 Power Level 才能执行该操作。

parameter	type	description
power	number	要升级的 power，PWR_* 常量之一。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是该 creep 的所有者。
ERR_NOT_ENOUGH_RESOURCES	-6	您账户中的 Power Level 不足。
ERR_FULL	-8	该 creep 的等级不允许升级指定的 power，或者 creep 已经到达了最大等级。
ERR_INVALID_ARGS	-10	指定了无效的 power ID。

usePower(power, [target])

Game.powerCreeps['PowerCreep1'].usePower(PWR_GENERATE_OPS);

Game.powerCreeps['PowerCreep1'].usePower(PWR_OPERATE_SPAWN, Game.spawns['Spawn1']);

在指定目标上附加该 creep 的 power。 你只能在没有控制器或者 power-enabled 的控制器所在的房间中使用 power。 同一 tick 中只能使用一种 power，每个 usePower 调用都将覆盖前一个。 如果目标拥有较低或相同等级的效果，则将已存在的效果覆盖。如果已存在的效果等级更高，则返回一个错误码。

可用 power 的完整列表

parameter	type	description
power	number	要使用的 power 能力，PWR_*常量之一。
target	RoomObject	房间中的指定目标。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是该 creep 的所有者。
ERR_BUSY	-4	该 creep 还没有出生。
ERR_NOT_ENOUGH_RESOURCES	-6	该 creep 没有足够的资源来使用这个 power。
ERR_INVALID_TARGET	-7	指定了无效的目标。
ERR_FULL	-8	目标拥有相同或更高等级的已激活效果。
ERR_NOT_IN_RANGE	-9	指定目标距离过远。
ERR_INVALID_ARGS	-10	该房间控制器还没有启用 power。
ERR_TIRED	-11	该 power 能力仍在冷却中。
ERR_NO_BODYPART	-12	该 creep 没有指定的 power 能力。

withdraw(target, resourceType, [amount])

if(creep.withdraw(storage, RESOURCE_ENERGY) == ERR_NOT_IN_RANGE) {
    creep.moveTo(storage);
}

从建筑(structure)或是墓碑(tombstone)中拿取资源。目标必须在紧邻 creep 的正方形区域中。多个 creep 可以在同一 tick 里从相同对象中拿取资源。你的 creep 同样也可以从敌对建筑/墓碑中拿取资源，如果它上面没有敌对的 rampart 的话。

此方法不应该被用来在 creep 之间转移资源。想要在 creep 之间转移，请对携带资源的 creep 执行 transfer 方法。

parameter	type	description
target	Structure, Tombstone	目标对象。
resourceType	string	RESOURCE_*常量之一。
amount (可选)	number	被传递资源的数量。如果没有这个参数，传递全部可用数量的资源。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是此 creep 的所有者，或者目标位于敌方 rampart 之下。
ERR_BUSY	-4	该 power creep 还没有出生。
ERR_NOT_ENOUGH_RESOURCES	-6	目标中没有足够数量的资源。
ERR_INVALID_TARGET	-7	目标不是一个能存储指定资源的对象。
ERR_FULL	-8	此 creep 的存储已经满了。
ERR_NOT_IN_RANGE	-9	目标太远了。
ERR_INVALID_ARGS	-10	resourceType 不是 RESOURCE_* 常量之一, 或者 amount 数量错误。

Resource

掉落的资源。 如果没有拿起，它会在一段时间后消失。 掉落的资源以每tickceil(amount/1000)的速度消失。

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

amountnumber

资源数量。

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

resourceTypestring

RESOURCE_*常量之一。

Room

一个代表了你的单位和建筑所在房间的对象。 它可以被用来“环顾四周”，查找路径等。所有 RoomObject 都有一个链接到其所在房间 Room 实例的属性 room。

controllerStructureController

该房间中的控制器（Controller）建筑，如果其不存在则返回 undefined。

energyAvailablenumber

本房间中所有 spawn 和 extension 中的可用能量总额。

energyCapacityAvailablenumber

本房间中所有 spawn 和 extension 的容量上限 energyCapacity 总额。

memoryany

room.memory.stage = 2;

Memory.rooms[room.name] 的简写。你可以用它来快速访问到该房间特定的内存数据对象。点此了解有关内存的更多信息。

namestring

房间名称。

storageStructureStorage

该房间中的 Storage 建筑，如果其不存在则返回 undefined。

terminalStructureTerminal

该房间中的 Terminal 建筑，如果其不存在则返回 undefined。

visualRoomVisual

该房间的 RoomVisual 对象。您可以使用该对象在房间中绘制简单的形状 (线条，圆，文本标签)。

Room.serializePath(path)

const path = spawn.pos.findPathTo(source);
Memory.path = Room.serializePath(path);
creep.moveByPath(Memory.path);

将路径数组序列化为适合存储在内存中的短字符串形式。

parameter	type	description
path	array	Room.findPath 返回的路径数组。

返回值

参数路径的序列化字符串。

Room.deserializePath(path)

const path = Room.deserializePath(Memory.path);
creep.moveByPath(path);

将短字符串形式的路径反序列化为路径数组。

parameter	type	description
path	string	一个序列化路径字符串。

返回值

一个路径数组

createConstructionSite(x, y, structureType, [name])
(pos, structureType, [name])

Game.rooms.sim.createConstructionSite(10, 15, STRUCTURE_ROAD);

Game.rooms.sim.createConstructionSite(10, 15, STRUCTURE_SPAWN,
    'MySpawn2');

在指定位置创建一个新的 ConstructionSite。

parameter	type	description
x	number	X 坐标。
y	number	Y 坐标。
pos	object	可以为 RoomPosition 对象或任何包含 RoomPosition 的对象。
structureType	string	STRUCTURE_* 常量之一。
name (可选)	string	建筑的名称，该建筑必须支持设置名字（当前仅有 spawn）。最长不能超过 100 个字符。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	该房间被敌对玩家占领（claim）或预定（reserve）。
ERR_INVALID_TARGET	-7	T该建筑无法被放置在指定位置。
ERR_FULL	-8	你已经放置了太多建筑工地。其上限为 100。
ERR_INVALID_ARGS	-10	不正确的位置。
ERR_RCL_NOT_ENOUGH	-14	房间控制器级别不足。了解更多

createFlag(x, y, [name], [color], [secondaryColor])
(pos, [name], [color], [secondaryColor])

Game.rooms.sim.createFlag(5, 12, 'Flag1');

在指定位置创建一个新的 Flag。

parameter	type	description
x	number	X 坐标。
y	number	Y 坐标。
pos	object	可以为 RoomPosition 对象或任何包含 RoomPosition 的对象。
name (可选)	string	新旗帜的名称。它应该是唯一的，即 Game.flags 不应该包含拥有相同名称（哈希键）的其他旗帜。如果未定义，则会生成随机名称。最长不得超过 100 字符。
color (可选)	string	新旗帜的颜色。应为 COLOR_* 常量之一。默认值为 COLOR_WHITE。
secondaryColor (可选)	string	新旗帜的次要颜色。应为 COLOR_* 常量之一。默认值等于 color 属性值。

返回值

新旗帜的名称，或者下列错误码之一：

constant	value	description
ERR_NAME_EXISTS	-3	该名称已被现有的旗帜使用。
ERR_FULL	-8	你放置了太多旗帜，每个玩家最多允许放置 10000 个旗帜。
ERR_INVALID_ARGS	-10	位置、名称或者颜色不正确。

find(type, [opts])

const targets = creep.room.find(FIND_DROPPED_RESOURCES);
if(targets.length) {
    creep.moveTo(targets[0]);
    creep.pickup(targets[0]);
}

const extensions = Game.spawns['Spawn1'].room.find(FIND_MY_STRUCTURES, {
    filter: { structureType: STRUCTURE_EXTENSION }
});
console.log('Spawn has '+extensions.length+' extensions available');

const targets = creep.room.find(FIND_HOSTILE_CREEPS, {
    filter: function(object) {
        return object.getActiveBodyparts(ATTACK) == 0;
    }
});

查找房间中指定类型的所有对象。在应用自定义的 filter 之前，搜索结果会被自动缓存到指定的房间和类型，自动缓存将持续到本 tick 结束。

parameter	type	description
type	number	FIND_* 常量之一。
opts (可选)	object	包含下列可选项的对象： filter object, function, string 将会使用 Lodash.filter 方法对结果列表进行筛选。

返回值

找到的对象数组

常量	类型	介绍
FIND_EXIT_TOP	RoomPosition	位于房间顶部的出口位置。
FIND_EXIT_RIGHT	RoomPosition	位于房间右侧的出口位置。
FIND_EXIT_BOTTOM	RoomPosition	位于房间底部的出口位置。
FIND_EXIT_LEFT	RoomPosition	位于房间左侧的出口位置。
FIND_EXIT	RoomPosition	所有出口位置。
FIND_CREEPS	Creep	所有 creep。
FIND_MY_CREEPS	Creep	所有属于您的 creep。
FIND_HOSTILE_CREEPS	Creep	所有不属于您的 creep。
FIND_SOURCES_ACTIVE	Source	仍有能量的 source。
FIND_SOURCES	Source	所有 source。
FIND_DROPPED_RESOURCES	Resource	所有掉落的资源。
FIND_STRUCTURES	Structure	所有建筑。
FIND_MY_STRUCTURES	Structure	所有属于您的建筑，不包含中立建筑。
FIND_HOSTILE_STRUCTURES	Structure	所有其他玩家的建筑，不包含中立建筑。
FIND_FLAGS	Flag	所有旗帜。
FIND_MY_SPAWNS	StructureSpawn	所有属于您的 spawn。
FIND_HOSTILE_SPAWNS	StructureSpawn	所有其他玩家的 spawn。
FIND_CONSTRUCTION_SITES	ConstructionSite	所有建筑工地。
FIND_MY_CONSTRUCTION_SITES	ConstructionSite	所有属于您的建筑工地。
FIND_HOSTILE_CONSTRUCTION_SITES	ConstructionSite	所有其他玩家的建筑工地。
FIND_MINERALS	Mineral	所有矿床。
FIND_NUKES	Nuke	所有将落地的核弹。
FIND_TOMBSTONES	Tombstone	所有墓碑。
FIND_RUINS	Ruin	所有废墟。

findExitTo(room)

const exitDir = creep.room.findExitTo(anotherCreep.room);
const exit = creep.pos.findClosestByRange(exitDir);
creep.moveTo(exit);

// 或简写为：
creep.moveTo(anotherCreep);
creep.moveTo(new RoomPosition(25,25, anotherCreep.pos.roomName));

找到通往另一个房间的出口方向。请注意，房间之间的移动不需要此方法，您只需将另一个房间中的目标传递给 Creep.moveTo 方法即可。

parameter	type	description
room	string, Room	其他房间的名称或者房间对象。

返回值

出口方向常量，下列之一：

• FIND_EXIT_TOP
• FIND_EXIT_RIGHT
• FIND_EXIT_BOTTOM
• FIND_EXIT_LEFT

或者下列错误码之一：

constant	value	description
ERR_NO_PATH	-2	无法找到路径。
ERR_INVALID_ARGS	-10	不正确的位置。

findPath(fromPos, toPos, [opts])

const path = creep.room.findPath(creep.pos, targetPos);
creep.move(path[0].direction);

PathFinder.use(true);
const path = creep.room.findPath(creep.pos, targetPos, {
    costCallback: function(roomName, costMatrix) {
        if(roomName == 'W1N5') {
            // 将其他 creep 所处位置设置为可通过
            costMatrix.set(anotherCreep.pos.x, anotherCreep.pos.y, 0);
            // 将旗帜的位置设置为障碍
            costMatrix.set(flag.pos.x, flag.pos.y, 255);
            // 将位置 (25,20) 的移动成本设置为 50
            costMatrix.set(25, 20, 50);
        }
    }
});

let path = creep.room.findPath(creep.pos, targetPos, {maxOps: 200});
if( !path.length || !targetPos.isEqualTo(path[path.length - 1]) ) {
    path = creep.room.findPath(creep.pos, targetPos, {
        maxOps: 1000, ignoreDestructibleStructures: true
    });
}
if( path.length ) {
    creep.move(path[0].direction);
}

使用跳点搜索算法 (Jump Point Search) 在 fromPos 和 toPos 之间找到房间内的最佳路径。

parameter	type	description
fromPos	RoomPosition	起始位置。
toPos	RoomPosition	结束位置。
opts (可选)	object	包含下列寻路可选项的对象： ignoreCreeps boolean 将其他 creep 所处的地块视作可通行的。在附近有大量移动的 creep 或者其他一些情况时会很有用。默认值为 false。 ignoreDestructibleStructures boolean 将可破坏的建筑 (constructed walls, ramparts, spawns, extensions) 所在的地块视作可通行的。默认为 false。 ignoreRoads boolean 无视道路。启用该项将加快搜索速度。默认值为 false。仅当新的 PathFinder 启用时才可用。 costCallback function(string, CostMatrix) 你可以使用该回调在搜索过程中为任意房间修改 CostMatrix。回调接受两个参数，roomName 和 costMatrix。使用 costMatrix 实例来修改地形移动成本。如果你从回调中返回了一个新的 matrix。它将会代替内置的缓存 matrix。仅当新的 PathFinder 启用时才可用。 ignore array 一个数组，其元素为房间中的对象或者 RoomPosition 对象，在搜索时会将该数组中的对象位置视作可通行的地块。当启用新的 PathFinder 时无法使用。（请用 costCallback 选项代替）。 avoid array 一个数组，其元素为房间中的对象或者 RoomPosition 对象，在搜索时会将该数组中的对象位置视作无法通行的地块。当启用新的 PathFinder 时无法使用。（请用 costCallback 选项代替）。 maxOps number 用于寻路的消耗上限。你可以限制在寻路上花费的 CPU 时间，基于 1 op ~ 0.001 CPU 的比例。默认值为 2000。 heuristicWeight number 应用于 A* 算法 F = G + weight * H 中的启发式权重(weight)。在使用该选项之前您最好已经了解了 A* 算法的底层实现！默认值为 1.2。 serialize boolean 如果为 true，将会使用 Room.serializePath 对结果路径进行序列化。默认值为 false。 maxRooms number 寻路所允许的最大房间数。默认值为 16。仅当新的 PathFinder 启用时才可用。 range number 找到到达位于目标指定线性区域内位置的路径。默认值为 0. plainCost number 平原地形的移动成本。默认为 1。 swampCost number 沼泽地形的移动成本。默认为 5。

返回值

一个数组，其元素为如下形式的路径步骤：

[
    { x: 10, y: 5, dx: 1,  dy: 0, direction: RIGHT },
    { x: 10, y: 6, dx: 0,  dy: 1, direction: BOTTOM },
    { x: 9,  y: 7, dx: -1, dy: 1, direction: BOTTOM_LEFT },
    ...
]

getEventLog([raw])

// 追踪特定 creep 执行的事件
_.filter(creep.room.getEventLog(), {objectId: creep.id});

// 查找针对您的 creep 和建筑的所有敌对行动
_.forEach(Game.rooms, room => {
    let eventLog = room.getEventLog();
    let attackEvents = _.filter(eventLog, {event: EVENT_ATTACK});
    attackEvents.forEach(event => {
        let target = Game.getObjectById(event.data.targetId);
        if(target && target.my) {
            console.log(event);
        }
    });
});

返回该房间中前一个 tick 发生的事件数组。

parameter	type	description
raw	boolean	如果该参数为 false 或者未定义，则本方法将会返回使用 JSON.parse 解析后的对象，在首次访问时可能会造成一些 CPU 消耗（返回值会被缓存以方便后续调用）。如果 raw 为 true。则原始的 JSON 字符串将会被返回。

返回值

事件数组。每个事件都代表一个游戏动作，其格式如下：

{
    event: EVENT_ATTACK,
    objectId: '54bff72ab32a10f73a57d017',
    data: { /* ... */ }
}

不同类型事件的 data 属性都是不相同的，详见下表：

事件	介绍
EVENT_ATTACK	一个 creep 或者建筑攻击了另一个对象。 targetId - 目标对象 ID damage - 造成的 hit 伤害量 attackType - 下列常量之一： EVENT_ATTACK_TYPE_MELEE - creep 使用 attack 进行了攻击 EVENT_ATTACK_TYPE_RANGED - creep 使用 rangedAttack 进行了攻击，或者 tower 使用 attack 进行了攻击 EVENT_ATTACK_TYPE_RANGED_MASS - creep 使用 rangedMassAttack 进行了攻击 EVENT_ATTACK_TYPE_DISMANTLE - creep 使用 dismantle 进行了攻击 EVENT_ATTACK_TYPE_HIT_BACK - creep 反击了其他 creep 的 attack 攻击 EVENT_ATTACK_TYPE_NUKE - 核弹着陆
EVENT_OBJECT_DESTROYED	一个游戏对象被摧毁或是被消灭。 type - 被摧毁对象的类型
EVENT_ATTACK_CONTROLLER	一个 creep 在该房间执行了 attackController
EVENT_BUILD	一个 creep 在该房间执行了 build。 targetId - 目标对象的 ID amount - 取得的建造进度 energySpent - 此次行动消耗的能量
EVENT_HARVEST	一个 creep 在该房间执行了 harvest。 targetId - 目标对象的 ID amount - 资源采集量
EVENT_HEAL	一个 creep 或者 tower 治疗了另一个 creep。 targetId - 目标对象的 ID amount - hit 治疗量 healType - 下列常量之一: EVENT_HEAL_TYPE_MELEE - 一个 creep 使用 heal 进行了治疗 EVENT_HEAL_TYPE_RANGED - 一个 creep 使用 rangedHeal进行了治疗，或者一个 tower 使用 heal 进行了治疗
EVENT_REPAIR	一个 creep 或者 tower 修复了建筑。 targetId - 目标对象 ID amount - hit 修复量 energySpent - 此次行动消耗的能量
EVENT_RESERVE_CONTROLLER	一个 creep 在该房间执行了 reserveController。 amount - 取得的预定时间
EVENT_UPGRADE_CONTROLLER	一个 creep 在该房间执行了 upgradeController。 amount - 获得的控制点数（control points） energySpent - 此次行动消耗的能量
EVENT_EXIT	一个 creep 移动到了其他房间。 room - 目标房间的名称 x, y - creep 将要出现在其他房间的坐标位置
EVENT_TRANSFER	一个 link 执行了 transferEnergy 或者一个 creep 执行了 transfer 或 withdraw。 targetId - 目标对象 ID resourceType - 被转移的资源类型 amount - 被转移的资源总量

getPositionAt(x, y)

const pos = Game.rooms.sim.getPositionAt(5,12);
const source = pos.findClosestByRange(FIND_SOURCES_ACTIVE);

获取指定位置的 RoomPosition 对象。

parameter	type	description
x	number	X 坐标。
y	number	Y 坐标。

返回值

一个 RoomPosition 对象，如果无法获取则返回 null。

getTerrain()

const terrain = Game.rooms['W1N1'].getTerrain();
switch(terrain.get(10,15)) {
    case TERRAIN_MASK_WALL:
        break;
    case TERRAIN_MASK_SWAMP:
        break;
    case 0:
        break;
}

获取一个 Room.Terrain 对象，可以用它来快速访问房间内的静态地形数据。即使没有指定房间的视野，您依旧可以使用该方法访问它的地形数据，该方法适用于游戏世界中的所有房间。

返回值

返回一个新的 Room.Terrain 对象。

lookAt(x, y)
(target)

const look = creep.room.lookAt(target);
look.forEach(function(lookObject) {
    if(lookObject.type == LOOK_CREEPS &&
       lookObject[LOOK_CREEPS].getActiveBodyparts(ATTACK) == 0) {
        creep.moveTo(lookObject.creep);
    }
});

获取指定房间位置的对象数组。

parameter	type	description
x	number	该房间中的 X 坐标。
y	number	该房间中的 Y 坐标。
target	object	可以是 RoomPosition 对象或者任何包含 RoomPosition 属性的对象。

返回值

一个位于指定位置的对象数组，格式如下：

[
    { type: 'creep', creep: {...} },
    { type: 'structure', structure: {...} },
    ...
    { type: 'terrain', terrain: 'swamp' }
]

lookAtArea(top, left, bottom, right, [asArray])

const look = creep.room.lookAtArea(10,5,11,7);

获取指定房间区域内的对象列表。

parameter	type	description
top	number	区域顶部边界的 Y 坐标。
left	number	区域左侧边界的 X 坐标。
bottom	number	区域底部边界的 Y 坐标。
right	number	区域右侧边界的 X 坐标。
asArray (可选)	boolean	设为 true 来获得纯数组形式。

返回值

如果 asArray 值为 false 或者未定义，则该方法以如下格式返回指定区域内的对象：

// 10,5,11,7

{
    10: {
        5: [{ type: 'creep', creep: {...} },
            { type: 'terrain', terrain: 'swamp' }],
        6: [{ type: 'terrain', terrain: 'swamp' }],
        7: [{ type: 'terrain', terrain: 'swamp' }]
    },
    11: {
        5: [{ type: 'terrain', terrain: 'plain' }],
        6: [{ type: 'structure', structure: {...} },
            { type: 'terrain', terrain: 'swamp' }],
        7: [{ type: 'terrain', terrain: 'wall' }]
    }
}

如果 asArray 值为 true，则该方法以如下格式返回指定区域内的对象数组：

[
    {x: 5, y: 10, type: 'creep', creep: {...}},
    {x: 5, y: 10, type: 'terrain', terrain: 'swamp'},
    {x: 6, y: 10, type: 'terrain', terrain: 'swamp'},
    {x: 7, y: 10, type: 'terrain', terrain: 'swamp'},
    {x: 5, y: 11, type: 'terrain', terrain: 'plain'},
    {x: 6, y: 11, type: 'structure', structure: {...}},
    {x: 6, y: 11, type: 'terrain', terrain: 'swamp'},
    {x: 7, y: 11, type: 'terrain', terrain: 'wall'}
]

lookForAt(type, x, y)
(type, target)

const found = creep.room.lookForAt(LOOK_CREEPS, target);
if(found.length && found[0].getActiveBodyparts(ATTACK) == 0) {
    creep.moveTo(found[0]);
}

在指定位置查找指定类型的对象。

parameter	type	description
type	string	LOOK_* 常量之一。
x	number	该房间中的 X 坐标。
y	number	该房间中的 Y 坐标。
target	object	可以是 RoomPosition 对象或者任何包含 RoomPosition 属性的对象。

返回值

在指定位置找到的指定类型的对象数组。

lookForAtArea(type, top, left, bottom, right, [asArray])

const look = creep.room.lookForAtArea(LOOK_STRUCTURES,10,5,11,7);

在指定房间区域查找指定类型的对象列表。

parameter	type	description
type	string	LOOK_* 常量之一
top	number	区域顶部边界的 Y 坐标。
left	number	区域左侧边界的 X 坐标。
bottom	number	区域底部边界的 Y 坐标。
right	number	区域右侧边界的 X 坐标。
asArray (可选)	boolean	设为 true 来获得纯数组形式。

返回值

如果 asArray 值为 false 或者未定义，则该方法以如下格式返回指定区域内的对象：

// 10,5,11,7

{
    10: {
        5: [{...}],
        6: undefined,
        7: undefined
    },
    11: {
        5: undefined,
        6: [{...}, {...}],
        7: undefined
    }
}

如果 asArray 值为 true，则该方法以如下格式返回指定区域内的对象数组：

[
    {x: 5, y: 10, structure: {...}},
    {x: 6, y: 11, structure: {...}},
    {x: 6, y: 11, structure: {...}}
]

Room.Terrain

提供快速访问房间地形数据的对象。您可以为游戏世界中的任何房间构造这些对象，即使没有该房间的视野。

从技术上讲，每个 Room.Terrain 对象都是一个非常轻量级的适配器，用于提供具有最小访问权限的静态地形缓冲区。

constructor(roomName)

const terrain = new Room.Terrain("E2S7");

const terrain = new Room.Terrain(Game.creeps.John.room.name);

通过房间名称创建一个新的 Terrain。Terrain 对象可以从游戏世界中的任何房间构造，即使没有该房间的视野。

parameter	type	description
roomName	string	房间名称。

get(x, y)

switch(terrain.get(10,15)) {
    case TERRAIN_MASK_WALL:
        break;
    case TERRAIN_MASK_SWAMP:
        break;
    case 0:
        break;
}

const roomName = "E2S7";
const terrain = new Room.Terrain(roomName);
const matrix = new PathFinder.CostMatrix;
const visual = new RoomVisual(roomName);

// 用默认地形成本填充 CostMatrix，以供将来分析：
for(let y = 0; y < 50; y++) {
    for(let x = 0; x < 50; x++) {
        const tile = terrain.get(x, y);
        const weight =
            tile === TERRAIN_MASK_WALL  ? 255 : // 墙壁 => 无法通行
            tile === TERRAIN_MASK_SWAMP ?   5 : // 沼泽 => 移动成本:  5
                                            1 ; // 平原 => 移动成本:  1
        matrix.set(x, y, weight);
        visual.text(weight, x, y);
    }
}

// 绑定到 WASM module heap
const heapView = new Uint8Array(wasmModule.HEAPU8.buffer, ...); 
const terrain = new Room.Terrain("E2S7");

// 将地形数据复制到二进制 WASM module heap：
for(let y = 0; y < 50; y++) {
    for(let x = 0; x < 50; x++) {
        heapView[y * 50 + x] = terrain.get(x, y);
    }    
}

通过 (x,y) 坐标获取指定房间位置处的地形。和 Game.map.getTerrainAt(...) 方法不同，此方法不执行任何字符串操作，并返回整数 terrain 类型值（详见下文）。

parameter	type	description
x	number	该房间中的 X 坐标。
y	number	该房间中的 Y 坐标。

返回值

以下整数值之一：

值	常量名 (如果存在)	介绍
0	不存在	地形为 plain
1	TERRAIN_MASK_WALL	地形为 wall
2	TERRAIN_MASK_SWAMP	地形为 swamp

getRawBuffer([destinationArray])

function myPrintRawTerain(raw) {
    const visual = new RoomVisual();
    for(let y = 0; y < 50; y++) {
        for(let x = 0; x < 50; x++) {
            const code = raw[y * 50 + x];
            const color =
                (code & TERRAIN_MASK_WALL ) ? "gray"  :
                (code & TERRAIN_MASK_SWAMP) ? "green" : "white" ;
            visual.circle(x, y, {fill: color, radius: 0.5});
        }
    }
}

const raw = (new Room.Terrain("E2S7")).getRawBuffer();
myPrintRawTerain(raw);

// 绑定到 WASM module heap
const heapView = new Uint8Array(wasmModule.HEAPU8.buffer, ...); 
const terrain = new Room.Terrain("E2S7");

// 快速将地形数据复制到 WASM module heap:
const t = Game.cpu.getUsed();
const result = terrain.getRawBuffer(heapView);
if(result !== ERR_INVALID_ARGS) {
    // 复制成功，在此处调用 WASM 函数：
    // wasmModule.myFunc(...); // 修改 "heapView" 的原始内存
    console.log("Distance transform done in", Game.cpu.getUsed() - t);
    myPrintRawTerain(heapView);
}

// 二进制模块内的某处源代码...
void myFunc(void* ptr) {
    auto u8ptr = static_cast<uint8_t*>(ptr);
    // 在这里进行计算...
}

获取基础静态地形缓冲区的副本。 当前使用的基础类型为 Uint8Array。

parameter	type	description
destinationArray (可选)	Uint8Array	地形数据要拷贝到的已定义的数组视图。

警告: 此方法依赖于地形数据的基础类型。此方法是获取整个房间（2500 地块）地形数据的最快方法，但是使用者需要始终牢记，该方法可能随时会被标记为已弃用。或者返回值的类型可能会因为基础类型的改变而改变。

请查看使用示例。点击 二进制模块 来了解更多。

返回值

基础房间地形数据的副本，存放在大小为 2500 的新 Uint8Array 类型数组（typed array）中。

每一个元素都是整数，地形类型可以通过对相应的 TERRAIN_MASK_* 常量执行位运算“与”（&）来获得。房间地块按行存储。

如果指定了 destinationArray 并且成功复制，则函数将会返回已填充 destinationArray 的引用，否则返回下列错误码：

constant	value	description
ERR_INVALID_ARGS	-10	destinationArray 类型不兼容。

RoomObject

房间中所有具有坐标的对象。几乎所有的游戏对象原型都是从RoomObject派生出来的。

effectsarray

附加的效果，一个对象数组包含如下属性：

parameter	type	description
power	number	被应用的效果id。可以是自然效果或者超能效果。
level	number	被应用的效果等级。如果不是超能效果的话则不存在。
ticksRemaining	number	多长时间之后会失去这个效果。

posRoomPosition

表示该对象在房间中的坐标的对象。

roomRoom

Room 对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为 undefined。

RoomPosition

表示房间中指定位置的对象。房间中的每个 RoomObject 都通过其 pos 属性链接到对应的 RoomPosition 上。可以使用 Room.getPositionAt 或者构造函数创建自定义地点的位置对象。

constructor(x, y, roomName)

const pos = new RoomPosition(10, 25, 'sim');

你可以使用其构造函数创建一个新的 RoomPosition 对象。

parameter	type	description
x	number	房间中的 X 坐标。
y	number	房间中的 Y 坐标。
roomName	string	房间名称。

roomNamestring

所处房间的名称。

xnumber

所处房间的 X 坐标。

ynumber

所处房间的 Y 坐标。

createConstructionSite(structureType, [name])

Game.flags['Flag1'].pos.createConstructionSite(STRUCTURE_ROAD);

Game.flags['Flag1'].pos.createConstructionSite(STRUCTURE_SPAWN, 'MySpawn2');

在指定位置创建新的 ConstructionSite。

parameter	type	description
structureType	string	STRUCTURE_* 常量之一。
name (可选)	string	建筑的名称，该建筑必须支持设置名字（当前仅有 spawn）。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_INVALID_TARGET	-7	该建筑无法被放置在指定位置。
ERR_FULL	-8	你已经放置了太多建筑工地。其上限为 100。
ERR_INVALID_ARGS	-10	不正确的位置。
ERR_RCL_NOT_ENOUGH	-14	房间控制器等级不足。了解更多

createFlag([name], [color], [secondaryColor])

creep.pos.createFlag('Flag1');

在指定位置创建一个新的 Flag。

parameter	type	description
name (可选)	string	新旗帜的名称。它应该是唯一的，即 Game.flags 不应该包含拥有相同名称(哈希键)的不同旗帜。如果未定义，则会生成随机名称。最长不得超过 60 字符。
color (可选)	string	新旗帜的颜色。应为 COLOR_* 常量之一。默认值为 COLOR_WHITE。
secondaryColor (可选)	string	新旗帜的次要颜色。应为 COLOR_* 常量之一。默认值等于 color 属性值。

返回值

新旗帜的名称，或者下列错误码之一：

constant	value	description
ERR_NAME_EXISTS	-3	该名称已被现有的旗帜使用。
ERR_INVALID_ARGS	-10	位置或者颜色不正确。

findClosestByPath(type, [opts])
(objects, [opts])

const target = creep.pos.findClosestByPath(FIND_MY_SPAWNS);
creep.moveTo(target);

const target = creep.pos.findClosestByPath(FIND_MY_SPAWNS, {maxOps: 500});
creep.moveTo(target);

const target = creep.pos.findClosestByPath(FIND_HOSTILE_CREEPS, {
    filter: function(object) {
        return object.getActiveBodyparts(ATTACK) == 0;
    }
});

const target = creep.pos.findClosestByPath(FIND_HOSTILE_CREEPS, {
    filter: { owner: { username: 'Invader' } }
});

const targets = [
    Game.creeps.John,
    Game.creeps.Mike,
    room.getPositionAt(10,10)
];
const closest = creep.pos.findClosestByPath(targets);

查找到该位置路径最短的对象。使用跳点搜索（Jump Point Search）算法和 Dijkstra's 算法进行搜索。

parameter	type	description
type	number	详见 Room.find。
objects	array	要执行搜索的房间对象数组或者 RoomPosition 对象数组。
opts (可选)	object	一个对象，包含了寻路选项（详见 Room.findPath），或下列属性： filter object, function, string 只有通过筛选器的对象才会被使用，由 Lodash.filter 执行筛选。 algorithm string 下列常量之一： astar 当可能存在的目标相对较少时运行速度更快； dijkstra 当可能存在的目标较多或者附近就有最近的目标时，速度会更快。 默认算法是使用启发法自行决定的。

返回值

返回找到的最近对象，没找到则返回 null。

findClosestByRange(type, [opts])
(objects, [opts])

const target = creep.pos.findClosestByRange(FIND_MY_SPAWNS);
creep.moveTo(target);

const target = creep.pos.findClosestByRange(FIND_HOSTILE_CREEPS, {
    filter: function(object) {
        return object.getActiveBodyparts(ATTACK) == 0;
    }
});

const target = creep.pos.findClosestByRange(FIND_HOSTILE_CREEPS, {
    filter: { owner: { username: 'Invader' } }
});

const targets = [
    Game.creeps.John,
    Game.creeps.Mike,
    room.getPositionAt(10,10)
];
const closest = creep.pos.findClosestByRange(targets);

查找到该位置线性距离最短的对象。

parameter	type	description
type	number	See Room.find.
objects	array	要执行搜索的房间对象数组或者 RoomPosition 对象数组。
opts (可选)	object	一个对象，包含下列选项： filter object, function, string 只有通过筛选器的对象才会被使用，由 Lodash.filter 执行筛选。

返回值

返回找到的最近对象，没找到则返回 null。

findInRange(type, range, [opts])
(objects, range, [opts])

const targets = creep.pos.findInRange(FIND_HOSTILE_CREEPS, 3);
if(targets.length > 0) {
    creep.rangedAttack(targets[0]);
}

const targets = [
    Game.creeps.John,
    Game.creeps.Mike,
    room.getPositionAt(10,10)
];
const inRangeTargets = creep.pos.findInRange(targets, 3);

查找在指定线性范围中的所有对象。

parameter	type	description
type	number	详见 Room.find。
objects	array	要执行搜索的房间对象数组或者 RoomPosition 对象数组。
range	number	范围距离（半径）。
opts (可选)	object	详见 Room.find。

返回值

找到的对象数组。

findPathTo(x, y, [opts])
(target, [opts])

const path = creep.pos.findPathTo(target);
creep.move(path[0].direction);

let path = creep.pos.findPathTo(target, {maxOps: 200});
if( !path.length || !target.equalsTo(path[path.length - 1]) ) {
    path = creep.pos.findPathTo(target,
        {maxOps: 1000, ignoreDestructibleStructures: true});
}
if( path.length ) {
    creep.move(path[0].direction);
}

使用 跳点搜索（Jump Point Search）算法查找到指定位置的最佳路径。该方法是 Room.findPath 的简写。如果目标在其他房间，则相应的出口将被作为目标。

parameter	type	description
x	number	该房间中的 X 坐标。
y	number	该房间中的 Y 坐标。
target	object	可以是 RoomPosition 对象或者任何包含 RoomPosition 属性的对象。
opts (可选)	object	一个对象，包含了寻路相关的选项标识 (查看 Room.findPath 来获得更多信息)。

返回值

一个如下格式的路径步骤（path step）数组：

[
    { x: 10, y: 5, dx: 1,  dy: 0, direction: RIGHT },
    { x: 10, y: 6, dx: 0,  dy: 1, direction: BOTTOM },
    { x: 9,  y: 7, dx: -1, dy: 1, direction: BOTTOM_LEFT },
    ...
]    

getDirectionTo(x,y)
(target)

const direction = creep.pos.getDirectionTo(target);
creep.move(direction);

获取到指定位置的直线方向。

parameter	type	description
x	number	房间中的 X 坐标。
y	number	房间中的 Y 坐标。
target	object	可以是 RoomPosition 对象或者任何包含 RoomPosition 属性的对象。

返回值

某一个方向常量的数字值。

getRangeTo(x,y)
(target)

const range = creep.pos.getRangeTo(target);
if(range <= 3) {
    creep.rangedAttack(target);
}

获取到指定位置的线性范围。

parameter	type	description
x	number	房间中的 X 坐标。
y	number	房间中的 Y 坐标。
target	object	可以是 RoomPosition 对象或者任何包含 RoomPosition 属性的对象。

返回值

到指定位置的地块数。

inRangeTo(x, y, range)
(target, range)

if(creep.pos.inRangeTo(target, 3)) {
    creep.rangedAttack(target);
}

检查该位置是否在其他位置的指定范围内。

parameter	type	description
x	number	房间中的 X 坐标。
y	number	房间中的 Y 坐标。
target	RoomPosition	目标位置
range	number	范围距离（半径）。

返回值

一个布尔值。

isEqualTo(x,y)
(target)

if(creep.pos.isEqualTo(10,25)) {
    creep.move(RIGHT);
}

if(creep.pos.isEqualTo(Game.flags.Flag1)) {
    creep.move(RIGHT);
}

检查该位置是否和指定位置相同。

parameter	type	description
x	number	房间中的 X 坐标。
y	number	房间中的 Y 坐标。
target	object	可以是 RoomPosition 对象或者任何包含 RoomPosition 属性的对象。

返回值

一个布尔值。

isNearTo(x,y)
(target)

if(creep.pos.isNearTo(target)) {
    creep.transfer(target, RESOURCE_ENERGY);
}

检查该位置是否在紧邻指定位置的正方形区域内。类似于 inRangeTo(target, 1)。

parameter	type	description
x	number	房间中的 X 坐标。
y	number	房间中的 Y 坐标。
target	object	可以是 RoomPosition 对象或者任何包含 RoomPosition 属性的对象。

返回值

一个布尔值。

look()

const look = Game.flags.Flag1.pos.look();
look.forEach(function(lookObject) {
    if(lookObject.type == LOOK_CREEPS &&
       lookObject[LOOK_CREEPS].getActiveBodyparts(ATTACK) == 0) {
        creep.moveTo(lookObject.creep);
    }
});

获取位于该位置的对象列表。

返回值

如下格式的数组，元素为位于该位置的所有对象。

[
    { type: 'creep', creep: {...} },
    { type: 'structure', structure: {...} },
    ...
    { type: 'terrain', terrain: 'swamp' }
]

lookFor(type)

const found = Game.flags.Flag1.pos.lookFor(LOOK_CREEPS);
if(found.length && found[0].getActiveBodyparts(ATTACK) == 0) {
    creep.moveTo(found[0]);
}

获取该位置上给定类型的对象列表。

parameter	type	description
type	string	LOOK_* 常量之一。

返回值

在该位置上找到的指定类型的对象数组。

RoomVisual

房间视觉效果提供了在游戏房间中显示可视化调试信息的途径。你可以使用 RoomVisual 对象绘制一个仅对您可见的简单图形。每一个已存在的 Room 对象都包含有 visual 属性，不过您也可以使用 constructor 给任何房间创建一个新的 RoomVisual 对象（即使没有视野）。

房间视觉效果并不会储存在数据库里，它们的目的仅仅是在您的浏览窗口里显示一些东西。所有绘制的图形只会保留 1 tick，如果后续没有更新的话就会消失。所有的 RoomVisual API 调用都不会产生 CPU 消耗（只会产生一些代码执行的自然成本，并且大多与简单的 JSON.serialize 调用有关）。然而，这里有一些使用限制：您最多只能为每个房间发布 500 KB 的序列化数据（详见 getSize 方法）。

所有的绘制坐标均等同于游戏坐标，并且以地块的中心为原点，即：(10, 10) 将指向位于 x:10; y:10 处 creep 的中心。允许使用小数坐标。

constructor([roomName])

Game.rooms['W10N10'].visual.circle(10,20).line(0,0,10,20);
// 等同于：
new RoomVisual('W10N10').circle(10,20).line(0,0,10,20);

// 所有房间都会显示该文本：
new RoomVisual().text('Some text', 1, 1, {align: 'left'}); 

您可以直接为任何房间创建 RoomVisual 对象，即使您的脚本没有该房间的视野。

parameter	type	description
roomName (可选)	string	房间的名称。如果未定义，则该效果将发布到所有房间。

roomNamestring

房间的名称。

line(x1, y1, x2, y2, [style])
(pos1, pos2, [style])

new RoomVisual('W1N1').line(10,15, 20,20);

creep.room.visual.line(creep.pos, target.pos,
    {color: 'red', lineStyle: 'dashed'});

绘制一条线。

parameter	type	description
x1	number	起始点的 X 坐标。
y1	number	起始点的 Y 坐标。
x2	number	结束点的 X 坐标。
y2	number	结束点的 Y 坐标。
pos1	RoomPosition	起始点位置对象。
pos2	RoomPosition	结束点位置对象。
style (可选)	object	包含下列属性的对象： width number 线条的宽度，默认值为 0.1。 color string 线条颜色，允许使用任何 web 格式颜色，默认值为 #ffffff (白色)。 opacity number 透明度，默认值为 0.5。 lineStyle string undefined (实线)，dashed (虚线) 或者 dotted (点线) 之一。默认值为 undefined。

返回值

该 RoomVisual 对象本身，您可以使用链式调用。

circle(x, y, [style])
(pos, [style])

new RoomVisual('W1N1').circle(10,15);

creep.room.visual.circle(creep.pos,
    {fill: 'transparent', radius: 0.55, stroke: 'red'});

绘制一个圆。

parameter	type	description
x	number	圆心的 X 坐标。
y	number	圆心的 Y 坐标。
pos	RoomPosition	圆心的位置对象。
style (可选)	object	包含下列属性的对象： radius number 圆的半径，默认值为 0.15。 fill string 填充颜色，允许使用任何 web 格式颜色，默认值为 #ffffff (白色)。 opacity number 透明度，默认值为 0.5。 stroke string 轮廓颜色，允许使用任何 web 格式颜色，默认未定义（没有轮廓）。 strokeWidth number 轮廓宽度，默认值为 0.1。 lineStyle string undefined (实线)，dashed (虚线) 或者 dotted (点线) 之一。默认值为 undefined。

返回值

该 RoomVisual 对象本身，您可以使用链式调用。

rect(x, y, width, height, [style])
(topLeftPos, width, height, [style])

// 从 (2,2) 到 (10,10) 的 9x9 区域
new RoomVisual('W1N1').rect(1.5, 1.5, 9, 9); 

// creep 上的矩形边框
creep.room.visual.rect(creep.pos.x - 0.6, creep.pos.y - 0.6, 
    1.2, 1.2,
    {fill: 'transparent', stroke: '#f00'});

绘制一个矩形。

parameter	type	description
x	number	左上角的 X 坐标。
y	number	左上角的 Y 坐标。
topLeftPos	RoomPosition	左上角的位置对象。
width	number	矩形的宽度。
height	number	矩形的高度。
style (可选)	object	包含下列属性的对象： fill string 填充颜色，允许使用任何 web 格式颜色，默认值为 #ffffff (白色)。 opacity number 透明度，默认值为 0.5。 stroke string 轮廓颜色，允许使用任何 web 格式颜色，默认未定义（没有轮廓）。 strokeWidth number 轮廓宽度，默认值为 0.1。 lineStyle string undefined (实线)，dashed (虚线) 或者 dotted (点线) 之一。默认值为 undefined。

返回值

该 RoomVisual 对象本身，您可以使用链式调用。

poly(points, [style])

const points = [];
points.push(creep1.pos);
points.push([10,15]);
points.push(new RoomPosition(20,21,'W1N1'));
new RoomVisual('W1N1').poly(points, {fill: 'aqua'}); 

// 将路径可视化
const path = Game.rooms['W1N1'].findPath(from, to);
new RoomVisual('W1N1').poly(path, {stroke: '#fff', strokeWidth: .15,
    opacity: .2, lineStyle: 'dashed'}); 

绘制一条折线。

parameter	type	description
points	array	折点数组。每个元素都应是两个数字的数组（即 [10,15]），或者是一个 RoomPosition 对象。
style (可选)	object	包含下列属性的对象： fill string 填充颜色，允许使用任何 web 格式颜色，默认值为 undefined（不填充）。 opacity number 透明度，默认值为 0.5。 stroke string 线条颜色，允许使用任何 web 格式颜色，默认值为 #ffffff (白色)。 strokeWidth number 线条宽度，默认值为 0.1。 lineStyle string undefined (实线)，dashed (虚线) 或者 dotted (点线) 之一。默认值为 undefined。

返回值

该 RoomVisual 对象本身，您可以使用链式调用。

text(text, x, y, [style])
(text, pos, [style])

new RoomVisual('W1N1').text("Target💥", 10, 15, {color: 'green', font: 0.8}); 

绘制一个文本标签。你可以使用任何有效的 Unicode 字符，包括 emoji。

parameter	type	description
text	string	文本信息
x	number	文本基线（baseline）起始点的 X 坐标。
y	number	文本基线起始点的 Y 坐标。
pos	RoomPosition	文本基线起始点的位置对象。
style (可选)	object	包含下列属性的对象： color string 字体颜色，允许使用任何 web 格式颜色，默认值为 #ffffff (白色)。 font number, string 数字或者字符串，应使用下列形式： 0.7 - 基于游戏坐标的相对大小 20px - 基于像素的绝对大小 0.7 serif bold italic 1.5 Times New Roman stroke string 轮廓颜色，允许使用任何 web 格式颜色，默认未定义（没有轮廓）。 strokeWidth number 轮廓宽度，默认值为 0.15。 backgroundColor string 背景颜色，允许使用任何 web 格式颜色，默认未定义（没有背景）。当启用背景时，文本的竖直对齐模式将设置为 middle（默认为 baseline）。 backgroundPadding number 背景矩形的 padding，默认值为 0.3。 align string 文本对齐模式，center，left 或者 right 之一。默认值为 center。 opacity number 透明度，默认值为 1.0。

返回值

该 RoomVisual 对象本身，您可以使用链式调用。

clear()

new RoomVisual('W1N1').clear();

移除该房间的所有视觉效果。

返回值

该 RoomVisual 对象本身，您可以使用链式调用。

getSize()

if(creep.room.visual.getSize() >= 512000) {
    // 本 tick 将无法添加更多的视觉效果
}

当前 tick 添加到该房间的视觉效果的存储大小。它不能超过 512,000（500 KB）。

返回值

视觉效果的大小（单位：字节）。

export()

Memory.RoomVisualData['E2S7'] = Game.rooms.E2S7.visual.export();

返回当前 tick 中添加到房间中的所有可视化效果的紧凑格式。

返回值

代表了可视化数据的字符串。除了将其存储以备后续使用外，您不应该对其进行其他操作。

import(val)

if(Memory.RoomVisualData['E2S7']) {
    Game.rooms.E2S7.visual.import(Memory.RoomVisualData['E2S7']);
}

将先前导出（使用RoomVisual.export）的房间可视化效果添加到当前 tick。

parameter	type	description
val	string	从 RoomVisual.export 返回的字符串。

返回值

RoomVisual 对象自身，以便进行链式调用。

Ruin

一个被摧毁的建筑。该对象允许其他单位在其上行走。

Decay

500 tick 除了某些情况外

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

destroyTimenumber

该建筑被摧毁的时间。

idstring

一个唯一的对象标识。你可以使用 Game.getObjectById 方法获取对象实例。

storeStore

一个包含了该建筑中所存储资源的 Store 对象。

structureStructure | OwnedStructure

一个包含了已被摧毁建筑基本信息的对象。

ticksToDecaynumber

该废墟离老化消失还有多少 tick。

Source

一个能量源对象。可以被拥有 WORK 身体部件的 creep 采集。

能量容量	中央房间：4000 被控制(owned)或者被预定(reserved)房间：3000 未预定房间：1500
能量再生	每 300 tick

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

energynumber

能量的剩余容量。

energyCapacitynumber

该 source 的总能量容量。

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

ticksToRegenerationnumber

该 source 还有多少 tick 将会再生。

Store

一个代表了其存储中资源的对象。

游戏中有两种类型的 store：通用型 store 和限定型 store。

• 通用型 store 可以储存任意类型的资源 (例如: creep, 容器(containers), 存储(storages), 终端(terminals))。

• 限定型 store 只能储存该对象所需的几种特定资源 (例如: spawn, 拓展(extension), 实验室(lab), 核弹(nuker))。

两种 Store 的原型都是相同的，但是其返回值取决于调用方法时传入的 resource 参数。

你可以把资源的类型当做对象属性来获取对应的资源:

console.log(creep.store[RESOURCE_ENERGY]);

getCapacity([resource])

if(creep.store[RESOURCE_ENERGY] < creep.store.getCapacity()) {
    goHarvest(creep);
}

返回指定资源的存储容量, 对于通用型 store，当 reource 参数为 undefined 则返回总容量。

parameter	type	description
resource (可选)	string	资源的类型

返回值

返回存储的数量, 当 resource 参数不是一个有效的存储类型时返回 null。

getFreeCapacity([resource])

if(structure.store.getFreeCapacity(RESOURCE_ENERGY) > 0) {
    creep.transfer(structure, RESOURCE_ENERGY);
}

返回该存储的剩余可用容量，对于限定型 store 来说，将在 resource 对该存储有效时返回该资源的剩余可用容量。

parameter	type	description
resource (可选)	string	资源类型。

返回值

返回可用的剩余容量，如果 resource 对该 store 无效则返回 null。

getUsedCapacity([resource])

if(Game.rooms['W1N1'].terminal.store.getUsedCapacity() == 0) {
    // terminal is empty
}

返回指定资源已使用的容量, 若为通用型存储时, reource 参数不存在则返回总使用容量。

parameter	type	description
resource (可选)	string	资源的类型

返回值

返回已使用的容量, 当 resource 参数不是一个有效的存储类型时返回 null。

Structure

所有建筑的基础原型对象。

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

hitsnumber

当前这个建筑的当前生命值。

hitsMaxnumber

这个建筑的最大生命值。

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

structureTypestring

STRUCTURE_*常量之一。

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者，或者不在你的房间中。
ERR_BUSY	-4	敌对creep在这个房间中。

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

StructureContainer

一个可以用来存储资源的小型容器。这是一个允许走上去的建筑。所有丢弃在同一方格上的资源都会被自动存储到 container 中。

控制器等级	任何等级 (包括无主房间)
每个房间允许建造的数量	5
容量	2,000
建筑花费	5,000
生命值	250,000
老化	在被自己控制的房间内每 500 tick 失去 5,000 生命值, 在没有控制的房间内该时间将降低至 100 tick。

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

storeStore

const containersWithEnergy = room.find(FIND_STRUCTURES, {
    filter: (i) => i.structureType == STRUCTURE_CONTAINER &&
                   i.store[RESOURCE_ENERGY] > 0
});

const total = _.sum(container.store);

容器内容物对象。每一个键都是RESOURCE_*常量，值是资源数量。如果没有RESOURCE_ENERGY，它的值始终为0，而其他资源的值为undefined。你可以使用lodash.sum来获得内容物总量。

storeCapacitynumber

一个包含了该建筑中所存储的货物的 Store 对象。

storeCapacitynumber

.store.getCapacity() 的别名。

ticksToDecaynumber

还有多少 tick 就要因老化而失去生命值。

StructureController

占领(claim) 这个建筑来控制其所在的房间。控制器无法被攻击或摧毁。

你可以通过 Room.controller 属性来快速访问到它。

等级	升级至下个等级	降级时间
1	200 energy	20,000 ticks
2	45,000 energy	10,000 ticks
3	135,000 energy	20,000 ticks
4	405,000 energy	40,000 ticks
5	1,215,000 energy	80,000 ticks
6	3,645,000 energy	120,000 ticks
7	10,935,000 energy	150,000 ticks
8	—	200,000 ticks

安全模式

效果	阻止本房间中的所有敌对 creep 的 attack, rangedAttack, rangedMassAttack, dismantle, heal, rangedHeal, attackController and withdraw 方法。以及敌对 Power Creep 的 enableRoom 和 usePower 方法。同一时间内只能有一个房间激活安全模式。 当安全模式被激活时，所有的敌对 creep 都将变透明并且可通过, 您的 creep 可以自由的穿过他们 (反之亦然)。
持续时间	20,000 ticks
冷却时间	50,000 ticks (新手区 (Novice Areas) 以及您第一个房间的初始安全模式都没有冷却时间)
获取途径	每次控制器升级时提供一次可用次数 可以使用 1,000 ghodium 化合物来生成一个可用次数 控制器降级时将会重置所有可用次数

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

Inherited from OwnedStructure

myboolean

是否是你拥有的建筑。

Inherited from OwnedStructure

ownerobject

建筑拥有者信息，一个包含如下属性的对象：

parameter	type	description
username	string	拥有者姓名。

isPowerEnabledboolean

该房间是否启用了超能 (power)。使用 PowerCreep.enableRoom 来启用超能。

levelnumber

当前的控制器等级，从 0 到 8。

progressnumber

当前控制器升级到下个等级的进度。

progressTotalnumber

控制器升级到下个等级所需的总进度。

reservationobject

如果控制器被预定，则该对象表示预定的信息:

parameter	type	description
username	string	预定了该房间的玩家名称。
ticksToEnd	number	预定时间还有多少 tick 结束。

safeModenumber

安全模式还有多少 tick 结束。没激活安全模式时返回 undefined。

safeModeAvailablenumber

可用的安全模式激活次数。

safeModeCooldownnumber

安全模式的冷却时间还有多少 tick。冷却结束前将无法激活安全模式，当安全模式没有冷却时返回 undefined。

signobject

如果控制器被签名，则该对象表示签名的信息：

parameter	type	description
username	string	将控制器签名的玩家名称。
text	string	签名的文本内容。
time	number	进行签名的游戏 tick 时间。
datetime	Date	进行签名的现实时间。

ticksToDowngradenumber

该控制器还有多少 tick 将要降级。当控制器升级或者降级时, 该计时器将被设置为总降级时间的 50%。可以使用 Creep.upgradeController 来增加该计时器的时间。控制器想要升级必须先保证该计时器满额。

upgradeBlockednumber

还有多少 tick 就能从控制器被攻击从而无法升级的状态中恢复过来。在此期间安全模式也不可用。

activateSafeMode()

room.controller.activateSafeMode();

激活安全模式 (如果有的话)。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是该控制器的所有者。
ERR_BUSY	-4	已经有其他房间处于安全模式下了。
ERR_NOT_ENOUGH_RESOURCES	-6	没有足够的可用激活次数。
ERR_TIRED	-11	上一个安全模式仍在冷却中，或者控制器正处于 upgradeBlocked 状态，或者控制器的降级计时器已经超过了 50% + 5000 tick 甚至更久。

unclaim()

room.controller.unclaim();

放弃该房间，使得控制器重新变为中立状态。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是该控制器的所有者。

StructureExtension

填充能量从而允许建造更大型的 creep。Extension 可以被放置在房间的任何地方，无论距离有多远，任何 spawn 都可以使用其中的能量进行孵化。

控制器等级
1	—
2	5 extensions (50 容量)
3	10 extensions (50 容量)
4	20 extensions (50 容量)
5	30 extensions (50 容量)
6	40 extensions (50 容量)
7	50 extensions (100 容量)
8	60 extensions (200 容量)
建造花费	3,000
生命值	1,000

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

Inherited from OwnedStructure

myboolean

是否是你拥有的建筑。

Inherited from OwnedStructure

ownerobject

建筑拥有者信息，一个包含如下属性的对象：

parameter	type	description
username	string	拥有者姓名。

energynumber

.store[RESOURCE_ENERGY] 的别名。

energyCapacitynumber

.store.getCapacity(RESOURCE_ENERGY) 的别名。

该 extension 所能容纳的能量上限。

storeStore

if(structure.store.getFreeCapacity(RESOURCE_ENERGY) > 0) {
    creep.transfer(structure, RESOURCE_ENERGY);
}

一个包含了该建筑中所存储的货物的 Store 对象。

StructureExtractor

允许采集矿藏 (Mineral)，点击 本文 查看更多关于矿物的内容。

控制器等级	6
建造花费	5,000
生命值	500
冷却时间	每次 harvest 操作冷却 5 tick

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

Inherited from OwnedStructure

myboolean

是否是你拥有的建筑。

Inherited from OwnedStructure

ownerobject

建筑拥有者信息，一个包含如下属性的对象：

parameter	type	description
username	string	拥有者姓名。

cooldownnumber

还有多少 tick 才能进行下次采集 (harvest) 操作。

StructureFactory

使用基础矿物和其他商品(commodities)来生产贸易商品。点击 本文 来了解有关商品的更多信息。

控制器等级
1-6	—
7-8	1 factory
生产花费	100,000
生命值	1000
容量	50,000
生产冷却	取决于生产的资源

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

Inherited from OwnedStructure

myboolean

是否是你拥有的建筑。

Inherited from OwnedStructure

ownerobject

建筑拥有者信息，一个包含如下属性的对象：

parameter	type	description
username	string	拥有者姓名。

cooldownnumber

还有多少 tick 才能进行下一次生产。

levelnumber

if(!factory.level) {
    Game.powerCreeps['MyOperator1'].usePower(PWR_OPERATE_FACTORY, factory);
}

工厂的等级，可以通过 PWR_OPERATE_FACTORY 超能来给一个新建的工厂设置等级。 一旦被设置，等级将无法再次更改。

storeStore

一个包含了该建筑中所存储的货物的 Store 对象。

storeCapacitynumber

.store.getCapacity() 的别名。

produce(resourceType)

factory.produce(RESOURCE_UTRIUM_BAR);

生产指定商品。工厂存储中应该包含所有的生产用料。

parameter	type	description
resourceType	string	RESOURCE_* 常量之一。

返回值

下列返回码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是该控制器的所有者。
ERR_BUSY	-4	无法通过 PWR_OPERATE_FACTORY 超能来操作此工厂。
ERR_NOT_ENOUGH_RESOURCES	-6	生产所需的资源数量不足。
ERR_INVALID_TARGET	-7	此工厂无法生产该等级的商品。
ERR_FULL	-8	此工厂的存储已无法容纳要生产的商品。
ERR_INVALID_ARGS	-10	提供的参数不正确。
ERR_TIRED	-11	工厂仍在冷却。
ERR_RCL_NOT_ENOUGH	-14	房间控制器等级不足以使用该建筑。

StructureInvaderCore

该 NPC 建筑是 NPC 要塞的控制中心，并且也统治着本区块中的所有入侵者。它会孵化要塞中的 NPC 守卫，重新装填 tower 以及修复建筑。 当它存在的时候，本区块中的所有房间都将会生成入侵者。它其中也储藏着一些有价值的资源，当您摧毁该建筑时，就可以从它的废墟（ruin）中搜刮这些资源。

一个入侵者核心 (Invader Core) 包含两个生命周期阶段：部署阶段和活动阶段。当它刚刚出现在本区块的某个随机房间中时，会包含一个 ticksToDeploy 属性， 周围在其周围的开放 rampart，并且也不会执行任何操作。在该阶段中，它将无法被攻击 (效果 EFFECT_INVULNERABILITY 生效)。当 ticksToDeploy 计时器结束的时候，它将解除无法被攻击的状态，并会在周围生成建筑和孵化 creep。与此同时，它将获得 EFFECT_COLLAPSE_TIMER 效果，在该计时器结束时，该要塞将会被移除。

一个活动的入侵者核心会在其相邻的中立房间中生成等级为 0 的小型入侵者核心。这些较小的核心会出现在房间控制器的附近，并且只会攻击（attack）和预定（reserve）房间控制器。一个入侵者核心一生中最多只能产生 42 个小型核心。

生命值	100,000
部署时间	5,000 ticks
活跃时间	75,000 tick 以及 10% 的随机浮动
小型核心生成间隔	要塞等级 1: 4000 ticks 要塞等级 2: 3500 ticks 要塞等级 3: 3000 ticks 要塞等级 4: 2500 ticks 要塞等级 5: 2000 ticks

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

Inherited from OwnedStructure

myboolean

是否是你拥有的建筑。

Inherited from OwnedStructure

ownerobject

建筑拥有者信息，一个包含如下属性的对象：

parameter	type	description
username	string	拥有者姓名。

levelnumber

此要塞的等级。该等级也决定了战利品的数量和质量。

ticksToDeploynumber

部署阶段的计时器，在要塞尚未部署完成时显示，否则为 undefined。

spawningStructureSpawn.Spawning

如果该核心正在孵化一个新的 creep，该属性将会包含一个 StructureSpawn.Spawning 对象，否则将为 null。

StructureKeeperLair

非玩家建筑。孵化 NPC 资源守护者（Source Keeper）来守卫某些房间中的能量 source 和 mineral。该建筑无法被摧毁。

孵化时间

300

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

Inherited from OwnedStructure

myboolean

是否是你拥有的建筑。

Inherited from OwnedStructure

ownerobject

建筑拥有者信息，一个包含如下属性的对象：

parameter	type	description
username	string	拥有者姓名。

ticksToSpawnnumber

距离孵化下一个资源守护者还有多少 tick。

StructureLab

使用基础矿物生产化合物，强化(boost) creep 和清除强化。 点击本文来了解更多关于矿物的信息。

控制器等级
1-5	—
6	3 labs
7	6 labs
8	10 labs
建造花费	50,000
生命值	500
容量	3000 单位矿物，2000 单位能量
产品	每次反应生成 5 单位化合物
反应冷却	取决于反应类型 (详见本文)
到输入 lab 的距离	2 格之内
强化消耗	每个身体部件消耗 30 单位矿物，20 单位能量

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

Inherited from OwnedStructure

myboolean

是否是你拥有的建筑。

Inherited from OwnedStructure

ownerobject

建筑拥有者信息，一个包含如下属性的对象：

parameter	type	description
username	string	拥有者姓名。

cooldownnumber

下次反应或者清除强化之前还需等待多少 tick 的冷却。

energynumber

.store[RESOURCE_ENERGY] 的别名。

energyCapacitynumber

.store.getCapacity(RESOURCE_ENERGY) 的别名。

mineralAmountnumber

lab.store[lab.mineralType] 的别名。

mineralTypestring

该 lab 储存的矿物类型。lab 同一时间内只能储存一种类型的矿物。

mineralCapacitynumber

lab.store.getCapacity(lab.mineralType || yourMineral) 的别名。

storeStore

if(structure.store.getFreeCapacity(RESOURCE_ENERGY) > 0) {
    creep.transfer(structure, RESOURCE_ENERGY);
}

一个包含了该建筑中所存储资源的 Store 对象。

boostCreep(creep, [bodyPartsCount])

使用存储中的矿物强化 creep 的身体部件。creep 必须在相邻与 lab 的正方形区域内。

parameter	type	description
creep	Creep	目标 creep。
bodyPartsCount (可选)	number	要强化的指定身体部件的数量。TOUGH 身体部件始终是从左到右进行强化，而其他部件则是从右到左。如果未指定，则对所有合适的身体部件进行强化。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	您不是该 lab 的所有者。
ERR_NOT_FOUND	-5	lab 中存放的矿物类型无法强化该 creep 的任何身体部件。
ERR_NOT_ENOUGH_RESOURCES	-6	lab 中没有足够的能量或者矿物。
ERR_INVALID_TARGET	-7	目标不是有效的 creep 对象。
ERR_NOT_IN_RANGE	-9	目标距离过远。
ERR_RCL_NOT_ENOUGH	-14	房间控制器等级不足。

reverseReaction(lab1, lab2)

将化合物还原为其反应底物。同一个输出 lab 可以和多个输入 lab 进行反应。

parameter	type	description
lab1	StructureLab	第一个输出 lab。
lab2	StructureLab	第二个输出 lab。

返回值

下列返回值之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	您不是该 lab 的所有者。
ERR_NOT_ENOUGH_RESOURCES	-6	源 lab 中没有足够的资源。
ERR_INVALID_TARGET	-7	目标不是有效的 lab 对象。
ERR_FULL	-8	有输出 lab 无法存放更多资源。
ERR_NOT_IN_RANGE	-9	目标距离过远。
ERR_INVALID_ARGS	-10	该资源无法进行还原。
ERR_TIRED	-11	该 lab 尚在冷却。
ERR_RCL_NOT_ENOUGH	-14	房间控制器等级不足。

runReaction(lab1, lab2)

使用另外两个 lab 中的矿物作为底物来生产化合物。同一个输入 lab 可以给多个输出 lab 提供底物。

parameter	type	description
lab1	StructureLab (lab)	第一个输入 lab。
lab2	StructureLab (lab)	第二个输入 lab。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	您不是该 lab 的所有者。
ERR_NOT_ENOUGH_RESOURCES	-6	输入 lab 没有足够的资源。
ERR_INVALID_TARGET	-7	目标不是有效的 lab 对象。
ERR_FULL	-8	目标无法接受更多资源。
ERR_NOT_IN_RANGE	-9	目标距离过远。
ERR_INVALID_ARGS	-10	无法使用输入 lab 中的资源进行反应。
ERR_TIRED	-11	该 lab 仍在冷却中。
ERR_RCL_NOT_ENOUGH	-14	房间控制器等级不足。

unboostCreep(creep)

立刻从 creep 身上移除强化并将强化所需的 50% 化合物丢弃在地面上，该操作不会关心 creep 的剩余存活时间。creep 必须在紧邻 lab 的正方形区域内。清除强化所需的冷却时间等于生产强化该 creep 所需化合物的总时间。

parameter	type	description
creep	Creep	目标 creep。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	您不是该 lab 或者目标 creep 的所有者。
ERR_NOT_FOUND	-5	目标没有强化过的身体部件。
ERR_INVALID_TARGET	-7	目标不是有效的 creep 对象。
ERR_NOT_IN_RANGE	-9	目标太远了。
ERR_TIRED	-11	该 lab 仍在冷却当中。
ERR_RCL_NOT_ENOUGH	-14	房间控制器等级不足。

StructureLink

将能量远程传输到同一房间的另一个 Link 中。

控制器等级
1-4	—
5	2 links
6	3 links
7	4 links
8	6 links
建造花费	5,000
生命值	1,000
容量	800
冷却时间	该 Link 到目标的线性距离每格增加 1 tick 冷却。
能量传输损耗	3%

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

Inherited from OwnedStructure

myboolean

是否是你拥有的建筑。

Inherited from OwnedStructure

ownerobject

建筑拥有者信息，一个包含如下属性的对象：

parameter	type	description
username	string	拥有者姓名。

cooldownnumber

下次传输之前还需多少 tick 的冷却。

energynumber

.store[RESOURCE_ENERGY] 的别名。

energyCapacitynumber

.store.getCapacity(RESOURCE_ENERGY) 的别名。

storeStore

if(structure.store.getFreeCapacity(RESOURCE_ENERGY) > 0) {
    creep.transfer(structure, RESOURCE_ENERGY);
}

一个包含了该建筑中所存储资源的 Store 对象。

transferEnergy(target, [amount])

const linkFrom = Game.rooms['W1N1'].lookForAt('structure', 10, 25)[0];

const linkTo = linkFrom.pos.findInRange(FIND_MY_STRUCTURES, 2,
    {filter: {structureType: STRUCTURE_LINK}})[0];

linkFrom.transferEnergy(linkTo);

将能量远程传输到同一房间中任何位置的另一个 Link 中。

parameter	type	description
target	StructureLink	目标对象。
amount (可选)	number	将要传输的能量值。如果省略，所有能量都将被传输。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是该 link 的所有者。
ERR_NOT_ENOUGH_RESOURCES	-6	这个建筑内的资源少于给定的数量。
ERR_INVALID_TARGET	-7	目标不是一个有效的 StructureLink 对象。
ERR_FULL	-8	目标无法接受更多能量。
ERR_NOT_IN_RANGE	-9	目标太远了。
ERR_INVALID_ARGS	-10	资源数量不正确。
ERR_TIRED	-11	该 link 仍在冷却中。
ERR_RCL_NOT_ENOUGH	-14	房间控制器等级不足以使用该 link。

StructureNuker

向其他房间发射一枚核弹，对着落区域造成大量伤害。 发射后需要时间冷却且需重新装填能量和 ghodium 资源。 发射后将会在目标房间位置创建一个对任何玩家可见的 Nuke 对象，直至其着陆。 已发射的核弹无法移动或者取消。核弹不能从新手房间发射或者发射向新手房间。放置到 StructureNuker 中的资源无法被取出 (withdraw)。

控制器等级
1-7	—
8	1 nuke
建造花费	100,000
生命值	1,000
攻击范围	10 rooms
发射花费	300,000 energy 5,000 ghodium
发射冷却	100,000 ticks
着陆时间	50,000 ticks
效果	立刻清除所有的 creep，建筑工地(construction site)和掉落的资源，即使它位于 rampart 之下。并对建筑造成如下伤害： 对着落位置造成 10,000,000 hits 伤害。 对周围 5x5 区域中的建筑造成 5,000,000 hits 伤害。 注意，您可以将来自多个不同房间的核弹叠加到同一位置来增强伤害。 Nuke 着落不会产生墓碑（tombstone）和遗迹（ruin），并且会销毁房间中所有存在的墓碑和遗迹。 如果核弹着落时房间正处于安全模式，则会立刻取消安全模式，并将安全模式的冷却时间重置为 0。 房间控制器将会触发 upgradeBlocked 计时，这意味着在接下来的 200 tick 中将无法再次使用安全模式。

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

Inherited from OwnedStructure

myboolean

是否是你拥有的建筑。

Inherited from OwnedStructure

ownerobject

建筑拥有者信息，一个包含如下属性的对象：

parameter	type	description
username	string	拥有者姓名。

energynumber

.store[RESOURCE_ENERGY] 的别名。

energyCapacitynumber

.store.getCapacity(RESOURCE_ENERGY) 的别名。

ghodiumnumber

.store[RESOURCE_GHODIUM] 的别名。

ghodiumCapacitynumber

.store.getCapacity(RESOURCE_GHODIUM) 的别名。

cooldownnumber

下次发射前还需多少 tick 的冷却时间。

storeStore

if(structure.store.getFreeCapacity(RESOURCE_ENERGY) > 0) {
    creep.transfer(structure, RESOURCE_ENERGY);
}

一个包含了该建筑中所存储资源的 Store 对象。

launchNuke(pos)

nuker.launchNuke(new RoomPosition(20,30, 'W1N1'));

向指定位置发射核弹。

parameter	type	description
pos	RoomPosition	目标房间位置

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_NOT_ENOUGH_RESOURCES	-6	该建筑没有足够的能量和/或 ghodium。
ERR_INVALID_TARGET	-7	nuke 无法发射至指定的 RoomPosition（见 起始区域）
ERR_NOT_IN_RANGE	-9	目标房间超出打击范围。
ERR_INVALID_ARGS	-10	目标不是有效的 RoomPosition。
ERR_TIRED	-11	该建筑仍在冷却。
ERR_RCL_NOT_ENOUGH	-14	房间控制中心等级不足。

StructureObserver

为你的代码提供远处房间的视野。

控制中心等级
1-7	—
8	1 观察者
建筑成本	8,000
生命值	500
观察范围	10个房间

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

Inherited from OwnedStructure

myboolean

是否是你拥有的建筑。

Inherited from OwnedStructure

ownerobject

建筑拥有者信息，一个包含如下属性的对象：

parameter	type	description
username	string	拥有者姓名。

observeRoom(roomName)

为你的代码提供远处房间的视野。目标房间将在下一个tick可见。

parameter	type	description
roomName	string	目标房间名。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_NOT_IN_RANGE	-9	房间roomName不在观察范围内。
ERR_INVALID_ARGS	-10	roomName参数不是一个有效的房间名。
ERR_RCL_NOT_ENOUGH	-14	房间控制中心等级不足。

StructurePowerBank

非玩家建筑。储存着超能资源，可以通过摧毁该建筑获得。攻击该建筑的 creep 每次攻击都会承受反弹回来的伤害。点击本文了解更多关于超能的信息。

生命值	2,000,000
反弹伤害	50%
容量	500 — 10,000
老化	5,000 ticks

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

powernumber

储存的 power 容量。

ticksToDecaynumber

该建筑还有多少 tick 就要因老化而消失。

StructurePowerSpawn

提炼超能 (power) 并注册到您的账户当中，可以孵化拥有独一无二能力的超能 creep (仍在开发中)。 点击本文查看跟多有关超能的信息。

控制器等级
1-7	—
8	1 power spawn
建造花费	100,000
生命值	5,000
容量	5,000 energy units, 100 power units
提炼花费	1 power 消耗 50 energy
提炼速度	每 tick 1 power

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

Inherited from OwnedStructure

myboolean

是否是你拥有的建筑。

Inherited from OwnedStructure

ownerobject

建筑拥有者信息，一个包含如下属性的对象：

parameter	type	description
username	string	拥有者姓名。

energynumber

.store[RESOURCE_ENERGY] 的别名。

energyCapacitynumber

.store.getCapacity(RESOURCE_ENERGY) 的别名。

powernumber

.store[RESOURCE_POWER] 的别名。

powerCapacitynumber

.store.getCapacity(RESOURCE_POWER) 的别名。

storeStore

if(structure.store.getFreeCapacity(RESOURCE_ENERGY) > 0) {
    creep.transfer(structure, RESOURCE_ENERGY);
}

一个包含了该建筑中所存储的货物的 Store 对象。

processPower()

将超能 (power) 资源注册到您的账户当中。注册超能允许开发超能 creep 的技能。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_NOT_ENOUGH_RESOURCES	-6	这个建筑没有足够的能量或者超能资源。
ERR_RCL_NOT_ENOUGH	-14	房间控制中心等级不足。

StructurePortal

一个非玩家建筑。立刻将你的 creep 传送至一个遥远房间的出口位置。传送门会在每个区块的中央房间随机刷新。

稳定时间	10 天
老化时间	30,000 ticks

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

destinationRoomPosition | object

如果这是个通往其他房间 的传送门，则该属性为指向目的地房间出口位置的 RoomPosition 对象。

如果这是个通往其他 shard 的传送门，则该属性为一个包含了 shard 和 room 字符串属性的对象。无法确定其具体出口位置，creep 会被随机传送到目标房间的任意空闲位置。

ticksToDecaynumber

还有多少 tick 就要因老化而失去生命值，当传送门稳定时其值为 undefined。

StructureRampart

阻挡敌方 creep 的移动。并防御本格空间上的我方建筑和 creep。可以当做可控门来进行使用。

控制器等级
1	—
2	最大生命值: 300,000 hits
3	最大生命值: 1,000,000 hits
4	最大生命值: 3,000,000 hits
5	最大生命值: 10,000,000 hits
6	最大生命值: 30,000,000 hits
7	最大生命值: 100,000,000 hits
8	最大生命值: 300,000,000 hits
花费	1
建造完成时的生命值	1
老化	每 100 ticks 失去 300 hits

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

Inherited from OwnedStructure

myboolean

是否是你拥有的建筑。

Inherited from OwnedStructure

ownerobject

建筑拥有者信息，一个包含如下属性的对象：

parameter	type	description
username	string	拥有者姓名。

isPublicboolean

当值为 false (默认) 时。只有你的 creep 能通过。当值为 true 时，任何玩家的 creep 都可以通过。

ticksToDecaynumber

还有多少 tick 就要因老化而失去生命值。

setPublic(isPublic)

将该 rampart 的状态设置为开放，从而允许其他玩家的 creep 通过。

parameter	type	description
isPublic	boolean	该 rampart 是否开放

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。

StructureRoad

将每个身体部件的移动成本降低至 1。建造道路之后，你就可以用更少的 MOVE 身体部件来孵化一个 creep。你也可以在自然墙壁上建造一个道路来使其可以通行。

控制器等级	任何等级 (包括无主房间)
花费	在平原上: 300 在沼泽上: 1,500 在墙壁上: 45,000
生命值	在平原上: 5,000 hits 在沼泽上: 25,000 hits 在墙壁上: 750,000 hits
老化	在平原上: 每 1,000 ticks 失去 100 hits 在沼泽上: 每 1,000 ticks 失去 500 hits 在墙壁上: 每 1,000 ticks 失去 15,000 hits 注意: creep 的每次移动都会导致更快的老化, 每一个身体部件都会降低老化计时器 1 tick。

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

ticksToDecaynumber

还有多少 tick 就要因老化而失去生命值。

StructureSpawn

母巢 (spawn) 是你的殖民地中心。此建筑可以创建、更新和回收 creeps 。 你能通过 Game.spawns 这个hash list 访问所有的母巢 (spawn) 。 母巢 (spawn) 每 tick 会生产少许能量，以免玩家陷入无 creep 可用、无 creep 可造的困境。

控制等级 (Controller level)
1-6	1 spawn
7	2 spawns
8	3 spawns
Cost	15,000
Hits	5,000
Capacity	300
Spawn time	3 ticks 每 body 组件
Energy auto-regeneration	当房间内的能量（所有的母巢和扩展中）低于300 时，母巢每 tick 会自动生成 1 单位的能量。

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

Inherited from OwnedStructure

myboolean

是否是你拥有的建筑。

Inherited from OwnedStructure

ownerobject

建筑拥有者信息，一个包含如下属性的对象：

parameter	type	description
username	string	拥有者姓名。

energynumber

.store[RESOURCE_ENERGY] 的别名.

energyCapacitynumber

.store.getCapacity(RESOURCE_ENERGY) 的别名.

memoryany

spawn.memory.queue = [];

Memory.spawns[spawn.name] 的一个简写。您可以使用它来快速访问母巢 (spawn) 的特定内存数据对象。 了解更多关于 memory

namestring

Spawn 的名字。在创建新母巢 (spawn) 时赋予，一但创建就无法更改，除非拆除重造。此名称是一个散列键，用于通过 Game.spawns 对象访问。

spawningStructureSpawn.Spawning

如果母巢 (spawn) 正在孵化一个新的 creep ， 母巢 (spawn) 将包含一个 StructureSpawn.Spawning 对象，否则为 null。

storeStore

if(structure.store.getFreeCapacity(RESOURCE_ENERGY) > 0) {
    creep.transfer(structure, RESOURCE_ENERGY);
}

一个 Store 对象，它包含这个建筑的所有货物。

canCreateCreep(body, [name])

if(spawn.canCreateCreep(body, name) == OK) {
    spawn.createCreep(body, name);
}

检查是否可以创建 creep。

parameter	type	description
body	array<string>	描述新 creep’s body 的数组。应该包含1至50个元素（以下常量之一）: WORK MOVE CARRY ATTACK RANGED_ATTACK HEAL TOUGH CLAIM
name (可选)	string	新 creep 的名字。最长不能超过 100 个字符。它应该是唯一的 creep 名称, 所以 Game.creeps 对象不应该包含另一个同名的 creep (hash key)。如果没有定义，将生成一个随机名称。

返回值

如下错误码之一：

constant	value	description
OK	0	可以创建具有给定 body 和名称的 creep。
ERR_NOT_OWNER	-1	你不是该 spawn 的所有者。
ERR_NAME_EXISTS	-3	已经有一个叫这个名字的 creep 了。
ERR_BUSY	-4	这个母巢 (spawn) 已经在孵化另一个 creep 了。
ERR_NOT_ENOUGH_ENERGY	-6	这个母巢 (spawn) 和它的扩展 (extension) 包含的能量不足以孵化具有给定 body 的 creep。
ERR_INVALID_ARGS	-10	Body 没有被恰当地描述。
ERR_RCL_NOT_ENOUGH	-14	您的房间控制器级别不足以使用此 spawn。

createCreep(body, [name], [memory])

Game.spawns['Spawn1'].createCreep([WORK, CARRY, MOVE], 'Worker1');

Game.spawns['Spawn1'].createCreep([WORK, CARRY, MOVE], null,
    {role: 'harvester'});

const result = Game.spawns['Spawn1'].createCreep([WORK, CARRY, MOVE]);

if(_.isString(result)) {
    console.log('The name is: '+result);
}
else {
    console.log('Spawn error: '+result);
}

启动 creep 孵化过程。所需的能量可以从房间里的所有母巢和扩展中提取出来。

parameter	type	description
body	array<string>	描述新 creep’s body 的数组。应该包含1至50个元素（以下常量之一） WORK MOVE CARRY ATTACK RANGED_ATTACK HEAL TOUGH CLAIM
name (可选)	string	新 creep 的名字。最长不能超过 100 个字符。它应该是唯一的 creep 名称, 所以 Game.creeps 对象不应该包含另一个同名的 creep (hash key)。如果没有定义，将生成一个随机名称。
memory (可选)	any	一个新 creep 的 memory 。如果提供，它将立即存储到Memory.creeps[name]。

返回值

产生一个新的 creep 会遇到这些错误代码之一:

constant	value	description
ERR_NOT_OWNER	-1	你不是该 spawn 的所有者。
ERR_NAME_EXISTS	-3	已经有一个叫这个名字的 creep 了。
ERR_BUSY	-4	这个母巢已经在孵化另一个 creep 了。
ERR_NOT_ENOUGH_ENERGY	-6	这个母巢和他的扩展包含的能量不足以孵化具有给定 body 的 creep。
ERR_INVALID_ARGS	-10	Body 没有被恰当地描述。
ERR_RCL_NOT_ENOUGH	-14	您的房间控制器级别不足以使用此 spawn。

spawnCreep(body, name, [opts])

Game.spawns['Spawn1'].spawnCreep([WORK, CARRY, MOVE], 'Worker1');

Game.spawns['Spawn1'].spawnCreep([WORK, CARRY, MOVE], 'Worker1', {
    memory: {role: 'harvester'}
});

Game.spawns['Spawn1'].spawnCreep([WORK, CARRY, MOVE], 'Worker1', {
    energyStructures: [
        Game.spawns['Spawn1'],
        Game.getObjectById('anExtensionId')
    ]
});

var testIfCanSpawn = Game.spawns['Spawn1'].spawnCreep([WORK, CARRY, MOVE],
    'Worker1', { dryRun: true });

启动 creep 孵化过程。所需的能量量可以从房间里的所有母巢和扩展中提取出来。

parameter	type	description
body	array<string>	描述新 creep’s body 的数组。应该包含1至50个元素（以下常量之一） WORK MOVE CARRY ATTACK RANGED_ATTACK HEAL TOUGH CLAIM
name	string	新 creep 的名字。最长不能超过 100 个字符。它应是个独一无二的 creep 名以保证 Game.creeps 不含有重名的的 creep 。
opts (可选)	object	为孵化进程提供附加选项的对象。 memory any 一个新 creep 的 memory 。如果提供，它将立即存储到Memory.creeps[name]。 energyStructures array 孵化时使用能量的 spawns/extensions 数组，建筑将按顺序使用其中的能量。 dryRun boolean 如果“dryRun”为 true，则操作将仅检查是否可以孵化 creep。 directions array 设置 creep 出生时移动的方向，是一个带有以下常量的数组: TOP TOP_RIGHT RIGHT BOTTOM_RIGHT BOTTOM BOTTOM_LEFT LEFT TOP_LEFT

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是该母巢 (spawn) 的所有者。
ERR_NAME_EXISTS	-3	已经有一个叫这个名字的 creep 了。
ERR_BUSY	-4	这个母巢 (spawn) 已经在孵化另一个 creep 了。
ERR_NOT_ENOUGH_ENERGY	-6	这个母巢 (spawn) 和他的扩展包含的能量不足以孵化具有给定 body 的 creep。
ERR_INVALID_ARGS	-10	Body 没有被恰当地描述。
ERR_RCL_NOT_ENOUGH	-14	您的房间控制器级别不足以使用此 spawn。

recycleCreep(target)

杀死 creep ，并视其剩余寿命而掉落最多100％的资源用于其繁殖和增强。目标应该在相邻的方块上。每个身体部位的能量回收限制在125个单位。

parameter	type	description
target	Creep	目标 creep 对象。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	您不是此母巢 (spawn) 或目标 creep 的所有者。
ERR_INVALID_TARGET	-7	指定的目标不是一个 creep 对象。
ERR_NOT_IN_RANGE	-9	目标 creep 太远了。
ERR_RCL_NOT_ENOUGH	-14	您的房间控制器级别不足以使用此 spawn。

renewCreep(target)

增加目标 creep 的剩余生存时间。目标应在相邻的方格处。spawn 不应忙于孵化过程，且不能包含 CLAIM 身体部件。每次执行都会增加 creep 的计时器，根据此公式按 ticks 数计算：

floor(600/body_size)

每次执行所需的能量由以下公式确定:

ceil(creep_cost/2.5/body_size)

更新 creep 会移除所有的增益。

parameter	type	description
target	Creep	目标 creep 对象。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是该母巢 (spawn) 或者该 creep 的所有者。
ERR_BUSY	-4	这个母巢 (spawn) 已经在孵化另一个 creep 了。
ERR_NOT_ENOUGH_ENERGY	-6	这个母巢 (spawn) 和他的扩展 (extension) 包含的能量不足以孵化具有给定 body 的 creep。
ERR_INVALID_TARGET	-7	指定的目标不是一个 creep 对象，或者其携带有 CLAIM 身体部件。
ERR_FULL	-8	目标计时器的时间已经满了。
ERR_NOT_IN_RANGE	-9	目标 creep 太远了。
ERR_RCL_NOT_ENOUGH	-14	您的房间控制器级别不足以使用此 spawn。

StructureSpawn.Spawning

当前正在孵化的 creep 的详细信息，可以通过StructureSpawn.spawning属性进行访问。

directionsarray

一个指示了出生方向的数组，参见 StructureSpawn.Spawning.setDirections.

namestring

新 creep 的名字。

needTimenumber

完成孵化总共需要的时间。

remainingTimenumber

剩下的时间。

spawnStructureSpawn

一个到对应 spawn 的链接。

cancel()

Game.spawns['Spawn1'].spawning.cancel();

立即取消孵化。不返还消耗的资源。

Return value

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是该 spawn 的所有者。

setDirections(directions)

Game.spawns['Spawn1'].spawning.setDirections([RIGHT, TOP_RIGHT]);

设置出生方向，以使它们在生成时应移动到的位置。

parameter	type	description
directions	array<number>	包含如下方向常量的数组: TOP TOP_RIGHT RIGHT BOTTOM_RIGHT BOTTOM BOTTOM_LEFT LEFT TOP_LEFT

Return value

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是该 spawn 的所有者。
ERR_INVALID_ARGS	-10	无效的方向数组

StructureStorage

可以储存大量资源的建筑。每个房间内仅允许建造一个，所以你可以使用 Room.storage 属性来快速访问它。

控制器等级
1-3	—
4-8	1 个 storage
花费	30,000
生命值	10,000
储量	1,000,000

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

Inherited from OwnedStructure

myboolean

是否是你拥有的建筑。

Inherited from OwnedStructure

ownerobject

建筑拥有者信息，一个包含如下属性的对象：

parameter	type	description
username	string	拥有者姓名。

storeStore

一个包含了该建筑中所存储的货物的 Store 对象。

storeCapacitynumber

.store.getCapacity() 属性的别名.

StructureTerminal

终端可以发送任意资源到另一个房间的终端。目标终端可以属于任何一个玩家。 每个事务都需要额外消耗能量（无论传输资源类型如何）， 可以使用Game.market.calcTransactionCost计算所需能量。 例如，从W0N0发送1000单位矿物到W10N5需要消耗742单位能量。 你可以使用Game.market对象跟踪你的收入和支出事务。 一个房间只会有一个终端，所以可以通过Room.terminal属性访问。

终端可以用于交易系统.

控制中心等级
1-5	—
6-8	1 terminal
建筑成本	100,000
生命值	3,000
容量	300,000
冷却时间	10 ticks

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

Inherited from OwnedStructure

myboolean

是否是你拥有的建筑。

Inherited from OwnedStructure

ownerobject

建筑拥有者信息，一个包含如下属性的对象：

parameter	type	description
username	string	拥有者姓名。

cooldownnumber

这个终端不能调用StructureTerminal.send或Game.market.deal的剩余tick。

storeStore

A Store object that contains cargo of this structure.

storeCapacitynumber

An alias for .store.getCapacity().

send(resourceType, amount, destination, [description])

Game.rooms['W1N1'].terminal.send(RESOURCE_UTRIUM, 100, 'W2N3',
    'trade contract #1');

发送资源给指定房间的终端

parameter	type	description
resourceType	string	RESOURCE_* 常量之一。
amount	number	发送资源数量。
destination	string	目标房间名称。这个房间不需要对你可见。
description (可选)	string	这个事务的备注。它只对收件人可见。最大长度100字符。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_NOT_ENOUGH_RESOURCES	-6	这个建筑没有对应数量的资源。
ERR_INVALID_ARGS	-10	无效参数。
ERR_TIRED	-11	这个终端依然在冷却中。

StructureTower

远程攻击creep，治疗creep，或维修建筑。房间里的任意对象都可以指定为它的目标。然而，效果线性地取决距离。每一个动作都会消耗能量。

Controller level
1-2	—
3-4	1个塔
5-6	2个塔
7	3个塔
8	6个塔
建筑成本	5,000
生命值	3,000
容量	1,000
每个动作能量消耗	10
攻击效果	从距离 ≤5 的 600 点到距离 ≥20 的 150 点
治疗效果	从距离 ≤5 的 400 点到距离 ≥20 的 100 点
维修效果	从距离 ≤5 的 800 点到距离 ≥20 的 200 点

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

Inherited from OwnedStructure

myboolean

是否是你拥有的建筑。

Inherited from OwnedStructure

ownerobject

建筑拥有者信息，一个包含如下属性的对象：

parameter	type	description
username	string	拥有者姓名。

energynumber

.store[RESOURCE_ENERGY] 的别名。

energyCapacitynumber

.store.getCapacity(RESOURCE_ENERGY) 的别名。

storeStore

if(structure.store.getFreeCapacity(RESOURCE_ENERGY) > 0) {
    creep.transfer(structure, RESOURCE_ENERGY);
}

一个代表这该结构所存储能量的 Store 对象。

attack(target)

远程攻击房间里的任意 creep、超能 creep 或房间内的结构。

parameter	type	description
target	Creep, PowerCreep, Structure	目标creep。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_NOT_ENOUGH_ENERGY	-6	这个塔没有足够的能量。
ERR_INVALID_TARGET	-7	这个目标不是一个有效的攻击目标。
ERR_RCL_NOT_ENOUGH	-14	房间控制等级不足。

heal(target)

远程治疗房间里的任意 creep 或超能 creep。

parameter	type	description
target	Creep, PowerCreep	The target creep.

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_NOT_ENOUGH_ENERGY	-6	这个塔没有足够的能量。
ERR_INVALID_TARGET	-7	这个目标不是一个有效的creep对象。
ERR_RCL_NOT_ENOUGH	-14	房间控制等级不足。

repair(target)

远程维修房间里的任意建筑。

parameter	type	description
target	Structure	目标建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_NOT_ENOUGH_ENERGY	-6	这个塔没有足够的能量。
ERR_INVALID_TARGET	-7	这个目标不是一个有效的可维修对象。
ERR_RCL_NOT_ENOUGH	-14	房间控制中心等级不足。

StructureWall

阻挡所有creep的移动。 玩家可以在已控制的房间中建造可破坏的构筑墙。 有些房间还包含不可破坏的构筑墙，将新手区或重生区与世界其他地方隔开，又或将新手/重生区划分为较小的区域。不可破坏的构筑墙没有hits属性。

控制中心等级	2
建造成本	1
建造完成时的生命值	1
最大生命值	300,000,000

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

Inherited from Structure

hitsnumber

当前这个建筑的当前生命值。

Inherited from Structure

hitsMaxnumber

这个建筑的最大生命值。

Inherited from Structure

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

Inherited from Structure

structureTypestring

STRUCTURE_*常量之一。

继承自 Structure

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_BUSY	-4	敌对creep在这个房间中。

继承自 Structure

isActive()

检查这个建筑是否可用。如果房间控制等级不足，这个方法会返回false，并且这个建筑会在游戏中红色高亮。

返回值

布尔值。

继承自 Structure

notifyWhenAttacked(enabled)

切换这个建筑受到攻击时的自动通知。通知会发送到你的账户邮箱。默认开启。

parameter	type	description
enabled	boolean	是否启用通知。

返回值

如下错误码之一：

constant	value	description
OK	0	这个操作已经成功纳入计划。
ERR_NOT_OWNER	-1	你不是这个建筑的拥有者。
ERR_INVALID_ARGS	-10	enable参数不是一个布尔值。

Tombstone

死亡creep的遗物。这个对象不阻碍行走。

消失	死去的creep每个身体部件5 tick

effectsarray

附加的效果，一个包含如下属性的对象数组：

parameter	type	description
effect	number	该附加效果的 ID。可以是自然效果 ID 或者 Power ID。
level (可选)	number	该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。
ticksRemaining	number	多长时间之后会失去这个效果。

Inherited from RoomObject

posRoomPosition

表示该对象在房间中的坐标的对象。

Inherited from RoomObject

roomRoom

Room对象的链接。如果对象是标志或工地并且放置在你不可见的房间中，则可能为undefined。

creepCreep | PowerCreep

room.find(FIND_TOMBSTONES).forEach(tombstone => {
    if(tombstone.creep.my) {
        console.log(`My creep died with ID=${tombstone.creep.id} ` +
             `and role=${Memory.creeps[tombstone.creep.name].role}`);   
    }    
});

room.find(FIND_TOMBSTONES).forEach(tombstone => {
    if(tombstone.creep instanceof PowerCreep) {
        console.log(`Power creep died here`);   
    }    
});
`

一个内含死亡creep或超能creep的对象。

deathTimenumber

死亡时间。

idstring

一个唯一的对象标识。你可以使用Game.getObjectById方法获取对象实例。

storeStore

一个表示该结构所存储资源的 Store 对象。

ticksToDecaynumber

这个墓碑消失的剩余时间。