Maps

The Maps folder is located inside the Data folder in your GameMode's ContentPath and contains all the map files that are used to run your GameMode.

The files contain many lines of code. Each line of code is a single object or group of map objects, also known as entities, which each can have a range of tags describing their characteristics.

A general note to all GameMode Mappers (MUST READ)

This page has been updated for Pokémon 3D v0.60. If you feel like something is missing from this page, feel free to notify us in our Discord Server

If you are a GameMode Mapper or trying to be one, we Recommend you to download Notepad++ and our Syntax Highlighting as it makes it easier to read the map files and find typos.

If you find something on this page that doesn't work the way you'd expect it to be, it might be a bug. Try asking us on our Discord Server.
Make sure to include the game version you're running and state clearly what you are trying to do.

You are free to create your folder structure in any way you'd like, though it's recommended to follow some kind of logical pattern. For example:

RegionName\
    Cities\
        CityName\
            PlayerHouse1F.dat
            PlayerHouse2F.dat
            Lab.dat
            Main.dat
    Routes\
        Route5\
           DayCare.dat
        Route1.dat
        Route2.dat
        Route3.dat
        Route4.dat
        Route5.dat

Important info / definition of certain things before we get started

Distance in Pokémon 3D (and in the documentation) is measured in "units". A unit is equal to the distance that the Player moves when they take a single step. A single three-dimensional unit can be compared to a cube that is 1x1x1 units in size.

By default, the Argument Types are:

• Str [String] (Strings are defined as letters or symbols)
• Int [Integer] (Integers are defined as Integer numbers)
• Sng [Single/Float] (Singles/Floats are defined as Real numbers, which may include decimals.)
• Bool [Boolean] (Booleans are defined as 0 or 1, e.g. Bool[0] = False & Bool[1] = True)
• Rec [Rectangle] (Rectangles are defined as an array of Integer numbers, e.g. Rec[0,0,16,16])
• RecArr [Rectangle Array] (Rectangle Arrays are defined as an array of Rectangles, e.g. RecArr[[0,0,16,16][16,0,16,16]])
• IntArr [Integer Array] (Integer Arrays are defined as an array of Integer numbers, e.g. IntArr[1,2,1])
• SngArr [Single Array] (Single Arrays are defined as an array of Real numbers, e.g. SngArr[0.5,0.5,0.75])
• IntArr2D [Animation Array] (Animation Arrays are slightly more complex. They are defined as one or multiple array of Integer numbers and are only relevant to AnimatedBlock entities. Their format is: IntArr2D[[FrameX,FrameY,FrameWidth,FrameHeight,AmountOfRows,AmountOfColumns,AnimationSpeed,StartRow,StartColumn]]).

If part of an argument or value looks like this: bold text, it's optional.

Creating a Map

To create a map file, create a new regular text file and change its extension to .dat instead of .txt. Then, you need to define its tags. You can do so by adding these templates to the start of the text file:

{"Level"{LEV[{"Name"{Str[]}}{"MusicLoop"{Str[]}}{"WildPokemon"{Bool[]}}{"OverworldPokemon"{Bool[]}}{"CurrentRegion"{Str[]}}{"RegionalForm"{Str[]}}{"HiddenAbility"{Int[]}}]}}

{"Actions"{LEV[{"CanTeleport"{Bool[]}}{"CanDig"{Bool[]}}{"CanFly"{Bool[]}}{"RideType"{Int[]}}{"EnvironmentType"{Int[]}}{"Weather"{Int[]}}{"Season"{Int[]}}{"Lighting"{Int[]}}{"DayTime"{Int[]}}{"IsDark"{Bool[]}}{"IsAurora"{Bool[]}}{"Terrain"{Str[]}}{"IsSafariZone"{Bool[]}}{"BugCatchingContest"{Str[]}}{"MapScript"{Str[]}}{"RadioChannels"{Str[]}}{"BattleMap"{Str[]}}{"SurfingBattleMap"{Str[]}}{"SaveOnly"{Bool[]}}]}}

These are all the available tags to define a map with. Not all tags are required, so you can remove the tags that return a default value if they don't exist.

{"Level"{LEV[Tag1,Tag2,...]}}

Tag	Description	Default Argument Value
{"Name"{Str[]}}	Determines the map name, displays in the upper left corner of the screen when first arriving at the place. Used to determine if a Pokémon evolves there, e.g. {"Name"{Str[Pallet Town]}}.	No Default Value
{"MusicLoop"{Str[]}}	Determines the default background music for the map. Be sure to write the name of the music file (relative to the Songs folder, including subfolders if any) without the extension. Example: {"MusicLoop"{Str[Cities\Pallet]}}.	No Default Value
{"WildPokemon"{Bool[]}}	Determines if wild Pokémon should be able to appear anywhere on the map (not just in tall grass or water).	{"WildPokemon"{Bool[0]}}.
{"OverworldPokemon"{Bool[]}}	Determines whether the first Pokémon in the Player's team should appear behind the Player on the map or not.	{"OverworldPokemon"{Bool[1]}}
{"CurrentRegion"{Str[]}}	Determines what region or regions the map should be considered to be a part of. Example: {"CurrentRegion"{Str[Johto,Kanto]}}.	{"CurrentRegion"{Str[Johto]}}
{"RegionalForm"{Str[]}}	Determines what regional forms are available on this map. Example: {"RegionalForm"{Str[Alola]}}.	No Default Value
{"HiddenAbility"{Int[]}}	Determines the chance of a Hidden Ability being on a wild Pokémon for this map. The value can range from 0 - 100.	{"HiddenAbility"{Int[0]}}

