{"id":13,"date":"2011-05-16T20:26:32","date_gmt":"2011-05-17T01:26:32","guid":{"rendered":"http:\/\/www.playwithlua.com\/?p=13"},"modified":"2020-05-22T13:20:14","modified_gmt":"2020-05-22T18:20:14","slug":"generating-heightmaps-in-lua","status":"publish","type":"post","link":"http:\/\/www.playwithlua.com\/?p=13","title":{"rendered":"Generating Heightmaps in Lua"},"content":{"rendered":"

Lua is a pretty much ideal language for playing around with map generating functions. I made a cute one today, combining linear noise with a couple other things.<\/p>\n

To start off with, here’s how I create a Lua map class: I start by making a “Map” table that contains a “methods” table. Anything class-level (what Java would call “static”) goes in Map; anything instance-level goes is Map.methods. I make a Map.new function that creates a new Map of a certain size, filling it with either a constant value or linear noise (I’m using 16 elevation levels):<\/p>\n\n

Map =<\/span> {<\/span>methods=<\/span>{<\/span>}<\/span>}<\/span>\n \n-- Make a grid of random values 0..15, or a fill value<\/span>\nfunction<\/span> Map.<\/span>new(<\/span>width,<\/span> height,<\/span> fill)<\/span>\n   local<\/span> map =<\/span> {<\/span>width=<\/span>width,<\/span> height=<\/span>height}<\/span>\n   setmetatable<\/span>(<\/span>map,<\/span>{<\/span>__index=<\/span>Map.<\/span>methods}<\/span>)<\/span>\n \n   for<\/span> n =<\/span> 1<\/span>,<\/span> (<\/span>width *<\/span> height)<\/span> do<\/span>\n\t  map[<\/span>n]<\/span> =<\/span> fill or<\/span> (<\/span>math.random<\/span>(<\/span>16<\/span>)<\/span> -<\/span> 1<\/span>)<\/span>\n   end<\/span>\n \n   return<\/span> map\nend<\/span><\/pre><\/div><\/div><\/div>\n\n
Pretty basic so far. I’ll add a few methods like at<\/code> and set<\/code> that change values based on x and y coordinates.<\/p>\n
One tricky thing: Lua libraries expect tables to be indexed from 1 (although it doesn’t really matter). So, I (probably inadvisedly) made mine like that, and then got plagued by off-by-one errors because I’ve written this class so many times in other languages that it’s practically muscle memory.<\/p>\n
So anyway, I’m going to skip a lot of these functions and just describe what they do. I start off with a small map that I fill with noise, then run a simple smoothing function over. The smoothing function just takes, for each cell, the average of its value and the values of all its neighbors:<\/p>\n\n
function<\/span> Map.<\/span>methods.<\/span>smooth(<\/span>self)<\/span>\n   local<\/span> new =<\/span> Map.<\/span>copy(<\/span>self)<\/span>\n \n   for<\/span> x =<\/span> 0<\/span>,<\/span> self.<\/span>width-<\/span>1<\/span> do<\/span>\n   \t  for<\/span> y =<\/span> 0<\/span>,<\/span> self.<\/span>height-<\/span>1<\/span> do<\/span>\n\t\t local<\/span> n =<\/span> self:<\/span>p2n{<\/span>x=<\/span>x,<\/span>y=<\/span>y}<\/span>\n\t\t local<\/span> s,<\/span> c =<\/span> self:<\/span>neighbor_sum(<\/span>x,<\/span> y)<\/span>\n\t\t local<\/span> nv =<\/span> (<\/span>self:<\/span>at(<\/span>x,<\/span>y)<\/span> +<\/span> s)<\/span> \/<\/span> (<\/span>c +<\/span> 1<\/span>)<\/span>\n\t\t new[<\/span>n]<\/span> =<\/span> math<\/span>.<\/span>round(<\/span>nv)<\/span>\n\t  end<\/span>\n   end<\/span>\n \n   return<\/span> new\nend<\/span><\/pre><\/div><\/div><\/div>\n\n
I keep this pattern of having every method return self so I can chain methods together. Then, I scale the map up 8x, by making an 8×8 tile for each pixel, with the corners being the adjacent pixels. So, the pixel at (0,0) becomes the upper-left corner of a tile that also has (1,0) at the upper right, (0,1) at the lower left, and so on.<\/p>\n
Now I can fractalize it. For each tile I pick new pixels to go in the middle of each edge and in the center, so the middle of the left side will be either the top-left or bottom-left pixels, and so on. Now I can divide it into four new tiles and recurse (because the new tiles have values in each of their corners).<\/p>\n
Once I recurse all the way to the bottom, I run the smoothing function one more time on the new map and then print it out. Making an image out of it is another little trick: rather than deal with finding an image-writing library and figuring out its API, since I’m just playing around, I write the image data by hand in XPM format. X Pixmap is a really simple image format, readable by the Gimp and Emacs, that was invented for storing X Windows icons, and is human-readable and trivial to write. Here’s an example:<\/p>\n\n
\/* XPM *\/<\/span>\nstatic<\/span> char<\/span> *<\/span> map_xpm[<\/span>]<\/span> =<\/span> {<\/span>\n"16 16 16 1"<\/span>,<\/span>\n"0 c #000033"<\/span>,<\/span>\n"1 c #000044"<\/span>,<\/span>\n"2 c #000055"<\/span>,<\/span>\n. . . etc<\/span> . . .\n"45575569ca787679"<\/span>,<\/span>\n"3457679aa998977a"<\/span>,<\/span>\n"4557799889b889ab"<\/span>,<\/span>\n. . . etc<\/span> . . .\n}<\/span><\/pre><\/div><\/div><\/div>\n\n
Becomes this:
\n\"\"<\/p>\n
So, since I can chain everything together, after playing with it some, I ended up with this to create a map:<\/p>\n\n
math.randomseed<\/span>(<\/span>1<\/span>)<\/span> -- Or whatever...<\/span>\nm =<\/span> Map.<\/span>new(<\/span>17<\/span>,<\/span> 17<\/span>)<\/span>:<\/span>smooth(<\/span>)<\/span>:<\/span>scale(<\/span>8<\/span>)<\/span>:<\/span>fractal_tile(<\/span>8<\/span>)<\/span>:<\/span>smooth(<\/span>)<\/span>:<\/span>slice(<\/span>0<\/span>,<\/span>0<\/span>,<\/span>128<\/span>,<\/span>128<\/span>)<\/span>\nfile =<\/span> io.open<\/span>(<\/span>"map.xpm"<\/span>,<\/span> "w"<\/span>)<\/span>\nfile:<\/span>write<\/span>(<\/span>m:<\/span>xpm(<\/span>)<\/span>)<\/span><\/pre><\/div><\/div><\/div>\n\n
(Since what I’m scaling are actually the spaces between cells, in order to get 16 tiles with corners I need a seed map 17×17)<\/p>\n
So, enough chatter. Let’s look at a few random maps:<\/p>\n
\"\" \"\" \"\"<\/p>\n
Here’s the code.<\/a> I think these came out much better than my last attempt at mapmaking. The elevations actually work; mountains slope gradually down into seas.<\/p>\n","protected":false},"excerpt":{"rendered":"
Lua is a pretty much ideal language for playing around with map generating functions. I made a cute one today, combining linear noise with a couple other things. To start off with, here’s how I create a Lua map class: I start by making a “Map” table that contains a “methods” table. Anything class-level (what […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1],"tags":[],"_links":{"self":[{"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=\/wp\/v2\/posts\/13"}],"collection":[{"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=13"}],"version-history":[{"count":0,"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=\/wp\/v2\/posts\/13\/revisions"}],"wp:attachment":[{"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=13"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=13"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.playwithlua.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=13"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}