grueserve 0.0.1

data/lib/grueserve.rb

@@ -0,0 +1,28 @@
+# grueserve - a game server in c and ruby for the gruesome game
+# Copyright (C) 2008  Martin Kihlgren <zond at troja dot ath dot cx>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+$: << File.dirname(File.expand_path(__FILE__))
+
+require 'grueserve_ext'
+require 'grueserve/debuggable.rb'
+require 'grueserve/map.rb'
+require 'grueserve/rated.rb'
+require 'grueserve/soldier.rb'
+require 'grueserve/client.rb'
+require 'grueserve/server.rb'
+require 'grueserve/application.rb'
+

data/lib/grueserve/application.rb

@@ -0,0 +1,72 @@
+# grueserve - a game server in c and ruby for the gruesome game
+# Copyright (C) 2008  Martin Kihlgren <zond at troja dot ath dot cx>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+require 'pathname'
+require 'optparse'
+
+module Grueserve
+
+  class Application
+
+    include Debuggable
+
+    attr_accessor :delay, :port, :timeout, :debug, :map_path, :map
+
+    def initialize
+      @map_path = Pathname.new(__FILE__).parent.parent.parent.join("example")
+      @port = 25999
+      @debug = Grueserve::Debuggable::LEVELS[Grueserve::Debuggable::LEVELS.size / 2]
+      @delay = 0.1
+      @timeout = 20.0
+    end
+
+    def go
+      ARGV.options do |o|
+        o.set_summary_indent('   ')
+        o.banner = "Usage: #{$0} [OPTIONS]"
+        o.define_head "Serves gruesome games."
+        o.separator ""
+        o.on("-p", "--port=PORT", Integer, :REQUIRED, "TCP port to listen on, defaults to #{@port}.") do |@port| end
+        o.on("-D", "--delay=DELAY", Float, "The delay constant to use when prioritizing connected players against connecting players. Defaults to #{@delay}.") do |@delay| end
+        o.on("-t", "--timeout=TIMEOUT", Float, "The timeout for broken and disconnected clients. Defaults to #{@timeout}.") do |@timeout| end
+        o.on("-m", "--map=MAP", String, "Directory where the map to serve can be found, defaults to #{@map_path}.") do |m|
+          @map_path = Pathname.new(m, self)
+        end
+        o.on("-d", "--debug=LEVEL", String, "Debug level to use, choose from '#{Grueserve::Debuggable::LEVELS.join(", ")}', defaults to #{@debug}.") do |d| 
+          @debug = d.to_sym
+        end
+        o.separator ""
+        o.on_tail("-h", "--help", "Show this help message.") do
+          puts o
+          exit
+        end
+        o.parse!
+        start_server!
+      end
+    end
+
+    def start_server!
+      Debuggable.level = @debug
+      log_info("Starting Grueserve::Server serving map #{@map} on port #{@port} with debug level #{@debug}")
+      @map = Grueserve::Map.new(@map_path, self)
+      @server = Grueserve::Server.new(:port => @port, :application => self)
+      @server.start!
+    end
+
+  end
+
+end

data/lib/grueserve/client.rb

