grueserve 0.0.1

data/lib/grueserve/map.rb

@@ -0,0 +1,178 @@
+# 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 'pathname'
+require 'yaml'
+require 'geo'
+
+module Grueserve
+  
+  class Map
+
+    def self.blocks?(distance, profile)
+      return true if profile >= 1
+      return false if profile <= 0
+      return rand < (profile - (1.0 / ((distance / 100) + (1.0 / profile))))
+    end
+
+    include Debuggable
+
+    attr_reader :teams, :application
+
+    def initialize(path, application = nil)
+      @path = path
+      @application = application
+      @attributes = YAML.load(@path.join("attributes.yaml").read)
+      init_lines("movement_obstacles")
+      init_lines("visibility_obstacles")
+      init_lines("bullet_obstacles")
+      init_lines("hearing_obstacles")
+      init_lines("fortifications")
+      init_areas("speed_areas")
+      init_areas("protection_areas")
+      init_areas("hidden_areas")
+      @hearing_distance_cutoff = (@attributes["hearing_distance_cutoff"] || 100).to_f
+      @viewing_distance_limit = (@attributes["viewing_distance_limit"] || 1000).to_f
+      @teams = @attributes["teams"].split
+      @start_points = @teams.inject({}) do |sum, team|
+        sum.merge(team => @attributes["#{team}_start_points"].split.collect do |point_string|
+                    coords = point_string.split(/,/)
+                    Geo::Point.new(coords.first.to_f, coords.last.to_f)
+                  end)
+      end
+    end      
+
+    def size_of_team(team)
+      members = 0
+      each_client do |client|
+        members += 1 if client.team == team
+      end
+      return members
+    end
+
+    def smallest_team
+      return @teams.sort do |team1,team2|
+        size_of_team(team1) <=> size_of_team(team2)
+      end.first
+    end
+
+    def send_binaries(client)
+      Pathname.glob(@path.join("sprites").join("**").join("*")).each do |sprite_frame|
+        client.send_bin(sprite_frame.basename, sprite_frame.read)
+      end
+      client.send_bin("map", img.read)
+    end
+
+    def protection_factor(location)
+      rval = 1.0
+      if area = protection_areas.first_container(location)
+        rval *= self[area] / 1000.0
+      end
+      return rval
+    end
+    
+    def start_point(team, not_point = nil)
+      points_to_choose_from = @start_points[team].clone
+      points_to_choose_from.delete(not_point) if not_point && points_to_choose_from.size > 1
+      the_point = points_to_choose_from[rand(points_to_choose_from.size)]
+      return Geo::Point.new(the_point.x, the_point.y)
+    end
+    
+    def img
+      @path.join(@attributes["map"])
+    end
+
+    def bullet_intersection(line)
+      definite_stop = bullet_obstacles.closest_intersection(line)
+      line.p2 = definite_stop.first if definite_stop
+      fortifications.intersections(line).sort do |a,b|
+        a.first.to(line.p1).abs <=> b.first.to(line.p1).abs
+      end.each do |possible_stop|
+        if self.class.blocks?(line.p1.to(possible_stop.first).abs, self[possible_stop.last] / 1000.0)
+          return possible_stop.first
+        end
+      end
+      return line.p2
+    end
+
+    def noise_damp(line)
+      obstacles_damp = hearing_obstacles.intersections(line).inject(1.0) do |sum, obstacle|
+        sum * self[obstacle.last] / 1000.0
+      end
+      (1.0 / ([(line.abs / @hearing_distance_cutoff),1].max ** 2)) * obstacles_damp
+    end
+
+    private
+
+    def init_areas(name)
+      triangle_set = self.send(name.to_sym)
+      if stringData = @attributes[name]
+        stringData.split(/:/).each do |segment|
+          pointString, valueString = segment.split(/=/)
+          value = @attributes["#{name}_default_value"].to_i
+          value = valueString.to_i if valueString
+          points = pointString.split
+          middle = point_from_string(points.shift)
+          (points.size - 1).times do |i|
+            p1 = points[i]
+            p1 = points.first if p1 == "loop"
+            p1 = point_from_string(p1)
+            p2 = points[i + 1]
+            p2 = points.first if p2 == "loop"
+            p2 = point_from_string(p2)
+            area = Geo::Triangle.new(middle, p1, p2)
+            log_debug("adding area #{area.inspect} with value #{value} to @#{name}")
+            triangle_set << area
+            self[area] = value
+          end
+        end
+      end
+    end
+
+    def init_lines(name)
+      line_set = self.send(name.to_sym)
+      if stringData = @attributes[name]
+        stringData.split(/:/).each do |segment|
+          pointString, valueString = segment.split(/=/)
+          value = @attributes["#{name}_default_value"].to_i
+          value = valueString.to_i if valueString
+          points = segment.split
+          (points.size - 1).times do |i|
+            p1 = points[i]
+            p1 = points.first if p1 == "loop"
+            p1 = point_from_string(p1)
+            p2 = points[i + 1]
+            p2 = points.first if p2 == "loop"
+            p2 = point_from_string(p2)
+            o = Geo::Line.new(p1, p2)
+            log_debug("adding obstacle #{o.inspect} with value #{value} to @#{name}")
+            line_set << o
+            self[o] = value
+          end
+        end
+      end
+    end
+
+    def point_from_string(s)
+      x,y = s.split(/,/)
+      return Geo::Point.new(x.to_i,y.to_i)
+    end
+    
+  end
+  
+end

