game_machine 0.0.8

data/games/example/lib/example_controller.rb

@@ -0,0 +1,21 @@
+module Example
+  class ExampleController < GameMachine::Actor::Base
+    include GameMachine
+    include GameMachine::Commands
+    include GameMachine::Actor::Development
+
+    # This is our initializer method. It is called once on actor start.
+    #
+    def post_init(*args)
+      # Just because
+      GameMachine.logger.info "#{self.class.name} post_init called"
+    end
+
+    def on_receive(message)
+
+      # Send message back to player who sent it
+      commands.player.send_message(message.to_entity,message.player.id)
+      GameMachine.logger.info("message sent to #{message.player.id}")
+    end
+  end
+end

data/games/example/lib/game.rb

@@ -0,0 +1,85 @@
+require 'digest/md5'
+require_relative 'models/vitals'
+require_relative 'models/attack'
+require_relative 'models/user'
+require_relative 'models/combat_update'
+require_relative 'models/player_command'
+require_relative 'authentication_handler'
+require_relative 'tracking_handler'
+require_relative 'player_register'
+require_relative 'example_controller'
+require_relative 'chatbot'
+require_relative 'combat_controller'
+require_relative 'npc_movement'
+require_relative 'npc'
+require_relative 'aggressive_npc'
+require_relative 'npc_group'
+require_relative 'player_manager'
+require_relative 'zone_manager'
+
+module Example
+  class Game
+    include GameMachine::Commands
+
+    attr_reader :game_root, :game_data
+
+    def self.npcs
+      if @npcs
+        @npcs
+      else
+        @npcs = java.util.concurrent.ConcurrentHashMap.new
+      end
+    end
+
+    def initialize(game_root)
+      @game_root = game_root
+      @game_data = load_game_data
+    end
+
+    def start
+
+      # Start your custom actors here.  In this example we show a simple method
+      # for loading some static data and passing it to the actor.
+      
+      # Builder.new takes the classname of the actor,and any number of other arguments.
+      # These extra arguments will be sent to the actor's post_init method when
+      # it starts
+      GameMachine::Actor::Builder.new(ExampleController).start
+
+      # Creating the actor with a specific name.  Useful if you want to start up
+      # multiple actors all using the same actor class.
+      # GameMachine::Actor::Builder.new(ExampleController).with_name('my_example_actor').start
+
+
+      # Using a router.
+      # This starts up 10 copies of the actor with router in front of them that
+      # distributes load using round robin
+      # GameMachine::Actor::Builder.new(ExampleController).
+      #   with_router(JavaLib::RoundRobinRouter,10)start
+
+      # Using a distributed ring of actors.
+      # This creates a dstributed actor ring that will hash messages to actors
+      # using the id passed to ExampleActor.find_distributed(id).
+      # GameMachine::Actor::Builder.new(ExampleController).
+      #   distributed(10).start
+
+      # Start our chatbot.  No good reason for this, just shows off some more tech
+      GameMachine::Actor::Builder.new(Chatbot,'global').start
+
+      # Misc player management stuff is taken care of by the player manager.
+      # This is game specific.
+      GameMachine::Actor::Builder.new(PlayerManager).start
+
+      # This actor is responsible for starting up everything associated with a zone.
+      # It waits until the region manager tells it that it is responsible for a
+      # particular zone.
+      GameMachine::Actor::Builder.new(ZoneManager,game_data).start
+    end
+
+    def load_game_data
+      filename = File.join(game_root,'/data/game_data.yml')
+      YAML.load(File.read(filename))
+    end
+
+  end
+end

data/games/example/lib/models/attack.rb

@@ -0,0 +1,9 @@
+module Example
+  module Models
+    class Attack < GameMachine::Model
+      attribute :target, String
+      attribute :attacker, String
+      attribute :combat_ability, String
+    end
+  end
+end

data/games/example/lib/models/combat_update.rb

@@ -0,0 +1,11 @@
+module Example
+  module Models
+    class CombatUpdate < GameMachine::Model
+      attribute :target, String
+      attribute :attacker, String
+      attribute :combat_ability, String
+      attribute :damage, Integer
+      attribute :target_health, Integer
+    end
+  end
+end

