Map Making Tutorials

What to install, what only you can do, and what to hand to the model.

1. What this course coversEverything that goes into one finished UMS map.1 min
2. Installing the map toolsScmDraft 2, TrigEditPlus, EUD Editor 3, and what each is for.1 min
3. Installing Claude Code (Windows / Mac)Written for someone opening a terminal for the first time.2 min
4. Your job and the model's jobIt will build the code. It cannot open the editor, compile, or launch the game.2 min
5. Which tool, and which versionThe newest version is not always the right one, and some editors you must not use at all.6 min
6. When the Korean breaksA map's text is stored in one of two encodings, and opening it in the wrong one cannot be undone.8 min
7. Setting up to write scriptsWhat you need once you move to epScript or eudplib: Python, an editor, and where things live.4 min

The part done in the editor. However much code a model writes, this groundwork is yours.

1. A new map, and who plays itThe player layout comes before the terrain.2 min
2. Terrain and placing unitsStructure first, decoration later.2 min
3. Creating locationsDeciding what parts of the map a trigger can point at - the resource a real map uses most.2 min
4. Changing what units can doHit points, damage, range, cost - all editable here, with no EUD involved.2 min
5. Renaming units to make countersThis is how you create variables, and it is a job only you can do.3 min
6. Getting around ScmDraftWhat you choose when you make a new map - including the one choice that is a nuisance to undo.5 min
7. Making terrain read as designedThe canvas size is not the budget - and regularity reads as not having designed anything.22 min
8. Terrain modes: Isometrical and RectangularThe same terrain comes out completely differently depending on the mode - and only one of the two can lay obstacle terrain and doodads.7 min
9. The diamond lattice Isometrical actually works inIsometrical does not paint in tiles. It paints on a lattice of 4x2-tile diamonds, and it redraws past the area you painted.11 min
10. The ScmDraft features nobody findsThings that are in a menu somewhere and go unused because of the label.8 min
11. Make a melee map firstFinishing one map that needs no triggers at all makes everything after it easier.4 min
12. Overlays: what the editor can show youWhere resources cannot go, how units find their way, and the limit that stops a map loading.5 min
13. Upgrades and techs, per playerThe map decides who has already researched what, and what they are allowed to research.4 min
14. Units, Unit Sprites and Pure SpritesThree things in the editor look like units. They are not the same thing.11 min

Ninety percent of a map is built here, before any EUD is involved.

1. Anatomy of a triggerPlayers, conditions, actions. That is the whole thing.2 min
2. Every conditionThere are 23 of them, and this is all of them.4 min
3. Every actionAll 57. You will not need most of them, but you need to know they exist.11 min
4. Text, colour and formattingColour and alignment are control codes placed inside the string.4 min
5. Death counters are your variablesStarCraft has no variables. Death counters are what you use instead.4 min
6. Making triggers run fastNothing works at the default speed. These days one plugin setting fixes it.7 min
7. Order and the trigger cycleThe same trigger gives a different result depending on where it sits.3 min
8. SwitchesThe lightest tool when all you need is on or off.2 min
9. When it does not workTriggers give you no error message. You have to go and look.3 min
10. Working with locationsOnce a location can move, area checks and tracking follow.3 min

The pieces almost every map uses, whatever the genre.

1. Measuring time with death countersUnder EUD Turbo, 24 deaths is one real second. Every period in your map comes from that one conversion.5 min
2. Spawns and wavesProduce enemies on a timer, cap how many, and step the waves up.4 min
3. Counting players and handling arrivalsWork out who is present, and give each of them a start.5 min
4. Zones, teleports and safe areasMove people around, and keep them out of where they should not be.3 min
5. Death and respawnPutting a player who lost their unit back into the game.3 min
6. Showing the player their own numbersWays to show level and money before you reach EUD.2 min
7. TrigEditPlus is a languageWriting triggers as text gets you variables and loops - but they run at compile time, not in the game.7 min
8. Previewing coloured textDo not compile and launch the game to check a colour. There is a tool for it.3 min
9. Building a real random number out of switchesOne switch is one coin flip. Several of them, read as digits, make a number.8 min
10. The mission briefingThe screen before the map starts. Like triggers, but with no conditions.4 min

Damage maths, frames, crashes and file size - the things you cannot guess correctly.

1. Damage types and unit sizeWhy a Siege Tank does not one-shot a Marine.6 min
2. Time and framesOne second on the Countdown Timer is not one second.7 min
3. The five pools the engine draws fromUnits, sprites, images, bullets and orders - each a fixed count, and "the 500 limit" is two different 500s.12 min
4. Why maps crash on loadSome things crash on placement alone, with no EUD involved.11 min
5. Sound and file sizeUse ogg and lower the quality. Music is 90% of a map's size.14 min

