game_machine 0.0.8

data/config/regions.example.yml

@@ -0,0 +1,9 @@
+---
+development:
+  regions:
+    zone1: Example::ZoneManager
+    zone2: Example::ZoneManager
+test:
+  regions:
+    zone1: GameMachine::GameSystems::Zone1Manager
+    zone2: GameMachine::GameSystems::Zone2Manager

data/config/standalone.conf

@@ -0,0 +1,36 @@
+
+standalone {
+  default-pinned-dispatcher {
+    executor = thread-pool-executor
+    type = PinnedDispatcher
+    thread-pool-executor.keep-alive-time = 315360000s
+    # note that disabling core timeout altogether doesn't work
+    # until ticket 2856 is fixed
+    thread-pool-executor.allow-core-timeout = off
+  }
+
+  akka {
+    actor.debug.unhandled = "on"   
+    jvm-exit-on-fatal-error=false
+    loglevel = "WARNING"
+
+    actor {
+      serializers {
+        java = "akka.serialization.JavaSerializer"
+        bytes = "akka.serialization.ByteArraySerializer"
+        myown = "com.game_machine.core.EntitySerializer"
+      }
+
+      serialization-bindings {
+        "[B" = bytes
+        "java.io.Serializable" = java
+        "com.dyuproject.protostuff.Message" = myown
+        "GameMachine.Messages.ClientMessage" = myown
+        "GameMachine.Messages.Entity" = myown
+        "GameMachine.Messages.ObjectdbGet" = myown
+        "GameMachine.Messages.ObjectdbPut" = myown
+        "GameMachine.Messages.ObjectdbUpdate" = myown
+      }
+    }
+  }
+}

data/game_machine.gemspec

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'game_machine/version'
+
+Gem::Specification.new do |gem|
+  gem.name        = "game_machine"
+  gem.version     = GameMachine::VERSION
+  gem.authors     = ["Chris Ochs"]
+  gem.email       = ["chris@ochsnet.com"]
+  gem.homepage    = "https://github.com/gamemachine/gamemachine"
+  gem.summary     = %q{Game Machine}
+  gem.description = %q{game server}
+
+  gem.files         = `git ls-files`.split($/).reject { |f| f =~ /^(games\/physics_experiments)/ }
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features|integration_tests)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'i18n'
+  gem.add_dependency 'rjack-logback'
+  gem.add_dependency 'settingslogic'
+  gem.add_dependency 'consistent-hashing'
+  gem.add_dependency  'json'
+  gem.add_dependency 'ffi'
+  gem.add_dependency 'sinatra'
+  gem.add_dependency 'sinatra-contrib'
+  gem.add_dependency 'haml'
+  gem.add_dependency 'webrick'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rspec-mocks'
+  gem.add_development_dependency 'rspec-expectations'
+  gem.add_development_dependency 'descriptive_statistics'
+
+  
+end

data/games/example/boot.rb

@@ -0,0 +1,6 @@
+
+require_relative 'lib/game'
+
+game_root = File.dirname(__FILE__)
+Example::Game.new(game_root).start
+

data/games/example/data/game_data.yml

@@ -0,0 +1,13 @@
+---
+zone1:
+  male: 200
+  viking: 200
+  golem: 200
+  worm: 200
+zone2:
+  male: 100
+  viking: 100
+  golem: 100
+  worm: 100
+
+

data/games/example/lib/aggressive_npc.rb