data/games/example/lib/models/player_command.rb

@@ -0,0 +1,7 @@
+module Example
+  module Models
+    class PlayerCommand < GameMachine::Model
+      attribute :command, String
+    end
+  end
+end

data/games/example/lib/models/user.rb

@@ -0,0 +1,11 @@
+module Example
+  module Models
+    class User < GameMachine::Model
+      attribute :id, String
+      attribute :password, String
+      attribute :authtoken, String
+      
+      set_id_scope :user
+    end
+  end
+end

data/games/example/lib/models/vitals.rb

@@ -0,0 +1,17 @@
+module Example
+  module Models
+    class Vitals < GameMachine::Model
+      attribute :max_health, Integer
+      attribute :health, Integer
+      attribute :id, String
+      attribute :defense_skill, Integer
+      attribute :offense_skill, Integer
+      attribute :entity_type, String
+      attribute :x, Integer
+      attribute :y, Integer
+      attribute :zone, String
+
+      set_id_scope :vitals
+    end
+  end
+end

data/games/example/lib/npc.rb

@@ -0,0 +1,111 @@
+module Example
+  class Npc
+    include GameMachine::Commands
+    include Models
+
+    attr_accessor :position, :id, :players, :movement, :player_index, :home, :vitals, :dead
+
+    def initialize(id)
+      @dead = false
+      @id = id
+      @position = GameMachine::Vector.new
+      @last_ai = Time.now.to_i
+      @player_check_counter = 0
+      @players = {}
+      set_spawn_point
+      @movement = NpcMovement.new(id,position)
+      movement.speed_scale = 2
+      @home = GameMachine::Vector.from(position)
+      @target = GameMachine::Vector.new
+      get_players
+      #GameMachine.logger.info "Npc #{id} created"
+      initialize_vitals
+      post_init
+    end
+
+    def initialize_vitals
+      if @vitals = Vitals.find(id,5000)
+
+        # Put dead npc's back to full health
+        if @vitals.health < @vitals.max_health
+          @vitals.health = @vitals.max_health
+          @vitals.save
+        end
+      else
+        @vitals = Vitals.new(
+          :id => id,
+          :max_health => 50,
+          :health => 50,
+          :entity_type => 'npc'
+        )
+        @vitals.save
+      end
+    end
+
+    def post_init
+    end
+
+    def update_combat(combat_update)
+      if combat_update.target == id && combat_update.target_health == 0
+        @dead = true
+        GameMachine.logger.info "Npc #{id} died!"
+        commands.grid.remove(id)
+      end
+    end
+
+    def set_spawn_point
+      position.x = rand(1000) + 1
+      position.y = rand(1000) + 1
+    end
+
+    def has_players?
+      players.size > 0
+    end
+
+    def sorted_players
+      players.values.sort do |a,b|
+        position.distance(a[:vector]) <=> position.distance(b[:vector])
+      end
+    end
+
+    def get_players
+      commands.grid.neighbors(position.x,position.y).each do |player|
+        if @players[player.id]
+          @players[player.id][:vector].x = player.x
+          @players[player.id][:vector].y = player.y
+          @players[player.id][:vector].z = 0
+        else
+          @players[player.id] = {:id => player.id, :vector => GameMachine::Vector.from(player)}
+        end
+      end
+    end
+
+    def check_players
+      get_players
+    end
+
+    def run_ai
+      pick_random_target
+    end
+
+    def pick_random_target
+      @target.x = position.x + rand(-30..30)
+      @target.y = position.y + rand(-30..30)
+      movement.set_target(@target)
+    end
+
+    def update
+      return if dead
+      if movement.has_target
+        if movement.reached_target
+          run_ai
+        end
+      else
+        run_ai
+      end
+
+      movement.update
+    end
+
+  end
+end

data/games/example/lib/npc_group.rb

