worldgen 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: de4a34b0248c80788bc6ce2f4a12403b49e8df05
-  data.tar.gz: d8210298cd91385beab0cb5366dcc19bfba9eefd
+  metadata.gz: 75fa665add8ad72d23153e40d262bdd86a553421
+  data.tar.gz: 4920045ba83ad3d26d0f2c424555ccd91be46d02
 SHA512:
-  metadata.gz: 2829eab4c21503c6243774487c0121dd84fc41300103759116d97c2eeb378ed0a0b5cce0a2f16061d70e24b81bd8ec226375abda3e50827828e3d5316ab8b26f
-  data.tar.gz: 58b82dcbc654c466ced978d629881bcba395d4577becff34b40017b912bff9a51462668e426033c36ec7106618be51c2e7b1d066fc24054dd55270acf1822691
+  metadata.gz: e95a80c4f3043220615ab1a5cae52e3ab0276460d236deb23ddc52bc0bfece292349c14682089a1148a219319c0c5ca7573957f14b23fb0a97ca5ac1a6b955e5
+  data.tar.gz: 0f6506cf096612852a6bd47d4e0e5ec8f797634bbc5a36ccac51eb116b33627893a923111535fa32fc9e485ebb444f276c6a40dc8375a39770e1b6c7df9a93aa

data/ext/worldgen/diamondsquare.c

