> For the complete documentation index, see [llms.txt](https://modding.corekeepergame.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://modding.corekeepergame.com/changelog/mod-sdk-changelog/1.0.md).

# 1.0

* Core Keeper is now available on consoles as well as PC. Modding is only available on PC, and we will most likely never support mods on consoles in the same way we do on PC. The platform owners (i.e. Sony, Microsoft and Nintendo) have strict requirements for all games that are released on their consoles, and there is no reasonable way to comply with them if players can modify the game to any meaningful extent.
* There is a known issue with mods not working properly on non-steam platforms due to some differences in the game initialization flow. We are working on a fix for this.
* Player controller has been changed to be server authoritative instead. This was also mentioned in the game changelog, but this is worth bringing up here as well as one of the biggest refactorings we’ve done. This means the player controller consists of a number of ECS systems. The code is still similar in places, but for example PlayerController have more static functions instead called from ECS.
* Apart from the player most enemies and objects are interpolated (shown with a server delay to avoid client-side computation). Some player interactions can still make them be predicted instead to improve responsiveness which means that a bunch of logic are now supporting prediction meaning a lot more systems are designed to run both on server and client.
* Completely new interaction system which is triggered from ECS. This part had to be completely remade instead of ported. Callbacks on EntityMonoBehaviours like OnUse should still be called in the same way via the new system.
* All SinglePugMap methods have been refactored to use world coordinates instead of render coordinates. Use EntityMonoBehaviour.ToWorldFromRender or Manager.camera.RenderOrigo to convert from render to world coordinates.
* RenderOrigo has been renamed to the more accurate RenderAnchor. You can access these using Manager.camera.GetRenderAnchor. If you don’t need it for the full session, call Manager.camera.ReturnRenderAnchor to return it so that it can be cleaned up.
* PugSprite has been completely removed. This component was used to create MeshRenderers from SpriteRenderer to get the batching support from Unity, but has since been replaced mostly by using SpriteObject instead of SpriteRenderer.
* Even more enemies and objects have been converted from SpriteRenderer to using our own sprite rendering solution SpriteObject.
* More parts of the code is now using Burst, especially after the player controller rework. This is mainly done to improve performance. We are aware that Burst-compiled code is a lot harder to patch, and we are already looking into ways to make this easier for modding.
* The new world generation uses a new GPU-driven framework to generate the terrain. This data is processed by an ECS system to create the ECS data that describes a world. The rules for this processing are described in the \`TileTypeMapping\` asset. You can also get direct access to the data produced by world generation shaders via the helper struct created by \`Manager.worldgen.CreateProceduralDataRequester\`. Each position in-game is described by a RGBA pixel. The current format is as follows:
  * Red channel: encodes the tile type. Use \`CoreKeeperWorld.GetTileType\` to get a more meaningful enum value.
  * Green channel: encodes the biome. Use \`CoreKeeperWorld.GetBiome\` to get a more meaningful enum value.
  * Blue channel: bit 0 (least significant) encodes if the position has only floor and no wall, bit 1 if there is a roof hole, and bit 3 if the Great Wall occupies this position. All other bits are currently unused.
  * Alpha channel: bits 0-2 encodes the ore type at this position. All other bits are currently unused.
* SerializeWorldSystem has been reworked to only load in things to the “live” world when the player is close enough (200 tiles). Previously, entities outside this range would be disabled but would still be kept in the live world. Some entities are always loaded like electricity, automation objects and bosses. The unloaded objects are kept in a separate ECS world (SerializeWorld) with a minimal representation. This world is what the world save file contains.
* AnimationAuthoring script was moved inadvertently, if you used this in any custom GameObject, you’ll have to reassign it. We try to not break references like that, but this one slipped the cracks in some refactor.
* WindUpAuthoring removed and same settings are moved to SecondaryUseAuthoring.
* Custom EntityMonoBehaviours aren’t updated as automatically as before, you might have to call some functions manually via GraphicalUpdate (see EnemyExample).
* Addressables are used in various places to load and unload assets to minimize memory footprint.
* A bunch of TimerSimple fields have been changed to use TickTimer. The typical reason is that this timer needs to be synchronized between server and client meaning that it needs to use NetworkTick instead of a regular floating point value to measure time.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://modding.corekeepergame.com/changelog/mod-sdk-changelog/1.0.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
