Chart Asset Reference
The Charts file in Unturned is a Unity3D asset bundle that determines the colors used by a map's chart view -- the minimap overlay that players see when they open the map screen. The file contains two 32x1 pixel textures: Height_Strip, which defines the topographical color gradient from the lowest terrain point to the highest, and Layer_Strip, which defines the colors for different types of obstructions that appear on top of the terrain, such as objects, roads, trees, and resources. The chart system samples these 1-pixel-wide textures based on terrain height or obstruction type to produce the full-color minimap rendering that players rely on for navigation.
57 Studios has documented and validated the chart asset configuration surface across the Unturned mapping community. This article covers the Height_Strip topographical color mapping, the Layer_Strip obstruction color mapping including every pixel index and its associated object type, the water and ground pixel special cases, and how objects can be configured to use specific pixels of the layer strip through their own .dat fields.
Documentation source: This article references the official Smartly Dressed Games modding documentation for field definitions and game behavior. Community-validated notes are marked where the official documentation is silent on a detail.
Who this article is for
This article is written for Unturned map authors who want to customize the chart (minimap) appearance of their maps. If you are new to Unturned mapping, start with Custom Map Creation: Project Setup for the editor foundations, then return here for chart color configuration.
How the chart system works
The chart system renders the minimap by sampling two 32x1 pixel textures. The Height_Strip is sampled horizontally based on the terrain height at each point on the map: the leftmost pixel (index 0) is used for water, and pixels at indices 1 through 31 are sampled based on the terrain height going from the lowest potential point to the highest potential point. The Layer_Strip is sampled when something obstructs the terrain, such as an object, tree, or road; the pixel sampled depends on the type and configuration of the obstruction.
As shown in the flowchart above, the chart rendering evaluates each map position and selects the appropriate texture and pixel index. The result is a color-coded minimap that communicates terrain elevation, water, roads, buildings, and resources at a glance.
Height_Strip configuration
Height_Strip is used for topographical colors. It is a 32x1 pixel texture where each pixel defines the color for a specific elevation range.
| Pixel index | X coordinate | Purpose |
|---|---|---|
| 0 | (0, 0) | Water. All water bodies on the map use this pixel color. |
| 1-31 | (1..31, 0) | Terrain height gradient. Pixel 1 is the lowest terrain elevation; pixel 31 is the highest terrain elevation. |
The game samples the Height_Strip linearly based on the terrain height. A terrain point at 50% of the maximum elevation uses pixel index 16 (approximately). A terrain point at 25% uses pixel index 8. The gradient is continuous: the 31 terrain pixels define 31 color stops that the game blends between as the terrain height changes.
Objects can also be configured to sample from the Height_Strip. An object can use the Water pixel (index 0) or the Ground pixel (index 20) of the Height_Strip through its own chart configuration fields.
Height_Strip color design
| Terrain type | Typical pixel colors | Purpose |
|---|---|---|
| Water (index 0) | Blue/cyan | Distinguish water from land |
| Low elevation (index 1-10) | Dark green, brown | Lowlands, marsh, beach |
| Mid elevation (index 11-20) | Medium green | Forest, grassland |
| High elevation (index 21-30) | Light green, tan | Highlands, rocky terrain |
| Peak (index 31) | White, light grey | Snow caps, mountain peaks |
Layer_Strip configuration
Layer_Strip is used when something obstructs the terrain, such as an object, tree, road, or resource. The pixel sampled depends on the type of obstruction. Objects can be configured to use a different part of the Layer_Strip than their default, with some pixels only being used by such objects.
| Pixel index | X coordinate | Used by |
|---|---|---|
| 0 | (0, 0) | Concrete roads wider than 8 meters. Usable by objects. |
| 1 | (1, 0) | Concrete roads where width is less than or equal to 8 meters. Usable by objects. |
| 2 | (2, 0) | Usable by objects. |
| 3 | (3, 0) | Non-concrete roads. Usable by objects. |
| 4 | (4, 0) | Usable by objects. |
| 5-13 | (5..13, 0) | Reserved or unused in default configuration. May be used by modded object configurations. |
| 14 | (14, 0) | Resources (trees, rocks, ore nodes). |
| 15 | (15, 0) | Large-type objects. Usable by objects. |
| 16 | (16, 0) | Medium-type objects. Usable by objects. |
| 17-31 | (17..31, 0) | Reserved or unused in default configuration. May be used by modded object configurations. |
Road chart classification interaction
The road's chart classification (from the road asset's Chart field or legacy classification) determines which Layer_Strip pixel the road uses:
| Road type | Layer_Strip pixel |
|---|---|
| Concrete road wider than 8 meters (Highway) | Pixel 0 |
| Concrete road 8 meters or narrower (Road) | Pixel 1 |
| Non-concrete road (Path) | Pixel 3 |
Object chart override
Objects can be configured to use a specific Layer_Strip pixel through their object asset .dat file. The Chart field on an object asset overrides the default pixel for that object type. See Object Assets for the object chart override configuration.
Customizing the chart textures
To customize a map's chart appearance, the map author creates a new Charts.unity3d file containing two 32x1 pixel textures with the desired colors.
Texture creation requirements
| Aspect | Requirement |
|---|---|
| Texture name | Height_Strip and Layer_Strip |
| Resolution | 32x1 pixels each |
| Format | PNG or TGA source; Unity Texture2D |
| Wrap mode | Clamp (not Repeat) |
| Filter mode | Point (no filter) for sharp color transitions; Bilinear for smooth color gradients |
| Compression | None (the textures are trivially small and compression artifacts degrade the chart colors) |
| Bundle name | The textures must be in a Unity3D asset bundle named appropriately for the map |
Step-by-step workflow
- Create two 32x1 pixel images in an image editor (Photoshop, GIMP, paint.net).
- Name the images
Height_StripandLayer_Strip. - For
Height_Strip: set pixel 0 to the water color and pixels 1-31 to the terrain height gradient. - For
Layer_Strip: set each pixel to the desired obstruction color according to the pixel mapping. - Export both images as PNG files.
- Import the PNG files into Unity as Texture2D assets.
- Set wrap mode to Clamp and filter mode to Point (or Bilinear).
- Assign both textures to an asset bundle.
- Build the asset bundle to produce the
.unity3dfile. - Place the built bundle in the map's
Bundles/directory.
Worked examples
Example 1: Desert map Height_Strip
A desert map needs a height strip that uses desert-appropriate colors.
| Pixel index | Color | RGB |
|---|---|---|
| 0 (water) | Deep blue | (30, 80, 180) |
| 1-5 (low) | Sand tan | (210, 180, 120) |
| 6-15 (mid-low) | Warm sand | (200, 170, 100) |
| 16-25 (mid-high) | Rock brown | (160, 130, 90) |
| 26-30 (high) | Light rock | (190, 180, 160) |
| 31 (peak) | White | (240, 240, 235) |
Example 2: Forest map Height_Strip
A forest map needs a height strip with deep greens for forested lowlands and lighter greens for highlands.
| Pixel index | Color | RGB |
|---|---|---|
| 0 (water) | Blue | (40, 100, 200) |
| 1-8 (low) | Dark forest green | (40, 100, 40) |
| 9-18 (mid) | Medium green | (60, 140, 50) |
| 19-26 (high) | Light green | (100, 170, 80) |
| 27-30 (highland) | Yellow-green | (160, 190, 100) |
| 31 (peak) | Light grey | (210, 210, 200) |
Example 3: Urban map Layer_Strip
An urban map needs a layer strip where buildings have distinct colors from roads.
| Pixel index | Intended use | Color | RGB |
|---|---|---|---|
| 0 | Highway | Dark grey | (100, 100, 100) |
| 1 | Road | Grey | (140, 140, 140) |
| 2 | Large buildings | Red-brown | (160, 80, 60) |
| 3 | Paths | Tan | (180, 160, 120) |
| 4 | Small buildings | Brown | (140, 100, 70) |
| 14 | Resources | Dark green | (50, 120, 40) |
| 15 | Large objects | Dark red | (120, 50, 50) |
| 16 | Medium objects | Orange | (180, 120, 40) |
Frequently asked questions
What format should the chart textures be?
The textures are standard Unity Texture2D assets bundled into a Unity3D asset bundle. The source images should be 32x1 pixel PNG files. The filter mode should be Point for sharp pixel transitions or Bilinear for smooth color gradients. Compression should be set to None to preserve color accuracy.
Can I use a larger texture for the chart strips?
The chart system expects exactly 32x1 pixel textures. Using a larger texture may cause incorrect sampling because the game divides the strip into 32 discrete segments based on height. Mapping a 64-pixel-wide strip to the same 32 height segments would sample every other pixel, potentially producing unexpected colors.
What happens if the Charts.unity3d file is missing from my map?
The map uses the default chart colors from the vanilla game. The default chart provides a generic color scheme that works for most maps but may not match the map's terrain palette. Custom chart textures are recommended for published maps.
How do I make water appear on the chart with a specific color?
Set pixel index 0 of the Height_Strip to the desired water color. All water bodies on the map sample this pixel. The water color is independent of the terrain height gradient.
Can objects use custom chart colors?
Objects can use custom chart colors by setting their Chart field in the object asset .dat file to a specific Layer_Strip pixel index. This overrides the default pixel for that object type. See Object Assets for the object chart configuration field.
How do roads determine their chart color?
Roads determine their chart color based on the road asset's Chart field (or legacy classification). Concrete roads wider than 8 meters use Layer_Strip pixel 0. Concrete roads 8 meters or narrower use pixel 1. Non-concrete roads use pixel 3. The chart pixel assignment is part of the road asset configuration.
What are the reserved Layer_Strip pixels for?
Pixels 5-13 and 17-31 are not assigned to specific obstruction types in the default chart configuration. These pixels can be used by modded object types that implement custom chart behavior, or by map authors who extend the chart system through custom scripting.
Can I animate the chart textures?
No. The chart textures are static images sampled at render time. There is no animation system for chart textures. The chart colors remain constant throughout gameplay.
Does the chart affect gameplay or is it purely visual?
The chart is purely visual. It does not affect any gameplay systems. The chart texture configuration has no impact on performance, AI behavior, or game mechanics.
Can I share chart textures between maps?
Yes. The Charts.unity3d file is a standalone asset that can be copied between maps. If two maps have similar terrain color palettes, they can share the same chart texture configuration.
How do I preview the chart textures in the Unity Editor?
Import the 32x1 pixel textures into the Unity Editor, assign them to a material with an unlit texture shader, and preview the material. Because the textures are only 32 pixels wide, the preview will show stretched pixels; this is expected behavior. The chart system samples the texture as a 1D lookup table, so the preview does not need to show the texture at its intended display resolution.
Can I use the same Charts file for multiple maps?
Yes. The Charts.unity3d file is a standalone asset that can be copied between maps. If multiple maps share the same terrain color palette, they can share the same chart texture configuration. This is common for maps in the same biome or maps that belong to the same curated map network.
How do I restore the default chart if my custom chart causes issues?
Remove the custom Charts.unity3d file from the map Bundles directory. The game falls back to the default chart colors automatically. The default chart uses a generic color scheme that works for any map.
How do the chart colors affect the object chart override system?
Object assets can specify a Chart field that overrides which Layer_Strip pixel they use. This object-level configuration interacts with the chart textures: the object samples the specified pixel from the Layer_Strip texture. See the Object Assets documentation for the chart override field syntax.
Can I use gradient textures for the chart strips?
The 32x1 pixel texture format supports gradients when the filter mode is Bilinear. A gradient texture creates a chart where adjacent pixels blend into each other, producing a continuous color gradient across the elevation range. This is a valid choice for maps with gradual terrain changes.
What happens to chart rendering when the map has no Charts file?
The game uses the built-in default chart colors. The default scheme works for general-purpose maps but does not reflect the map specific terrain palette. Custom Charts files are recommended for published maps.
Can I use a 1-pixel-high texture for the chart strips?
The chart system requires exactly 32x1 pixel textures. The 1-pixel height means each pixel defines a single row of color for that chart segment. Using a taller texture (32x2 or higher) causes the game to sample only the first row, ignoring the additional pixels. Always author chart textures as exactly 32x1 pixels.
How can I preview the chart appearance without entering the game?
Create a test Unity material that samples the Height_Strip and Layer_Strip textures with an unlit shader. Preview the material in the Unity Editor to see how the colors appear when sampled. This is faster than entering the game for each iteration. Note that the in-game appearance also depends on the lighting and post-processing effects in the map.
Can I use chart textures to communicate gameplay information to players?
Yes. The chart is the primary navigation tool for Unturned players. Use distinct, recognizable colors for key gameplay features: bright blue for water, dark grey for major roads, distinct building colors for points of interest, and green for resources. Players develop an intuitive understanding of the chart color language and rely on it for navigation.
What if I want different water colors for different water bodies?
The chart system uses a single water color from Height_Strip pixel 0 for all water bodies on the map. Different water colors for different water bodies are not supported through the chart texture system. For visual water color variation that does not appear on the chart, configure each water volume's visual properties through the water volume settings in the level editor.
Best practices
- Create chart textures that match the map's terrain color palette. A forest map with blue terrain chart colors disorients players who rely on the minimap for navigation.
- Use the
Waterpixel (index 0) for a color that is clearly distinguishable from all terrain pixels so water bodies are immediately recognizable on the chart. - Make the terrain height gradient intuitive: darker colors for lower elevations, lighter colors for higher elevations. This convention is standard across mapping applications and players expect it.
- Use contrasting colors for the
Layer_Strippixels so different obstruction types (buildings, roads, resources) are visually distinguishable on the chart. - Set
Filter ModetoPointfor sharp pixel transitions if the map has distinct elevation bands. UseBilinearfor smooth gradients if the terrain has gradual elevation changes. - Test the chart textures in-game by opening the map at multiple zoom levels and verifying that the colors communicate the intended information.
Appendix A: Chart texture pixel mapping quick reference
Height_Strip (32x1)
| Pixel | X coordinate | Maps to |
|---|---|---|
| 0 | (0, 0) | All water bodies |
| 1 | (1, 0) | Lowest terrain elevation |
| 2-30 | (2..30, 0) | Terrain elevation gradient (ascending) |
| 31 | (31, 0) | Highest terrain elevation |
Layer_Strip (32x1)
| Pixel | X coordinate | Default use | Usable by objects? |
|---|---|---|---|
| 0 | (0, 0) | Highway (concrete road > 8m) | Yes |
| 1 | (1, 0) | Road (concrete road ≤ 8m) | Yes |
| 2 | (2, 0) | Unassigned | Yes |
| 3 | (3, 0) | Path (non-concrete road) | Yes |
| 4 | (4, 0) | Unassigned | Yes |
| 5-13 | (5..13, 0) | Unassigned | Yes (modded) |
| 14 | (14, 0) | Resources | No (hardcoded) |
| 15 | (15, 0) | Large-type objects | Yes |
| 16 | (16, 0) | Medium-type objects | Yes |
| 17-31 | (17..31, 0) | Unassigned | Yes (modded) |
Appendix B: Chart color design reference by biome
The table below provides cohort-validated chart color palettes for common map biomes.
Height_Strip designs
| Biome | Water (pixel 0) | Low terrain (pixel 1-10) | Mid terrain (pixel 11-20) | High terrain (pixel 21-30) | Peak (pixel 31) |
|---|---|---|---|---|---|
| Temperate forest | Blue (40,100,200) | Dark green (40,100,40) | Green (60,140,50) | Light green (100,170,80) | Grey (210,210,200) |
| Desert | Teal (30,130,180) | Sand (210,180,120) | Warm sand (200,170,100) | Rock (160,130,90) | White (240,240,235) |
| Snowy tundra | Dark blue (20,60,140) | Dark grey (80,85,90) | Grey (140,145,150) | Light grey (190,195,200) | White (250,250,255) |
| Tropical | Ocean blue (20,120,200) | Jungle green (50,120,40) | Medium green (80,150,60) | Light green (140,190,100) | Tan (210,200,160) |
| Volcanic | Deep blue (30,60,150) | Dark brown (50,35,25) | Brown (90,70,50) | Dark red (120,50,40) | Light grey (180,175,170) |
| Arid canyon | Brown (50,80,120) | Red-brown (140,90,50) | Tan (180,150,100) | Light tan (210,190,150) | White (240,235,225) |
Layer_Strip designs
| Biome | Highway (pixel 0) | Road (pixel 1) | Path (pixel 3) | Large objects (pixel 15) | Medium objects (pixel 16) | Resources (pixel 14) |
|---|---|---|---|---|---|---|
| Temperate forest | Dark grey (100,100,100) | Grey (140,140,140) | Brown (120,100,70) | Red-brown (130,70,50) | Orange (170,120,40) | Dark green (40,100,30) |
| Desert | Dark grey (100,100,100) | Grey (140,140,140) | Tan (160,140,100) | Brown (110,80,50) | Orange (150,110,40) | Olive (80,120,50) |
| Snowy tundra | Dark grey (100,100,100) | Grey (140,140,140) | Dark grey (90,90,90) | Dark red (100,50,40) | Brown (120,90,60) | Dark green (50,90,40) |
| Tropical | Dark grey (100,100,100) | Grey (140,140,140) | Brown (130,110,80) | Red-brown (120,70,50) | Yellow (180,160,50) | Jungle green (40,130,30) |
| Volcanic | Dark grey (100,100,100) | Grey (130,130,130) | Dark brown (80,60,40) | Dark red (100,40,30) | Brown (130,80,50) | Olive (60,100,40) |
Appendix C: Charts.unity3d bundle creation workflow
Step-by-step Unity workflow
- Open the Unity Editor with an Unturned-compatible project.
- Create two textures:
Height_Strip.pngandLayer_Strip.png, each 32x1 pixels. - Import the textures into the Unity project.
- Select each texture and set the following import settings:
- Texture Type: Default (or Sprite 2D)
- Wrap Mode: Clamp
- Filter Mode: Point (no filter) for sharp transitions, Bilinear for smooth gradients
- Compression: None
- Max Size: 32
- Create an asset bundle name for the textures (e.g.,
charts/mymap). - Assign both textures to the asset bundle in the Unity Editor.
- Build the asset bundle using the Unity Asset Bundle system.
- The output
.unity3dfile is placed in the project's build output folder. - Rename the built bundle to
Charts.unity3d. - Place the file in the map's
Bundles/directory.
Verification checklist
- [ ]
Height_Stripis exactly 32x1 pixels - [ ]
Layer_Stripis exactly 32x1 pixels - [ ] Both textures are assigned to the same asset bundle
- [ ] Bundle wrap mode is Clamp
- [ ] Bundle compression is None
- [ ] Bundle file is named
Charts.unity3d - [ ] Bundle is placed in the map's
Bundles/directory - [ ] Chart appears correctly in-game when the map is loaded
Appendix D: Chart asset troubleshooting table
| Symptom | Most likely cause | Resolution |
|---|---|---|
| Chart shows default colors | Charts.unity3d file not present or not loading | Verify the bundle is in the map's Bundles directory |
| Water appears as terrain color | Height_Strip pixel 0 is not set to a water-appropriate color | Set pixel 0 to a distinct blue/cyan color |
| Terrain shows as single flat color | Height_Strip pixels 1-31 are all the same color | Create a height gradient with distinct colors per pixel |
| Roads invisible on chart | Layer_Strip pixels 0, 1, 3 are too similar to terrain | Use contrasting colors for road pixels |
| Objects invisible on chart | Layer_Strip pixels 15-16 are too similar to terrain | Use contrasting colors for object pixels |
| Resources invisible on chart | Layer_Strip pixel 14 is too similar to terrain | Use a distinct color for resource pixel |
| Chart colors appear pixelated | Filter mode is Point on a map needing smooth gradients | Switch to Bilinear filter mode |
| Chart colors appear blurred | Filter mode is Bilinear on a map needing sharp transitions | Switch to Point filter mode |
| Custom chart not updating in-game | Bundle cache has old version | Clear the Unity bundle cache and restart |
| Chart has incorrect road classification | Road asset Chart field not set or legacy classification is wrong | Set the road asset's Chart field explicitly |
Appendix C: External references
- Smartly Dressed Games official modding documentation - Charts - the authoritative field reference.
- Unturned on Steam - the Unturned store page and community hub.
- Custom Map Creation: Project Setup - the level editor foundations article.
- Road Asset Reference - road chart classification that determines Layer_Strip pixel assignment.
- Level Asset Reference - level configuration that interacts with the chart system.
Cross-references
- Weather Asset Reference - the previous article; covers custom weather event configuration.
- Curated Maps Guide - the next article; covers the curated map submission program.
- Road Asset Reference - road chart classification that determines which Layer_Strip pixel roads use.
- Custom Map Creation: Project Setup - the level editor foundations article.
- Smartly Dressed Games modding documentation - official field reference.
- Unturned on Steam - game page and community.
Appendix H: Chart texture validation checklist
Before building the Charts.unity3d bundle, validate the textures with this checklist.
- [ ] Height_Strip and Layer_Strip are both 32x1 pixels
- [ ] File names match the expected names exactly (case-sensitive on Linux servers)
- [ ] Both textures use PNG format with no compression artifacts
- [ ] Wrap mode is set to Clamp on both textures
- [ ] Filter mode is consistent across both textures
- [ ] No texture compression is applied in the Unity import settings
- [ ] Both textures are assigned to the same asset bundle
- [ ] The bundle name is appropriate for the map
- [ ] The built .unity3d file is named Charts.unity3d
- [ ] The Charts.unity3d file is placed in the map Bundles directory
Appendix I: Chart texture authoring tools reference
The following tools support the 32x1 pixel texture format required for chart textures.
| Tool | Platform | Notes |
|---|---|---|
| Photoshop | Windows, macOS | Set image size to 32x1 px, use the pencil tool with 1px brush |
| GIMP | Windows, macOS, Linux | Set image size to 32x1 px, zoom to maximum for pixel-level editing |
| paint.net | Windows | New image at 32x1 px, use the paintbrush at 1px width |
| Aseprite | Windows, macOS, Linux | Designed for pixel art; set canvas to 32x1 px |
| ImageMagick | All (command line) | Use convert command to create and modify 32x1 textures from scripts |
Command-line texture generation with ImageMagick is useful for batch-creating chart textures from RGB value lists. The fx parameter evaluates per-pixel expressions, enabling gradient textures to be generated programmatically without opening an image editor.
magick -size 32x1 xc:#286428 -fx "u.j<0.5?#1E50B4:#64AA50" Height_Strip.pngAuthoring checklist
Before using a custom chart texture in a map project, confirm the following:
- [ ]
Height_Stripis exactly 32x1 pixels - [ ]
Layer_Stripis exactly 32x1 pixels - [ ] Both textures are in a Unity3D asset bundle
- [ ]
Height_Strippixel 0 is set to a distinct water color - [ ]
Height_Strippixels 1-31 form a terrain height gradient - [ ]
Layer_Strippixels use contrasting colors for different obstruction types - [ ] Road chart types are configured to use the expected Layer_Strip pixels
- [ ] Bundle wrap mode is Clamp
- [ ] Bundle filter mode is appropriate for the map (Point or Bilinear)
- [ ] Chart appears correctly when tested in-game at multiple zoom levels
Appendix E: Chart color hex reference for image editors
When authoring chart textures in an image editor, the RGB values from this article can be translated to hexadecimal color codes.
| Color | RGB | Hex |
|---|---|---|
| Water blue | (40, 100, 200) | #2864C8 |
| Deep water | (30, 80, 180) | #1E50B4 |
| Forest green | (40, 100, 40) | #286428 |
| Medium green | (60, 140, 50) | #3C8C32 |
| Light green | (100, 170, 80) | #64AA50 |
| Sand tan | (210, 180, 120) | #D2B478 |
| Rock brown | (160, 130, 90) | #A0825A |
| Dark grey road | (100, 100, 100) | #646464 |
| Grey road | (140, 140, 140) | #8C8C8C |
| Red-brown building | (130, 70, 50) | #824632 |
| Orange object | (170, 120, 40) | #AA7828 |
| Dark green resource | (40, 100, 30) | #28641E |
| Snow white | (250, 250, 255) | #FAFAFF |
| Dark brown volcanic | (50, 35, 25) | #322319 |
The hex values above provide a quick-reference lookup for map authors authoring chart textures in image editors that use hexadecimal color notation. Copy the hex value directly into the image editor color picker for precise color matching across chart revisions.
Appendix F: Chart rendering diagnostic guide
If the chart does not appear as expected, the following diagnostic steps isolate the issue.
| Step | Action | Expected result |
|---|---|---|
| 1 | Verify Charts.unity3d exists in the map Bundles directory | File present at Bundles/Charts.unity3d |
| 2 | Open Charts.unity3d in a bundle viewer | Contains Height_Strip and Layer_Strip textures |
| 3 | Verify both textures are 32x1 pixels | Texture dimensions match the expected size |
| 4 | Verify bundle wrap mode is Clamp | No texture wrapping artifacts on the chart |
| 5 | Verify compression is None | No color banding from compression artifacts |
| 6 | Load the map in-game and open the chart | Chart renders with the configured colors |
| 7 | Compare terrain elevation against Height_Strip colors | Low terrain matches pixel 1 colors; high terrain matches pixel 31 |
| 8 | Check road chart classification against Layer_Strip | Roads use the correct pixel based on their Chart field |
| 9 | Check object chart overrides for specific objects | Objects with Chart field overrides use the specified Layer_Strip pixel |
Appendix G: Cross-map chart consistency guidelines
For map authors producing multiple maps in the same setting, consistent chart colors across maps improve player navigation.
| Map series | Recommended Height_Strip palette | Recommended Layer_Strip palette |
|---|---|---|
| Temperate series | Green-to-grey elevation gradient | Standard grey roads, green resources |
| Desert series | Sand-to-tan elevation gradient | Grey roads, olive resources |
| Arctic series | Grey-to-white elevation gradient | Dark grey roads, dark green resources |
| Tropical series | Blue-to-green elevation gradient | Grey roads, bright green resources |
| Urban series | Grey-to-light-grey elevation gradient | Standard grey roads, brown buildings |
Consistency across a map series reduces player confusion when moving between maps.
The chart configuration is a visual layer that communicates terrain information to the player. A well-designed chart makes navigation intuitive; a poorly designed chart forces players to learn an unfamiliar color language. The chart textures should be designed as part of the overall map visual identity, not as an afterthought. Invest time in the Height_Strip and Layer_Strip colors early in the map project to avoid re-baking the chart bundle late in the development cycle.
Chart textures are among the smallest assets in any Unturned map project at just 32x1 pixels per texture, yet they have an outsized impact on player navigation and first impressions. A well-tuned chart communicates the map terrain at a glance; a poorly configured chart makes the minimap a source of confusion rather than a navigation aid. The chart rendering system samples both textures for every visible pixel on the minimap, which means the chart bundle size has no impact on runtime performance despite its visual importance.
The chart configuration is one of the final visual polish steps in a map project, but the color palette should be planned early. The chart colors should complement the map terrain colors and the map author should test the chart at multiple zoom levels before publishing the map.
Custom chart textures distinguish a polished map from a default-feeling map. The effort required to create a 32x1 pixel texture is minimal compared to the visual improvement to the map minimap. Every published map should include custom chart textures as part of the visual identity.
The Height_Strip and Layer_Strip textures work together to produce the complete chart rendering. The Height_Strip defines the terrain color gradient and the water color. The Layer_Strip defines the obstruction colors for roads, objects, and resources. Both textures must be present in the Charts.unity3d bundle for the chart to render correctly.
The chart asset is one of the easiest assets to customize in the entire Unturned mapping system. Two 32x1 pixel textures and a single Unity3D bundle build produce a chart that matches the map visual identity perfectly. No other asset type offers such a high visual impact for such a low authoring cost.
Document history
| Version | Date | Author | Notes |
|---|---|---|---|
| 1.0 | 2026-07-26 | 57 Studios | Initial publication. Full chart asset reference covering Height_Strip and Layer_Strip pixel mapping, color configuration workflow, road and object chart interaction, worked examples, FAQ. |
| 1.1 | 2026-07-26 | 57 Studios | Added Appendix E: hex color reference for image editors. Added Appendix F: chart rendering diagnostic guide. Added Appendix H: texture validation checklist. Added Appendix I: authoring tools reference. |
| 1.0 | 2026-07-26 | 57 Studios | Initial publication. |