gosu 0.7.6.1-mswin32 → 0.7.7-mswin32

data/examples/ChipmunkIntegration.rb

@@ -0,0 +1,282 @@
+## File: ChipmunkIntegration.rb
+## Author: Dirk Johnson
+## Version: 1.0.0
+## Date: 2007-10-05
+## License: Same as for Gosu (MIT)
+## Comments: Based on the Gosu Ruby Tutorial, but incorporating the Chipmunk Physics Engine
+
+require 'rubygems'
+require 'gosu'
+require 'chipmunk'
+
+SCREEN_WIDTH = 640
+SCREEN_HEIGHT = 480
+
+# The number of steps to process every Gosu update
+# The Player ship can get going so fast as to "move through" a
+# star without triggering a collision; an increased number of
+# Chipmunk step calls per update will effectively avoid this issue
+SUBSTEPS = 6
+
+# Convenience methods for converting between Gosu degrees, radians, and Vec2 vectors
+class Numeric 
+  def gosu_to_radians
+    (self - 90) * Math::PI / 180.0
+  end
+  
+  def radians_to_gosu
+    self * 180.0 / Math::PI + 90
+  end
+  
+  def radians_to_vec2
+    CP::Vec2.new(Math::cos(self), Math::sin(self))
+  end
+end
+
+# Layering of sprites
+module ZOrder
+  Background, Stars, Player, UI = *0..3
+end
+
+# This game will have one Player in the form of a ship
+class Player
+  attr_reader :shape
+
+  def initialize(window, shape)
+    @image = Gosu::Image.new(window, "media/Starfighter.bmp", false)
+    @shape = shape
+    @shape.body.p = CP::Vec2.new(0.0, 0.0) # position
+    @shape.body.v = CP::Vec2.new(0.0, 0.0) # velocity
+    
+    # Keep in mind that down the screen is positive y, which means that PI/2 radians,
+    # which you might consider the top in the traditional Trig unit circle sense is actually
+    # the bottom; thus 3PI/2 is the top
+    @shape.body.a = (3*Math::PI/2.0) # angle in radians; faces towards top of screen
+  end
+  
+  # Directly set the position of our Player
+  def warp(vect)
+    @shape.body.p = vect
+  end
+  
+  # Apply negative Torque; Chipmunk will do the rest
+  # SUBSTEPS is used as a divisor to keep turning rate constant
+  # even if the number of steps per update are adjusted
+  def turn_left
+    @shape.body.t -= 400.0/SUBSTEPS
+  end
+  
+  # Apply positive Torque; Chipmunk will do the rest
+  # SUBSTEPS is used as a divisor to keep turning rate constant
+  # even if the number of steps per update are adjusted
+  def turn_right
+    @shape.body.t += 400.0/SUBSTEPS
+  end
+  
+  # Apply forward force; Chipmunk will do the rest
+  # SUBSTEPS is used as a divisor to keep acceleration rate constant
+  # even if the number of steps per update are adjusted
+  # Here we must convert the angle (facing) of the body into
+  # forward momentum by creating a vector in the direction of the facing
+  # and with a magnitude representing the force we want to apply
+  def accelerate
+    @shape.body.apply_force((@shape.body.a.radians_to_vec2 * (3000.0/SUBSTEPS)), CP::Vec2.new(0.0, 0.0))
+  end
+  
+  # Apply even more forward force
+  # See accelerate for more details
+  def boost
+    @shape.body.apply_force((@shape.body.a.radians_to_vec2 * (3000.0)), CP::Vec2.new(0.0, 0.0))
+  end
+  
+  # Apply reverse force
+  # See accelerate for more details
+  def reverse
+    @shape.body.apply_force(-(@shape.body.a.radians_to_vec2 * (1000.0/SUBSTEPS)), CP::Vec2.new(0.0, 0.0))
+  end
+  
+  # Wrap to the other side of the screen when we fly off the edge
+  def validate_position
+    l_position = CP::Vec2.new(@shape.body.p.x % SCREEN_WIDTH, @shape.body.p.y % SCREEN_HEIGHT)
+    @shape.body.p = l_position
+  end
+  
+  def draw
+    @image.draw_rot(@shape.body.p.x, @shape.body.p.y, ZOrder::Player, @shape.body.a.radians_to_gosu)
+  end
+end
+
+# See how simple our Star is?
+# Of course... it just sits around and looks good...
+class Star
+  attr_reader :shape
+  
+  def initialize(animation, shape)
+    @animation = animation
+    @color = Gosu::Color.new(0xff000000)
+    @color.red = rand(255 - 40) + 40
+    @color.green = rand(255 - 40) + 40
+    @color.blue = rand(255 - 40) + 40
+    @shape = shape
+    @shape.body.p = CP::Vec2.new(rand * SCREEN_WIDTH, rand * SCREEN_HEIGHT) # position
+    @shape.body.v = CP::Vec2.new(0.0, 0.0) # velocity
+    @shape.body.a = (3*Math::PI/2.0) # angle in radians; faces towards top of screen
+  end
+
+  def draw  
+    img = @animation[Gosu::milliseconds / 100 % @animation.size];
+    img.draw(@shape.body.p.x - img.width / 2.0, @shape.body.p.y - img.height / 2.0, ZOrder::Stars, 1, 1, @color, :additive)
+  end
+end
+
+# The Gosu::Window is always the "environment" of our game
+# It also provides the pulse of our game
+class GameWindow < Gosu::Window
+  def initialize
+    super(SCREEN_WIDTH, SCREEN_HEIGHT, false, 16)
+    self.caption = "Gosu & Chipmunk Integration Demo"
+    @background_image = Gosu::Image.new(self, "media/Space.png", true)
+
+    # Put the beep here, as it is the environment now that determines collision
+    @beep = Gosu::Sample.new(self, "media/Beep.wav")
+    
+    # Put the score here, as it is the environment that tracks this now
+    @score = 0
+    @font = Gosu::Font.new(self, Gosu::default_font_name, 20)
+    
+    # Time increment over which to apply a physics "step" ("delta t")
+    @dt = (1.0/60.0)
+    
+    # Create our Space and set its damping
+    # A damping of 0.8 causes the ship bleed off its force and torque over time
+    # This is not realistic behavior in a vacuum of space, but it gives the game
+    # the feel I'd like in this situation
+    @space = CP::Space.new
+    @space.damping = 0.8    
+    
+    # Create the Body for the Player
+    body = CP::Body.new(10.0, 150.0)
+    
+    # In order to create a shape, we must first define it
+    # Chipmunk defines 3 types of Shapes: Segments, Circles and Polys
+    # We'll use s simple, 4 sided Poly for our Player (ship)
+    # You need to define the vectors so that the "top" of the Shape is towards 0 radians (the right)
+    shape_array = [CP::Vec2.new(-25.0, -25.0), CP::Vec2.new(-25.0, 25.0), CP::Vec2.new(25.0, 1.0), CP::Vec2.new(25.0, -1.0)]
+    shape = CP::Shape::Poly.new(body, shape_array, CP::Vec2.new(0,0))
+    
+    # The collision_type of a shape allows us to set up special collision behavior
+    # based on these types.  The actual value for the collision_type is arbitrary
+    # and, as long as it is consistent, will work for us; of course, it helps to have it make sense
+    shape.collision_type = :ship
+    
+    @space.add_body(body)
+    @space.add_shape(shape)
+
+    @player = Player.new(self, shape)
+    @player.warp(CP::Vec2.new(320, 240)) # move to the center of the window
+    
+    @star_anim = Gosu::Image::load_tiles(self, "media/Star.png", 25, 25, false)
+    @stars = Array.new
+        
+    # Here we define what is supposed to happen when a Player (ship) collides with a Star
+    # I create a @remove_shapes array because we cannot remove either Shapes or Bodies
+    # from Space within a collision closure, rather, we have to wait till the closure
+    # is through executing, then we can remove the Shapes and Bodies
+    # In this case, the Shapes and the Bodies they own are removed in the Gosu::Window.update phase
+    # by iterating over the @remove_shapes array
+    # Also note that both Shapes involved in the collision are passed into the closure
+    # in the same order that their collision_types are defined in the add_collision_func call
+    @remove_shapes = []
+    @space.add_collision_func(:ship, :star) do |ship_shape, star_shape|
+      @score += 10
+      @beep.play
+      @remove_shapes << star_shape
+    end
+    
+    # Here we tell Space that we don't want one star bumping into another
+    # The reason we need to do this is because when the Player hits a Star,
+    # the Star will travel until it is removed in the update cycle below
+    # which means it may collide and therefore push other Stars
+    # To see the effect, remove this line and play the game, every once in a while
+    # you'll see a Star moving
+    @space.add_collision_func(:star, :star, &nil)
+  end
+
+  def update
+    # Step the physics environment SUBSTEPS times each update
+    SUBSTEPS.times do
+      # This iterator makes an assumption of one Shape per Star making it safe to remove
+      # each Shape's Body as it comes up
+      # If our Stars had multiple Shapes, as would be required if we were to meticulously
+      # define their true boundaries, we couldn't do this as we would remove the Body
+      # multiple times
+      # We would probably solve this by creating a separate @remove_bodies array to remove the Bodies
+      # of the Stars that were gathered by the Player
+      @remove_shapes.each do |shape|
+        @stars.delete_if { |star| star.shape == shape }
+        @space.remove_body(shape.body)
+        @space.remove_shape(shape)
+      end
+      @remove_shapes.clear # clear out the shapes for next pass
+      
+      # When a force or torque is set on a Body, it is cumulative
+      # This means that the force you applied last SUBSTEP will compound with the
+      # force applied this SUBSTEP; which is probably not the behavior you want
+      # We reset the forces on the Player each SUBSTEP for this reason
+      @player.shape.body.reset_forces
+      
+      # Wrap around the screen to the other side
+      @player.validate_position
+      
+      # Check keyboard
+      if button_down? Gosu::Button::KbLeft
+        @player.turn_left
+      end
+      if button_down? Gosu::Button::KbRight
+        @player.turn_right
+      end
+      
+      if button_down? Gosu::Button::KbUp
+        if ( (button_down? Gosu::Button::KbRightShift) || (button_down? Gosu::Button::KbLeftShift) )
+          @player.boost
+        else
+          @player.accelerate
+        end
+      elsif button_down? Gosu::Button::KbDown
+        @player.reverse
+      end
+      
+      # Perform the step over @dt period of time
+      # For best performance @dt should remain consistent for the game
+      @space.step(@dt)
+    end
+    
+    # Each update (not SUBSTEP) we see if we need to add more Stars
+    if rand(100) < 4 and @stars.size < 25 then
+      body = CP::Body.new(0.0001, 0.0001)
+      shape = CP::Shape::Circle.new(body, 25/2, CP::Vec2.new(0.0, 0.0))
+      shape.collision_type = :star
+      
+      @space.add_body(body)
+      @space.add_shape(shape)
+      
+      @stars.push(Star.new(@star_anim, shape))
+    end
+  end
+
+  def draw
+    @background_image.draw(0, 0, ZOrder::Background)
+    @player.draw
+    @stars.each { |star| star.draw }
+    @font.draw("Score: #{@score}", 10, 10, ZOrder::UI, 1.0, 1.0, 0xffffff00)
+  end
+
+  def button_down(id)
+    if id == Gosu::Button::KbEscape
+      close
+    end
+  end
+end
+
+window = GameWindow.new
+window.show