@@ -0,0 +1,42 @@
+module Example
+  class NpcGroup < GameMachine::Actor::Base
+    include GameMachine::Commands
+
+    attr :npcs
+    def post_init(*args)
+      @npcs = {}
+      group = args.first
+      klass = args.last
+      group.each do |npc_id|
+        npcs[npc_id] = klass.new(npc_id)
+      end
+
+      # schedule_once was not yet in the base actor, needs to be abstracted
+      # out to there
+      unit = java.util.concurrent.TimeUnit::MILLISECONDS
+      @duration = GameMachine::JavaLib::Duration.create(30, unit)
+      @scheduler = get_context.system.scheduler
+      @dispatcher = get_context.system.dispatcher
+      schedule_once('update')
+    end
+
+    def schedule_once(message)
+      @scheduler.schedule_once(@duration, get_self, message, @dispatcher, nil)
+    end
+
+    def on_receive(message)
+      if message == 'update'
+        npcs.each_value do |npc|
+          npc.update
+        end
+        schedule_once('update')
+      elsif message.is_a?(Models::CombatUpdate)
+        if npc = npcs.fetch(message.target,nil)
+          npc.update_combat(message)
+        end
+      end
+
+    end
+
+  end
+end

data/games/example/lib/npc_movement.rb

@@ -0,0 +1,116 @@
+module Example
+  class NpcMovement
+    include GameMachine::Commands
+
+    attr_accessor :updates_between_move
+    attr_reader :current_target, :position, :updates_for_move,
+      :position_changed, :has_target, :last_move, :id,
+      :reached_target, :current_distance_to_target
+    attr_accessor :speed_scale
+    def initialize(id,position)
+      @id = id
+      @position = position
+      @last_move = Time.now.to_f
+      @position_changed = false
+      @has_target = false
+      @reached_target = false
+      @updates_for_move = 0
+      @updates_between_move = 15
+      @speed_scale = 4
+      @current_distance_to_target = 0
+      commands.grid.track(id,position.x,position.y,position.z)
+    end
+
+    def update
+      @position_changed = false
+
+      if has_target && !reached_target
+        if @updates_for_move >= updates_between_move
+          move
+          @updates_for_move = 0
+        end
+      else
+        return
+      end
+
+      # Only update position if we moved
+      if position_changed
+        commands.grid.track(id,position.x,position.y,0)
+        @position_changed = false
+      end
+
+      @updates_for_move += 1
+    end
+
+    def distance_to_target
+      current_distance_to_target
+    end
+
+    def set_target(target)
+      update_target(target)
+      @last_move = Time.now.to_f
+      @has_target = true
+      @reached_target = false
+    end
+
+    def update_target(target)
+      @current_distance_to_target = position.distance(target)
+      @current_target = target
+
+      if current_distance_to_target == 0
+        @reached_target = true
+        return
+      end
+
+      current_distance_to_target
+    end
+
+    def drop_target
+      @current_target = nil
+      @has_target = false
+      @reached_target = false
+      @current_distance_to_target = 0
+    end
+
+    def set_reached_target
+      position.x = current_target.x
+      position.y = current_target.y
+      @reached_target = true
+    end
+
+    def move
+      @current_distance_to_target =  position.distance(current_target)
+      if current_distance_to_target == 0
+        set_reached_target
+        return
+      end
+
+      delta_time = Time.now.to_f - last_move.to_f
+
+      # Save object creation by not using methods that return new vector
+      x = current_target.x - position.x
+      y = current_target.y - position.y
+      dirx = GameMachine::Vector.norm(x)
+      diry = GameMachine::Vector.norm(y)
+      position.x += dirx * speed_scale * delta_time
+      position.y += diry * speed_scale * delta_time
+
+      #direction = (current_target - position).normalize
+      #position.x += direction.x * speed_scale * delta_time
+      #position.y += direction.y * speed_scale * delta_time
+
+      # Not really what we want
+      #position.interpolate(current_target, speed_scale * delta_time)
+
+      if position.distance(current_target) > current_distance_to_target
+        set_reached_target
+      end
+
+      #if id.match(/viking_499/) || id.match(/worm/)
+      #  puts "#{id}: old_distance :#{current_distance_to_target} new_distance: #{position.distance(current_target)} time: #{delta_time}"
+      #end
+      @last_move = Time.now.to_f
+      @position_changed = true
+    end
+  end
+end