Map System #

This is our walkthrough of the system, including all the most common use cases:

And many would like to know how to integrate:

World to Map World to Texture Map Loc #

To start, I think it is good to know that the hard part about any map system is the difference between a world location, a new relative world location based on your map size, and a texture map location. The differences are:

• World Location
  • This is the basic location in unreal engine. E.g. 10000*20000*100
• Map World Position
  • Your map will not always precisely be the same as the world location as in UE. So we need our own world position in the map relative to the size of our generated map. The position only has to be an x and an y value
• Texture Map location (Or Map Size Box Location, since we manipulate the size box size, not the texture)
  • Our new Map world position needs to be translated into the texture of the map that we use to display any info on via overlay markers on that map image.

An example:

• We have a landscape in unreal. Starting position is 10000x and 10000y
• We require our own map world position. So the 10000x becomes 0 and 10000y becomes zero.
• We have a map texture and it is 1024*1024 pixels
• How to show something on that map texture?
  • Now we would like to show something on that map texture. E.g. player position.
  • We assume our own map size is 10k by 10k units
  • The player is at 12000*12000 in the map
  • However, this is 2000*2000 on our own map
  • We want to show our player position 20% in the top of the y axis and 20 % to the right on the x axis.
    • This means our player texture should be at: 204,8 pixels x * 204,8 pixels y (20% of 1024) on the texture overlay of the map image
• Determine the size of the world:
  • E.g. 9000 units by 7000.
  • Place these units into a texture
  • We need to store the world size.
• Texture size
  • The texture of the world map should not be 9000×7000. This is too large and too slow.
  • So we need to map these units to a texture size. E.g. 900*700.
  • Power of two:
    • However, to capture a texture via render target, it needs to be a power of two.
    • This means we need to fit the 900*700 in a texture of 1024*1024. This will mean that the relative positions will not be mapped one on one.
• Relative reference point of the map
  • The world can have a specific size, however, the position of the world can be relatively different placed. E.g. on 20000x axis and -88888 y. This means we also need a relative reference point of the map to base world position calculations of.
  • Reference points:
    • If we create two target points, we will know the size of the map:
      • UpperLeft
      • LowerRight
    • We can use a targepoint for the references
  • All of the locations in the world are not based on these two corner points. However, we want to use these points as the “orgin” of the world so we can calulate a specific position.
    • .e.g when the player is exactly on the upperleft corner, the location should be 0,0,0 eventhough the world location in unreal can be something different.
• UI size
  • The world map is placed in the UI. The texture size is different from the world size. And the UI size can be different than the texture size.
• Layering
  • To zoom in, it is best to allow layering in textures and divide the world into grids and change the used textures based on zoom level.
• Capturing/Rendering World Texture
  • We can capture it in a render target.
  • We use a scene capture component for it.
    • The scene capture component can be set to orthographic view for a full top down look.
    • The ortho width in this capture is the width of the capture itself. So this should be exactly the world width or height, whichever one is greater. As long as the whole map fits into the capture.
      • This means that the capture always will be in a square shape
    • We should filter our some things in the capture. To do so, open the scene capture component general show flags settings under advanced and de-select the things you don’t want to capture.
  • Center the capture
    • To make sure to capture the map, we need to place the capture component precisly in the center of the map. We can do that on construction script, or via a button (call in editor function)
• UI
  • Worldmap_Size
    • We are going to set the texture of the map into a UI element. The map image should be under a SizeBox which should be a variable. The reason is because we want to dynamically adapt that sizebox when we want to zoom in and zoom out.
  • Overlay
    • If we want to display markers on the worldmap, we want to be able to show it above the map texture. Therefore we ara using an overlay. We can make multiple overlays for multiple marker categories so we can filter it out easily.
  • UI_Map_Main
    • The world map with the size box should be in a main UI which determines the position on the canvas. The map should be in the middle of the canvas and size to content so it auto adapts when the size is changed.
  • PlayerPosition
    • We want to show the player position on the map. By doing so, it will be a child of the map overlay which contains the original map texture.
    • We also want to be able to control the size of the icon. Therefore we will wrap the player position image with a size box.
    • Position:
      • To determine the player position, we can use the render transform in the ui to change the position in x and y directions. We will move the size box renter transform > translation (x and y) in our code in realtime.
  • Center position of any overlay image on the map:
    • It is good to know that when an image on the map is set, it is not in the middle. E.g. if an image is 50*50 pixels, and set to the 0,0 location in the overlay widget of the map, the image does not show at the 0,0 location.
    • However, if we use half of it, e.g. -25, -25, the image is centered. So by positioning images on the map, we also need to consider the size of the markers we put in the overlay.