@@ -0,0 +1,176 @@
+require 'benchmark'
+module Example
+  class AggressiveNpc < Npc
+    include GameMachine::Commands
+    include Models
+
+    attr_reader :target_id
+
+    def post_init
+      @target_id = nil
+      @check_home_counter = 0
+      @check_home_interval = 5
+      @acquire_target_counter = 0
+      @acquire_target_interval = 5
+      @agro_radius = 15
+      @leash_radius = 30
+  
+      movement.speed_scale = 4
+      @last_attack = Time.now.to_i
+      @attack_interval = 2
+    end
+
+    def log(msg)
+      GameMachine.logger.info "#{id} #{msg}"
+    end
+
+    def set_spawn_point
+      position.x = rand(1000) + 1
+      position.y = rand(1000) + 1
+      #position.z = 40
+    end
+
+    def has_target?
+      target_id.nil? ? false : true
+    end
+
+    def update_target
+      if target = players.fetch(target_id,nil)
+        movement.update_target(target[:vector])
+        true
+      else
+        @target_id = nil
+        false
+      end
+    end
+
+    def choose_target
+      if player = sorted_players.first
+        if position.distance(player[:vector]) <= @agro_radius
+          movement.set_target(player[:vector])
+          @target_id = player[:id]
+          #log("target chosen #{@target_id}")
+        end
+      end
+    end
+
+    def leash?
+      if @check_home_counter >= @check_home_interval
+        @check_home_counter = 0
+        if movement.position.distance(home) > @leash_radius
+          return true
+        elsif movement.current_target &&
+          (movement.position.distance(movement.current_target) > @leash_radius)
+          return true
+        end
+      end
+      false
+    end
+
+    def go_home!
+      log("going home")
+      @target_id = 'home'
+      movement.set_target(@home)
+    end
+
+    def going_home?
+      @target_id == 'home'
+    end
+
+    def reached_home?
+      going_home? && movement.reached_target
+    end
+
+    def reset_target
+      movement.drop_target
+      @target_id = nil
+    end
+
+    def attack_target
+      if Time.now.to_i - @last_attack < @attack_interval
+        return
+      end
+
+      attack = Attack.new(
+        :target => target_id,
+        :attacker => id,
+        :combat_ability => 'bite'
+      )
+      CombatController.find.tell(attack)
+      #log("attacked target #{target_id}")
+      @last_attack = Time.now.to_i
+    end
+
+    def update
+      return if dead
+      if going_home?
+        if reached_home?
+          log("home reached")
+          reset_target
+        else
+          movement.update_target(home)
+          movement.update
+        end
+        return
+      end
+
+      if leash?
+        log("leashed!")
+        reset_target
+        go_home!
+        return
+      end
+
+      # if we have a target, acquire their location every tick, otherwise only
+      # check every acquire_target_interval updates
+      if has_target? || @acquire_target_counter >= @acquire_target_interval
+        movement.updates_between_move = 1
+        check_players
+        if has_players?
+          unless has_target?
+            choose_target
+          end
+        else
+          # No players but we have a player target?  Player must have logged out
+          # or otherwise disappeared, so we need to reset
+          if @target_id && @target_id != 'home'
+            GameMachine.logger.info "#{id} No players but has target!?? (target: #{@target_id})"
+            reset_target
+            go_home!
+          elsif movement.position.distance(home) > 0
+            GameMachine.logger.info "#{id} No players but is #{position.distance(home)} from home (target: #{@target_id})"
+            reset_target
+            go_home!
+          end
+        end
+
+        @acquire_target_counter = 0
+      else
+        movement.updates_between_move = 20
+      end
+
+      if has_target?
+        if movement.distance_to_target <= 3
+          attack_target
+        end
+
+        if movement.reached_target
+          reset_target
+        else
+          if update_target
+            movement.update
+          else
+            # Target out of range for some reason (logged out, etc..)
+            GameMachine.logger.info "#{id} lost target! #{@target_id}"
+            reset_target
+            go_home!
+          end
+        end
+      end
+
+      @acquire_target_counter += 1
+      @check_home_counter += 1
+    end
+
+  end
+end

data/games/example/lib/authentication_handler.rb

