Back to docs

Game

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

Game.constructionSitesobject<string, ConstructionSite>

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

Game.cpuobject

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

parametertypedescription
limitnumber

你在当前指定 shard 的CPU限制。

tickLimitnumber

当前游戏 tick 可用的 CPU 时间。
通常它高于 Game.cpu.limit. 了解更多

bucketnumber

在你的 bucket 中累积的未使用的 CPU 数量。

shardLimitsobject
<string,number>

包含了每个 shard cpu 上限的对象,以 shard 名称为关键字。你可以使用 setShardLimits 方法重设他们。

unlockedboolean

您的账户是否已经解锁了完整的 CPU。

unlockedTimenumber

您账户解锁完整 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)的对象,具有以下属性:

parametertypedescription
levelnumber

当前的等级。

progressnumber

到下一个等级当前的进展。

progressTotalnumber

到下一个等级所需的进展。

Game.gplobject

你的全局能量等级(Global Power Level)的对象,具有以下属性:

parametertypedescription
levelnumber

当前的等级。

progressnumber

到下一个等级当前的进展。

progressTotalnumber

到下一个等级所需的进展。

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 的对象。

parametertypedescription
namestring

shard 的名称。

typestring

目前总是等于 normal.

ptrboolean

这个 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 小时只能使用一次。

parametertypedescription
limitsobject<string, number>

表示每个 shard 的 CPU 值,与 Game.cpu.shardLimits 格式相同。

返回值

以下代码之一:

constantvaluedescription
OK0

该操作已成功安排。

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 分钟之内)来为您的账户应用解锁。

返回值

下列返回值之一:

constantvaluedescription
OK0

该操作已成功安排。

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 资源。

constantvaluedescription
OK0

该操作已成功安排。

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 的对象。 它可以是任何类型的游戏对象。 只能访问您可见的房间内的物体。

parametertypedescription
idstring

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 个通知。在模拟模式中不可用。

parametertypedescription
messagestring

将在消息中发送的自定义文本。最大长度为 1000 个字符。

groupIntervalnumber

如果被设为 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 的数据替换为新的值。

parametertypedescription
valuestring

格式化为字符串的新数据。

InterShardMemory.getRemote(shard)

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

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

parametertypedescription
shardstring

Shard 名称。

Game.map

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

Game.map.describeExits(roomName)

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

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

parametertypedescription
roomNamestring

房间名。

返回值

出口信息按照以下格式给出,在房间不存在时返回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));

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

parametertypedescription
fromRoomstring, Room

起点房间名或房间对象。

toRoomstring, Room

终点房间名或房间对象。

opts (可选)object

包含寻路选项的对象。参见findRoute

返回值

房间方向常量,下列之一:

或下列错误码:

constantvaluedescription
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);

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

parametertypedescription
fromRoomstring, Room

起点房间名或房间对象。

toRoomstring, Room

终点房间名或房间对象。

opts (可选)object

包含下列选项的对象:

  • routeCallback
    function
    这个回调函数接受两个参数: function(roomName, fromRoomName)。 它可以用来计算进入一个房间的开销。你可以用它实现优先进入自己的房间或者回避某些房间等功能。你应该返回一个浮点数开销,或者返回Infinity代表不可进入。

返回值

如下格式的路径数组:

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

或如下错误码之一:

constantvaluedescription
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

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

parametertypedescription
roomName1string

第一个房间名。

roomName2string

第二个房间名。

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 对象,快捷访问静态地形数据。此方法适用于所有房间,哪怕是无法访问的房间。

parametertypedescription
roomNamestring

房间名。

返回值

一个新Room.Terrain对象。

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

此方法已被弃用,不久将被删除。 请使用更高效的方法Game.map.getRoomTerrain替代.

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

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

parametertypedescription
xnumber

房间内X坐标。

ynumber

房间内Y坐标。

roomNamestring

房间名。

posRoomPosition

坐标对象。

返回值

下列字符串值:

Game.map.getWorldSize()

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

Game.map.isRoomAvailable(roomName)

此方法已被弃用,不久将被删除。 Please use Game.map.getRoomStatus instead.

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

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

parametertypedescription
roomNamestring

The room name.

返回值

布尔值

Game.map.getRoomStatus(roomName)

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

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

parametertypedescription
roomNamestring

房间名

返回值

包含如下属性的对象:

属性 类型 介绍
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'});

绘制一条线。

parametertypedescription
pos1RoomPosition

起始点位置对象。

pos2RoomPosition

结束点位置对象。

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'});

绘制一个圆。

parametertypedescription
posRoomPosition

中心点位置对象。

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'});

绘制一个矩形。

parametertypedescription
topLeftPosRoomPosition

左上角的位置对象。

widthnumber

矩形的宽。

