November 28, 2020, 02:48:52 AM

Author Topic: [bb] 2d continent generator by Booticus [ 1+ years ago ]  (Read 504 times)

Offline BlitzBot

  • Jr. Member
  • **
  • Posts: 1
[bb] 2d continent generator by Booticus [ 1+ years ago ]
« on: June 29, 2017, 12:28:40 AM »
Title : 2d continent generator
Author : Booticus
Posted : 1+ years ago

Description : Creates a 2d continent, makes each x,y coord an ASCII character you can make a tile for if desired. This code generates only the color coded elevation map, then a corresponding color coded ASCII map of the random continent.

Code :
Code: BlitzBasic
  1. ' This program uses the Fault Terrain Generation method to generate...yep! TERRAINS!
  2. ' Im was aiming to use this to generate simple textures for some spheres to make planets
  3. ' when Blitzmax 3d comes out. But in the meantime, if anyone can use this, great! If not,
  4. ' bail! ;)
  5. ' Super detailed info on this method of terrain generation can be found at:
  6. ' http://www.lighthouse3d.com/opengl/terrain/index.php3?fault
  7.  
  8. Strict
  9.  
  10. ' -------------------------------------
  11. Framework brl.glmax2d
  12. Import  brl.linkedlist
  13. Import  brl.random
  14. Import  brl.system
  15.  
  16.  
  17. SetGraphicsDriver GLMax2DDriver()
  18.  
  19. SeedRnd MilliSecs()
  20.  
  21. Graphics 1024,768
  22. SetBlend ALPHABLEND     ' Select ALPHABLEND
  23.  
  24. ' Set up our map types, they'll initialize
  25. ' in their own Tlist, defined in the type
  26. Local maps=0
  27.  
  28. For Local a:Int = 0 To maps
  29.         Cls
  30.         Local thecontinent:continent = New continent
  31.         thecontinent.init
  32.         thecontinent.createcontinent(800)
  33. Next
  34.  
  35. '#Region Main loop
  36. While Not KeyHit(KEY_ESCAPE)
  37.         checkkey
  38.         Cls
  39.         displaymaps
  40.         FlushMem
  41.         SetColor 255,255,255
  42.         drawtext "Hit SPACE to generate another random continent. ESC to exit.",100,15
  43.         Flip
  44. Wend
  45. '#End Region
  46.  
  47. Type continent
  48.         Field continentwidth:Int = 64
  49.         Field continentheight:Int = 32
  50.         Field terrain:Float[continentwidth,continentheight]
  51.         Field ascii:String[continentwidth,continentheight]
  52.         Global continentlist:TList
  53.        
  54.         Method New ()
  55.                 continentwidth:-1
  56.                 continentheight:-1             
  57.                 If continentlist = Null Then continentlist = CreateList ()
  58.                 ListAddLast continentlist, Self
  59.         End Method
  60.        
  61.         Method init()
  62.                 For Local x:Int = 0 To continentwidth
  63.                         For Local y:Int = 0 To continentheight
  64.                                 terrain[x,y]=50 ' We're resetting each spot on our continent to be 50 high.
  65.                                 ascii[x,y]="A"
  66.                         Next
  67.                 Next
  68.         End Method
  69.        
  70.         Method createcontinent(theiterations:Int)
  71.                 ' Iteration is the amount of passes
  72.                 ' the algorithm runs. The more passes, the
  73.                 ' more detailed. Fiddle with variables!
  74.                 ' This method works well, I like its results
  75.                 Local increase:Float = .75 ' Fiddle with this in small amounts to see some different products.
  76.                 Local a:Int
  77.                 Local x:Int
  78.                 Local y:Int
  79.                 Local b:Int
  80.                 Local d:Int
  81.                 Local c:Int
  82.                 Local w:Int = continentwidth
  83.                 Local l:Int = continentheight
  84.                 Local iterations:Int = theiterations
  85.                
  86.                 For x = 0 To continentwidth
  87.                         For y = 0 To continentheight
  88.                                 terrain[x,y]=50 ' We're resetting each spot on our continent
  89.                                 ascii[x,y]="A"
  90.                         Next
  91.                 Next
  92.        
  93.                 For Local j:Int = 0 To iterations
  94.                         Local x1:Int=Rnd(-w,w*2)
  95.                         Local z1:Int=Rnd(-l,l)
  96.                         Local x2:Int   
  97.                         Local z2:Int   
  98.                         Repeat
  99.                                 x2=Rnd(-w,w*2)
  100.                                 z2=Rnd(-l,l)
  101.                         Until x2<>x1 And z2<>z1
  102.                         'a = (z2 - z1)
  103.                         'b = -(x2 - x1)
  104.                         a = (z2 - z1)
  105.                         b = -(x2 - x1)
  106.                         c = -x1*(z2-z1) + z1*(x2-x1)           
  107.        
  108.                         For x = 0 To continentwidth
  109.                                 For y = 0 To continentheight
  110.                                         If (a*x + b*y - c > 0)
  111.                                                 terrain[x,y] :+ increase
  112.                                                 If terrain[x,y] > 255
  113.                                                         terrain[x,y]=255
  114.                                                 EndIf                                  
  115.                                         Else
  116.                                                 terrain[x,y] :- increase
  117.                                                 If terrain[x,y] < 1
  118.                                                         terrain[x,y]=1
  119.                                                 EndIf                                  
  120.                                         EndIf
  121.                                 Next
  122.                         Next
  123.                 Next
  124.  
  125.                 ' Smooth the terrain
  126.                 ' THIS takes a lot of CPU time...remove for quicker
  127.                 ' continent generation, but less smooth detail.
  128.                 Self.smooth
  129.  
  130.                
  131.                 ' OK weve generated our continent by faultlines.
  132.                 ' Now, begin checking terraint height, and assign
  133.                 ' an asciiI character accordingly for tilemap.
  134.                 ' This function will draw our continent data
  135.                 ' as derived from our terrain[x,y] array
  136.                 Local offsetx:Int=0
  137.                 Local offsety:Int=0
  138.                 Local level1:Int=50
  139.                 Local level2:Int = 55
  140.                 Local level3:Int = 58
  141.                 Local level4:Int = 61
  142.                 Local level5:Int = 64
  143.                 Local level6:Int = 67
  144.                 Local level7:Int = 70
  145.                 Local level8:Int = 73
  146.                 Local level9:Int = 76
  147.                 Local level10:Int = 79
  148.                 For x = 0 To continentwidth
  149.                         For y = 0 To continentheight
  150.                                 ' Now in here you can experiment with the coloring of the
  151.                                 ' display depending on height. So for instance I currently
  152.                                 ' have only the sealevel as a coloring, anything above
  153.                                 ' the sealevel is drawn as a increasingly bright shade of
  154.                                 ' green. Maybe above certain heights, change to white
  155.                                 ' color for snowcapped mountains, etc.
  156.                                 Local i:Float=terrain[x,y]
  157.                                 If i>=level1 And i<level2
  158.                                         ascii[x,y]="A"
  159.                                 Else If i>=level2 And i<level3
  160.                                         ascii[x,y]="B"                         
  161.                                 Else If i >=level3 And i<level4
  162.                                         ascii[x,y]="C"
  163.                                 Else If i>=level4 And i<level5
  164.                                         ascii[x,y]="D"
  165.                                 Else If i>=level5 And i<level6
  166.                                         ascii[x,y]="E"
  167.                                 Else If i>=level6 And i<level7
  168.                                         ascii[x,y]="F"
  169.                                 Else If i>=level7 And i<level8
  170.                                         ascii[x,y]="G"
  171.                                 Else If i>=level8 And i<level9
  172.                                         ascii[x,y]="H"
  173.                                 Else If i>=level9 And i<level10
  174.                                         ascii[x,y]="J"
  175.                                 Else If i>level10
  176.                                         ascii[x,y]="J"
  177.                                 EndIf
  178.                         Next
  179.                 Next
  180.                
  181.                 ' This next is optional. It will Normalize
  182.                 ' our terrain, EACH TERRAIN x,y AT A TIME!
  183.                 ' So it might be a time consumer
  184.                
  185.         End Method
  186.        
  187.         Method draw(offsetx:Int,offsety:Int)
  188.                 ' This function will draw our continent data
  189.                 ' as derived from our terrain[x,y] array
  190.                 ' Yes, we can probably use a grabimage
  191.                 ' to grab an image of the continent instead
  192.                 ' of drawing each and every pixel....
  193.                 ' but Im far too lazy.
  194.                 Local x:Int
  195.                 Local y:Int
  196.                 For x = 0 To continentwidth
  197.                         For y = 0 To continentheight
  198.                                 SetColor 75,75,255
  199.                                 Select ascii[x,y]
  200.                                         Case "A"
  201.                                                 SetColor 75,75,255
  202.                                         Case "B"
  203.                                                 SetColor 132,247,140
  204.                                         Case "C"
  205.                                                 SetColor 231,239,115
  206.                                         Case "D"
  207.                                                 SetColor 255,206,82
  208.                                         Case "E"
  209.                                                 SetColor 214,115,66
  210.                                         Case "F"
  211.                                                 SetColor 148,0,0
  212.                                         Case "G"
  213.                                                 SetColor 214,0,0
  214.                                         Case "H"
  215.                                                 SetColor 200,200,200
  216.                                         Case "I"
  217.                                                 SetColor 222,222,222
  218.                                         Case "J"
  219.                                                 SetColor 255,255,255
  220.                                 End Select
  221.                                 Plot x+offsetx,y+offsety
  222.                         Next
  223.                 Next
  224.        
  225.         End Method
  226.        
  227.         Method drawascii(offsetx:Int,offsety:Int)
  228.                 ' This function will draw our continent data
  229.                 ' as derived from our terrain[x,y] array
  230.                 Local textoffset:Int = 10
  231.                 Local x:Int
  232.                 Local y:Int
  233.                 ' Thin of these as the height levels
  234.                 ' on an elevation map...
  235.                 For x = 0 To continentwidth
  236.                         For y = 0 To continentheight   
  237.                                 ' Now in here you can experiment with the coloring of the
  238.                                 ' display depending on height. So for instance I currently
  239.                                 ' have only the sealevel as a coloring, anything above
  240.                                 ' the sealevel is drawn as a increasingly bright shade of
  241.                                 ' green. Maybe above certain heights, change to white
  242.                                 ' color for snowcapped mountains, etc.
  243.                                 Select ascii[x,y]
  244.                                         Case "A"
  245.                                                 SetColor 75,75,255
  246.                                         Case "B"
  247.                                                 SetColor 132,247,140
  248.                                         Case "C"
  249.                                                 SetColor 231,239,115
  250.                                         Case "D"
  251.                                                 SetColor 255,206,82
  252.                                         Case "E"
  253.                                                 SetColor 214,115,66
  254.                                         Case "F"
  255.                                                 SetColor 148,0,0
  256.                                         Case "G"
  257.                                                 SetColor 214,0,0
  258.                                         Case "H"
  259.                                                 SetColor 200,200,200
  260.                                         Case "I"
  261.                                                 SetColor 222,222,222
  262.                                         Case "J"
  263.                                                 SetColor 255,255,255
  264.                                 End Select
  265.  
  266.                                 DrawText ascii[x,y],x*textoffset+offsetx,y*textoffset+offsety
  267.                         Next
  268.                 Next
  269.         End Method
  270.        
  271.         Method smooth()
  272.                 Local x:Int
  273.                 Local y:Int
  274.                 Local k:Float = 0.75
  275.        
  276.                 '/* Rows, left to right */
  277.                 For x = 1 To continentwidth
  278.                         For y = 0 To continentheight
  279.                                 terrain[x,y] = terrain[x-1,y] * (1-k) + terrain[x,y] * k
  280.                         Next
  281.                 Next
  282.        
  283.                 '/* Rows, right to left*/
  284.                 For x = continentwidth-1 To 0 Step -1
  285.                         For y = 0 To continentheight
  286.                                 terrain[x,y] = terrain[x+1,y] * (1-k) + terrain[x,y] * k
  287.                         Next
  288.                 Next
  289.        
  290.                 '/* Columns, bottom to top */
  291.                 For x = 0 To continentwidth
  292.                         For y = 1 To continentheight
  293.                                 terrain[x,y] = terrain[x,y-1] * (1-k) + terrain[x,y] * k
  294.                         Next
  295.                 Next
  296.        
  297.                 '/* Columns, top to bottom */
  298.                 For x = 0 To continentwidth
  299.                         For y = continentheight -1To 0 Step-1
  300.                                 terrain[x,y] = terrain[x,y+1] * (1-k) + terrain[x,y] * k
  301.                         Next
  302.                 Next
  303.        
  304.         End Method
  305.        
  306.         Method destroy()
  307.                 ListRemove(continentlist,Self)                                 
  308.         End Method
  309.  
  310. End Type
  311.  
  312. Function displaymaps()
  313.         Local i:Int=0
  314.     For Local thecontinent:continent = EachIn continent.continentlist
  315.         thecontinent.Draw(i*32+2,0)
  316.         thecontinent.Drawascii(i*32,40)
  317.         i:+1
  318.     Next
  319. End Function
  320.  
  321. Function checkkey()
  322.         If KeyHit(KEY_SPACE)
  323.                 resetall
  324.         EndIf  
  325. End Function
  326.  
  327. Function resetall()
  328.         Local i:Int=1
  329.            For Local thecontinent:continent = EachIn continent.continentlist
  330.                thecontinent.destroy
  331.                i:+1
  332.            Next
  333.                 ' Set up our maps
  334.                 Local maps=0
  335.                 For Local a:Int = 0 To maps
  336.                         Local thecontinent:continent = New continent
  337.                         thecontinent.init
  338.                         thecontinent.createcontinent(800)
  339.                 Next
  340. End Function


Comments :


RGR(Posted 1+ years ago)

 
Code: [Select]
If Program_Uses_BMX_Commands Then
  Use .bmx
Else
  Use .bb
EndIF



Rimmsy(Posted 1+ years ago)

 Cool little program. I could play with for hours. Nice one!


Booticus(Posted 1+ years ago)

 Why thanks!


Booticus(Posted 1+ years ago)

 Update! For the REAL DEAL on this type of stuff, check out Impixi's one!<a href="http://www.blitzmax.com/Community/posts.php?topic=49025#713851" target="_blank">http://www.blitzmax.com/Community/posts.php?topic=49025#713851[/url] [/i]

 

SimplePortal 2.3.6 © 2008-2014, SimplePortal