@@ -0,0 +1,339 @@
+# grueserve - a game server in c and ruby for the gruesome game
+# Copyright (C) 2008  Martin Kihlgren <zond at troja dot ath dot cx>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+require 'rubygems'
+require 'set'
+require 'digest/sha1'
+require 'geo'
+require 'xml/libxml'
+
+module Grueserve
+  
+  class Client
+
+    class Command
+      def initialize(node)
+        self.name = node.name
+        node.each_attr do |attribute|
+          self[attribute.name] = attribute.value
+        end
+      end
+    end
+
+    class CommandSet
+      def initialize(node = nil)
+        unless node.nil?
+          node.each_child do |child|
+            self << Command.new(child)
+          end
+        end
+      end
+    end
+
+    class Location < Geo::Point
+      attr_accessor :client
+      def initialize(x,y,client)
+        super(x,y)
+        @client = client
+      end
+    end
+
+    include Debuggable
+    include Rated
+
+    attr_accessor :ready, :application, :client_threads, :last_start_point
+
+    def initialize(options)
+      self.socket = options.delete(:socket)
+      @application = options.delete(:application)
+      raise "Unknown options to #{self.class}.new: #{options.inspect}" unless options.empty?
+      self.map = @application.map
+      self.team = map.smallest_team
+      @last_start_point = @application.map.start_point(self.team)
+      @client_threads = Set.new
+    end
+
+    def new_message
+      msg = XML::Document.new
+      root = XML::Node.new("MESSAGE")
+      msg.root = root
+      return msg
+    end
+    def thread_with_rescue(&block)
+      new_thread = Thread.new do
+        begin
+          yield
+        rescue Exception => e
+          log_fatal(e)
+        ensure
+          self.client_threads.delete(Thread.current)
+        end
+      end
+      self.client_threads << new_thread
+    end
+    def shutdown
+      if registered?
+        self.unregister!
+        client_threads.each do |thread|
+          thread.kill
+        end
+        viewers.each do |viewer|
+          viewer.send_disappearance(self)
+        end
+        broadcast_message("#{nickname} disconnected")
+      end
+    end
+
+    def handle_ready
+      self.body.relocate(last_start_point)
+      refill
+      self.register!
+      broadcast_message("#{nickname} connected")
+      update_viewing
+    end
+    
+    def handle_policy_request
+      msg = XML::Document.new
+      root = XML::Node.new("cross-domain-policy")
+      access = XML::Node.new("allow-access-from")
+      access["domain"] = "*"
+      access["to-port"] = "*"
+      root << access
+      msg.root = root
+      send_xml(msg.to_s)
+    end
+
+    def handle_helo(node)
+      self.nickname = node["nickname"]
+      self.nickname = "Anonymous" if self.nickname.empty?
+      application.map.send_binaries(self)
+    end
+
+    def send_bin(key, val)
+      log_debug("Going to send bin to #{self}: #{key.inspect}") 
+      log_trace(" => #{val.inspect}")
+      send("bin:#{key}:#{val}")
+    end
+    
+    def send_xml(message)
+      log_debug("Going to send xml to #{self}: #{message.inspect}")
+      send("xml:#{message}")
+    end
+
+    def fire_bullet(angle)
+      bullet_line = body.origo.to(1000,0)
+      bullet_line.angle = angle
+      bullet_line.p2 = application.map.bullet_intersection(bullet_line)
+      calculate_bullet_effects(bullet_line)
+    end
+
+    def calculate_bullet_effects(bullet_line)
+      viewers = map.viewers_of(bullet_line.p1) + map.viewers_of(bullet_line.p2)
+      viewers.each do |viewer|
+        viewer.send_bullet(bullet_line)
+      end
+      broadcast_noise("shot", bullet_line.p1);
+      Set.new(map.body_parts.intersections(bullet_line)).each do |intersection|
+        unless (victim = map[intersection.last]) == self
+          victim.shot_at(self, bullet_line)
+        end
+      end
+    end
+
+    def send_aim(x, y, radius)
+      msg = new_message
+      aim = XML::Node.new("AIM")
+      aim["x"] = x.to_i.to_s
+      aim["y"] = y.to_i.to_s
+      aim["radius"] = radius.to_i.to_s
+      msg.root << aim
+      send_xml(msg.to_s)
+    end
+
+    def send_throw(thro_line, speed)
+      msg = new_message
+      thro = XML::Node.new("THROW")
+      thro["x1"] = thro_line.p1.x.to_i.to_s
+      thro["y1"] = thro_line.p1.y.to_i.to_s
+      thro["x2"] = thro_line.p2.x.to_i.to_s
+      thro["y2"] = thro_line.p2.y.to_i.to_s
+      thro["speed"] = speed.to_i.to_s
+      msg.root << thro
+      send_xml(msg.to_s)
+    end
+
+    def send_bullet(bullet_line)
+      msg = new_message
+      bullet = XML::Node.new("BULLET")
+      bullet["x1"] = bullet_line.p1.x.to_i.to_s
+      bullet["y1"] = bullet_line.p1.y.to_i.to_s
+      bullet["x2"] = bullet_line.p2.x.to_i.to_s
+      bullet["y2"] = bullet_line.p2.y.to_i.to_s
+      msg.root << bullet
+      send_xml(msg.to_s)
+    end
+
+    def broadcast_noise(sound, source)
+      self.map.each_client do |client|
+        noise_line = client.body.origo.to(source)
+        noise_damp = application.map.noise_damp(noise_line)
+        client.send_noise(sound, noise_damp, (noise_line.abs > 0 ? noise_line.angle : nil))
+      end
+    end
+
+    def broadcast_message(m)
+      self.map.each_client do |client|
+        client.send_message(m)
+      end
+    end
+
+    def send_message(m)
+      msg = new_message
+      broadcast = XML::Node.new("BROADCAST")
+      broadcast["message"] = m
+      msg.root << broadcast
+      send_xml(msg.to_s)
+    end
+
+    def send_noise(sound, volume = 1.0, angle = nil)
+      msg = new_message
+      noise = XML::Node.new("NOISE")
+      noise["angle"] = angle.to_s
+      noise["volume"] = volume.to_s
+      noise["sound"] = sound
+      msg.root << noise
+      send_xml(msg.to_s)
+    end
+
+    #
+    # Uses the Box-Muller transform to generate a bit of normal distribution with variance 1
+    #
+    def fuzz
+      Math.sqrt(-2 * Math.log(rand)) * Math.cos(2 * Math::PI * rand)
+    end
+
+    def handle_input(message)
+      case message.root.name
+      when "MESSAGE"
+        message.root.each_child do |child|
+          case child.name
+          when "HELO"
+            extend(Soldier)
+            handle_helo(child)
+          when "READY"
+            handle_ready
+          when "COMMAND"
+            self.current_command = CommandSet.new(child)
+          when "PING"
+            handle_ping
+          end
+        end
+      else
+        log_warn("Got unknown message: #{message.to_s}")
+      end
+    end
+
+    def handle_ping
+      self.ping!
+    end
+
+    def killed_by(client)
+      self.score -= 1
+      self.deaths += 1
+      set_position(body.origo, :dead)
+      broadcast_noise("scream", body.origo)
+      thread_with_rescue do
+        sleep(dead_time)
+        revive
+      end
+    end
+
+    def adjusted_damage(dmg)
+      return dmg
+    end
+
+    def shot_at(client, bullet_line)
+      if hit_me?(bullet_line)
+        if self.state != :dead
+          self.hitpoints -= adjusted_damage(client.damage)
+          if self.hitpoints <= 0
+            killed_by(client)
+            client.killed(self)
+          end
+        end
+      end
+    end
+
+    def hit_me?(bullet_line)
+      return !Map.blocks?(bullet_line.p1.to(body.origo).abs, 1.0 - profile)
+    end
+
+    def killed(client)
+      self.kills += 1
+      if client.team == self.team
+        broadcast_message("#{nickname} teamkilled #{client.nickname}")
+        self.score -= 2
+      else
+        broadcast_message("#{nickname} killed #{client.nickname}")
+        self.score += 2
+      end
+    end
+
+    def revive
+      new_position = application.map.start_point(self.team, self.last_start_point)
+      set_position(new_position, :standing)
+      self.last_start_point = new_position
+      refill
+    end
+
+    def refill
+      self.hitpoints = max_hitpoints
+    end
+
+    def standing_profile
+      1.0
+    end
+
+    def damage
+      0.0
+    end
+    
+    def dead_time
+      5
+    end
+
+    def max_hitpoints
+      10
+    end
+
+    def speed
+      rval = running_speed
+      rval /= 5.0 if state == :dodging
+      rval *= application.map.speed_factor(body.origo)
+      return rval
+    end
+
+    def profile
+      rval = standing_profile
+      rval /= 3.0 if state == :dodging
+      rval *= application.map.protection_factor(body.origo)
+      return rval
+    end
+
+  end
+
+end