heightnumber

矩形的高。

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'});

绘制一段折线.

parametertypedescription
pointsarray

包含了所有拐点的数组。每个数组元素都应是一个 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

parametertypedescription
textstring

文本信息

posRoomPosition

文本基线(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
    文本对齐,centerleftright 之一。默认为 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。

parametertypedescription
valstring

从 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.sendGame.market.deal 方法的能量交易成本。 算法:

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

要发送的资源数量。

roomName1string

第一个房间的名称。

roomName2string

第二个房间的名称。

返回值

进行交易所需的能量。

Game.market.cancelOrder(orderId)

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

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

parametertypedescription
orderIdstring

Game.market.orders 中提供的订单 ID。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

ERR_INVALID_ARGS-10

无效的订单 ID。

Game.market.changeOrderPrice(orderId, newPrice)

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

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

parametertypedescription
orderIdstring

Game.market.orders 提供的订单 ID。

newPricenumber

新的订单单价。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 来将其状态设置为活跃和非活跃。

parametertypedescription
paramsobject

包含下列参数的对象:

  • 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 常量)时本参数不使用。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 笔交易。

parametertypedescription
orderIdstring

来自 Game.market.getAllOrders 的订单 ID。

amountnumber

要转移的资源数量。

yourRoomName (可选)string

您某个房间的名称,该房间应该存在一个可用终端且该终端存放了足够的能量。当订单的资源类型为账户绑定资源之一(见 INTERSHARD_RESOURCES 常量)时本参数不使用。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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);

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

parametertypedescription
orderIdstring

Game.market.orders 中提供的订单 ID。

addAmountnumber

要增加多少容量。不能为负数。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 内置索引。

parametertypedescription
filter (可选)object, function

一个对象或者函数,将使用 lodash.filter 方法对结果列表进行筛选。

返回值

一个订单数组,订单格式如下:

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

Game.market.getHistory([resourceType])

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

parametertypedescription
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');

检索指定的市场订单。

parametertypedescription
idstring

订单 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));

origingoal 之间查找最佳路径。

parametertypedescription
originRoomPosition

起始位置。

goalobject

一个或一组目标。如果提供了多个目标,则返回所有目标中移动成本最低的路径。目标可以是一个 RoomPosition 或者包含下列定义的对象:

重要: 请注意,如果您的目标是无法行走的(例如,一个 source),请至少将 range 设置成至少为 1。否则您将浪费很多 CPU 资源来查找一个无法到达的目标。

  • pos
    目标。
  • 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 plainCostswampCost 和任何给定的 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.

parametertypedescription
isEnabledboolean

是否要激活新的 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 获取分段。 该对象包含以下属性:

parametertypedescription
usernamestring

其他玩家的名称

idnumber

被请求的内存分段 ID。

datastring

分段的内容。

RawMemory.interShardSegmentstring

此属性已被弃用,将很快删除。 请使用 InterShardMemory 代替。

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 值。

parametertypedescription
valuestring

新的字符串形式的 memroy 值。

RawMemory.setActiveSegments(ids)

RawMemory.setActiveSegments([0,3]);

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

parametertypedescription
idsarray

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

RawMemory.setActiveForeignSegment(username, [id])

RawMemory.setActiveForeignSegment('player');
RawMemory.setActiveForeignSegment('player', 10);
RawMemory.setActiveForeignSegment(null);

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

parametertypedescription
usernamestring | null

其他用户的名称。传入 null 来清除外部分段。

id (可选)number

0 到 99 之间的请求分段 ID。如果未定义,将请求该用户通过 setDefaultPublicSegment 设置的默认公开分段。

RawMemory.setDefaultPublicSegment(id)

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

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

parametertypedescription
idnumber | null

0 到 99 之间的内存分段 ID。传入 null 来移除您的默认公开分段。

RawMemory.setPublicSegments(ids)

RawMemory.setPublicSegments([5,3]);
RawMemory.setPublicSegments([]);

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

parametertypedescription
idsarray

分段 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

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

parametertypedescription
effectnumber

该附加效果的 ID。可以是自然效果 ID 或者 Power ID。

level (可选)number

该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。

ticksRemainingnumber

多长时间之后会失去这个效果。

Inherited from RoomObject
posRoomPosition

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

Inherited from RoomObject
roomRoom

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

idstring

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

myboolean

你是否拥有这个工地。

ownerobject

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

parametertypedescription
usernamestring

拥有者姓名。

progressnumber

当前建造进度。

progressTotalnumber

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

structureTypestring

STRUCTURE_*常量之一。

remove()

删除这个工地。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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

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

parametertypedescription
effectnumber

该附加效果的 ID。可以是自然效果 ID 或者 Power ID。

level (可选)number

该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。