{"Actions"{LEV[Tag1,Tag2,...]}}

Tag	Description	Default Argument Value
{"CanTeleport"{Bool[]}}	Determines whether a Pokémon should be able to use the field move Teleport on this map.	{"CanTeleport"{Bool[0]}}
{"CanDig"{Bool[]}}	Determines if a Pokémon should be able to use the field move Dig on this map.	{"CanDig"{Bool[0]}}
{"CanFly"{Bool[]}}	Determines if a Pokémon should be able to use the field move Fly on this map. Tip: If you have two maps, both with the "CanFly" Tag set to 1, you can warp from one to the other using a WarpBlock without having the "enter" sound effect play.	{"CanFly"{Bool[0]}}
{"RideType"{Int[]}}	Determines whether a Pokémon can use the field move Ride on this map. 0 - If either "CanFly" or "CanDig" = True, then it's able to use Ride. 1 - Always able to use Ride. 2 - Never able to use Ride.	{"RideType"{Int[0]}}
{"EnvironmentType"{Int[]}}	Determines the environment (sky/background) of the map. 0 - Outside 1 - Inside 2 - Cave 3 - Darkness 4 - Underwater 5 - Forest	{"EnvironmentType"{Int[0]}}
{"Weather"{Int[]}}	Determines the Weather of the map. 0 - Random based on the season 1 - Clear 2 - Rain 3 - Snow 4 - Underwater 5 - Sunny 6 - Fog 7 - Thunderstorm 8 - Sandstorm 9 - Ash 10 - Blizzard 11 - Mist	{"Weather"{Int[0]}}
{"Season"{Int[]}}	Changes the current in-game season until another map has its Season tag set to -1 or when a script changes it. -1 = The season from the current month 0 = Always Winter 1 = Always Spring 2 = Always Summer 3 = Always Fall	No Default Value
{"Lighting"{Int[]}}	Determines the lighting of the map. 0 = Use the lighting corresponding to the current time of day. 1 = Disable lighting 2 = Always Night 3 = Always Morning 4 = Always Day 5 = Always Evening	{"Lighting"{Int[1]}}
{"DayTime"{Int[]}}	Determines the time of day to use for the Outside sky/background and default lighting. 0 = Use the DayTime corresponding to the current time of day. 1 = Always Night 2 = Always Morning 3 = Always Day 4 = Always Evening	{"DayTime"{Int[0]}}
{"IsDark"{Bool[]}}	Determines if a darkness screen overlay should appear while on this map that requires the field move Flash to get rid of.	{"IsDark"{Bool[0]}}.
{"IsAurora"{Bool[]}}	Determines if the Outside sky/background texture should be the Aurora Borealis texture on this map.	{"IsAurora"{Bool[0]}}.
{"Terrain"{Str[]}}	Determines the terrain type of the map. Plain Sand Cave Rock TallGrass LongGrass PondWater SeaWater Underwater DistortionWorld Puddles Snow Magma PvPBattle	{"Terrain"{Str[Plain]}}.
{"IsSafariZone"{Bool[]}}	Determines if the map is a Safari Zone.	{"IsSafariZone"{Bool[0]}}.
{"SaveOnly"{Bool[]}}	When set to 1, only allows the Player to save the game on certain maps (and prevents access to the other options in the menu)	{"SaveOnly"{Bool[0]}}.
{"BugCatchingContest"{Str[]}}	Determines the data used in a bug catching contest. You can use this template: {"BugCatchingContest"{Str[EndContestMenuScript,CheckRemainingBallsMenuScript,RemainingBallsItemName]}} Example: {"BugCatchingContest"{Str[NationalPark\End_Contest_Menu,NationalPark\Sport_Balls,Sport Balls]}}	No Default Value
{"MapScript"{Str[]}}	Determines the script to run when the Player enters this map.	No Default Value
{"RadioChannels"{Str[]}}	Determines which Radio Channel frequencies can be used on this map. Example: {"RadioChannels"{Str[13.5,20.5]}}	No Default Value (All channels are available)
{"BattleMap"{Str[]}}	Determines the Map that is visible in the background during regular battles and optionally its offset position. The following formats are valid: {"BattleMap"{Str[MapName,xOffset,yOffset,zOffset]}} {"BattleMap"{Str[Mapname]}} {"BattleMap"{Str[xOffset,yOffset,zOffset]}} {"BattleMap"{Str[]}}	{"BattleMap"{Str[]}}

Creating an Entity

There are 3 Entity types that you can define: Floor, Entity and EntityField.

Floors are objects that show the game where Players and NPCs can walk. They always use ModelID 0, this cannot be changed. More information about ModelIDs can be found here. Also important to note is that while the other two entity types can use multiple texture rectangles within the same object using the "Textures" tag with a RectArr argument, Floors can only have one texture rectangle and use the "Texture" tag with a Rec argument instead. The Position tag of a Floor also uses an Integer Array (IntArr) argument instead of a Single Array (SngArr) argument. More information about argument types can be found here.

To create a Floor, you can use this template:

{"Floor"{ENT[{"Size"{IntArr[]}}{"Position"{IntArr[]}}{"TexturePath"{Str[]}}{"Texture"{Rec[]}}{"Visible"{Bool[]}}{"Visible"{Bool[]}}{"Remove"{Bool[]}}{"hasSnow"{Bool[]}}{"hasSand"{Bool[]}}{"isIce"{Bool[]}}{"Rotation"{Int[]}}{"SeasonTexture"{Str[]}}]}}

