TypeScript Definition Files for The Game Screeps

screeps.d.ts

declare var Game: screeps.IGame;

declare module screeps {

	export interface IGame {
		cpuLimit: number;
		creeps: { [screepName: string]: ICreep };
		flags: { [flagName: string]: IFlag };
		map: IMap;
		rooms: { [roomName: string]: IRoom };
		spawns: { [spawnName: string]: ISpawn };
		structures: { [structureName: string]: IStructure };
		time: number;

		getObjectById(id: string): any;
		getUsedCpu(): number;
		notify(message: string, groupInterval?: number): void;
	}

	export interface ICreep extends IHasRoomPosition {
		body: { type: string, hits: number }[];
		carry: { energy: number };
		carryCapacity: number;
		fatigue: number;
		hits: number;
		hitsMax: number;
		id: string;
		memory: any;
		my: boolean;
		name: string;
		owner: IOwner;
		room: IRoom;
		spawning: boolean;
		ticksToLive: number;

		attack(target: ICreep|ISpawn|IStructure): ActionResultCode;
		build(target: IConstructionSite): ActionResultCode;
		cancelOrder(methodName: string): ActionResultCode;
		claimController(target: IStructure): ActionResultCode;
		dropEnergy(amount?: number): ActionResultCode;
		getActiveBodyparts(type: string): number;
		harvest(target: ISource): ActionResultCode;
		heal(target: ICreep): ActionResultCode;
		move(direction: number): ActionResultCode;
		moveByPath(path: IPathStep[]): ActionResultCode;
		moveTo(x: number, y: number, opts?: MoveToOptions);
		moveTo(target: RoomPosition|IHasRoomPosition);
		notifyWhenAttacked(enabled: boolean): ActionResultCode;
		pickup(target: IEnergy): ActionResultCode;
		rangedAttack(target: ICreep|ISpawn|IStructure): ActionResultCode;
		rangedHeal(target: ICreep): ActionResultCode;
		rangedMassAttack(): ActionResultCode;
		repair(target: ISpawn|IStructure): ActionResultCode;
		say(message: string): ActionResultCode;
		suicide(): ActionResultCode;
		transferEnergy(target: ICreep|ISpawn|IStructure, amount?: number): ActionResultCode;
		unclaimController(target: IStructure): ActionResultCode;
		upgradeController(target: IStructure): ActionResultCode;
	}

	export class RoomPosition {
		constructor(x: number, y: number, roomName: string);
		roomName: string;
		x: number;
		y: number;
		createConstructionSite(structureType: string): ActionResultCode;
		createFlag(name?: string, color?: string): ActionResultCode;
		findClosest(type: number, opts?: IPathfindingOptions|IFilterOption|IPathfindingAlgorithmOption): any;
		findClosest(objects: any[], opts?: IPathfindingOptions|IFilterOption|IPathfindingAlgorithmOption): any;
		findClosestByRange(type: number, opts?: IFilterOption): any;
		findClosestByRange(objects: any[], opts?: IFilterOption): any;
		findInRange<T>(type:number, range: number, opts?: IFilterOption): T[];
		findInRange(objects, range: number, opts?: IFilterOption): any[];
		findPathTo(x: number, y: number, opts?: IPathfindingOptions): IPathStep[];
		findPathTo(target: RoomPosition|IHasRoomPosition, opts?: IPathfindingOptions): IPathStep[];
		getDirectionTo(x: number, y: number): number;
		getDirectionTo(target: RoomPosition|IHasRoomPosition): number;
		getRangeTo(x: number, y: number): number;
		getRangeTo(target: RoomPosition|IHasRoomPosition): number;
		inRangeTo(toPos: RoomPosition|IHasRoomPosition, range: number): boolean;
		isEqualTo(x: number, y: number): boolean;
		isEqualTo(target: RoomPosition|IHasRoomPosition): boolean;
		isNearTo(x: number, y: number): boolean;
		isNearTo(target: RoomPosition|IHasRoomPosition): boolean;
		look(): { type: string }[];
		lookFor(type: string): any[];
		lookFor(type: 'constructionSite'): IConstructionSite[];
		lookFor(type: 'creep'): ICreep[];
		lookFor(type: 'energy'): IEnergy[];
		lookFor(type: 'exit'): IExit[];
		lookFor(type: 'flag'): IFlag[];
		lookFor(type: 'source'): ISource[];
		lookFor(type: 'structure'): IStructure[];
		lookFor(type: 'terrain'): ITerrain[];
	}