ticksRemainingnumber

多长时间之后会失去这个效果。

Inherited from RoomObject
posRoomPosition

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

Inherited from RoomObject
roomRoom

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

bodyarray

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

parametertypedescription
booststring | undefined

如果该身体部件被强化(boost)了,则该属性指定了强化所用的化合物类型。化合物为 RESOURCE_* 常量之一。 了解更多

typestring

身体部件常量之一。

hitsnumber

该身体部件剩余的生命值。

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 的所有者信息,包含以下属性:

parametertypedescription
usernamestring

所有者姓名。

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 中,则该目标会自动进行反击。

parametertypedescription
targetCreep, PowerCreep, Structure

要攻击的目标

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 相邻。

parametertypedescription
targetStructure

目标房间控制器对象。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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);
    }
}

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

parametertypedescription
targetConstructionSite

待建造的目标工地。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 中给出的某个指令。

parametertypedescription
methodNamestring

需要被取消的 creep 方法名。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作被成功取消了。

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) 该房间。点击了解更多

parametertypedescription
targetStructureController

目标控制中心对象。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 部件的数量正相关。

parametertypedescription
targetStructure

目标建筑。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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);
}

将资源丢弃到地上。

parametertypedescription
resourceTypestring

RESOURCE_* 常量之一。

amount (可选)number

丢弃资源的数量。如果没有这个参数,丢弃全部资源。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 资源。

parametertypedescription
targetStructureController

目标控制中心。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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);
}

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

parametertypedescription
typestring

一个身体部件类型,下列身体部件类型常量之一:

  • 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 相邻。

parametertypedescription
targetSource, Mineral, Deposit

要采集的对象。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 相邻。

parametertypedescription
targetCreep, PowerCreep

目标 creep 对象。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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_TIREDERR_NO_BODYPART 检查; 否则将跳过 ERR_NOT_IN_RANGE 检查。

parametertypedescription
directionCreep|number

一个相邻的 creep 或者下列常量之一:

  • TOP
  • TOP_RIGHT
  • RIGHT
  • BOTTOM_RIGHT
  • BOTTOM
  • BOTTOM_LEFT
  • LEFT
  • TOP_LEFT

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 身体部件。

parametertypedescription
patharray|string

Room.findPath, RoomPosition.findPathToPathFinder.search 方法返回的路径值,数组或序列字符串形式都可接受。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 身体部件。

parametertypedescription
xnumber

目标在 creep 所在房间中的 x 坐标。

ynumber

目标在 creep 所在房间中的 y 坐标。

targetobject

可以是 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 方法支持的可选项。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 受到攻击时切换自动通知。通知将发送到您的帐户邮箱。默认情况下启用。

parametertypedescription
enabledboolean

是否启用通知。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 在相同位置。

parametertypedescription
targetResource

要捡起的目标对象。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 移动。

parametertypedescription
targetCreep

目标 creep。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 正方形区域内。

parametertypedescription
targetCreep, PowerCreep, Structure

要攻击的目标。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 正方形区域内。

parametertypedescription
targetCreep, PowerCreep

目标 creep 对象。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 身体部件。对目标造成的伤害随距离的增加而衰减。友方单位不会受到影响。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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]);
    }
}

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

parametertypedescription
targetStructure

要修复的目标建筑。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 相邻。

parametertypedescription
targetStructureController

要预定的目标控制器对象。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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

parametertypedescription
messagestring

要显示的信息,最长 10 字符。

public (可选)boolean

设置为 true 来让其他玩家也能看到该信息。默认为 false。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 相邻。传递一个空字符串来移除签名。

parametertypedescription
targetStructureController

要签名的目标控制器对象。

textstring

签名文本,最多 100 字符,之后的内容将被截断。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

ERR_BUSY-4

这个 creep 依然在孵化中。

ERR_INVALID_TARGET-7

目标不是一个有效的控制器对象。

ERR_NOT_IN_RANGE-9

目标太远了。

suicide()

立刻杀死该 creep。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 相邻。

parametertypedescription
targetCreep, PowerCreep, Structure

目标对象。

resourceTypestring

RESOURCE_* 常量之一。

amount (可选)number

要转移的资源数量。如果省略,将转移携带的全部指定资源。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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)。需要 WORKCARRY 身体部件。目标必须位于以 creep 为中心的 7*7 正方形区域内。

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

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

parametertypedescription
targetStructureController

要进行升级的目标控制器。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 方法。

parametertypedescription
targetStructure, Tombstone, Ruin

目标对象。

resourceTypestring

RESOURCE_* 常量之一。

amount (可选)number

被传递资源的数量。如果没有这个参数,传递全部可用数量的资源。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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

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

parametertypedescription
effectnumber

该附加效果的 ID。可以是自然效果 ID 或者 Power ID。