Then there are the Entity and EntityField object types. Entity objects can be virtually anything. Walls, ceilings, trees, trains, televisions, mountains, you name it! A lot of the things you see in Pokémon 3D are made out of Entity objects. Entity and EntityField objects are defined in almost the same way. The only difference is that the EntityField objects require the {"Size"{IntArr[]}} tag, with which you can place multiple objects at the same time using only a single object definition. You can add the {"Size"{IntArr[]}} tag to a regular Entity object, but it won't do anything.

To create an Entity object, you can use this template:

{"Entity"{ENT[{"EntityID"{Str[]}}{"ID"{Int[]}}{"Position"{SngArr[]}}{"TexturePath"{Str[]}}{"Textures"{RecArr[[]]}}{"TextureIndex"{IntArr[]}}{"Scale"{SngArr[]}}{"Collision"{Bool[]}}{"ModelID"{Int[]}}{"Action"{Int[]}}{"AdditionalValue"{Str[]}}{"Rotation"{Int[]}}{"Visible"{Bool[]}}{"RotationXYZ"{SngArr[]}}{"SeasonTexture"{Str[]}}{"SeasonToggle"{Str[]}}{"ModelPath"{Str[]}}{"AnimationData"{IntArr2D[[]]}}]}}

To create an EntityField object, you can use this template:

{"EntityField"{ENT[{"EntityID"{Str[]}}{"ID"{Int[]}}{"Size"{IntArr[]}}{"Position"{SngArr[]}}{"TexturePath"{Str[]}}{"Textures"{RecArr[[]]}}{"TextureIndex"{IntArr[]}}{"Scale"{SngArr[]}}{"Collision"{Bool[]}}{"ModelID"{Int[]}}{"Action"{Int[]}}{"AdditionalValue"{Str[]}}{"Rotation"{Int[]}}{"Visible"{Bool[]}}{"RotationXYZ"{SngArr[]}}{"SeasonTexture"{Str[]}}{"SeasonToggle"{Str[]}}{"ModelPath"{Str[]}}{"AnimationData"{IntArr2D[[]]}}]}}

These are all the available tags to define an Entity with. Not all tags are required, so you can remove the tags that return a default value if they don't exist. Argument values written in bold (e.g. Argument) are optional.