Defence, arena and rounds, tag, racing, and the computer players behind them - pick whichever is closest to what you are building. The progression side is the next module.

1. Defence: waves and leaksEnemies reaching the goal cost you a life.7 min
2. A yardstick for what a weapon is worthComparing damage alone is wrong, and two tables defined against each other will drift.7 min
3. The wave difficulty curveOne growth rate cannot work, because a fresh team and a maxed one cannot sit on the same curve.13 min
4. Rounds and teamsThe structure arena, PvP and survival maps share.7 min
5. Winning, losing and eliminationHow to end the game, and how to eliminate someone without ending it.4 min
6. Giving a boss behaviourRe-issue orders to keep it in line, and change phase by health.3 min
7. Escape maps: checkpoints and instant deathDying puts you back at the last point you reached.5 min
8. Tag and infectionPick who is it, then turn whoever they catch.5 min
9. Racing: laps and finishing orderForce the checkpoints in order, then record who arrives first.4 min
10. Minigame collectionsRotate through short games and carry the score between them.4 min
11. Idle games and automatic incomeThe number goes up on its own, and you spend it to make it go up faster.7 min
12. Making the computer player actThe stock AI scripts that make a computer attack and share vision - and the two reasons its units stop moving: a ceiling at a thousand, and one flag bit.12 min
13. Writing your own AI scriptAttacking with the composition you want, when you want it, means replacing aiscript.bin itself.9 min
14. Making one unit attack exactly thatNeither the trigger actions nor the AI scripts have “this unit attacks that unit”. Five struct fields do.13 min

Shops, inventory, levels, skills, summons and transforms - the parts a progression map is made of, and where each quietly breaks.

1. Shops, and restricting who can buyStand on a pad to buy, and the trap that comes with it.5 min
2. An inventoryKeeping the item catalogue separate from the inventory, and slicing one array across every player.8 min
3. Experience and levelsNot just for RPGs - difficulty tiers in a defence map and ranks in an arena use the same structure.5 min
4. Skills and cooldownsA production building becomes the skill button - the same structure serves an arena ultimate or a defence map's special ability.9 min
5. Paying for skillsGas, energy or a variable - all three are used and each gives up something. And fractional regeneration is an accumulator, not a division.6 min
6. Damage and projectiles of your ownBetter to make the game deal the damage than to subtract it yourself - and fast projectiles have a famous trap in their hit detection.8 min
7. Knowing that a unit just attackedLifesteal, crits, on-hit procs. There is no attack event, but the cooldown gives one away.11 min
8. Toggle skillsGive a Corsair a cloak button and it still will not cloak - the executable refuses the order.6 min
9. Area effects and knockbackFour ways to find who is inside an area, and the invulnerability knockback quietly hands out.8 min
10. Transform: changing a unit without dropping the selectionRemove and recreate loses the selection and the state. Driving the game's own morph order keeps both.6 min
11. A graphic attached to a unit, for freeA glow on a buffed hero, a brand on a marked target - and why a second unit on top is the wrong way to make one.6 min
12. SummonsThe easiest skill to build and the easiest to leave broken. There are four places it leaks.7 min
13. Drops and probabilityRandomised switches are where probability comes from.7 min

What EUD is and what you build it with, why a death count is memory, PTR and EPD, where one unit keeps its own data, how to count what is on the map - and how to find out why it is not working.

1. What EUD is, and where you write itReading and writing the game's own memory - and the two places that code goes.3 min
2. PTR and EPDWhy one death trigger is exactly one memory write.7 min
3. Structure offsets: one unit's own dataEvery Marine shares its damage; each Marine has its own hit points. Where that line falls.6 min
4. Who owns a death counterRead one counter in two places and whoever clears it first wins.5 min
5. Counting units lags a cycleA unit you just created is not counted yet.15 min
6. Plugin order decides the screenWhen two plugins write the same line, only the later one is visible.4 min
7. Debugging an EUD mapThe "this EUD map is not supported" dialog names an address. Read the number before opening the source.7 min
8. Make the build refuseCompiling proves syntax. Whether the design still holds is a separate question.6 min

What is inside a map file, where the code actually goes, why a variable costs 72 bytes, and why which way round you write a condition is the cost. Not required reading - but it explains everything else.