level (可选)number

该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。

ticksRemainingnumber

多长时间之后会失去这个效果。

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

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

parametertypedescription
effectnumber

该附加效果的 ID。可以是自然效果 ID 或者 Power ID。

level (可选)number

该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。

ticksRemainingnumber

多长时间之后会失去这个效果。

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);

给旗帜设置一个新颜色

parametertypedescription
colorstring

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

secondaryColor (可选)string

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

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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') );

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

parametertypedescription
xnumber

相同房间内的 x 坐标。

ynumber

相同房间内的 y 坐标。

posobject

可以是 RoomPosition 对象或者任何包含 RoomPosition 属性的对象。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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

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

parametertypedescription
effectnumber

该附加效果的 ID。可以是自然效果 ID 或者 Power ID。

level (可选)number

该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。

ticksRemainingnumber

多长时间之后会失去这个效果。

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

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

parametertypedescription
effectnumber

该附加效果的 ID。可以是自然效果 ID 或者 Power ID。

level (可选)number

该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。

ticksRemainingnumber

多长时间之后会失去这个效果。

Inherited from RoomObject
posRoomPosition

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

Inherited from RoomObject
roomRoom

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

idstring

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

launchRoomNamestring

发射此核弹的房间名。

timeToLandnumber

着落倒计时。

OwnedStructure

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

effectsarray

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

parametertypedescription
effectnumber

该附加效果的 ID。可以是自然效果 ID 或者 Power ID。

level (可选)number

该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。

ticksRemainingnumber

多长时间之后会失去这个效果。

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()

立即摧毁这个建筑。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

ERR_NOT_OWNER-1

你不是这个建筑的拥有者。

ERR_BUSY-4

敌对creep在这个房间中。

继承自 Structure
isActive()

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

返回值

布尔值。

继承自 Structure
notifyWhenAttacked(enabled)

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

parametertypedescription
enabledboolean

是否启用通知。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

ERR_NOT_OWNER-1

你不是这个建筑的拥有者。

ERR_INVALID_ARGS-10

enable参数不是一个布尔值。

myboolean

是否是你拥有的建筑。

ownerobject

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

parametertypedescription
usernamestring

拥有者姓名。

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 中设置指定位置的移动成本。

parametertypedescription
xnumber

位置在房间中的 x 坐标。

ynumber

位置在房间中的 y 坐标。

costnumber

该位置的移动成本,必须是整数。值为 0 时将使用该地块默认的地形移动成本。大于或等于 255 的移动成本将视为无法通过。

get(x, y)

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

parametertypedescription
xnumber

位置在房间中的 x 坐标。

ynumber

位置在房间中的 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。

parametertypedescription
valobject

任何 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 才能执行该操作。

parametertypedescription
namestring

新 power creep 的名字。最长不能超过 100 个字符。

classNamestring

新 power creep 的类型,POWER_CLASS 常量之一。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

ERR_NAME_EXISTS-3

指定的 power creep 名称已被使用。

ERR_NOT_ENOUGH_RESOURCES-6

您的账户中没有足够的 Power Level。

ERR_INVALID_ARGS-10

指定的 power creep 名称超过长度,或者 power creep 的类型(class)无效。

effectsarray

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

parametertypedescription
effectnumber

该附加效果的 ID。可以是自然效果 ID 或者 Power ID。

level (可选)number

该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。

ticksRemainingnumber

多长时间之后会失去这个效果。

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

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

parametertypedescription
usernamestring

拥有者姓名。

storeStore

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

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

powersobject

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

parametertypedescription
levelnumber

该 power 的等级。

cooldownnumber

剩余的冷却时间,当 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 已经调用的操作。

parametertypedescription
methodNamestring

要取消的 creep 方法名称。

返回值

如下错误码之一:

constantvaluedescription
OK0

该操作已被成功取消。

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) 来取消删除。

parametertypedescription
cancelboolean

将其设为 true 来取消之前的删除计划。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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);
}

Drop this resource on the ground.

parametertypedescription
resourceTypestring

RESOURCE_*常量之一。

amount (可选)number

要被丢弃的资源数量。如果为空,则所有该类型资源都会被丢弃。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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。房间控制器应位于相邻的地块上。

parametertypedescription
controllerStructureController

房间控制器。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 朝指定方向移动一个地块。

parametertypedescription
directionCreep|number

一个相邻的 creep 或者下列常量之一:

  • TOP
  • TOP_RIGHT
  • RIGHT
  • BOTTOM_RIGHT
  • BOTTOM
  • BOTTOM_LEFT
  • LEFT
  • TOP_LEFT

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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);

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

parametertypedescription
patharray|string