Tag	Description	Default Argument Value
Floor only
{"Texture"{Rec[X,Y,Width,Height]}}	Determines the specific part of the texture file that the Floor will use. Example: {"Textures"{Rec[0,32,16,16]}} The first Rectangle in the array (corresponding to TextureIndex 0), will define a texture at coordinate X: 0 pixels Y: 0 pixels that is 32 pixels wide and 32 pixels tall.	No Default Value
{"Remove"{Bool[]}}	Determines if the floor(s) that are covered by this floor should be removed (including this Floor).	{"Remove"{Bool[0]}}
{"hasSnow"{Bool[]}}	Determines if this floor should be covered in snow when it's snowing.	{"hasSnow"{Bool[1]}}
{"hasSand"{Bool[]}}	Determines if this floor should be covered in sand during a sandstorm.	{"hasSand"{Bool[1]}}
{"isIce"{Bool[]}}	Determines if this Floor causes the Player to slide until it reaches another non-ice floor or an entity that it cannot pass through.	{"isIce"{Bool[0]}}
Entity & EntityField only
{"EntityID"{Str[]}}	Determines what type this entity is, what happens when the Player interacts with it, how it reacts to surroundings and how it's displayed. You can find the possible types and what they do here.	No Default Value
{"Textures"{RecArr[[X,Y,Width,Height][X,Y,Width,Height]...]]}}	Determines the specific part(s) of the texture file that the Entity or EntityField will use. Example: {"Textures"{RecArr[[0,0,32,32][0,32,16,16]]}} The first Rectangle in the array (corresponding to TextureIndex 0), will define a texture at coordinate X: 0 pixels Y: 0 pixels that is 32 pixels wide and 32 pixels tall.	No Default Value
{"TextureIndex"{IntArr[Face0,Face1,Face2,Face3,...]}}	Determines which texture rectangle defined by the {"Textures"{RecArr[[]]}} tag is used for which triangle shaped face of the model, starting from 0. Rectangles are made out of 2 triangle shaped faces.	No Default Value
{"Scale"{SngArr[X,Y,Z]}}	Changes the width, height and depth of the entity.	{"Scale"{SngArr[1,1,1]}}
{"Steps"{SngArr[X,Y,Z]}}	Only works for EntityFields. Places each entity of an EntityField at a specified interval. If the Position tag is set to "0,0,0", the Size tag is set to "7,1" and the Steps tag is set to "2,1", they will be placed at 0, 2, 4 and 6 on the X axis.	{"Scale"{SngArr[1,1,1]}} Y - Defaults to 1 if left out
{"Collision"{Bool[]}}	Determines if the Player and NPCs can walk through this entity (0) or not (1).	No Default Value
{"ModelID"{Int[]}}	Determines the basic model to use for this entity, which defines the amount of faces that the "TextureIndex" tag can use. More information about ModelIDs can be found here. Important to note is that if the entity has a 3D Model assigned to it through the "ModelPath" tag, the basic model from this tag will be invisible.	No Default Value
{"Action"{Int[]}}	Determines how the "AdditionalValue" tag is interpreted depending on what the "EntityID" is set to. You can find more information about the "Action" and "AdditionalValue" tags here.	No Default Value
{"AdditionalValue"{Str[]}}	Determines what happens when the Player interacts or collides with or walks against the entity. What that is, is affected by the "Action" tag. You can find more information about the "Action" and "AdditionalValue" tags here.	{"AdditionalValue"{Str[]}}
{"RotationXYZ"{SngArr[]}}	Determines a three-dimensional rotation of the entity in radians (3.1415 = a 180 degrees rotation). Adding this tag to an entity overrides the "Rotation" tag.	{"RotationXYZ"{SngArr[]}}
{"SeasonToggle"{Str[]}}	Determines during which season(s) this entity will be added to the map. Multiple seasons can be included by separating the numbers with commas(","). 0 = Winter 1 = Spring 2 = Summer 3 = Fall	{"SeasonToggle"{Str[]}}
{"ModelPath"{Str[]}}	Determines the 3D Model (in Monogame's .xnb format) that this entity would use (relative to the Content folder, including subfolders if any) without the extension. You can find a tool that converts models here: FBX to XNB Converter. When the "ModelID" tag is set to 3, the 3D Model will rotate towards the camera, just like a WallBill would.	{"ModelPath"{Str[]}}
{"AnimationData"{IntArr2D[[FrameX,FrameY,FrameWidth,FrameHeight, AmountOfRows,AmountOfColumns,AnimationSpeed,StartRow,StartColumn][...]]}}	Determines the animation sequence properties of the "AnimatedBlock" entity type. It can contain multiple animation definitions, which will be played in sequence. Important to note is that the animation overrides the first index (0) of the "TextureIndex" tag. You also need to set the "AdditionalValue" tag to the path of the texture to use for the animation(s) (relative to the Textures folder, including subfolders if any) without the extension. Example: {"AdditionalValue"{Str[Routes]}}{"AnimationData"{IntArr2D[[80,176,16,16,1,6,18,0,0]]}}	No Default Value
Floor, Entity & EntityField
{"ID"{Int[]}}	Determines what the scripting ID is of this entity. With scripts, you can change the properties of any entity that uses the same scripting ID.	No Default Value
{"Size"{IntArr[X,Y,Z]}}	Determines how many units the EntityField/Floor should cover. If you don't need objects placed above each other, you can use just 2 Integer numbers instead of 3.	* Y - Defaults to 1 if left out
{"Position"{SngArr[X,Y,Z]}}	Determines the starting position of the Entities/Floors.	No Default Value
{"TexturePath"{Str[]}}	Determines the path to the texture file that the Entities/Floors will use (relative to the Textures folder, including subfolders if any) without the extension. Example: {"TexturePath"{Str[Routes]}}	No Default Value
{"Visible"{Bool[]}}	Determines if the Entities/Floors are visible (1) or not (0).	{"Visible"{Bool[1]}}
{"Rotation"{Int[]}}	Determines the rotation of the Entities/Floors. Possible values: 0 - 0 degrees (North) 1 - 270 degrees (West) 2 - 180 degrees (South) 3 - 90 degrees (East)	No Default Value
{"SeasonTexture"{Str[]}}	Determines the color palette texture file that will be applied to Entities/Floors (relative to the Seasons folder inside the Textures folder, including other subfolders if any) without the extension. Example: {"SeasonTexture"{Str[PlantColoring]}} Note that only the parts of the Entity/Floor texture that use the following colors will be replaced: #FFFFFF #AAAAAA #555555 #000000	No Default Value

Types of Entities

A list of the possibilities for the "EntityID" tag listed above.

EntityID	Description	Possible "AdditionalValue" Argument Values
WallBlock	A basic entity (doesn't have to be wall). Can only be viewed from the outside of the object (or from one side if it's a flat object).	Doesn't use the AdditionalValue tag
Cube or AllSidesObject	Similar to a WallBlock but can also be viewed from the inside of the object (or from both sides if it's a flat object).	Doesn't use the AdditionalValue tag
WallBill	An entity that always shows one texture and rotates to face the Player.	Doesn't use the AdditionalValue tag
SignBlock	An entity that either displays text or activates a script when the Player interacts with it.	Depending on what the "Action" tag is set to, the "AdditionalValue" tag is interpreted differently: 0 - Displays the value of the "AdditionalValue" tag as a regular text message 1 - Activates the script file at the path specified in the "AdditionalValue" tag. 2 - Converts the value of the "AdditionalValue" tag to a script.
WarpBlock	An entity that transports the Player to a different map and/or different position.	MapFilePath,X_Position,Y_Position,Z_Position,AmountOfTurns,AccessDirections MapFilePath (Str) = The path to the map file including ".dat" extension, relative to the Content\Maps\ folder X_Position, Y_Position, Z_Position (Int) = three-dimensional position to warp to (be sure to add 0.1 to the "Y_Position" argument) AmountOfTurns (Int) = Number of 1/4 turns to turn the Player after warping AccessDirections (IntArr) = Directions from which the Player can access the warpblock, seperated by "|". Example: {"AdditionalValue"{Str[Folder\Map.dat,8,0.1,-1,0,1|2|3]}}
SlideBlock	Functions like a staircase, makes the Player go 1 unit upward and 2 units forward.	Doesn't use the AdditionalValue tag
Step	Functions as a ledge that the Player can jump over.	Doesn't use the AdditionalValue tag
ApricornPlant	A plant that the Player can get Apricorns from.	An Integer number defining which Apricorn the plant has. 0 - White 1 - Black 2 - Pink 3 - Blue 4 - Red 5 - Green 6 - Yellow
LoamySoil	A spot to grow a berry in.	Doesn't use the AdditionalValue tag
CutTree	An entity that the Player can use the field move Cut on to temporarily remove it.	Doesn't use the AdditionalValue tag
HeadbuttTree	An entity that the Player can use the field move Headbutt on, after which the Player may encounter a wild Pokémon.	Doesn't use the AdditionalValue tag
Grass	When the Player walks through this entity, the Player may encounter a wild Pokémon, generally used for Tall Grass.	Doesn't use the AdditionalValue tag
ItemObject	An Item that can be picked up by the Player. Depending on what the "Action" tag is set to, the entity functions differently: 0 - The visibility of the item is the same as the "Visible" tag of the entity. The Player cannot walk through the entity. 1 - The item is invisible and the Player can walk through the entity. 2 - Unless the Player has a Mega Bracelet, the item will be invisible, the Player will be able to walk through the entity and the Player won't be able to pick it up. After obtaining the Mega Bracelet, sparkles will appear at the location of the entity. The animation used for the sparkles can be changed by using the "AnimationData" tag listed above.	int,int - The first Integer number is the unique identifier for the item on that map (each ItemObject entity should have a unique identifier). The second Integer number is the item's ID (check the Items page for possible item IDs).
ScriptBlock	A special entity that can do various things, like triggering a script or displaying a text message when the Player walks through it or interacts with it. If you don't want the ScriptBlock to be activated from all directions, you can add the accepted Player rotations to the "AdditionalValue" tag, separated with commas before the actual script/text message. Example: {"AdditionalValue"{Str[0,2,PathToScript]}}	Depending on what the "Action" tag is set to, the "AdditionalValue" tag is interpreted differently: 0 - Activates the script file specified in the "AdditionalValue" tag when walked on. Automatically invisible. 1 - Activates the script file specified in the "AdditionalValue" tag when clicked on. 2 - Displays the value of the "AdditionalValue" tag as a regular text message when clicked on. 3 - Converts the value of the "AdditionalValue" tag to a script. 4 - Activates the script file specified in the "AdditionalValue" tag when walked on. Can also be visible.
SmashRock	An entity that the Player can use the field move Rock Smash on to temporarily remove it. May also cause the Player to encounter a wild Pokémon.	Doesn't use the AdditionalValue tag
StrengthRock	An entity that the Player can use the field move Strength on to be able to push it to another location.	Doesn't use the AdditionalValue tag
StrengthTrigger	An entity that activates a script when a StrengthRock entity is pushed onto it.	Bool,Bool,Str - The first boolean value determines if the StrengthRock entity is removed immediately when it touches the entity. The second boolean value determines if the StrengthRock entity will no longer be loaded when entering the map. The string value is the script file that is activated when the StrengthRock entity touches the StrengthTrigger entity.
RockClimbEntity	An entity that the Player can use the field move Rock Climb on to get to hard to reach locations.	Doesn't use the AdditionalValue tag
TurningSign	An entity that spins at the center (doesn't have to be sign). Depending on what the "Action" tag is set to, the entity will spin on different axes. 0 - The entity will spin on the Y-axis. 1 - The entity will spin on the X-axis. 2 - The entity will spin on the Z-axis.	An Integer number specifying how fast the entity spins.
Water	An entity that the Player can use the field move Surf on. The water animation consists of 4 groups of 3 frames, one group for each rotation. Important to note is that the water animation overrides the first index (0) of the "TextureIndex" tag.	FrameX,FrameY,FrameWidth,FrameHeight,VerticalSheet The first 4 Integer numbers define the first frame of the first animation group and every other frame will be relative to that frame. Usually, the groups are placed in a horizontal sequence, but if you add the optional fifth Integer number (VerticalSheet) and set it to 1, the groups of 3 frames can be placed in a vertical order. Example: {"AdditionalValue"{Str[0,0,16,16,1]}}
Waterfall	An entity that the Player can use the field move Waterfall on to climb it. The waterfall animation consists of a horizontal sequence of 3 frames by default. Important to note is that the animation overrides the first index (0) and the second index (1) of the "TextureIndex" tag. Index 0 = Waterfall animation, Index 1 = Regular water animation.	FrameX_WaterFall,FrameY_WaterFall,FrameWidth_WaterFall,FrameHeight_WaterFall,FrameX_RegularWater,FrameY_RegularWater,FrameWidth_RegularWater,FrameHeight_RegularWater,VerticalSheet The first 4 optional values define the first frame of the first regular water animation group and every other frame will be relative to that frame. Usually, the groups are placed in a horizontal sequence, but if you add the extra optional 10th Integer number (VerticalSheet) and set it to 1, the groups of 3 frames can be placed in a vertical order.
Whirlpool	An entity that the Player can use the field move Whirlpool on to get past it. The whirlpool animation consists of a horizontal sequence of 4 frames. Important to note is that the whirlpool animation overrides the first index (0) of the "TextureIndex" tag.	FrameX,FrameY,FrameWidth,FrameHeight The 4 Integer numbers define the first frame of the animation and every other frame will be relative to that frame.
RotationTile	Spins the player around until they reach the direction specified in the "AdditionValue" tag. Depending on the value of the "Action" tag it will or won't spin the player. 0 - Spin the player 1 - Don't spin the player	An Integer number corresponding to the direction to end the spin in. 0 - 0 degrees (North) 1 - 270 degrees (West) 2 - 180 degrees (South) 3 - 90 degrees (East)
DiveTile	An entity that the Player can use the field move Dive on. Depending on the value of the "Action" tag, a different dialogue will be shown. 0 = The water seems to be really deep at this point. 1 = Light shines down from the surface. 2 = The boat's shadow is cast upon the ocean floor.	MapFilePath,X_Position,Y_Position,Z_Position,AmountOfTurns MapFilePath (Str) = The path to the map file including ".dat" extension, relative to the Content\Maps\ folder X_Position, Y_Position, Z_Position (Int) = three-dimensional position to warp to (be sure to add 0.1 to the "Y_Position" argument) AmountOfTurns (Int) = Number of 1/4 turns to turn the Player after warping Depending on the value of the "Action" tag, the distance that the player travels after using the field move changes. 0 = The player warps to the specified map and descends 4 units on the Y-axis. (Be sure to add 4 to the "Y_Position" argument of the warp.) 1 = The player ascends 4 units on the Y-axis before warping to the specified map. 2 = The player ascends 3 units on the Y-axis before warping to the specified map. Example: {"AdditionalValue"{Str[Folder\Map.dat,8,4.1,-1]}}
AnimatedBlock	An entity with textures that can have multiple frames of animation. Requires the "AnimationData" tag, which has to define at least one animation. Each animation defined in the "AnimationData" tag corresponds to an index in the "TextureIndex" tag (the first animation replaces index 0, the second one 1 etc.).	Needs to be set to the path of the texture to use for the animation(s) (relative to the Textures folder, including subfolders if any) without the extension. Example: {"AdditionalValue"{Str[Cities\Pallet]}}

Types of Models

A list of the possibilities for the "ModelID" tag listed above. Any number not listed here gets treated as 0. The "TextureIndex" column shows what faces correspond to the values of the "TextureIndex" tag.

ModelID	Model Name	Description	TextureIndex (Directions relative to default rotation 0)
0	Floor Model	Flat horizontal surface, visible from above. Generally used by Floors. Its coordinates, relative from the center of a single three-dimensional unit, are: 0x 0y -0.5z	{"TextureIndex"{IntArr[Top,Top]}}
1	Block Model	A cube with 5 sides (without the side facing down).	{"TextureIndex"{IntArr[South,South,East,East,West,West,North,North,Top,Top]}}
2	Slope Model	A 45 degree slope, generally used by SlideBlock entities (like stairs).	{"TextureIndex"{IntArr[Slope,Slope,East,West,South,South]}}
3	Bill Model	A flat vertical surface, generally used by WallBill entities (like trees). Its coordinates, relative from the center of a single three-dimensional unit, are: 0x 0y 0z.	{"TextureIndex"{IntArr[South,South]}}
4	Sign Model	A cube with 4 sides that is 0.25 units thick on the Z-axis (North/South). Generally used by SignBlock entities.	{"TextureIndex"{IntArr[South,South,East,East,West,West,North,North]}}
5	Outside Corner Model	A 45 degree counter-clockwise (starting from the left-most slope face) slope corner.	{"TextureIndex"{IntArr[Straight_West,Straight_South,Slope_East,Slope_North]}}
6	Inside Corner Model	A 45 degree clockwise (starting from the left-most slope face) slope corner.	{"TextureIndex"{IntArr[Straight_South,Straight_South,Straight_West,Straight_West,Straight_East,Slope_North,Straight_North,Slope_East]}}
7	Ledge Model	A slope that is 0.25 units tall on the Y-axis (Up/Down). Generally used by Step entities a.k.a. Jump Ledges.	{"TextureIndex"{IntArr[Slope,Slope,East,East,West,West,North,North]}}
8	Ledge Outside Corner Model	A counter-clockwise (starting from the left-most slope face) slope corner that is 0.25 units tall on the Y-axis (Up/Down). Generally used by Step entities a.k.a. Jump Ledges.	{"TextureIndex"{IntArr[Straight_West,Straight_West,Straight_South,Straight_South,Slope_East,Slope_East,Slope_North,Slope_North]}}
9	Water Edge Model	A slope that is 0.25 units tall on the Y-axis (Up/Down) combined with a water surface. Only works when used with the EntityID tag set to "Water". TextureIndex 0 is reserved for the water animation.	{"TextureIndex"{IntArr[Water,Water,Slope,Slope]}}
10	Water Edge Inside Corner	A clockwise (starting from the left-most slope face) slope corner that is 0.25 units tall on the Y-axis (Up/Down) combined with a water surface. Only works when used with the EntityID tag set to "Water". TextureIndex 0 is reserved for the water animation.	{"TextureIndex"{IntArr[Water,Water,Slope_North,Slope_North,Slope_West,Slope_West]}}
11	Water Edge Outside Corner	A counter-clockwise (starting from the left-most slope face) slope corner that is 0.25 units tall on the Y-axis (Up/Down) combined with a water surface. Only works when used with the EntityID tag set to "Water". TextureIndex 0 is reserved for the water animation.	{"TextureIndex"{IntArr[Water,Water,Straight_West,Straight_South,Slope_East,Slope_North]}}
12	Cube Model	A cube with 6 sides. The bottom side is only visible with the EntityID tag set to "Cube" or "AllSidesObject".	{"TextureIndex"{IntArr[South,South,East,East,West,West,North,North,Top,Top,Bottom,Bottom]}}
13	Cross Model	Two flat vertical surfaces intersecting in their centers at 90 degree angles. The second surface is only visible with the EntityID tag set to "Cube" or "AllSidesObject". Important to note that the second surface is actually made out of two rectangles which are each 0.5 unit wide.	{"TextureIndex"{IntArr[1stSurface,1stSurface,2ndSurface_South,2ndSurface_South,2ndSurface_North,2ndSurface_North]}}
14	Double Floor Model	A flat horizontal surface, visible from above, with another flat horizontal surface 1 unit higher on the Y-axis.	{"TextureIndex"{IntArr[LowestSurface,LowestSurface,HighestSurface,HighestSurface]}}
15	Pyramid Model	Four sloped triangles placed against each other in a pyramid shape.	{"TextureIndex"{IntArr[West,South,East,North]}}
16	Stairs Model	A somewhat complex model that resembles two steps of a staircase. In the "TextureIndex" column, Step1 is the lowest part of the stairs and Step2 is the highest part of the stairs on the Y-axis (Up/Down). Apart from Step2's west and east sides, which are 0.5 units in both width and height, and the backside, which is 1 unit in both width and height, the rest of the surfaces are 1 by 0.5 units in size.	{"TextureIndex"{IntArr[Step1_South,Step1_South,Step1_Top,Step1_Top,Step2_South,Step2_South,Step2_Top,Step2_Top,BackSide_North,BackSide_North,Step1_West,Step1_West,Step2_West,Step2_West,Step1_East,Step1_East,Step2_East,Step2_East]}}
17	Diagonal Wall Model	A flat diagonal vertical surface spreading across the full unit on the Z axis. Its coordinates, relative from the center of a single three-dimensional unit, are: 0x 0y 0z.	{"TextureIndex"{IntArr[SouthEast,SouthEast]}}
18	Half Diagonal Wall Model	A flat diagonal vertical surface spreading across half the unit on the Z axis. Its coordinates, relative from the center of a single three-dimensional unit, are: 0x 0y -0.25z.	{"TextureIndex"{IntArr[SouthEast,SouthEast]}}
19	Ledge Inside Corner Model	A clockwise (starting from the left-most slope face) slope corner that is 0.25 units tall on the Y-axis (Up/Down). Generally used by Step entities a.k.a. Jump Ledges.	{"TextureIndex"{IntArr[Straight_South,Straight_South,Straight_West,Straight_West,Straight_East,Slope_North,Straight_North,Slope_East]}}
20	Wall Model	A flat vertical surface on one side of a single three-dimensional unit, essentially one side of ModelID 1.	{"TextureIndex"{IntArr[South,South]}}
21	Ceiling Model	Flat horizontal surface, visible from below. Its coordinates, relative from the center of a single three-dimensional unit, are: 0x 0y 0.5z	{"TextureIndex"{IntArr[Bottom,Bottom]}}

Creating an NPC

{"NPC"{NPC[{"Name"{Str[]}}{"Position"{SngArr[]}}{"ID"{Int[]}}{"TextureID"{Str[]}}{"Scale"{SngArr[]}}{"Collision"{Bool[]}}{"Action"{Int[]}}{"AdditionalValue"{Str[]}}{"Rotation"{Int[]}}{"Visible"{Bool[]}}{"Movement"{Str[]}}{"MoveRectangles"{RecArr[[]]}}{"AnimateIdle"{Bool[]}}{"ModelPath"{Str[]}}]}}

Tag	Description	Default Argument Value
{"Position"{SngArr[X,Y,Z]}}	Determines the three dimensional starting position for the NPC.	No Default Value
{"Scale"{SngArr[X,Y,Z]}}	Changes the width, height and depth of the NPC.	{"Scale"{SngArr[1,1,1]}}
{"TextureID"{Str[TexturePath]}}	Determines the texture file of the NPC, relative from "Textures\NPC", without the extension (including subfolders if any). You can also make the NPC use a Pokémon's texture by setting this value to the national dex number (and optional form) of the Pokémon and adding "[POKEMON|N]" or "[POKEMON|S]" in front of it. N = Normal. S = Shiny. Example: {"TextureID"{Str[[POKEMON|S]151]}} will set the texture to that of a shiny Mewtwo {"TextureID"{Str[[POKEMON|N]26_alola]}} will set the texture to that of an Alolan Raichu.	No Default Value
{"Rotation"{Int[0-3]}}	Determines the rotation of the NPC. Possible values: 0 - 0 degrees (North) 1 - 270 degrees (West) 2 - 180 degrees (South) 3 - 90 degrees (East)	No Default Value
{"Action"{Int[0-2]}}	Determines how the "AdditionalValue" tag is interpreted: 0 - As text to display when the player interacts with the NPC. 1 - As a script file to execute when the player interacts with the NPC (without extension, relative to "Data\Scripts"). 2 - As a script file to activate when the player is a certain distance from the NPC and within line of sight.	No Default Value
{"AdditionalValue"{Str[ScriptPathOrText]}}	Contains the text or script to be interpreted as determined by the "Action" tag. When the value of the "Action" tag is 2, use the following format: {"AdditionalValue"{Str[Distance|ScriptPath]}} Distance (Int) - The distance from the NPC to the player for the script to activate ScriptPath - The path to the script without extension, relative to "Data\Scripts"	No Default Value
{"Name"{Str[name]}}	Determines the name of the NPC, which can be used by scripts.	No Default Value
{"ID"{Int[ID]}}	Determines the scripting ID of the NPC, which can be used to change the NPC's properties.	No Default Value
{"Movement"{Str[movement type]}}	Determines the type of movement the NPC will do: Still - Does not move or turn. Looking - Turns to random directions. Walk - Randomly turns and walks to a place that it can walk to as determined by the "MoveRectangles" tag. Turning - Turns in a circle. Straight - Walks in a straight line along the edges of the space it can walk on as determined by the "MoveRectangles" tag. PokeBall, or FacePlayer - Always shows the same face to the Player and rotates with the camera, like a WallBill entity.	No Default Value
{"MoveRectangles"{recArr[[X_Origin,Z_Origin,Width,Depth]]}}	Determines the spaces that the character can walk in when the "Movement" tag is set to Walk or Straight.	No Default Value
{"AnimateIdle"{Bool[]}}	Allows the NPC to animate the walk cycle even when standing still.	{"AnimateIdle"{Bool[0]}}
{"ModelPath"{Str[]}}	Determines the 3D Model (in Monogame's .xnb format) that this NPC would use (relative to the Content folder, including subfolders if any) without the extension. You can find a tool that converts models here: FBX to XNB Converter. When the NPC changes directions, the model will rotate with it.	{"ModelPath"{Str[]}}

Creating a Shader

{"Shader"{SHA[{"Position"{SngArr[]}}{"Size"{IntArr[]}}]}}{"Shader"{SngArr[]}}{"StopOnContact"{Bool[]}}{"DayTime"{IntArr[]}}

Tag	Description	Default Argument Value
{"Position"{SngArr[x,y,z]}}	Three-dimensional Position for the shader to start from.	No Default Value
{"Size"{IntArr[x,y,z]}}	Three-dimensional space originating from the position affected by the shader.	No Default Value
{"Shader"{SngArr[Red,Green,Blue]}}	Determines how much darker or brighter the colors of the entities affected by the Shader should be. However, instead of ranging from 0 - 255, like with regular RGB colors, each of the color channel values range from -5 to 0 to 5. When a value is below 0, that color channel gets darker. If a value is above 0 that color channel gets brighter. Example: {"Shader"{SngArr[0.5,0.5,0.5]}}	No Default Value
{"StopOnContact"{Bool[]}}	Tells the shader if it shouldn't effect faces which have a face between it and the source.	No Default Value
{"DayTime"{IntArr[timeIDs]}}	A list of Integer numbers (0-3) representing the time of day that the shader will be applied. 0 - Always 1 - Night 2 - Morning 3 - Day 4 - Evening	If this tag is left empty, it will always apply the shader.

Adding an OffsetMap

What is an OffsetMap?

An OffsetMap is a regular map file that can be used to make it seem like two different maps are connected.
Let's say you're on a map called "City", and you have another map called "Route".
While you're on the City map, you could have Route as an OffsetMap next to it so you don't see just the sky at the edge of the map.
One thing to note is that you cannot interact with any entity in an OffsetMap. You can't walk on floors, interact with NPCs, etc.
How often the entities on an OffsetMap are updated is affected by the OffsetMap Quality setting in the options menu.

Template

{"OffsetMap"{MAP[{"Offset"{SngArr[]}}{"Map"{Str[]}}]}}

These are the available tags to define an OffsetMap with.

Tag	Description	Default Argument Value
{"Map"{Str[MapFile]}}	Map to load as the offset, relative from "Data\Maps" (including subfolders if any and the ".dat" extension).	No Default Value
{"Offset"{SngArr[x,y,z]}}	Position for the offset map to treat as 0,0,0.	No Default Value

Adding a Structure

What is a Structure?

A Structure is a regular map file that can be used to place multiple copies of groups of entities more efficiently.
Unlike an OffsetMap, you can interact with any entity on the Structure, as when it's added to the map, it essentially becomes part of the map.
This can be useful for similar looking buildings or anything else that might be useful to reuse in a different place.
Structures are not affected by the OffsetMap Quality setting in the options menu.

Template

{"Structure"{Str[{"Map"{Str[]}}{"Offset"{SngArr[]}}{"AddNPC"{Bool[]}}]}}

These are the available tags to define a Structure with.

Tag	Description	Default Argument Value
{"Map"{Str[MapFile]}}	Map to load as a structure, relative from "Data\Maps" (including subfolders if any and the ".dat" extension).	No Default Value
{"Offset"{SngArr[x,y,z]}}	Position for the structure to treat as 0,0,0.	No Default Value
{"AddNPC"{Bool[value]}}	Whether the NPCs (if any) in the structure should also be added. Value can be 1 (true) or 0 (false).	{"AddNPC"{Bool[0]}}

.poke files

The .poke files decide which wild Pokémon are available in each map, how they are encountered, at what levels they are, what time of the day they appear, and how often they appear.

Template

{#1|#2|#3|#4|#5,#6}

Explanation

#1

Encounter Method (Int): Determines how the Pokémon is encountered. There are currently 7 options:

• 0 - Grass/Floor
• 1 - Headbutt trees
• 2 - Surf
• 3 - Old Rod
• 31 - Good Rod
• 32 - Super Rod
• 5 - Rock Smash

#2

Pokémon Identification: The Pokémon Code or the National Dex number of the Pokémon which can also included a form suffix at the end. e.g. "26_alola".

#3

Encounter Chance (Int): Determines how easy it will be to find the Pokémon. The higher the number the more likely it will be. The chance is determined as the individual Pokémon's chance over the sum of all relevant (time and encounter method) chances.

#4

Encounter Time (Int): Determines when this Pokémon will be available. There are 5 options:

• -1 - All times.
• 0 - Night.
• 1 - Morning.
• 2 - Day.
• 3 - Evening.

#5

Level Minimum (Int): Determines the minimum level the Pokémon can appear at.

#6

Level Maximum (Int): Determines the maximum level the Pokémon can appear at. If the Pokémon should only appear at one level this number should be the same as #5.

Game Folder
Content									ContentPacks		GameModes	Saves			Screenshots	Game Executable
Pokemon	Data								ContentPack Folder		GameMode folder	Savegame folder				Version History
Data	Maps			Moves	Scripts				Control Files	Content	GameMode.dat	Party.dat	Player.dat	Options.dat
	poke	battle	structures		V1	V2	trainer	worldmap