@@ -0,0 +1,69 @@
+
+# This class is set in the configuration.
+
+# This is a simple implementation that works together with the built in
+# user registration and login via http. User data is stored in the object database.
+
+# The minimum necessary to implement is the authtoken_for method.  That method can
+# block as it is only called once when the client first connects and is cached
+# internally after that. So you could make an external http call for example.
+require 'digest/md5'
+module Example
+  class AuthenticationHandler
+    include Models
+
+    def initialize
+      @sessions = {}
+    end
+
+    # Returns true is authorized, false if not
+    def authorize(username,password)
+      GameMachine.logger.info "authorize: #{username} #{password}"
+      if user = User.find(username,5000)
+        GameMachine.logger.info "user: #{user.id} #{user.password}"
+        if password == user.password
+          @sessions[username] = authtoken(username,password)
+          user.authtoken = @sessions[username]
+          user.save
+          return @sessions[username]
+        else
+          GameMachine.logger.info "user: #{user.id} password does not match"
+          false
+        end
+      else
+        GameMachine.logger.info "user: #{username} not found"
+        false
+      end
+      false
+    end
+
+    # Returns a session token for a logged in user.  This must be a string and
+    # should not be too long, as it gets sent with every message.
+    def authtoken_for(username)
+      if authtoken = @sessions.fetch(username,nil)
+        return authtoken
+
+      # user authenticated on different server, we have to look up their authtoken
+      # and save it in the local sessions hash
+      elsif user = User.find(username)
+        if user.authtoken
+          @sessions[username] = authtoken
+          return user.authtoken
+        else
+          GameMachine.logger.info "Authoken for #{username} is nil"
+          nil
+        end
+      else
+        GameMachine.logger.info "User #{username} not found"
+        nil
+      end
+    end
+
+    private
+
+    def authtoken(username,password)
+      Digest::MD5.hexdigest("#{username}#{password}#{rand(10000)}")
+    end
+  end
+end
+

data/games/example/lib/chatbot.rb

@@ -0,0 +1,61 @@
+
+# Shows how to use the messaging/chat system programmatically from the server.
+# Also shows how to use the schedular to send ourselves a recurring message that
+# we can use to trigger recurring actions.
+
+module Example
+  class Chatbot < GameMachine::Actor::Base
+    include GameMachine
+    include GameMachine::Commands
+
+    attr_reader :topic, :chatbot_id
+    def post_init(*args)
+      @topic = args.first
+      @chatbot_id = 'overlord'
+
+      # On the server side we use register, which takes our chat id
+      # and the name of this actor.
+      commands.chat.register(chatbot_id,'Example::Chatbot')
+
+      # Then we send a regular join request
+      commands.chat.join('global',chatbot_id)
+
+      # Send ourselves a 'doit' message every few seconds
+      schedule_message('doit',50,:seconds)
+    end
+
+    def message_queue
+      MessageQueue.find
+    end
+
+    def on_receive(message)
+
+      # This is our scheduled message
+      if message.is_a?(String)
+        if message == 'doit'
+          commands.chat.send_group_message('global','Would you like to play a game?',chatbot_id)
+        end
+
+      # Status update we get from chat system, we don't care..
+      elsif message.has_chat_channels
+
+      # Must be a chat message
+      elsif message.has_chat_message
+
+        # ignore our own messages
+        sender_id = message.chat_message.sender_id
+        unless sender_id == chatbot_id
+          text = message.chat_message.message
+          GameMachine.logger.info "Chatbot received text #{text}"
+
+          # Respond with a private message
+          if text.match(/shut up/)
+            reply = 'Same to you!'
+            commands.chat.send_private_message(reply,sender_id)
+          end
+
+        end
+      end
+    end
+  end
+end

data/games/example/lib/combat_controller.rb