Room.findPathRoomPosition.findPathToPathFinder.search 的返回值。数组和序列化的字符串都可以接受。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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( ) 的调用简写。如果目标在其他房间,则相应的出口将被当做目标(在本房间中)。

parametertypedescription
xnumber

目标在 creep 所在房间中的 x 坐标。

ynumber

目标在 creep 所在房间中的 y 坐标。

targetobject

可以是 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 方法支持的可选项。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 受到攻击时切换自动通知。通知将发送到您的帐户邮箱。默认情况下启用。

parametertypedescription
enabledboolean

是否启用通知。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 在相同位置。

parametertypedescription
targetResource

要捡起的目标对象。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 必须尚未出生。

parametertypedescription
namestring

power creep 的新名字。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 恢复最大的存活时间。目标必须在相邻的地块上。

parametertypedescription
targetStructurePowerBank | StructurePowerSpawn

目标建筑。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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

parametertypedescription
messagestring

要显示的信息,最长 10 字符。

public (可选)boolean

设置为 true 来让其他玩家也能看到该信息。默认为 false。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

ERR_NOT_OWNER-1

你不是这个creep的拥有者。

ERR_BUSY-4

该 power creep 还没有出生。

spawn(powerSpawn)

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

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

parametertypedescription
powerSpawnStructurePowerSpawn

您的 Power Spawn 建筑。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 它。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 的正方形区域中。

parametertypedescription
targetCreep, Structure

The target object.

resourceTypestring

RESOURCE_*常量之一。

amount (可选)number

要转移的资源数量。如果省略,将转移携带的全部指定资源。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 才能执行该操作。

parametertypedescription
powernumber

要升级的 power,PWR_* 常量之一。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 的完整列表

parametertypedescription
powernumber

要使用的 power 能力,PWR_*常量之一。

targetRoomObject

房间中的指定目标。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 方法。

parametertypedescription
targetStructure, Tombstone

目标对象。

resourceTypestring

RESOURCE_*常量之一。

amount (可选)number

被传递资源的数量。如果没有这个参数,传递全部可用数量的资源。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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

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

parametertypedescription
effectnumber

该附加效果的 ID。可以是自然效果 ID 或者 Power ID。

level (可选)number

该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。

ticksRemainingnumber

多长时间之后会失去这个效果。

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);

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

parametertypedescription
patharray

Room.findPath 返回的路径数组。

返回值

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

Room.deserializePath(path)

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

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

parametertypedescription
pathstring

一个序列化路径字符串。

返回值

一个路径数组

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

parametertypedescription
xnumber

X 坐标。

ynumber

Y 坐标。

posobject

可以为 RoomPosition 对象或任何包含 RoomPosition 的对象。

structureTypestring

STRUCTURE_* 常量之一。

name (可选)string

建筑的名称,该建筑必须支持设置名字(当前仅有 spawn)。最长不能超过 100 个字符。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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

parametertypedescription
xnumber

X 坐标。

ynumber

Y 坐标。

posobject

可以为 RoomPosition 对象或任何包含 RoomPosition 的对象。

name (可选)string

新旗帜的名称。它应该是唯一的,即 Game.flags 不应该包含拥有相同名称(哈希键)的其他旗帜。如果未定义,则会生成随机名称。最长不得超过 100 字符。

color (可选)string

新旗帜的颜色。应为 COLOR_* 常量之一。默认值为 COLOR_WHITE

secondaryColor (可选)string

新旗帜的次要颜色。应为 COLOR_* 常量之一。默认值等于 color 属性值。

返回值

新旗帜的名称,或者下列错误码之一:

constantvaluedescription
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 结束。

parametertypedescription
typenumber

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 方法即可。

parametertypedescription
roomstring, Room

其他房间的名称或者房间对象。

返回值

出口方向常量,下列之一:

或者下列错误码之一:

constantvaluedescription
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 之间找到房间内的最佳路径。

parametertypedescription
fromPosRoomPosition

起始位置。

toPosRoomPosition

结束位置。

opts (可选)object

包含下列寻路可选项的对象:

  • ignoreCreeps
    boolean
    将其他 creep 所处的地块视作可通行的。在附近有大量移动的 creep 或者其他一些情况时会很有用。默认值为 false。
  • ignoreDestructibleStructures
    boolean
    将可破坏的建筑 (constructed walls, ramparts, spawns, extensions) 所在的地块视作可通行的。默认为 false。
  • ignoreRoads
    boolean
    无视道路。启用该项将加快搜索速度。默认值为 false。仅当新的 PathFinder 启用时才可用。
  • costCallback
    function(string, CostMatrix)
    你可以使用该回调在搜索过程中为任意房间修改 CostMatrix。回调接受两个参数,roomNamecostMatrix。使用 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 发生的事件数组。

parametertypedescription
rawboolean