@@ -38,9 +38,7 @@ VALUE diamond_square(int argc, VALUE *argv, VALUE self) {
 
   roughness = vroughness == Qnil ? DEFAULT_ROUGHNESS : NUM2DBL(vroughness);
 
-  // need to allocate on the heap since Ruby will throw stack size problems
-  // if we don't
-  heights = (double *)malloc(sizeof(double) * num_points(size));
+  heights = (heightmap_points)malloc(sizeof(double) * num_points(size));
 
   memset(heights, 0.0, sizeof(double) * num_points(size));
 

data/ext/worldgen/heightmap.c

@@ -91,6 +91,33 @@ VALUE each_height(VALUE self) {
   return self;
 }
 
+/**
+ * Get the value of our heightmap at a specified point.
+ */
+VALUE get_at(VALUE self, VALUE vx, VALUE vy) {
+  int x = FIX2INT(vx);
+  int y = FIX2INT(vy);
+  heightmap map = get_heights(self);
+  int size = map.size;
+
+  return ARR(map.heights, x, y);
+}
+
+/**
+ * Set the value of our heightmap at a specified point.
+ */
+VALUE set_at(VALUE self, VALUE vx, VALUE vy, VALUE vheight) {
+  int x = FIX2INT(vx);
+  int y = FIX2INT(vy);
+  double height = NUM2DBL(vheight);
+  heightmap map = get_heights(self);
+  int size = map.size;
+
+  ARR(map.heights, x, y) = height;
+
+  return vheight;
+}
+
 void load_heightmap() {
   VALUE mod, height_map;
 
@@ -101,6 +128,8 @@ void load_heightmap() {
   rb_define_private_method(height_map, "initialize_native", initialize_native, 1);
   rb_define_method(height_map, "num_points", num_points_wrapped, 0);
   rb_define_method(height_map, "each_height", each_height, 0);
+  rb_define_method(height_map, "[]=", get_at, 2);
+  rb_define_method(height_map, "[]=", set_at, 3);
 
   HeightmapData = rb_define_class_under(height_map, "HeightmapData", rb_cObject);
 }

data/generate.rb

@@ -1,7 +1,9 @@
 require 'optparse'
 require "worldgen"
 
-options = {}
+options = {
+  verbose: true
+}
 
 OptionParser.new do |opts|
   opts.on("--heightmap [FILE]", String, "Output a heightmap to FILE") do |file|
@@ -19,6 +21,10 @@ OptionParser.new do |opts|
   opts.on("--num-plates [N]", Integer, "Generate N plates") do |n|
     options[:num_plates] = n
   end
+
+  opts.on("-q", "--quiet", "Disable verbose logging") do |n|
+    options[:verbose] = false
+  end
 end.parse!
 
 if not options[:size]
@@ -41,10 +47,10 @@ if options[:platemap]
   end
 
   platemap = Worldgen::PlateMap.new(options[:size])
-  platemap.generate_plates! options[:num_plates]
+  platemap.generate_plates!(options[:num_plates], options[:verbose])
   puts "Converting to height map..."
-  heightmap = platemap.to_height_map
-  render_heightmap heightmap, options[:platemap]
+  heightmap = platemap.to_height_map(0.5)
+  Worldgen::Render.heightmap heightmap, options[:platemap]
 end
 
 puts "Done."

data/lib/worldgen.rb

@@ -1,5 +1,6 @@
 require "worldgen/version"
 require "worldgen/heightmap"
+require "worldgen/platemap"
 require "worldgen/render"
 require_relative "worldgen.so"
 

data/lib/worldgen/platemap.rb

@@ -0,0 +1,230 @@
+module Worldgen
+  # A map that generates plates within a square map.
+  class PlateMap
+    # A class representing a single plate.
+    # TODO: using Ruby for this is kinda slow, maybe port a good chunk of this
+    # stuff to C
+    class Plate
+      # Attributes:
+      # * seed - the initial point within the map for this plate
+      # * map - the map that this plate is in
+      # * id - the ID number of this plate (how this plate identifies itself)
+      # * type - the type of plate (continental vs. ocean)
+      attr_accessor :seed, :map, :id, :type
+
+      # Set the seed for this plate. Construct the frontier.
+      def seed= seed
+        @seed = seed
+        @frontier = empty_neighbours(@seed)
+      end
+
+      # See if this plate has a frontier or not
+      def has_frontier?
+        @frontier and @frontier.length > 0
+      end
+
+      # Get the length of this plate's frontier
+      def frontier_length
+        @frontier ? @frontier.length : 0
+      end
+
+      # Absorb a single empty point along the frontier
+      def absorb_frontier!
+        # Shuffle the frontier so that we end up grabbing a random point
+        @frontier.shuffle!
+        value = nil
+
+        # It's possible another plate has absorbed part of our frontier since
+        # the last time we set our frontier, so shift until we find an empty
+        # spot
+        while value == nil and @frontier.length > 0
+          value = @frontier.shift
+          value = nil unless at(*value) < 0
+        end
+
+        if value
+          # move it into me
+          @map[value[0]][value[1]] = @id
+
+          # add new points onto my frontier
+          @frontier += empty_neighbours(value)
+        end
+
+        value
+      end
+
+      # Get the empty neighbours around `point`
+      def empty_neighbours point
+        neighbours(point).select do |(x, y)|
+          at(x, y) < 0
+        end
+      end
+
+      # Get the neighbours of `point` - directly adjacent only, no diagonals
+      def neighbours point
+        [
+          [-1, 0],
+          [1, 0],
+          [0, 1],
+          [0, -1]
+        ].map do |(dx, dy)|
+          [
+            (point[0] + dx + @map.length) % @map.length,
+            (point[1] + dy + @map.length) % @map.length
+          ]
+        end
+      end
+
+    private
+      # Get the point at x, y
+      def at x, y
+        @map[x][y]
+      end
+    end
+
+    attr_reader :size
+
+    def initialize size
+      @size = size
+      @plate_ids = nil
+      @plates = nil
+    end
+
+    # Get the number of points in the map.
+    def num_points
+      @size * @size
+    end
+
+    # Convert to a height map - very simple, just give the continents one height
+    # and the oceans another height. This is controlled by a single parameter,
+    # (({sea_gap})), which will be the difference between the continents height and
+    # oceans height.
+    def to_height_map sea_gap
+      raise "Sea gap should be between 0 and 1" if sea_gap < 0 or sea_gap > 1
+
+      plate_heights = @plates.map do |plate|
+        if plate.type == :continent
+          0.5 + sea_gap / 2
+        else
+          0.5 - sea_gap / 2
+        end
+      end
+
+      map = HeightMap.new @size
+      
+      each_plate_point do |x, y, id|
+        map[x, y] = plate_heights[id]
+      end
+
+      map
+    end
+
+    # Iterate across the entire map.
+    #
+    # Usage:
+    #
+    #   each_plate_point do |x, y, plate_id|
+    #     # do something with this information
+    #   end
+    def each_plate_point
+      (0...@size).each do |x|
+        (0...@size).each do |y|
+          yield x, y, @plate_ids[x][y]
+        end
+      end
+    end
+
+    # Generate plates within this map.
+    #
+    # Arguments:
+    # * num_plates - the number of plates to generate
+    # * verbose (default: true) - output logging while we're generating
+    def generate_plates! num_plates, verbose=true
+      @plate_ids = Array.new(@size) { Array.new(@size) { -1 }}
+
+      # Initialize plates in random spots
+      @plates = (0...num_plates).map do |plate_num|
+        # Find an unoccupied point
+        point = nil
+        while point == nil
+          x, y = rand(@size), rand(@size)
+
+          point = [x, y] if @plate_ids[x][y] < 0
+        end
+
+        x, y = point
+        @plate_ids[x][y] = plate_num
+
+        Plate.new.tap do |plate|
+          plate.map = @plate_ids
+          plate.id = plate_num
+          plate.type = rand < 0.5 ? :continent : :ocean
+          plate.seed = point
+        end
+      end
+
+      num_points = self.num_points - num_plates
+      valid_plates = @plates.select(&:has_frontier?)
+
+      i = 0
+      while valid_plates.length > 0
+        if verbose and i % (num_points / 100) == 0
+          puts "#{i}/#{num_points} #{(i.fdiv(num_points) * 100).round}%"
+        end
+
+        # Find a plate with neighbours
+        loop do
+          idx = choose_plate valid_plates
+          plate = valid_plates[idx]
+
+          # absorb a point from the frontier
+          value = plate.absorb_frontier!
+
+          if not value
+            valid_plates.delete_at idx
+            break if valid_plates.length == 0
+          else
+            break
+          end
+        end
+
+        i += 1
+      end
+    end
+    
+    private
+
+    # Choose a plate randomly from a list of plates
+    def choose_plate plates
+      # Weighted choice based on frontier length - if we do it perfectly uniform
+      # then we end up with plates that "compress" into small remaining places
+      # which results in "snaky" plates and weird convergence points between
+      # many plates
+      
+      # TODO: could probably pull weighted randoms into a different module
+      total = plates.map(&:frontier_length).inject(&:+)
+
+      # TODO: using a uniform random generator here gives plates that are all
+      # roughly the same size - kinda boring, maybe try using a non-uniform
+      # distribution here
+      point = rand(total)
+
+      idx = 0
+      begin
+        while point > plates[idx].frontier_length
+          point -= plates[idx].frontier_length
+          idx += 1
+        end
+      rescue
+        # TODO: fix this - once in a while we get an out of bounds problem here
+        puts $!
+        puts $!.backtrace.join("\n")
+        puts "Point: #{point}"
+        puts "Idx: #{idx}"
+        puts "Total: #{total}"
+      end
+
+      idx
+    end
+  end
+end

data/lib/worldgen/version.rb

@@ -1,3 +1,3 @@
 module Worldgen
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: worldgen
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Rob Britton
@@ -88,6 +88,7 @@ files:
 - generate.rb
 - lib/worldgen.rb
 - lib/worldgen/heightmap.rb
+- lib/worldgen/platemap.rb
 - lib/worldgen/render.rb
 - lib/worldgen/version.rb
 - worldgen.gemspec