1. What is inside a .scxA .scx is an archive holding one file, that file is a list of named chunks, and each chunk is one of the editor's tabs.9 min
2. Knowing what a unit is standing onGrass, a cliff you can walk down, water - instead of hundreds of locations, read the map's tiles once at compile time.9 min
3. Everything is a triggerRemastered runs no scripting language. epScript works because it turns into triggers.8 min
4. The 222 triggers that run when the map startsA compiled EUD map's trigger list is not empty - it holds a heap of identical-looking SetMemory triggers, and they are the loader.11 min
5. The order of one frameTriggers run last in the frame. Almost every "why is it one beat late?" ends with that one line.13 min
6. Why a variable costs 72 bytesA variable is a trigger holding one SetDeathsX action - which is why reads are expensive and writes are cheap.12 min
7. Writing one and two byte fieldsA death trigger moves in four byte steps. Anything smaller needs a mask.5 min
8. Angles, distances and binary searchThe functions for working with coordinates, and the search you do not have to write yourself.9 min
9. Which way round you write a condition is the costOne branch is two triggers, and the false side is the cheap one - the exact opposite of the classic-trigger instinct.6 min
10. Arrays are not freeWhich of EUDArray and EUDVArray is faster depends on whether the index is a constant or a variable - and precomputing the multiply usually loses.10 min
11. A condition is an object, not a true or falseUse a condition as if it were a value and you get a compile error that names neither the file nor the line.5 min

How to hold on to one unit and read and move it, how you know a player pressed a button, and how both of those can drop everybody else - in that order.

1. The Current Player trickHow to hold an address in a variable and write to it - the only way EUD follows a pointer.8 min
2. Getting a handle on one unitHow to learn the structure offset of a unit you just created, and how to keep trusting it.12 min
3. Four ways to read the struct wrongThe same bytes mean different things per unit kind, a flag is not a number, the padding is a free per-unit variable - and there are four bytes that do not read back at all.12 min
4. Holding on to many unitsUnitGroup and EUDBag: keeping a list of units instead of finding them again every cycle.11 min
5. Scanning the whole map every cycle without the lagFour structural ideas from autorepair - the shape of any system that looks at every unit and picks the ones that match.13 min
6. Reading what a unit is doingThe order number alone does not tell you. order, orderState and orderSignal move together, and the three of them are how you catch a spell being cast.15 min
7. Moving a unit yourselfTeleporting, walking, turning on the spot and a no-go zone an auto-mouse cannot beat - all of it out of the same three or four fields.16 min
8. Between air and groundWhether a unit is air or ground is not one thing but four separate ones - which is how you get something that flies and that Zerglings can hit.8 min
9. Detecting a button press with the build queueThe modern standard for a skill button: press a production button, read the queue, clear it.18 min
10. Skills that take a targetThe build queue tells you a button was pressed. Which route you take depends on whether the target is a unit or a patch of ground, and on whether you charge minerals or energy.20 min
11. The primitives that are already writtenSkill detection, area damage, geometry - open TETools before writing any of them by hand.8 min
12. Choreography as a timetable: Queue, Plan, ExecStop computing the animation every cycle. Write the whole thing down the moment the skill is cast, and pop each step when its time comes.14 min
13. Precomputing the whole thing at compile timeInstead of computing a coordinate each frame, compute every frame at build time and leave the map a jump table.13 min
14. Desync, and the local playerDrive a change everyone shares from a condition only one machine can see, and everyone else drops.21 min
15. A menu you click with the mouseRead the mouse, work out which line it is over - and remember that all of it is local.7 min
16. Removing graphics you did not ask forThe rock that appears from nowhere, and the overlay that follows a unit around.5 min
17. Writing it in Python insteadUsing eudplib directly instead of epScript brings Python's own syntax with it.9 min
18. The plugins worth knowingBefore writing it, check whether it already exists.10 min
19. Reading three shipped examplesThe difference between Trigger, RawTrigger and DoActions, and when each is right.5 min

StarCraft has no UI. Eleven lines of chat, the wireframe panel and the buttons on the command card - everything a player sees is built from those three.

1. Taking keyboard input (MSQC)Only one machine knows a key was pressed. MSQC turns that into a death count every machine agrees on.9 min
2. Using chat as a command lineRead what a player typed and you have -help and friends. Four things get in the way.12 min
3. Building a UI out of textStarCraft has no UI widgets. It has eleven lines of chat.9 min
4. Showing an explosion, in one lineHow to put any of StarCraft's effect graphics wherever you want: one unit and one write.11 min
5. Effects on the screen itself: brightness, fog, vision, cameraEffects that are not drawn with units at all - they cost no sprite, no unit, and so they never hit the limits.16 min
6. Colouring an effectYellow, red and black come out of a frame number; purple is made by stacking two of them.10 min
7. Putting a picture on the map without spending a unitAn image frozen with build size 0, and lying to the tileset to draw any frame you like.12 min
8. FileManager: the game's own wordsWhere weapon names, ranks and tooltips are changed - and why changing one changes all of them.13 min
9. Renaming a unit: by type, by player, by individualThere is one name per unit type - but only one unit's name is ever on screen, and that one slot does all three jobs.14 min
10. FireGraft: button sets and the unit panelWhere buttons are made - and the one side effect that merely switching it on causes.12 min