data/lib/grueserve/rated.rb

@@ -0,0 +1,44 @@
+# 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 Rated
+    
+    class Rate
+      def initialize(n)
+        @n = n
+        @times = {}
+      end
+      def times_a_second(&block)
+        time = (@times[:second] ||= Time.now.to_f)
+        if Time.now.to_f - time > 1.0 / @n
+          @times[:second] = Time.now.to_f
+          yield
+        end
+      end
+    end
+
+    def max_rate_of(n)
+      @rates ||= {}
+      @rates[n] ||= Rate.new(n)
+    end
+
+  end
+
+end

data/lib/grueserve/server.rb

@@ -0,0 +1,201 @@
+# 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 'socket'
+require 'pp'
+require 'monitor'
+require 'xml/libxml'
+
+module Grueserve
+
+  class Server
+
+    module ClientSocket
+
+      class PolicyFileRequest < RuntimeError
+      end
+
+      include MonitorMixin
+      include Debuggable
+
+      attr_accessor :buffer, :bufferSize, :client, :server
+
+      def init_client_socket(client, server)
+        mon_initialize
+        @client = client
+        @server = server
+        @buffer = ""
+        @bufferSize = 0
+      end
+
+      def readTo(char)
+        rval = ""
+        while (next_char = self.read_nonblock(1)) != char
+          rval += next_char
+          if rval == "<policy-file-request/>\0"
+            log_debug("Received policy file request #{rval.inspect}")
+            raise PolicyFileRequest.new
+          end 
+        end
+        return rval
+      end
+
+      def handle_input
+        begin
+          @bufferSize = readTo(":").to_i if @bufferSize == 0
+          log_trace("Expecting package of size #{@bufferSize}")
+          gotten = self.read_nonblock(@bufferSize - @buffer.size)
+          log_trace("Received buffer #{gotten.inspect}")
+          @buffer += gotten
+          if @buffer.size == @bufferSize
+            log_debug("Received complete buffer from #{self}: #{@buffer.inspect}")
+            doc = XML::Parser.string(@buffer).parse
+            client.handle_input(doc)
+            @buffer = ""
+            @bufferSize = 0
+          end
+        rescue Exception => e
+          server.kill_socket(self)
+          raise e
+        end
+      end
+
+    end
+
+    include Debuggable
+
+    def initialize(options = {})
+      @port = options.delete(:port) || 25999
+      raise "#{self.class}.new requires an :application argument." unless options.include?(:application)
+      @application = options.delete(:application)
+      @frequency = options.delete(:frequency) || 100
+      raise "Unknown options to #{self.class}: #{options.inspect}" unless options.empty?
+      @sockets = []
+      @sockets_to_close = Set.new
+    end
+
+    def start!
+      start_updating!
+      start_listening!
+      start_serving!
+    end
+
+    def start_updating!
+      @updater ||= nil
+      @updater.kill if @updater.respond_to?(:kill)
+      @updater = Thread.new do
+        counter = 0
+        timer = Time.now
+        sleep_sum = 0
+        loop do
+          begin
+            start_time = Time.now
+            @application.map.update!
+            if (diff = (1.0 / @frequency) - ((stop_time = Time.now).to_f - start_time.to_f)) > 0
+              sleep_sum += diff
+              sleep(diff)
+            end
+            counter += 1
+            if Time.now - timer > 10
+              avg_frequency = counter / (Time.now.to_f - timer.to_f)
+              avg_sleep = sleep_sum / (Time.now.to_f - timer.to_f)
+              log_info("Avg frequency: #{avg_frequency}, sleeping #{(avg_sleep * 100).to_i}% of the time")
+              report
+              reset
+              timer = Time.now
+              counter = 0
+              sleep_sum = 0
+            end
+          rescue Exception => e
+            log_warn(e)
+          end
+        end
+      end
+    end
+
+    def kill_socket(socket)
+      socket.client.shutdown
+      @sockets.delete(socket)
+      @sockets_to_close << socket
+    end
+
+    def start_listening!
+      @listener ||= nil
+      @listener.kill if @listener.respond_to?(:kill)
+      @listener = Thread.new do
+        loop do
+          begin
+            to_close = @sockets_to_close.to_a
+            while (socket = to_close.shift)
+              socket.close unless socket.closed?
+            end
+            read_ready, write_read, errors = select(@sockets, nil, @sockets, 1)
+            unless errors.nil?
+              errors.each do |socket|
+                log_warn("Going to drop #{socket} from #{@sockets.inspect} since it got an error")
+                kill_socket(socket)
+              end
+            end
+            unless read_ready.nil?
+              read_ready.each do |socket|
+                if socket.eof?
+                  log_info("Going to drop #{socket} from #{@sockets.inspect} since it is closed")
+                  kill_socket(socket)
+                else
+                  begin
+                    socket.handle_input
+                  rescue ClientSocket::PolicyFileRequest => e
+                    log_info("Got policy file request from #{socket.inspect}")
+                    socket.client.handle_policy_request
+                  end
+                end
+              end
+            end
+          rescue Exception => e
+            log_warn(e)
+          end
+        end
+      end
+      log_debug("Started listener")
+    end
+
+    def start_serving!
+      log_debug("Starting serving")
+      @server ||= nil
+      @server.close if @server.respond_to?(:close)
+      @server = TCPServer.new(@port)
+      loop do
+        begin
+          socket = @server.accept_nonblock
+          socket.extend(ClientSocket)
+          socket.init_client_socket(Client.new(:socket => socket, :application => @application), self)
+          log_info("Received #{socket}, adding it to #{@sockets.inspect}")
+          @sockets << socket
+        rescue Errno::EAGAIN, Errno::ECONNABORTED, Errno::EPROTO, Errno::EINTR => e
+          log_trace("Got TCPServer error: #{e}")
+          IO.select([@server])
+          retry
+        rescue Exception => e
+          log_warn(e)
+        end      
+      end
+    end
+
+  end
+
+end