• Zooming in and out
  • To zoom in and out, we will manipulate the size boxe of the map, and all the overlay elements should be updated too.
  • Because of this, it is good to know what all the original values are in the current UI setting.
  • Be carefull that the sizes are not conflicting. You need a central place to manage all your target UI sizes and set all your UI elements accordingly.
  • For zooming, we use a multiplier to change the size. E.g. 2 would be 2 times the original size, to twice as much zoomed in.
  • We would like to use the enhanced input for the zoom in and out, however, I can’t seem to get the input due to focus issues of enhanced input when creating the ui. This is the reason why I am manually listening to mouse scrolling in the UI itself.
• Updating the map
  • The map should only update when the map itself is visible.
• Panning in the map
  • In the Map UI, we can get the Map Overlay (the child of the Map Size box, and the parent of every overlay on the map).
    • If we move the translation of that overlay in the UI (the x and y), we can pan and move it arround.
  • To listen to a panning key, we are listening in the UI to on mouse button down event.
  • If we are releasing the down anywhere outside of the current map ui, it will keep panning. So please override the is panning to false when mouse button is down on any other UI or focused lost.
  • Boundries:
    • We also want to check if a map is out of its boundaries. To do so, we can check the desired size of the map UI, and compare it with the current viewport size.
      • If the x or the y of the desired size is out of the viewport x or y, it is out of the boundary.

Map Elements

Map elements are all the things we display on the map. It is important for us to know all the types of elements and categorize them in the different thins which all have different programming behaviour. A map element is a visual marker or symbol on a game map that provides players with navigational information, indicating locations, points of interest, or dynamic events. The categories:

Assign Map elements:

All map elements are predefined in actor components. You can assign these map elements to any actor in the world and define the properties to quickly add map elements. Check the example map for some examples.

Map element categorization:

We categorize our map elements into Passive and Dynamic elements.

Passive:

• • Passive elements are event-based updated.
  • These can be constructed and stored on begin play so there is no overhead of creating and deleting them continouisly.
  • They do not require frequent updates besides some stat changes like discovered/undiscovered
  • Example elements:
    • Discovery Points
      • Landmarks: Notable, often iconic locations on the map such as cities, unique buildings, or natural formations.
      • Points of Interest (POIs): Specific locations that provide exploration opportunities or notable features.
      • Fast Travel Points: Designated spots that allow players to instantly travel to previously discovered locations.
      • Shops and Vendors: Icons indicating places where players can buy, sell, or trade items.
      • Safe Houses/Save Points: Locations where players can save their progress or rest to recover.
    • Passive Quest Markers: Icons indicating the locations related to active quests or missions. For specific fixed locations.
    • Quest Area’s (e.g. Area to search in)
    • Player Waypoints: Custom markers set by the player to navigate towards specific locations.
    • Event Locations: Markers highlighting areas where special or dynamic in-game events are occurring.

Dynamic

• • Dynamic elements are constantly updating.
    • We split them up into two categories:
      • Nearby/InRadius Elements
        • Continousily add them and remove them from the list of nearby elements.
      • Always Visible Elements
        • Store them to always be visible and update in real-time
    • Each element can be either nearby only, or always visible. Example elements can be:
      • NPC Locations: Icons indicating the positions of important non-player characters, requiring real-time updates.
      • Resource Nodes: Locations where players can gather materials like minerals, herbs, or other resources.
      • Player Location: A dynamic marker showing the current position of the player on the map.
      • Dynamic Quest Markers: for quest objects that are moving
• Minimap vs worldmap vs compass elements
  • All passive elements can be placed on the worldmap on begin play. However, that is not needed for the minimap or the compass.
  • Compass And Minimap
    • Both the compass and Minimap ONLY work in radius, and with excpections to always show elements.
      • The compass and minimap only have dynamic elements, however, we also want to show passive elements. So we get all the passive elements in the radius, and display them to our dynamic lists.
    • Some can be always visible, and some show and disappear in radius.
  • The minimap does not require all passive elements to be loaded in, however, it should show the passive elements when in the minimap radius. Therefore, all the elements that are passive on the worldmap, can be dynamic on the minimap.

Map element Interfaces

Each map element can have different BPI’s assinged. We use BPI’s to categorize them, and get elements by intentend functionality.

• BPI_Map_Element
  • Assigned to each map element and is able to get all the map element info.
• BPI_Map_Element_Passive
  • Assigned to each element that should behave passive