如果该参数为 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 执行了 transferwithdraw
  • targetId - 目标对象 ID
  • resourceType - 被转移的资源类型
  • amount - 被转移的资源总量

getPositionAt(x, y)

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

获取指定位置的 RoomPosition 对象。

parametertypedescription
xnumber

X 坐标。

ynumber

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);
    }
});

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

parametertypedescription
xnumber

该房间中的 X 坐标。

ynumber

该房间中的 Y 坐标。

targetobject

可以是 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);

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

parametertypedescription
topnumber

区域顶部边界的 Y 坐标。

leftnumber

区域左侧边界的 X 坐标。

bottomnumber

区域底部边界的 Y 坐标。

rightnumber

区域右侧边界的 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]);
}

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

parametertypedescription
typestring

LOOK_* 常量之一。

xnumber

该房间中的 X 坐标。

ynumber

该房间中的 Y 坐标。

targetobject

可以是 RoomPosition 对象或者任何包含 RoomPosition 属性的对象。

返回值

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

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

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

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

parametertypedescription
typestring

LOOK_* 常量之一

topnumber

区域顶部边界的 Y 坐标。

leftnumber

区域左侧边界的 X 坐标。

bottomnumber

区域底部边界的 Y 坐标。

rightnumber

区域右侧边界的 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);

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

parametertypedescription
roomNamestring

房间名称。

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 类型值(详见下文)。

parametertypedescription
xnumber

该房间中的 X 坐标。

ynumber

该房间中的 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

parametertypedescription
destinationArray (可选)Uint8Array

地形数据要拷贝到的已定义的数组视图。

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

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

返回值

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

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

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

constantvaluedescription
ERR_INVALID_ARGS-10

destinationArray 类型不兼容。

RoomObject

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

effectsarray

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

parametertypedescription
powernumber

被应用的效果id。可以是自然效果或者超能效果。

levelnumber

被应用的效果等级。如果不是超能效果的话则不存在。

ticksRemainingnumber

多长时间之后会失去这个效果。

posRoomPosition

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

roomRoom

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

RoomPosition

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

constructor(x, y, roomName)

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

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

parametertypedescription
xnumber

房间中的 X 坐标。

ynumber

房间中的 Y 坐标。

roomNamestring

房间名称。

roomNamestring

所处房间的名称。

xnumber

所处房间的 X 坐标。

ynumber

所处房间的 Y 坐标。

createConstructionSite(structureType, [name])

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

在指定位置创建新的 ConstructionSite

parametertypedescription
structureTypestring

STRUCTURE_* 常量之一。

name (可选)string

建筑的名称,该建筑必须支持设置名字(当前仅有 spawn)。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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

parametertypedescription
name (可选)string

新旗帜的名称。它应该是唯一的,即 Game.flags 不应该包含拥有相同名称(哈希键)的不同旗帜。如果未定义,则会生成随机名称。最长不得超过 60 字符。

color (可选)string

新旗帜的颜色。应为 COLOR_* 常量之一。默认值为 COLOR_WHITE

secondaryColor (可选)string

新旗帜的次要颜色。应为 COLOR_* 常量之一。默认值等于 color 属性值。

返回值

新旗帜的名称,或者下列错误码之一:

constantvaluedescription
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 算法进行搜索。

parametertypedescription
typenumber

详见 Room.find

objectsarray

要执行搜索的房间对象数组或者 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);

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

parametertypedescription
typenumber

See Room.find.

objectsarray

要执行搜索的房间对象数组或者 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);

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

parametertypedescription
typenumber

详见 Room.find

objectsarray

要执行搜索的房间对象数组或者 RoomPosition 对象数组。

rangenumber

范围距离(半径)。

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 的简写。如果目标在其他房间,则相应的出口将被作为目标。

parametertypedescription
xnumber

该房间中的 X 坐标。

ynumber

该房间中的 Y 坐标。

targetobject

可以是 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);

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

parametertypedescription
xnumber

房间中的 X 坐标。

ynumber

房间中的 Y 坐标。

targetobject

可以是 RoomPosition 对象或者任何包含 RoomPosition 属性的对象。

返回值

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

getRangeTo(x,y)
(target)

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

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

parametertypedescription
xnumber

房间中的 X 坐标。

ynumber

房间中的 Y 坐标。

targetobject

可以是 RoomPosition 对象或者任何包含 RoomPosition 属性的对象。

返回值

到指定位置的地块数。

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

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

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

parametertypedescription
xnumber

房间中的 X 坐标。

ynumber

房间中的 Y 坐标。

targetRoomPosition

目标位置

rangenumber

范围距离(半径)。

返回值

一个布尔值。

isEqualTo(x,y)
(target)