	export interface IHasRoomPosition {
		pos: RoomPosition;
	}

	export interface IFlag extends IHasRoomPosition {
		id: string;
		color: string;
		memory: any;
		name: string;
		room: IRoom;
		roomName: string;
		remove(): ActionResultCode;
		setColor(color: string): ActionResultCode;
		setPosition(x: number, y: number): ActionResultCode;
		setPosition(pos: RoomPosition|IHasRoomPosition): ActionResultCode;
	}

	export interface IEnergy extends IHasRoomPosition {
		energy: number;
		id: string;
		room: IRoom;
	}

	export interface ISpawn extends IHasRoomPosition {
		energy:number;
		energyCapacity:number;
		hits:number;
		hitsMax:number;
		id:string;
		memory:any;
		my:boolean;
		name:string;
		owner:IOwner;
		room:IRoom;
		structureType:string;
		spawning:{
			name:string;
			needTime:number;
			remainingTime:number;
		};
		canCreateCreep(body:string[], name?:string):ActionResultCode;
		createCreep(body:string[], name?:string, memory?:any):ActionResultCode;
		destroy():ActionResultCode;
		notifyWhenAttacked(enabled:boolean):ActionResultCode;
		transferEnergy(target:ICreep, amount?:number);
	}
	
	export interface IStructure extends IHasRoomPosition { 
		hits:number;
		hitsMax:number;
		id:string;
		my:boolean;
		owner:IOwner;
		room:IRoom;
		structureType:string;
		destroy():ActionResultCode;
		notifyWhenAttacked(enabled:boolean):ActionResultCode;
	}
	
	export interface IExtension extends IStructure {
		energy:number;
		energyCapacity:number;
		transferEnergy(target:ICreep, amount?:number):ActionResultCode;
	}
	
	export interface ILink extends IStructure {
		cooldown:number;
		energy:number;
		energyCapacity:number;
		transferEnergy(target:ICreep|ILink, amount?:number):ActionResultCode;
	}
	
	export interface IKeeperLair extends IStructure {
		ticksToSpawn:number;
	}
	
	export interface IController extends IStructure{
		level:number;
		progress:number;
		progressTotal:number;
		ticksToDowngrade:number;
	}
	
	export interface IRampart extends IStructure {
		ticksToDecay:number;
	}
	
	export interface IRoad extends IStructure {
		ticksToDecay:number;
	}
	
	export interface IWall extends IStructure {
		ticksToLive:number;
	}
	
	export interface IStorage extends IStructure {
		store:{energy:number};
		storeCapacity:number;
		transferEnergy(target:ICreep, amount?:number):ActionResultCode;
	}
	
	export interface ISource extends IHasRoomPosition { 
		energy:number;
		energyCapacity:number;
		id:string;
		room:IRoom;
		ticksToRegeneration:number;
	}

	export interface IOwner { 
		username: string 
	}

	export interface IConstructionSite extends IHasRoomPosition {
		id: string;
		my: boolean;
		owner: IOwner;
		progress: number;
		progressTotal: number;
		room: IRoom;
		structureType: string;
		remove(): ActionResultCode;
	}