Rewriting the game's own tables - units, weapons, images - while it runs, and the ceilings and traps that come with it.

1. DatEdit: the unit tabWhere a unit's own data is changed - and why what you change here does not reach units already on the map.7 min
2. dat writes do not stay writtenYou do not write it once. You write it every cycle.6 min
3. scdata: game data by name, not by addressUnits, weapons, upgrades and a player's own resources all read and write as objects. There is no longer a reason to do the bitmask arithmetic by hand.7 min
4. Every field has a ceilingPast 65,535 the number wraps - and how to check an offset is real.8 min
5. One flingy, many unitsChange a unit's look and you change every other unit wearing it.5 min
6. What you must not touchSome unit ids and some addresses kill the map immediately.4 min
7. Creating units the editor refuses to createPlacing units the editor does not list, and putting them where the terrain says no.6 min
8. Giving a building a weaponMaking a building that does not attack, attack. Five things have to line up.9 min
9. Replacing graphics: a unit, and a whole tilesetRemastered uses anim, not GRP, and you only ever draw half the directions - and a tileset is a file-size problem before it is a graphics one.17 min
10. Making any unit cast a spellSwap a unit's iscript index and a non-caster gains a cast animation - at a price.9 min
11. Why there is a rock floating above itAn iscript header's length depends on its type. Read a slot that is not there and script bytes get used as an animation address - and that rock is where it ends.11 min

The language that makes EUD readable.

1. What eudplib actually doesWhat is working underneath EUD Editor 3, and the three ideas you need.3 min
2. The basicsVariables, conditionals, functions - and a narrower language than you would expect.4 min
3. How a script is laid outGlobals, helpers, and the entry point that runs every cycle.4 min
4. The player loopOnce per cycle, once per player.6 min
5. Reading a counter as a numberConditions give you true or false. What if you need the number?3 min
6. Putting values on screenDisplayText for fixed text, f_eprintf for text with values in it.6 min
7. The traps that get everyoneThe cases that compile cleanly and then behave strangely in game.8 min
8. Loops and branches: for, foreach, once, epdswitchA loop that unrolls at compile time and a loop that runs in game are different things, and confusing them misuses both.11 min
9. There is only one kind of valueEvery epScript variable is a 32-bit unsigned integer. There is no such thing as a string variable.6 min
10. The rest of the declaration syntaxstatic var, type annotations, bodiless declarations, import, and running Python at compile time.7 min
11. object: making a structHow to group values in a language whose only value is a 32-bit integer - and where a copy is not a copy.11 min
12. There are four kinds of stringCompile-time, map, string data and TBL strings. Mix them up and it either will not compile or prints the wrong thing.16 min
13. What you can do at compile timeMost people know py_eval and stop there. Printing to the build log, reading an external file and generating your own reader all happen at compile time.12 min
14. One data block instead of six arraysIf adding one hero means editing six arrays together, an index bug is a matter of time. Write the data once and let the compiler make the arrays.14 min

If progress has to survive the game, this is half the work - and painful to bolt on late.

1. Why saving decides the mapIf what you built up disappears, there is no reason to come back.6 min
2. Building a save system and wiring it inChoosing what to store, generating the system and wiring it into the map - and what you store is what decides how long the code is.9 min
3. Shutting out the obvious cheatsA solo lobby and a computer slot are the two main doors.13 min
4. Operating a map that savesThe moment a map saves, it stops being something you publish and becomes something you keep. What usually kills one is not the code.9 min
5. When you update the mapKeep old codes working; stop new ones opening on old builds.4 min

From here on it is entirely hands-on.

1. CompilingKeeping the source and the output apart.6 min
2. Testing in gameThe bugs that never show up when you play alone.3 min
3. Finding what is making the map lagWhich code is expensive is measured, not guessed - and the tool comes with euddraft.19 min
4. PublishingA map page, downloads, and a way to be found.2 min
5. Leaving a notice for an AIA line that survives compilation, addressed to whatever opens your map.5 min
6. The eds file: plugins and load orderThe file that tells euddraft what to put in and in what order - and the order changes behaviour.8 min