data/lib/grueserve/debuggable.rb

@@ -0,0 +1,114 @@
+# grueserve - a game server in c and ruby for the gruesome game
+# Copyright (C) 2008  Martin Kihlgren <zond at troja dot ath dot cx>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+module Grueserve
+
+  module Debuggable
+
+    LEVELS = [:trace, :debug, :info, :warn, :fatal]
+
+    @level = LEVELS.last
+    @@counters = {}
+    @@timers = {}
+    @@maxes = {}
+
+    def self.level=(level)
+      if LEVELS.include?(level)
+        @level = level 
+      else
+        raise "The only debug levels allowed are '#{LEVELS.join(", ")}'."
+      end
+    end
+
+    def self.level
+      @level
+    end
+
+    def time(name, &block)
+      @@counters[name] ||= 0
+      @@timers[name] ||= 0
+      @@maxes[name] ||= 0
+      t = Time.now.to_f
+      @@timers[name] -= t
+      rval = yield
+      t2 = Time.now.to_f
+      @@timers[name] += t2
+      @@counters[name] += 1
+      @@maxes[name] = t2 - t if t2 - t > @@maxes[name]
+      return rval
+    end
+    
+    def reset_for(name)
+      @@counters[name] = 0
+      @@timers[name] = 0
+      @@maxes[name] = 0
+    end
+
+    def reset
+      @@timers = {}
+      @@counters = {}
+      @@maxes = {}
+    end
+
+    def report_for(name)
+      @@timers[name] ||= 0
+      @@counters[name] ||= 0
+      @@maxes[name] ||= 0
+      log_info("#{name}: total: #{@@counters[name]} in #{@@timers[name]}, avg: #{@@counters[name] == 0 ? "0" : @@timers[name] / @@counters[name]}, max: #{@@maxes[name]}")
+    end
+
+    def report
+      @@timers.keys.each do |k|
+        report_for(k)
+      end
+    end
+
+    def method_missing(meth, *args)
+      if match = meth.to_s.match(/log_(.*)$/)
+        level = match[1].to_sym
+        if LEVELS.include?(level) && args.size == 1
+          Debuggable.output(level, *args)
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+
+    def self.source_part(caller_ary)
+      caller_ary[2].gsub(/^.*\/(grueserve\/.*\.rb.*)$/, '\1')
+    end
+
+    def self.format(s, level)
+      STDERR.puts("#{Time.now}\t#{level}\t#{source_part(caller)}\t#{s}")
+    end
+
+    def self.output(level, m)
+      if LEVELS.index(@level) <= LEVELS.index(level)
+        format(m, level)
+        if m.respond_to?(:backtrace)
+          m.backtrace.each do |line|
+            format(line, level)
+          end
+        end
+      end
+    end
+
+  end
+
+end