	export interface IMap {
		describeExits(roomName:string):{[index:number]:string};
		findExit(fromRoom:string|IRoom, toRoom:string|IRoom):number;
		findRoute(fromRoom, toRoom):{exit:number, room:string}[]|ActionResultCode;
		isRoomProtected(roomName:string):boolean;
	}
	
	export interface IRoom {
		controller?:IController;
		energyAvailable:number;
		energyCapacityAvailable:number;
		memory:any;
		mode:string;
		name:string;
		storage?:IStorage;
		survivalInfo?:{score:number, timeToWave:number, wave:number};
		createConstructionSite(x:number, y:number, structureType:string):ActionResultCode;
		createConstructionSite(pos:RoomPosition|IHasRoomPosition, structureType:string):ActionResultCode;
		createFlag(x:number, y:number, name?:string, color?:string):ActionResultCode;
		createFlag(pos:RoomPosition|IHasRoomPosition, name?:string, color?:string):ActionResultCode;
		find<T>(type:number, opts?:IFilterOption):T[];
		findExitTo(room:string|IRoom):number;
		findPath(fromPos:RoomPosition, toPos:RoomPosition, opts?:IPathfindingOptions):IPathStep[];
		getPositionAt(x:number, y:number):RoomPosition;
		lookAt(x:number, y:number): {type:string}[];
		lookAt(target:RoomPosition|IHasRoomPosition): {type:string}[];
		lookAtArea(top:number, left:number, bottom:number, right:number):IAreaFindResults<{type:string}>;
		lookForAt(type:string, x:number, y:number):any[];
		lookForAt(type:'constructionSite', x:number, y:number):IConstructionSite[];
		lookForAt(type:'creep', x:number, y:number):ICreep[];
		lookForAt(type:'energy', x:number, y:number):IEnergy[];
		lookForAt(type:'exit', x:number, y:number):IExit[];
		lookForAt(type:'flag', x:number, y:number):IFlag[];
		lookForAt(type:'source', x:number, y:number):ISource[];		
		lookForAt(type:'structure', x:number, y:number):IStructure[];
		lookForAt(type:'terrain', x:number, y:number):ITerrain[];
		lookForAt(type:string, target:RoomPosition|IHasRoomPosition):any[];
		lookForAt(type:'constructionSite', target:RoomPosition|IHasRoomPosition):IConstructionSite[];
		lookForAt(type:'creep', target:RoomPosition|IHasRoomPosition):ICreep[];
		lookForAt(type:'energy', target:RoomPosition|IHasRoomPosition):IEnergy[];
		lookForAt(type:'exit', target:RoomPosition|IHasRoomPosition):IExit[];
		lookForAt(type:'flag', target:RoomPosition|IHasRoomPosition):IFlag[];
		lookForAt(type:'source', target:RoomPosition|IHasRoomPosition):ISource[];		
		lookForAt(type:'structure', target:RoomPosition|IHasRoomPosition):IStructure[];
		lookForAt(type:'terrain', target:RoomPosition|IHasRoomPosition):ITerrain[];
		lookForAtArea(type:string, top:number, left:number, bottom:number, right:number):IAreaFindResults<any>;
		lookForAtArea(type:'constructionSite',top:number, left:number, bottom:number, right:number):IAreaFindResults<IConstructionSite>;
		lookForAtArea(type:'creep',top:number, left:number, bottom:number, right:number):IAreaFindResults<ICreep>;
		lookForAtArea(type:'energy',top:number, left:number, bottom:number, right:number):IAreaFindResults<IEnergy>;
		lookForAtArea(type:'exit',top:number, left:number, bottom:number, right:number):IAreaFindResults<IExit>;
		lookForAtArea(type:'flag',top:number, left:number, bottom:number, right:number):IAreaFindResults<IFlag>;
		lookForAtArea(type:'source',top:number, left:number, bottom:number, right:number):IAreaFindResults<ISource>;		
		lookForAtArea(type:'structure',top:number, left:number, bottom:number, right:number):IAreaFindResults<IStructure>;
		lookForAtArea(type:'terrain',top:number, left:number, bottom:number, right:number):IAreaFindResults<ITerrain>;
	}
	