• BPI_Map _Element_Dynamic
  • Assigned to each element that should behave dynamic
• BPI_Map_Element _AlwaysVisible
  • Assigned to each element that always should be visible on the map. E.g. a focussed quest marker that is moving. This is also used for the compass for focusable/tracked objects.
• BPI_Map_Element _Nearby
  • Assigned to elements that should show in the nearby radius of the player. E.g. enemies, resources, etc.
• BPI_Map_Element_Discovery
  • Assigned to every actor that can be discovered
• BPI_Map_Element_FastTravel
  • Assign to any fast travel location
• BPI_Map_Element_NPC
  • Assigned to any NPC
• BPI_Map_Element_Compass
  • Assigned to any element that should display on the compass

• Any element to show on the map:
  • BPI_Map_Element
  • BPI_Map_Element _Nearby (In nearly all casus you also want to show any map element in the nearby radius)
• A quest marker
  • BPI_Map _Element_Passive
• A focussed quest marker:
  • BPI_Map _Element_Passive
  • BPI_Map_Element _AlwaysVisible
• A moving quest marker (e.g. a player to follow)
  • BPI_Map _Element_Dynamic
  • BPI_Map_Element _AlwaysVisible
• A nearby NPC or item resource
  • BPI_Map _Element_Dynamic
  • BPI_Map_Element _Nearby
• A fast travel point:
  • BPI_Map _Element_Passive
  • BPI_Map_Element_Discovery
  • BPI_Map_Element_FastTravel

Map Elements Logic:

• Size Update
  • All map elements require a (optional) size update when zooming in/out. To determine the new position on the map based on the new zoom size. This should only be triggered when a zoom in or out event is called.
• Location Update
  • Static landmarks should not be able to require a location update. If they do (e.g. a traveling vendor?, it might just be a dynamic marker). However, we could program it the same as the dynamic markers and just optionally listen to it.
  • The event based dynamic markers, require an update based on a specific triggered event. The update should be targeted to a specific dynamic marker and not on all of them.
  • The realtime-dynamic elements require a continuous update. However, they should only update when near the player.
• World Actor
  • Each element that is displayed on the map, requires to be able to sent information to the map manager.

Minimap

• Options:
  • We can assign the map texture to a material, and update the position on that minimap via a material parameter collection to set the location and rotation.
• Minimap Icons
  • Update Icon Position function to set the position of the icon on the map
• Minimap Masking
  • All the map elements are placed in a square. To make sure we mask out the minimap we use a retainer mask element with a custom texture in it.

Compass

• There are two categories to show on the compas:
  • Always show
    • Tracked Quest markers
    • Player created and focussed waypoints
  • Show in Radius
    • NPC’s
    • Resources
    • Map Elements (non tracked)
• Everything that is showing in radius should have a realtime update
• In Radius Detection:
  • We are using an overlap box on the player to determine all the actors that are in the radius.
  • We are using a custom collision channel to trigger the overlap event to prevent overhead
  • Every actor that overlaps is added to a list to track in radius
  • Every tracked actor is being distance traced. We are assinging a BPI_InRadius interface and each actor can determine themselves when they want to show themselves on the compass. So we need to check the radius that they want to be showed on and display it in the compass or on the map.

---

Map Fog/Undiscovered #

• We are storing map fog into a render target.
• We are updating and drawing in realtime (on a timer function) to update the discover radius.

---

BP_Map_Texture_Generator #

The settings:

---

How to position the texture generator? #

• Place the BP_Map_Texture_Generator in the world
• Manually set the map size OR snap to an orging actor and have Auto set map size to true
• Click on snap orging to target and position the corner points.

---

How to generate the texture? #

• Update the capture
• Select a desired resolution

• In the content browser, select your used RT_MapRender and right click Create Static texture:

• Assign your generated texture

---

Test #

Play and test if it works with the default character of the map system:

---

World Beacons: #

• Large Map Beacon
  • This is a large beacon which shows high op the map. Normally with a particle beam to give focus.
  • It can dynamically change height based on distance from player. So when we are far away, we can see it. And if we are near, we can also see it.
  • Uses icon of a map element
  • Used for:
    • Any foccused element
      • E.g. focussed quest
      • Custom player waypoints
      • Or custom focussed map element
• Nearby beacon
  • Used to display points of intrests in the word when nearby. E.g. a vendor shows an icon above his head that he is a blacksmith. This same icon is on the map and compass when nearby.
  • Only shows icon and requires a custom offset. E.g. 50 above the head of a target.
  • Only show when nearby. We use the dynamic marker compass nearby radius for this.