data/examples/CptnRuby.rb

@@ -1,10 +1,3 @@
-begin
-  # In case you use Gosu via rubygems.
-  require 'rubygems'
-rescue LoadError
-  # In case you don't.
-end
-
 # Basically, the tutorial game taken to a jump'n'run perspective.
 
 # Shows how to
@@ -32,6 +25,13 @@ end
 # ...Enemies, a more sophisticated object system, weapons, title and credits
 # screens...
 
+begin
+  # In case you use Gosu via rubygems.
+  require 'rubygems'
+rescue LoadError
+  # In case you don't.
+end
+
 require 'gosu'
 include Gosu
 

data/examples/OpenGLIntegration.rb

@@ -0,0 +1,232 @@
+# The tutorial game over a landscape rendered with OpenGL.
+# Basically shows how arbitrary OpenGL calls can be put into
+# the block given to Window#gl, and that Gosu Images can be
+# used as textures using the gl_tex_info call.
+
+begin
+  # In case you use Gosu via RubyGems.
+  require 'rubygems'
+rescue LoadError
+  # In case you don't.
+end
+
+require 'gosu'
+require 'gl'
+require 'glu'
+
+include Gl
+include Glu
+
+module ZOrder
+  Stars, Player, UI = *0..3
+end
+
+# The only really new class here.
+# Draws a scrolling, repeating texture with a randomized height map.
+class GLBackground
+  # Height map size
+  POINTS_X = 7
+  POINTS_Y = 7
+  # Scrolling speed
+  SCROLLS_PER_STEP = 50
+
+  def initialize(window)
+    @image = Gosu::Image.new(window, "media/Earth.png", true)
+    @scrolls = 0
+    @height_map = Array.new(POINTS_Y) { Array.new(POINTS_X) { rand } }
+  end
+  
+  def scroll
+    @scrolls += 1
+    if @scrolls == SCROLLS_PER_STEP then
+      @scrolls = 0
+      @height_map.shift
+      @height_map.push Array.new(POINTS_X) { rand }
+    end
+  end
+  
+  def exec_gl
+    # Get the name of the OpenGL texture the Image resides on, and the
+    # u/v coordinates of the rect it occupies.
+    # gl_tex_info can return nil if the image was too large to fit onto
+    # a single OpenGL texture and was internally split up.
+    info = @image.gl_tex_info
+    return unless info
+
+    # Pretty straightforward OpenGL code.
+    
+    glDepthFunc(GL_GEQUAL)
+    glEnable(GL_DEPTH_TEST)
+    glEnable(GL_BLEND)
+
+    glMatrixMode(GL_PROJECTION)
+    glLoadIdentity
+    glFrustum(-0.10, 0.10, -0.075, 0.075, 1, 100)
+
+    glMatrixMode(GL_MODELVIEW)
+    glLoadIdentity
+    glTranslate(0, 0, -4)
+  
+    glEnable(GL_TEXTURE_2D)
+    glBindTexture(GL_TEXTURE_2D, info.tex_name)
+    
+    offs_y = 1.0 * @scrolls / SCROLLS_PER_STEP
+    
+    0.upto(POINTS_Y - 2) do |y|
+      0.upto(POINTS_X - 2) do |x|
+        glBegin(GL_TRIANGLE_STRIP)
+          z = @height_map[y][x]
+          glColor4d(1, 1, 1, z)
+          glTexCoord2d(info.left, info.top)
+          glVertex3d(-0.5 + (x - 0.0) / (POINTS_X-1), -0.5 + (y - offs_y - 0.0) / (POINTS_Y-2), z)
+
+          z = @height_map[y+1][x]
+          glColor4d(1, 1, 1, z)
+          glTexCoord2d(info.left, info.bottom)
+          glVertex3d(-0.5 + (x - 0.0) / (POINTS_X-1), -0.5 + (y - offs_y + 1.0) / (POINTS_Y-2), z)
+        
+          z = @height_map[y][x + 1]
+          glColor4d(1, 1, 1, z)
+          glTexCoord2d(info.right, info.top)
+          glVertex3d(-0.5 + (x + 1.0) / (POINTS_X-1), -0.5 + (y - offs_y - 0.0) / (POINTS_Y-2), z)
+
+          z = @height_map[y+1][x + 1]
+          glColor4d(1, 1, 1, z)
+          glTexCoord2d(info.right, info.bottom)
+          glVertex3d(-0.5 + (x + 1.0) / (POINTS_X-1), -0.5 + (y - offs_y + 1.0) / (POINTS_Y-2), z)
+        glEnd
+      end
+    end
+  end
+end
+
+# Roughly adapted from the tutorial game. Always faces north.
+class Player
+  Speed = 7
+  
+  attr_reader :score
+
+  def initialize(window, x, y)
+    @image = Gosu::Image.new(window, "media/Starfighter.bmp", false)
+    @beep = Gosu::Sample.new(window, "media/Beep.wav")
+    @x, @y = x, y
+    @score = 0
+  end
+
+  def move_left
+    @x = [@x - Speed, 0].max
+  end
+  
+  def move_right
+    @x = [@x + Speed, 800].min
+  end
+  
+  def accelerate
+    @y = [@y - Speed, 50].max
+  end
+  
+  def brake
+    @y = [@y + Speed, 600].min
+  end
+  
+  def draw
+    @image.draw(@x - @image.width / 2, @y - @image.height / 2, ZOrder::Player)
+  end
+  
+  def collect_stars(stars)
+    stars.reject! do |star|
+      if Gosu::distance(@x, @y, star.x, star.y) < 35 then
+        @score += 10
+        @beep.play
+        true
+      else
+        false
+      end
+    end
+  end
+end
+
+# Also taken from the tutorial, but drawn with draw_rot and an increasing angle
+# for extra rotation coolness!
+class Star
+  attr_reader :x, :y
+  
+  def initialize(animation)
+    @animation = animation
+    @color = Gosu::Color.new(0xff000000)
+    @color.red = rand(255 - 40) + 40
+    @color.green = rand(255 - 40) + 40
+    @color.blue = rand(255 - 40) + 40
+    @x = rand * 800
+    @y = 0
+  end
+
+  def draw  
+    img = @animation[Gosu::milliseconds / 100 % @animation.size];
+    img.draw_rot(@x, @y, ZOrder::Stars, @y, 0.5, 0.5, 1, 1, @color, :additive)
+  end
+  
+  def update
+    # Move towards bottom of screen
+    @y += 3
+    # Return false when out of screen (gets deleted then)
+    @y < 650
+  end
+end
+
+class GameWindow < Gosu::Window
+  def initialize
+    super(800, 600, false)
+    self.caption = "Gosu & OpenGL Integration Demo"
+    
+    @gl_background = GLBackground.new(self)
+    
+    @player = Player.new(self, 400, 500)
+
+    @star_anim = Gosu::Image::load_tiles(self, "media/Star.png", 25, 25, false)
+    @stars = Array.new
+    
+    @font = Gosu::Font.new(self, Gosu::default_font_name, 20)
+  end
+
+  def update
+    @player.move_left if button_down? Gosu::Button::KbLeft or button_down? Gosu::Button::GpLeft
+    @player.move_right if button_down? Gosu::Button::KbRight or button_down? Gosu::Button::GpRight
+    @player.accelerate if button_down? Gosu::Button::KbUp or button_down? Gosu::Button::GpUp
+    @player.brake if button_down? Gosu::Button::KbDown or button_down? Gosu::Button::GpDown
+
+    @player.collect_stars(@stars)
+    
+    @stars.reject! { |star| !star.update }
+    
+    @gl_background.scroll
+    
+    @stars.push(Star.new(@star_anim)) if rand(20) == 0
+  end
+
+  def draw
+    # gl will execute the given block in a clean OpenGL environment, then reset
+    # everything so Gosu's rendering can take place again.
+    
+    gl do
+      glClearColor(0.0, 0.2, 0.5, 1.0)
+      glClearDepth(0)
+      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+     
+      @gl_background.exec_gl
+    end
+    
+    @player.draw
+    @stars.each { |star| star.draw }
+    @font.draw("Score: #{@player.score}", 10, 10, ZOrder::UI, 1.0, 1.0, 0xffffff00)
+  end
+
+  def button_down(id)
+    if id == Gosu::Button::KbEscape
+      close
+    end
+  end
+end
+
+window = GameWindow.new
+window.show

