SEARCH + DIAGNOSTICS
Search discovers the most relevant guides, references, return codes, and tools. When the answer is still uncertain, continue through symptom diagnostics, API surfaces, and accepted Runtime Evidence.
Problem → likely cause → return code / API → guide / tool → accepted Runtime Evidence.
Symptom diagnostics → · API reference → · Return codes → · Runtime Evidence Hub →
80 matching results
When harvest() has no visible effect, confirm the return code, target type, range, WORK parts, and available resource before rewriting role logic.
When the Spawn queue produces nothing, separate busy state, Energy, body/name arguments, and RCL limits instead of blaming the queue generically.
When a Creep appears stuck, first separate command rejection, path failure, fatigue, and target/range logic instead of repeatedly calling moveTo().
When boostCreep() appears to fail, capture the real return value first, then separate ownership, eligible parts, Lab resources, target validity, range, and RCL; after OK, verify body boosts and Lab Store changes on a later tick.
Screeps API surface: spawn.recycleCreep(creep).
Screeps API surface: spawn.spawnCreep(body, name, opts?).
Record the harvest() result, target type, WORK parts, resource amount, and later-tick Store/Source changes.
A focused hub for Creep movement, harvesting, hauling, Controller upgrading, return codes, guides, and tools.
Calculate Energy cost, spawn time, hits, carry capacity, and loaded movement speed.
Check Spawn, workforce, Energy, Controller, construction, CPU, and bucket risks from a static snapshot.
Search common Game, Creep, Room, Structure, Market, and PathFinder APIs and continue to matching guides or official documentation.
High-frequency Screeps error codes with diagnostic paths into APIs, object hubs, guides, tools, and runtime verification.
Find the action that returned ERR_NOT_IN_RANGE, use its documented range, submit movement separately, and retry the action on a later tick.
Call Game.notify(), use groupInterval and simple Memory incident state to avoid repeated alerts, preserve the checked engine result, and keep scheduling separate from external email delivery.
Start from visible symptoms such as a Creep not moving, Spawn failures, Controller downgrade pressure, Link transfer problems, Market failures, high CPU, or stalled logistics, then continue into return codes, APIs, object hubs, guides, tools, and runtime verification.
Validate one fixed anchor against Controller range 3 and Link range 1, recover the exact owned Controller Link, diagnose Energy and active body parts, preserve move, withdraw, and upgrade return codes, and verify later position, Store, or event evidence.
Use Creep.harvest() to find an active Source, move into range, keep harvesting until your Creep is ready to deliver, and read Source-specific return codes without treating ERR_FULL as a harvest result.
See which high-frequency diagnostic paths have accepted Console or live multi-tick verification, what evidence is missing, and which runtime checks should come next.
Validate the same-tile Extractor and Miner, record only accepted harvest calls, match the exact EVENT_HARVEST on the next tick, and separate event identity from Store overflow and depletion.
Use dryRun to validate a WORK-CARRY-MOVE body, submit one safe spawnCreep() request, read its return code, and verify the new Creep across later ticks.
Find a Container that currently holds Energy, check the Creep's free capacity, call withdraw(), handle range and return codes, and keep the delivery task outside this focused guide.
Build a four-mode Screeps CPU degradation scheduler with hysteresis, consecutive-tick confirmation, critical-first task tiers, stable staggering, CPU headroom guards, and gradual recovery.
Use Creep.attack() with the correct range-1 boundary, active ATTACK parts, documented return codes, Rampart behavior, and later-tick verification.
Make one Creep transfer Energy to a named Spawn, keep delivery mode until it is empty, and connect harvesting and delivery into a first repeatable round trip.
Learn why Harvester, Upgrader, and Builder are player-defined responsibilities, how roles differ from body parts, and why a Creep name does not create behavior.
Combine three fixed beginner roles in one small loop, submit one validated Spawn request, keep Energy phases stable, expose failure statuses, and verify accepted commands on later ticks.
Inspect a misplaced Construction Site, validate its identity, submit remove() once, handle return codes, and verify the result on the next tick.
Capture the actual Spawn request, interpret each documented return code, separate dryRun from the final submission, and verify scheduled spawning across later ticks.
Verify movement over later ticks, then isolate fatigue, repeated movement intents, traffic, cached paths, room edges, and impossible stop ranges.
Measure one code section with Game.cpu.getUsed() deltas, compare equivalent server ticks, separate bucket context from profiling, and protect essential work before optional tasks.
Read the previous tick's Room events, distinguish parsed and raw mode, filter event-specific data safely, match actor and target IDs when attribution matters, and keep optional history bounded.
Use fill: 'transparent' for unfilled RoomVisual circles and rectangles, then add debug labels and target paths without confusing visuals with game results.
Catch JavaScript exceptions at room or subsystem boundaries, retain bounded rate-limited evidence, pause repeatedly failing optional work, and retry after cooldown without confusing API return codes or CPU termination with exceptions.
Diagnose room.energyAvailable below energyCapacityAvailable by reconciling active Spawn and Extension Stores, holding one stable fill target, preserving transfer() results, and matching the processed Energy transfer on the next tick.
Learn what Screeps is, how JavaScript controls its persistent world, and how Rooms, Creeps, Sources, Spawns, and Controllers work together for new players.
Open a Screeps Room, switch to the code editor and player Console, then use read-only checks to match exact Room, Spawn, Creep, Source, and Controller data.
Understand a Screeps tick, Game.time, and module.exports.loop, then run safe observations that show why actions and state changes appear across later ticks.
Inspect one Creep's active WORK, CARRY, and MOVE parts, then use its action result, Store, fatigue, and damage to diagnose missing abilities.
Distinguish local variables, disposable heap cache, and persistent Memory; initialize Creep state safely; store JSON-compatible values; and recover current game objects from IDs.
Clean stale Memory.creeps entries by comparing them with Game.creeps. Delete only confirmed dead names and keep custom task indexes in sync.
Detect whether a capable harvester exists or is already spawning, submit one minimum recovery request, save the exact Spawn and Creep name, and verify that request across later ticks.
Learn StructureSpawn.renewCreep() requirements, TTL and Energy formulas, Boost and CLAIM limits, return codes, and how to verify renewal on the next tick.
Bind one retirement request to exact Spawn and Creep IDs, reserve both objects, record pending evidence only after OK, then match the exact destruction event and Creep-tile Tombstone.
Calculate unboosted Creep movement from MOVE recovery, loaded body weight, road, plain, and swamp costs; account for empty CARRY parts; and separate a static body estimate from live multi-tick movement proof.
Learn why Game.rooms[roomName] is undefined without current room vision, how to guard live Room reads, and why Memory.rooms does not prove visibility.
In Screeps PathFinder, a CostMatrix cost of 255 is unwalkable. See what 0, 1–254, and 255 mean, plus practical road, obstacle, and roomCallback rules.
Learn StructureLab.boostCreep() requirements, bodyPartsCount usage, return codes, current-tick scheduling, and how to verify exact boosted body parts afterward.
Find injured owned Creeps, rank lower hit ratios before missing hits and nearest-Tower range, require active owned Towers with TOWER_ENERGY_COST, save heal() results, avoid caching stale targets, and leave over-heal optimization to a later dispatcher.
Enter Controller recovery with hysteresis, reject blocked or unready attempts, submit one upgrader action, and verify the exact Creep in the next tick's room event log.
Bind confirmation to the exact Extension and owned room, block hostile Creeps and Power Creeps, submit one queued destroy call, then distinguish original-ID removal from a later replacement at the tile.
Keep one main loop, export small functions, pass current game objects into modules, validate role contracts once per runtime, isolate per-Creep failures, and keep durable state out of module scope.
Change, extend, or cancel one owned Screeps market order with nullable room fingerprints, conservative fee budgeting, one-writer request IDs, raw return codes, and next-tick state verification.
Calculate a replacement deadline from ticksToLive, current Spawn work, body spawn time, travel and safety margin, prevent duplicate role replacements, preserve spawnCreep results, and observe the accepted name later.
Confirm a blocked Screeps Spawn exit from current spawning state and all eight adjacent tiles, then fix direction policy without confusing accepted intents with observed birth.
Centralize Creep demand, deduplicate stable request keys, rank emergency and replacement work, reserve shared room Energy locally, assign each idle Spawn once, and verify accepted names on later ticks.
Call PathFinder.search() with the goal range your action actually needs, interpret path, ops, cost, and incomplete correctly, and reject partial paths before handing movement to a Creep.
Coordinate Creep.pull(), the puller's movement, and target.move(puller) in the same tick, handle adjacency and fatigue correctly, and verify the pair moved later.
Find your Screeps Arena Spawn with getObjectsByPrototype(), call spawnCreep(body), read object or error results, and avoid mixing Arena with MMO syntax.
Browse 25 published English guides related to Creeps.
A focused hub for spawnCreep(), renewCreep(), recycleCreep(), Spawn return codes, and capacity planning.
A practical hub for Store used, free, and total capacity semantics across Creep hauling, Storage, Containers, and room economy.
The English home for practical Screeps learning, debugging, references, and tools.
A learning sequence from ticks and the first Creep to roles, upgrading, construction, and a room loop.
Definitions for Creep, Spawn, tick, Memory, Controller, RCL, GCL, CPU, bucket, store, and fatigue.
Build one Upgrader1 loop that harvests from an active Source, moves within Controller range 3, spends Energy with upgradeController(), and switches state across ticks.
Confirm RCL 2, place one Extension Construction Site, make Builder1 harvest and build it, and understand progress, capacity, and common failure states.
Give Builder1 a clear priority: build owned sites, repair selected damaged structures, and upgrade the Controller when no higher task exists.
Filter FIND_DROPPED_RESOURCES for Energy, rank valid piles by collectible amount and path length, handle decay and changing targets, and inspect pickup() and movement results.
Enter acquire at zero Energy, enter work when full, preserve the previous phase at partial values, initialize explicitly, and keep state selection separate from actions and outcomes.
Save an ID with room and kind metadata, return explicit invalid, no-vision, missing, wrong-type, and ready states, and keep restoration separate from reselection and actions.
Separate minimum, target, and emergency body policies; scale one role template within current Energy and the 50-part limit; then validate spawning separately.
Separate ERR_NO_PATH from missing cached paths and incomplete PathFinder searches, then inspect goal range, CostMatrix rules, callbacks, limits, and room routes.
Choose between getRangeTo(), inRangeTo(), isNearTo(), isEqualTo(), findClosestByRange(), findClosestByPath(), and findInRange() without confusing linear range with route reachability.
Separate room planning from exit-tile pathfinding, validate the first route step, use finite risk costs versus hard bans, and verify the border transition on later ticks.
Collect requests, choose one target per Observer, make one final observeRoom() call, store only that accepted target, read it next tick, and keep visibility attribution honest.
Cache derived IDs and plain data in global, rebuild after resets, invalidate with explicit versions, and keep callers correct when the cache is missing or stale.
Request active Segment IDs once, read them on a later tick, distinguish unavailable from empty, validate versioned JSON, and write only after a successful read.
Freeze one reviewed order revision, reserve the creation fee and account mutation slot, call createOrder once, and verify the exact new order ID in the next account snapshot.
Freeze one reviewed deal revision, reserve both an account deal slot and the exact Terminal, submit once, and verify the new transaction ID and actual partial or full amount next tick.
Freeze one transfer revision, reserve the exact Terminal against send and market-deal conflicts, submit once, normalize ledger descriptions, and verify the actual full or partial outgoing transaction next tick.