data/lib/grueserve/soldier.rb

@@ -0,0 +1,181 @@
+# 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 Soldier
+
+    class Aim
+      attr_accessor :point, :precision
+      def initialize(point, precision)
+        @point = point
+        @precision = precision
+      end
+    end
+
+    RELOAD = "RELOAD"
+
+    def self.extend_object(o)
+      super
+      o.init_soldier
+    end
+
+    def init_soldier
+      self.behaviour = "soldier"
+      @reloading = false
+      @aim = nil
+      subscribe("LBUTTON", :handle_lbutton)
+      subscribe("RELOAD", :handle_reload)
+    end
+
+    def refill
+      super
+      self.ammo = max_ammo
+    end
+
+    def ammo
+      @ammo
+    end
+
+    def ammo=(x)
+      @ammo = x
+      self.extra_status = " Ammo: #{@ammo}"
+    end
+
+    def max_ammo
+      32
+    end
+
+    def base_grenade_precision_factor
+      2
+    end
+    
+    def grenade_precision_delta
+      0.1
+    end
+
+    def grenade_max_precision_factor
+      5
+    end
+
+    def reload_time
+      3
+    end
+
+    def throwing_speed
+      100
+    end
+
+    def max_throwing_distance
+      200
+    end
+
+    def reload
+      if !@reloading && @aim.nil
+        @reloading = true
+        broadcast_noise("reload", body.origo)
+        thread_with_rescue do
+          sleep(reload_time)
+          self.ammo = max_ammo
+          @reloading = false
+        end
+      end
+    end
+
+    def throw_grenade
+      this_fuzz_factor = @aim.point.abs / @aim.precision
+      loc = body.origo + Geo::Point.new(@aim.point.x + (this_fuzz_factor * fuzz),
+                                        @aim.point.y + (this_fuzz_factor * fuzz))
+      send_throw(body.origo.to(loc), throwing_speed)
+      @aim = nil
+    end
+    
+    def handle_lbutton(command)
+      unless @reloading
+        if command.nil?
+          unless @aim.nil?
+            throw_grenade
+          end
+        else
+          if current_command.include?("SHIFT")
+            max_rate_of(10).times_a_second do
+              if @aim.nil?
+                new_point = Geo::Point.new(command["x"].to_i, command["y"].to_i) - body.origo
+                new_point.abs = max_throwing_distance if new_point.abs > max_throwing_distance
+                @aim = Aim.new(new_point, base_grenade_precision_factor)
+              else
+                @aim.precision += grenade_precision_delta unless @aim.precision > grenade_max_precision_factor
+              end
+              aim_point = body.origo + @aim.point
+              send_aim(aim_point.x, aim_point.y, @aim.point.abs / @aim.precision)
+            end
+          else
+            if @aim.nil?
+              if ammo > 0
+                max_rate_of(8).times_a_second do
+                  shot_line = body.origo.to(command["x"].to_i, command["y"].to_i)
+                  this_fuzz_factor = shoot_fuzz_factor
+                  angle = fuzz * this_fuzz_factor + shot_line.angle
+                  send_aim(command["x"], command["y"], Math.tan(this_fuzz_factor) * shot_line.abs)
+                  fire_bullet(angle)
+                  self.ammo -= 1
+                end
+              else
+                max_rate_of(1).times_a_second do
+                  broadcast_noise("dry_shot", body.origo)
+                end
+              end
+            else
+              throw_grenade
+            end
+          end
+        end
+      end
+    end
+
+    def handle_reload(command)
+      unless command.nil?
+        reload
+      end
+    end
+
+    def damage
+      2
+    end
+
+    def shoot_fuzz_factor
+      rval = 1.0
+      if moving?
+        if state == :dodging
+          rval *= 4
+        else
+          rval *= 2
+        end
+      else
+        rval *= 0.5 if state == :dodging
+      end
+      return rval / precision
+    end
+
+    def precision
+      30.0
+    end
+
+  end
+
+
+end