data/examples/RMagickIntegration.rb

@@ -1,10 +1,3 @@
-begin
-  # In case you use Gosu via RubyGems.
-  require 'rubygems'
-rescue LoadError
-  # In case you don't.
-end
-
 # A (too) simple Gorilla-style shooter for two players.
 # Shows how Gosu and RMagick can be used together to generate a map, implement
 # a dynamic landscape and generally look great.
@@ -18,6 +11,13 @@ end
 # * The look of dead soldiers is, err, by accident. Soldier.png needs to be
 #   designed in a less obfuscated way :)
 
+begin
+  # In case you use Gosu via RubyGems.
+  require 'rubygems'
+rescue LoadError
+  # In case you don't.
+end
+
 require 'gosu'
 require 'rmagick'
 
@@ -130,12 +130,14 @@ class Map
     top = (y - SH_RADIUS) / TILE_SIZE
     bottom = (y + SH_RADIUS) / TILE_SIZE
 
-    # Set affected images to nil. (A 'double-free' doesn't hurt!)
+    # Set affected images to nil.
+    # A 'double-free' doesn't hurt if e.g. left == right! However, we have to watch out
+    # for out-of-bounds errors.
     
-    @gosu_images[left][top] = nil
-    @gosu_images[right][top] = nil
-    @gosu_images[left][bottom] = nil
-    @gosu_images[right][bottom] = nil
+    @gosu_images[left][top] = nil unless left < 0 or top < 0
+    @gosu_images[right][top] = nil unless right >= TILES_X or top < 0
+    @gosu_images[left][bottom] = nil unless left < 0 or bottom >= TILES_Y
+    @gosu_images[right][bottom] = nil unless right >= TILES_X or bottom >= TILES_Y
 
     # Create the crater image (basically a circle shape that is used to erase
     # parts of the map) and the crater shadow image, if they don't exist