if(creep.pos.isEqualTo(10,25)) {
    creep.move(RIGHT);
}
if(creep.pos.isEqualTo(Game.flags.Flag1)) {
    creep.move(RIGHT);
}

检查该位置是否和指定位置相同。

parametertypedescription
xnumber

房间中的 X 坐标。

ynumber

房间中的 Y 坐标。

targetobject

可以是 RoomPosition 对象或者任何包含 RoomPosition 属性的对象。

返回值

一个布尔值。

isNearTo(x,y)
(target)

if(creep.pos.isNearTo(target)) {
    creep.transfer(target, RESOURCE_ENERGY);
}

检查该位置是否在紧邻指定位置的正方形区域内。类似于 inRangeTo(target, 1)

parametertypedescription
xnumber

房间中的 X 坐标。

ynumber

房间中的 Y 坐标。

targetobject

可以是 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]);
}

获取该位置上给定类型的对象列表。

parametertypedescription
typestring

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 对象,即使您的脚本没有该房间的视野。

parametertypedescription
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'});

绘制一条线。

parametertypedescription
x1number

起始点的 X 坐标。

y1number

起始点的 Y 坐标。

x2number

结束点的 X 坐标。

y2number

结束点的 Y 坐标。

pos1RoomPosition

起始点位置对象。

pos2RoomPosition

结束点位置对象。

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'});

绘制一个圆。

parametertypedescription
xnumber

圆心的 X 坐标。

ynumber

圆心的 Y 坐标。

posRoomPosition

圆心的位置对象。

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'});

绘制一个矩形。

parametertypedescription
xnumber

左上角的 X 坐标。

ynumber

左上角的 Y 坐标。

topLeftPosRoomPosition

左上角的位置对象。

widthnumber

矩形的宽度。

heightnumber

矩形的高度。

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'}); 

绘制一条折线。

parametertypedescription
pointsarray