	export interface IAreaFindResults<T> {
		[x:number]:{
			[y:number]:T[]
		}
	}
	
	export interface IExit extends IHasRoomPosition { 
		exit:number;
		id:string;
		room:IRoom;
	}
	
	export interface ITerrain { }

	enum ActionResultCode {
		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_INVALID_TARGET = -7,
		ERR_FULL = -8,
		ERR_NOT_IN_RANGE = -9,
		ERR_INVALID_ARGS = -10,
		ERR_TIRED = -11,
		ERR_NO_BODYPART = -12,
		ERR_RCL_NOT_ENOUGH = -14,
		ERR_GCL_NOT_ENOUGH = -15
	}

	export interface IPathStep {
		x: number;
		y: number;
		dx: number;
		dy: number;
		direction: number;
	}

	export interface IPathfindingOptions {
		ignoreCreeps?: boolean;
		ignoreDestructibleStructures?: boolean;
		ignore?: any[];
		avoid?: any[];
		maxOps?: number;
		heuristicWeight?: number;
	}

	export interface IReusePathOptions {
		reusePath?: number;
		noPathFinding?: boolean;
	}

	export interface IFilterOption {
		filter: Object|Function|string;
	}

	export interface IPathfindingAlgorithmOption {
		algorithm: string;
	}

	type MoveToOptions = IPathfindingOptions|IReusePathOptions;
}

declare module 'screeps' {
	export = Game;
}

//Search Type Constants
declare const FIND_CREEPS: number;
declare const FIND_MY_CREEPS: number;
declare const FIND_HOSTILE_CREEPS: number;
declare const FIND_MY_SPAWNS: number;
declare const FIND_HOSTILE_SPAWNS: number;
declare const FIND_SOURCES: number;
declare const FIND_SOURCES_ACTIVE: number;
declare const FIND_DROPPED_ENERGY: number;
declare const FIND_STRUCTURES: number;
declare const FIND_MY_STRUCTURES: number;
declare const FIND_HOSTILE_STRUCTURES: number;
declare const FIND_FLAGS: number;
declare const FIND_CONSTRUCTION_SITES: number;
declare const FIND_EXIT_TOP: number;
declare const FIND_EXIT_RIGHT: number;
declare const FIND_EXIT_BOTTOM: number;
declare const FIND_EXIT_LEFT: number;
declare const FIND_EXIT: number;

//Structure Type Constants
declare const STRUCTURE_EXTENSION: string;
declare const STRUCTURE_RAMPART: string;
declare const STRUCTURE_ROAD: string;
declare const STRUCTURE_SPAWN: string;
declare const STRUCTURE_WALL: string;
declare const STRUCTURE_KEEPER_LAIR: string;
declare const STRUCTURE_PORTAL: string;
declare const STRUCTURE_CONTROLLER: string;
declare const STRUCTURE_LINK: string;

//Flag Color Constants
declare const COLOR_WHITE: string;
declare const COLOR_GREY: string;
declare const COLOR_RED: string;
declare const COLOR_PURPLE: string;
declare const COLOR_BLUE: string;
declare const COLOR_CYAN: string;
declare const COLOR_GREEN: string;
declare const COLOR_YELLOW: string;
declare const COLOR_ORANGE: string;
declare const COLOR_BROWN: string;

//Room Mode Constants
declare const MODE_SIMULATION: string;
declare const MODE_SURVIVAL: string;
declare const MODE_WORLD: string;
declare const MODE_ARENA: string;

//Creep Body Type Constants
declare const WORK: string;
declare const MOVE: string;
declare const CARRY: string;
declare const ATTACK: string;
declare const RANGED_ATTACK: string;
declare const HEAL: string;
declare const TOUGH: string;