@@ -364,7 +366,7 @@ class GameWindow < Gosu::Window
   
   def initialize()
     super(800, 600, false)
-    self.caption = "Medal of Anna - Gosu & RMagick integration demo"
+    self.caption = "Medal of Anna - Gosu & RMagick Integration Demo"
 
     # Texts to display in the appropriate situations.
     @player_instructions = []

data/examples/Tutorial.rb

@@ -79,7 +79,7 @@ class Star
   end
 
   def draw  
-    img = @animation[Gosu::milliseconds / 100 % @animation.size];
+    img = @animation[Gosu::milliseconds / 100 % @animation.size]
     img.draw(@x - img.width / 2.0, @y - img.height / 2.0,
         ZOrder::Stars, 1, 1, @color, :additive)
   end
@@ -127,7 +127,7 @@ class GameWindow < Gosu::Window
   end
 
   def button_down(id)
-    if id == Gosu::Button::KbEscape
+    if id == Gosu::Button::KbEscape then
       close
     end
   end

metadata

@@ -3,15 +3,15 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: gosu
 version: !ruby/object:Gem::Version 
-  version: 0.7.6.1
-date: 2007-10-17 00:00:00 +02:00
+  version: 0.7.7
+date: 2007-10-29 00:00:00 +01:00
 summary: 2D game development library.
 require_paths: 
 - lib
 email: julian@raschke.de
 homepage: http://code.google.com/p/gosu/
 rubyforge_project: 