折点数组。每个元素都应是两个数字的数组(即 [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

parametertypedescription
textstring

文本信息

xnumber

文本基线(baseline)起始点的 X 坐标。

ynumber

文本基线起始点的 Y 坐标。

posRoomPosition

文本基线起始点的位置对象。

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
    文本对齐模式,centerleft 或者 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。

parametertypedescription
valstring

从 RoomVisual.export 返回的字符串。

返回值

RoomVisual 对象自身,以便进行链式调用。

Ruin

一个被摧毁的建筑。该对象允许其他单位在其上行走。

Decay 500 tick 除了某些情况外

effectsarray

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

parametertypedescription
effectnumber

该附加效果的 ID。可以是自然效果 ID 或者 Power ID。

level (可选)number

该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。

ticksRemainingnumber

多长时间之后会失去这个效果。

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

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

parametertypedescription
effectnumber

该附加效果的 ID。可以是自然效果 ID 或者 Power ID。

level (可选)number

该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。

ticksRemainingnumber

多长时间之后会失去这个效果。

Inherited from RoomObject
posRoomPosition

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

Inherited from RoomObject
roomRoom

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

energynumber

能量的剩余容量。

energyCapacitynumber

该 source 的总能量容量。

idstring

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

ticksToRegenerationnumber

该 source 还有多少 tick 将会再生。

Store

一个代表了其存储中资源的对象。

游戏中有两种类型的 store:通用型 store 和限定型 store。

两种 Store 的原型都是相同的,但是其返回值取决于调用方法时传入的 resource 参数。

你可以把资源的类型当做对象属性来获取对应的资源:

console.log(creep.store[RESOURCE_ENERGY]);

getCapacity([resource])

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

返回指定资源的存储容量, 对于通用型 store,当 reource 参数为 undefined 则返回总容量。

parametertypedescription
resource (可选)string

资源的类型

返回值

返回存储的数量, 当 resource 参数不是一个有效的存储类型时返回 null

getFreeCapacity([resource])

if(structure.store.getFreeCapacity(RESOURCE_ENERGY) > 0) {
    creep.transfer(structure, RESOURCE_ENERGY);
}

返回该存储的剩余可用容量,对于限定型 store 来说,将在 resource 对该存储有效时返回该资源的剩余可用容量。

parametertypedescription
resource (可选)string

资源类型。

返回值

返回可用的剩余容量,如果 resource 对该 store 无效则返回 null

getUsedCapacity([resource])

if(Game.rooms['W1N1'].terminal.store.getUsedCapacity() == 0) {
    // terminal is empty
}

返回指定资源已使用的容量, 若为通用型存储时, reource 参数不存在则返回总使用容量。

parametertypedescription
resource (可选)string

资源的类型

返回值

返回已使用的容量, 当 resource 参数不是一个有效的存储类型时返回 null

Structure

所有建筑的基础原型对象。

effectsarray

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

parametertypedescription
effectnumber

该附加效果的 ID。可以是自然效果 ID 或者 Power ID。

level (可选)number

该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。

ticksRemainingnumber

多长时间之后会失去这个效果。

Inherited from RoomObject
posRoomPosition

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

Inherited from RoomObject
roomRoom

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

hitsnumber

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

hitsMaxnumber

这个建筑的最大生命值。

idstring

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

structureTypestring

STRUCTURE_*常量之一。

destroy()

立即摧毁这个建筑。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

ERR_NOT_OWNER-1

你不是这个建筑的拥有者,或者不在你的房间中。

ERR_BUSY-4

敌对creep在这个房间中。

isActive()

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

返回值

布尔值。

notifyWhenAttacked(enabled)

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

parametertypedescription
enabledboolean

是否启用通知。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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

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

parametertypedescription
effectnumber

该附加效果的 ID。可以是自然效果 ID 或者 Power ID。

level (可选)number

该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。

ticksRemainingnumber

多长时间之后会失去这个效果。

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()

立即摧毁这个建筑。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

ERR_NOT_OWNER-1

你不是这个建筑的拥有者。

ERR_BUSY-4

敌对creep在这个房间中。

继承自 Structure
isActive()

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

返回值

布尔值。

继承自 Structure
notifyWhenAttacked(enabled)

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

parametertypedescription
enabledboolean

是否启用通知。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

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 的 enableRoomusePower 方法。同一时间内只能有一个房间激活安全模式。
当安全模式被激活时,所有的敌对 creep 都将变透明并且可通过, 您的 creep 可以自由的穿过他们 (反之亦然)。
持续时间 20,000 ticks
冷却时间 50,000 ticks (新手区 (Novice Areas) 以及您第一个房间的初始安全模式都没有冷却时间)
获取途径
  • 每次控制器升级时提供一次可用次数
  • 可以使用 1,000 ghodium 化合物来生成一个可用次数
  • 控制器降级时将会重置所有可用次数

effectsarray

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

parametertypedescription
effectnumber

该附加效果的 ID。可以是自然效果 ID 或者 Power ID。

level (可选)number

该附加效果的 Power 等级。如果效果不是 Power 效果则不存在该属性。

ticksRemainingnumber

多长时间之后会失去这个效果。

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()

立即摧毁这个建筑。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

ERR_NOT_OWNER-1

你不是这个建筑的拥有者。

ERR_BUSY-4

敌对creep在这个房间中。

继承自 Structure
isActive()

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

返回值

布尔值。

继承自 Structure
notifyWhenAttacked(enabled)

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

parametertypedescription
enabledboolean

是否启用通知。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

ERR_NOT_OWNER-1

你不是这个建筑的拥有者。

ERR_INVALID_ARGS-10

enable参数不是一个布尔值。

Inherited from OwnedStructure
myboolean

是否是你拥有的建筑。

Inherited from OwnedStructure
ownerobject

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

parametertypedescription
usernamestring

拥有者姓名。

isPowerEnabledboolean

该房间是否启用了超能 (power)。使用 PowerCreep.enableRoom 来启用超能。

levelnumber

当前的控制器等级,从 0 到 8。

progressnumber

当前控制器升级到下个等级的进度。

progressTotalnumber

控制器升级到下个等级所需的总进度。

reservationobject

如果控制器被预定,则该对象表示预定的信息:

parametertypedescription
usernamestring

预定了该房间的玩家名称。

ticksToEndnumber

预定时间还有多少 tick 结束。

safeModenumber

安全模式还有多少 tick 结束。没激活安全模式时返回 undefined。

safeModeAvailablenumber

可用的安全模式激活次数。

safeModeCooldownnumber

安全模式的冷却时间还有多少 tick。冷却结束前将无法激活安全模式,当安全模式没有冷却时返回 undefined。

signobject

如果控制器被签名,则该对象表示签名的信息:

parametertypedescription
usernamestring

将控制器签名的玩家名称。

textstring

签名的文本内容。

timenumber

进行签名的游戏 tick 时间。

datetimeDate

进行签名的现实时间。

ticksToDowngradenumber

该控制器还有多少 tick 将要降级。当控制器升级或者降级时, 该计时器将被设置为总降级时间的 50%。可以使用 Creep.upgradeController 来增加该计时器的时间。控制器想要升级必须先保证该计时器满额。

upgradeBlockednumber

还有多少 tick 就能从控制器被攻击从而无法升级的状态中恢复过来。在此期间安全模式也不可用。

activateSafeMode()

room.controller.activateSafeMode();

激活安全模式 (如果有的话)。

返回值

如下错误码之一:

constantvaluedescription
OK0

这个操作已经成功纳入计划。

ERR_NOT_OWNER-1

你不是