@@ -0,0 +1,145 @@
+
+# Handles all the combat.  Npc controllers and clients send Attack messages
+# to this actor which calculates damage, persists any changes, and sends out
+# combat updates to all players in the area as well as to any npc's that were
+# hit.
+
+# If the attack combat_ability is 'aoe', we use the aoe grid which is a 
+# secondary grid with a smaller radius.  Currently we use the attacker as the
+# point to query on, but it could be easily extended to use any point, so you
+# could have aoe damage with a center anywhere you want it to be.
+
+
+module Example
+  class CombatController < GameMachine::Actor::Base
+    include GameMachine::Commands
+    include Models
+
+    attr_reader :aoe_grid
+    def post_init(*args)
+      @aoe_grid = GameMachine::Grid.find_or_create('aoe')
+    end
+
+    def hit?
+      return true
+      chance = rand(0..10)
+      chance >= 5 ? true : false
+    end
+
+    def damage(entity_type)
+      if entity_type == 'player'
+        rand(1..8)
+      else
+        rand(20..120)
+      end
+    end
+
+    def on_receive(message)
+      if message.is_a?(Attack)
+        attack = message
+        attacker_vitals = Vitals.find(attack.attacker)
+
+        if attacker_vitals.entity_type == 'player'
+          player_id = attack.attacker
+        else
+          player_id = attack.target
+        end
+
+        # gets our targets.  Does range query if aoe
+        targets = find_targets(attack,attacker_vitals)
+        #GameMachine.logger.info "targets #{targets.map{|target| target.id}.join(',')}"
+
+        # calculates/applies damage and returns a combat update for each hit
+        combat_updates = attack_targets(targets,attack)
+
+        # Get all players within our larger radius so we can send them the updates
+        neighbors = commands.grid.get_neighbors_for(attack.attacker)
+
+        combat_updates.each do |combat_update|
+          GameMachine.logger.info "#{combat_update.attacker} hit #{combat_update.target} for #{combat_update.damage} #{attack.combat_ability} damage"
+          commands.player.send_message(combat_update,player_id)
+
+          if neighbors
+            neighbors.each do |neighbor|
+              next if neighbor.id == player_id
+              commands.player.send_message(combat_update,neighbor.id)
+            end
+          end
+        end
+
+      end
+    end
+
+    def attack_targets(targets,attack)
+      combat_updates = []
+
+      targets.each do |target_vitals|
+          
+        if target_vitals.entity_type.blank?
+          target_vitals.entity_type = 'npc'
+          GameMachine.logger.info "#{target_vitals.id} has no entity type, fixing"
+        end
+        if hit?
+          dmg = damage(target_vitals.entity_type)
+          next if dmg == 0
+          if target_vitals.health - dmg <= 0
+            target_vitals.health = 0
+          else
+            target_vitals.health -= dmg
+          end
+          target_vitals.save
+          #GameMachine.logger.info "#{target_vitals.id}(#{target_vitals.entity_type}) has #{target_vitals.health}"
+
+          combat_update = CombatUpdate.new(
+            :target => target_vitals.id,
+            :attacker => attack.attacker,
+            :damage => dmg,
+            :target_health => target_vitals.health
+          )
+          combat_updates << combat_update
+
+          if target_vitals.entity_type == 'npc'
+            if npc_group_actor = Game.npcs.fetch(target_vitals.id,nil)
+              GameMachine::Actor::Base.find(npc_group_actor).tell(combat_update)
+            else
+              GameMachine.logger.info "group actor for #{target_vitals.id} not found"
+            end
+          end
+
+        end
+      end
+      combat_updates
+    end
+
+    # If it's an aoe attack, use our aoe grid to find targets in range, otherwise
+    # use the specified target
+    def find_targets(attack,attacker)
+      targets = []
+
+      # npc's only hit players, players hit everything
+      if attacker.entity_type == 'npc'
+        search_type = 'player'
+      else
+        search_type = nil
+      end
+
+      if attack.combat_ability == 'aoe'
+        if grid_value = @aoe_grid.get(attack.attacker)
+          @aoe_grid.neighbors(grid_value.x,grid_value.y,search_type).each do |grid_value|
+            next if grid_value.id == attack.attacker
+            if target_vitals = Vitals.find(grid_value.id)
+              targets << target_vitals
+            end
+          end
+        end
+      else
+        if target_vitals = Vitals.find(attack.target)
+          targets << target_vitals
+        end
+      end
+      targets
+    end
+
+
+  end
+end