-description: 2D game development library.  The library features easy to use and game-friendly interfaces to 2D graphics and text (accelerated by 3D hardware), sound samples and music as well as keyboard, mouse and gamepad/joystick input.  Integrates with RMagick.
+description: 2D game development library.  The library features easy to use and game-friendly interfaces to 2D graphics and text (accelerated by 3D hardware), sound samples and music as well as keyboard, mouse and gamepad/joystick input.  Includes demos for integration with RMagick, Chipmunk and Ruby-OpenGL.
 autorequire: 
 default_executable: 
 bindir: bin
@@ -30,28 +30,14 @@ authors:
 - Julian Raschke
 - Jan Luecker
 files: 
-- examples/media/Beep.wav
-- examples/media/CptnRuby Gem.png
-- examples/media/CptnRuby Map.txt
-- examples/media/CptnRuby Tileset.bmp
-- examples/media/CptnRuby Tileset.png
-- examples/media/CptnRuby.png
-- examples/media/Earth.png
-- examples/media/Explosion.wav
-- examples/media/LargeStar.png
-- examples/media/Sky.jpg
-- examples/media/Smoke.png
-- examples/media/Soldier.png
-- examples/media/Space.png
-- examples/media/Star.png
-- examples/media/Starfighter.bmp
-- examples/Tutorial.rb
-- examples/CptnRuby.rb
-- examples/RMagickIntegration.rb
 - lib/gosu.so
-- lib/fmod.dll
 - README
 - LICENSE
+- examples/ChipmunkIntegration.rb
+- examples/CptnRuby.rb
+- examples/OpenGLIntegration.rb
+- examples/RMagickIntegration.rb
+- examples/Tutorial.rb
 test_files: []
 
 rdoc_options: []

data/examples/media/CptnRuby Map.txt

@@ -1,25 +0,0 @@
-#....................................................#
-#....................................................#
-#.............xx......x.x............................#
-#............x..x....................................#
-#x....x...x..x.......#####..xxx....................x.#
-#.x.........................xxx.........##.........x.#
-#...............""..........###...##..........##.....#
-#..##..###..##..##...................................#
-#........................................xx........###
-#.............................###....................#
-##....##.............................................#
-#....................##....##......##....##....##....#
-#.................................................x..#
-#...x....##....##.......x...x.....................x..#
-#.....x...............x...x...x...................x..#
-#......x...##.....##.................................#
-#.......x.........................................#..#
-#...........##........#...#...#..#.......x...........#
-#...#................................................#
-#....."""".................x.......#..#####...###....#
-#x....#......................##......................#
-#"""""#.....#.....x..................#...............#
-##xxxx......#........................................#
-##xxxx...#####............."...""""".................#
-######"""#############################################