teien 0.0.3 → 0.1.0

data/lib/teien/ui/view_object.rb

@@ -0,0 +1,142 @@
+require "teien/animation/animation_operator.rb"
+
+module Teien
+
+class ViewObject
+  # Ogre3D accessor
+  ## center of view objects(sceneNode) and kept to equal with the rigid_body position.
+  attr_accessor :pivot_scene_node 
+  attr_accessor :scene_node
+  attr_accessor :entity
+  attr_accessor :animation_operators
+
+  attr_accessor :object
+
+  def initialize(view)
+    @view = view
+    @pivot_scene_node = nil
+    @scene_node = nil
+    @entity = nil
+    @animation_operators = Hash.new
+    @attached_objects = Hash.new
+    @base_object_manager = Teien::get_component("base_object_manager")
+  end
+
+  def finalize()
+    @pivot_scene_node.remove_child(@scene_node)
+    @view.scene_mgr.destroySceneNode(@scene_node)
+    @view.scene_mgr.get_root_scene_node.remove_child(@pivot_scene_node)
+    @view.scene_mgr.destroySceneNode(@pivot_scene_node)
+    @view.scene_mgr.destroyEntity(@entity)
+  end
+
+  def update_attached_objects(view)
+    # attached
+    @object.attached_objects.each_pair {|key, info|
+      unless @attached_objects[key]
+        attached_object = @base_object_manager.objects[info.object_name]
+        attached_entity = view.objects[attached_object.name].entity
+        attached_scene_node = view.objects[attached_object.name].scene_node
+
+        puts "attached: #{info.bone_name}, #{attached_entity}"
+
+        attached_scene_node.detach_object(attached_entity)
+        tag = @entity.attach_object_to_bone(info.bone_name, attached_entity)
+#        @manager.physics.dynamics_world.remove_rigid_body(obj.rigid_body)
+        attached_object.mode = Teien::BaseObject::MODE_ATTACHED
+        @attached_objects[key] = info
+      end
+    }
+
+    # detached
+    @attached_objects.each_pair {|key, info|
+      unless @object.attached_objects[key]
+        detached_object = @base_object_manager.objects[info.object_name]
+        detached_entity = view.objects[detached_object.name]
+        detached_scene_node = view.objects[detached_object.name].scene_node
+
+        @entity.detach_object_from_bone(detached_entity)
+        detached_scene_node.attach_object(obj.entity)
+=begin
+        if obj.physics_info.collision_filter
+          @manager.physics.dynamics_world.add_rigid_body(obj.rigid_body, 
+                                                         obj.physics_info.collision_filter.group,
+                                                         obj.physics_info.collision_filter.mask)
+        else
+          @manager.physics.dynamics_world.add_rigid_body(obj.rigid_body)
+        end
+=end
+        detached_object.mode = Teien::BaseObject::MODE_FREE
+        @attached_objects.delete(key)
+      end
+    }
+
+
+  end
+
+  def update_animation(delta, animation)
+    animation.operators.each_pair{|key, value|
+      unless @animation_operators[key]
+        @entity.get_skeleton().set_blend_mode(animation.blend_mode)
+        ani_ope = AnimationOperator.new(@entity)
+        ani_ope.init(value.name, value.loop)
+        @animation_operators[key] = ani_ope
+      end
+
+      if (value.name != @animation_operators[key].name ||
+          value.loop != @animation_operators[key].loop)
+        @animation_operators[key].play(value.name, value.loop)
+      end
+      @animation_operators[key].add_time(delta * value.speed)
+    }
+  end
+
+  #
+  # The offset changes the local position of the created scene_node in Object.
+  #
+  def set_scene_node(entity, offset = Vector3D.new(0, 0, 0), rotate = Quaternion.new(0, 0, 0, 1.0))
+    if (@pivot_scene_node == nil)
+      @pivot_scene_node = @view.scene_mgr.get_root_scene_node().create_child_scene_node()
+    end
+    @scene_node = @pivot_scene_node.create_child_scene_node(Vector3D.to_ogre(offset), 
+                                                            Quaternion.to_ogre(rotate))
+    @pivot_scene_node.instance_variable_set(:@child, @scene_node) # prevent this from GC.
+
+    if entity
+      @scene_node.attach_object(entity)
+      @entity = entity
+    end
+
+    return @scene_node
+  end
+
+  #
+  # handlers of BaseObject
+
+  def set_position(aPos)
+    if @pivot_scene_node
+      @pivot_scene_node.set_position(aPos.x, aPos.y, aPos.z)
+    else
+      # object_info.class == LightObjectInfo
+      @entity.set_position(Vector3D.to_ogre(aPos))
+    end
+  end
+
+  def set_world_transform(transform)
+    newPos = transform.get_origin()
+    newRot = transform.get_rotation()
+    # puts "newRot(#{id}: #{newRot.x}, #{newRot.y}, #{newRot.z}, #{newRot.w})"
+    # puts "newPos(#{id}: #{newPos.x}, #{newPos.y}, #{newPos.z})"
+    
+    return if (newRot.x.nan?)
+    
+    @pivot_scene_node.set_position(newPos.x, newPos.y, newPos.z) 
+    @pivot_scene_node.set_orientation(newRot.w, newRot.x, newRot.y, newRot.z)
+  end
+
+  def set_rotation(rot)
+    @pivot_scene_node.set_orientation(Quaternion.to_ogre(rot))
+  end
+end
+
+end

data/lib/teien/ui/view_object_factory.rb

@@ -0,0 +1,23 @@
+require 'teien/base_object/base_object'
+require 'teien/ui/view_object'
+
+module Teien
+
+class ViewObjectFactory
+  @creators = Hash.new
+
+  def self.create_object(obj, view)
+    if @creators[obj.object_info.class] != nil
+      return @creators[obj.object_info.class].call(obj, view)
+    else
+      puts "not a supported object: #{obj.object_info.class}"
+      return nil
+    end
+  end
+
+  def self.set_creator(info_klass, creator)
+    @creators[info_klass] = creator
+  end
+end
+
+end

data/lib/teien/version.rb

@@ -1,3 +1,3 @@
 module Teien
-  VERSION = "0.0.3"
+  VERSION = "0.1.0"
 end

data/lib/teien.rb

@@ -7,82 +7,7 @@ require "ois.so"
 require "ogrebites.so"
 require "teienlib.so"
 
-require "teien/tools.rb"
-require 'teien/object_info'
-require 'teien/physics_info'
-require 'teien/animation'
-require 'teien/smooth_mover'
-require "teien/garden.rb"
-require "teien/model.rb"
-require "teien/controller.rb"
-require "teien/ai.rb"
+require "teien/core/tools.rb"
+require "teien/core/component_manager"
+require "teien/core/event_router"
 
-module Teien
-
-def self.start_server_garden(ip, port, sync_period = 0.5)
-  require "teien/synchronizer"
-
-  cwd = Dir.getwd
-  Dir.glob("#{cwd}/app/models/*.rb") {|file|
-    require "#{file}"
-  }
-
-  garden = Teien::Garden.new()
-  Teien::Model::load(garden)
-#  garden_script = garden_script_klass.new(garden)
-  sync = Synchronizer.new(garden, sync_period)
-  garden.run(ip, port)
-end
-
-def self.start_client_garden(ip, port)
-  require "teien/proxy_garden.rb"
-  require 'teien/user_interface'
-
-  cwd = Dir.getwd
-  Dir.glob("#{cwd}/app/controllers/*.rb") {|file|
-    require "#{file}"
-  }
-
-  garden = Teien::ProxyGarden.new()
-  ui = Teien::UserInterface.new(garden)
-  Teien::Controller::load(garden, ui)
-#  controller_script = controller_script_klass.new(garden, ui)  
-  garden.run(ip, port)
-end
-
-def self.start_ai_garden(ip, port)
-  require "teien/proxy_garden.rb"
-
-  cwd = Dir.getwd
-  Dir.glob("#{cwd}/app/ais/*.rb") {|file|
-    require "#{file}"
-  }
-
-  garden = Teien::ProxyGarden.new()
-  Teien::Ai::load(garden)
-  garden.run(ip, port)
-end
-
-
-def self.start_local_garden()
-  require_relative 'teien/user_interface'
-
-  pid = Process.fork {
-    start_server_garden("0.0.0.0", 11922, 0.1)
-  }
-  begin
-    start_client_garden("0.0.0.0", 11922)
-  ensure
-    Process.kill("TERM", pid)
-  end
-  
-=begin
-  garden = Teien::Garden.new()
-  ui = Teien::UserInterface.new(garden)
-  garden_script = garden_script_klass.new(garden)
-  controller_script = controller_script_klass.new(garden, ui)
-  garden.run
-=end
-end
-
-end

data/mods/actor/addons/sinbad/lib/sinbad/sinbad_info.rb

@@ -0,0 +1,16 @@
+require "teien/actor/actor_info"
+
+class SinbadInfo < Teien::ActorInfo
+  attr_accessor :object_name
+
+  def initialize(actor_name)
+    @actor_name = actor_name
+    @object_name = nil
+  end
+
+  def self.create_actor(sinbad_info)
+    Sinbad.new(sinbad_info)
+  end
+
+  Teien::ActorFactory::register_creator(self, self.method(:create_actor))
+end

data/{sample/actor/app/helpers → mods/actor/addons/sinbad/lib}/sinbad/sinbad_state.rb

@@ -5,13 +5,11 @@ class SinbadState
     @stateHash = {}
     @stateHash["Stop"] = Stop.new(parent)
     @stateHash["Run"] = Run.new(parent)
-    @stateHash["GravityFree"] = GravityFree.new(parent)
     @stateHash["InAir"] = InAir.new(parent)
     @stateHash["Jump"] = Jump.new(parent)
     @stateHash["JumpLoop"] = JumpLoop.new(parent)
     @stateHash["JumpEnd"] = JumpEnd.new(parent)
     set_state("Stop")
-
   end
 
   def set_state(state)
@@ -20,9 +18,7 @@ class SinbadState
       @state.fini() if (@state != nil)
       @prevState = @state
       @state = nextState
-
-      puts state 
-
+#      puts state 
       @state.init() if(@state != nil)
       return true
     end
@@ -58,7 +54,7 @@ class SinbadState
     def init()
       @parent.play_top_animation("IdleTop")
       @parent.play_base_animation("IdleBase")
-#      @parent.object.set_damping(0.9, 0)
+      @parent.object.set_damping(0.9, 0)
     end
     def update(delta)
       unless @parent.check_on_ground()
@@ -83,11 +79,16 @@ class SinbadState
     def init()
       @parent.play_top_animation("RunTop")
       @parent.play_base_animation("RunBase")
-#      @parent.object.set_damping(0.0, 0)
+      @parent.object.set_damping(0.0, 0)
       @parent.object.set_max_horizontal_velocity(17.0)
     end
 
     def update(delta)
+      unless @parent.check_on_ground()
+        @parent.state.set_state("InAir")
+        return
+      end
+
       @parent.mover.update_target(delta)
       unless (@parent.mover.moving?())
         @parent.state.set_state("Stop")
@@ -98,33 +99,6 @@ class SinbadState
     end
   end
 
-  class GravityFree
-    def initialize(parent)
-      @parent = parent
-    end
-
-    def init()
-      @parent.play_top_animation("IdleTop")
-      @parent.play_base_animation("IdleBase")
-#      @parent.object.set_damping(0, 0)
-
-      grav = @parent.object.get_gravity()
-      puts "gravity: (#{grav.x}, #{grav.y}, #{grav.z})"
-      @parent.object.set_gravity(Vector3D.new(0, 0, 0))
-
-      @parent.mover = @parent.grav_mover
-    end
-
-    def update(delta)
-      @parent.mover.update_target(delta)
-    end
-
-    def fini()
-      @parent.object.set_gravity(Vector3D.new(0, -9.8, 0))
-      @parent.mover = @parent.sm_mover
-    end
-  end
-
   class InAir
     def initialize(parent)
       @parent = parent
@@ -133,7 +107,7 @@ class SinbadState
     def init()
       @parent.play_top_animation("IdleTop")
       @parent.play_base_animation("IdleBase")
-#      @parent.object.set_damping(0, 0)
+      @parent.object.set_damping(0, 0)
 
       @parent.object.set_gravity(Vector3D.new(0, -9.8, 0))
     end
@@ -156,10 +130,11 @@ class SinbadState
     def init()
       @parent.play_top_animation("IdleTop")
       @parent.play_base_animation("JumpStart")
-#      @parent.object.set_damping(0, 0)
+      @parent.object.set_damping(0, 0)
 
       @parent.object.set_gravity(Vector3D.new(0, -9.8, 0))
-      @parent.object.set_acceleration(Vector3D.new(0, 39.8, 0))
+#      @parent.object.set_acceleration(Vector3D.new(0, 39.8, 0))
+      @parent.object.set_acceleration(Vector3D.new(0, 60, 0))
       @timer = 0
     end
 
@@ -184,7 +159,7 @@ class SinbadState
     def init()
       @parent.play_top_animation("IdleTop")
       @parent.play_base_animation("JumpLoop")
-#      @parent.object.set_damping(0, 0)
+      @parent.object.set_damping(0, 0)
       @parent.object.set_acceleration(Vector3D.new(0, 0.0, 0))
     end
 
@@ -207,7 +182,7 @@ class SinbadState
     def init()
       @parent.play_top_animation("IdleTop")
       @parent.play_base_animation("JumpEnd")
-#      @parent.object.set_damping(0, 0)
+      @parent.object.set_damping(0, 0)
 
       @parent.object.set_gravity(Vector3D.new(0, -9.8, 0))
     end

data/mods/actor/addons/sinbad/lib/sinbad.rb

@@ -0,0 +1,180 @@
+require_relative "sinbad/sinbad_state"
+require_relative "sinbad/sinbad_info"
+
+class ClosestNotMe < Bullet::ClosestRayResultCallback
+  def initialize(rb)
+    super(Bullet::BtVector3.new(0.0, 0.0, 0.0), Bullet::BtVector3.new(0.0, 0.0, 0.0))
+    @rigidBody = rb
+  end
+
+  def add_single_result(rayResult, normalInWorldSpace)
+    return 1.0 if (rayResult.m_collisionObject == @rigedBody)
+    return super(rayResult, normalInWorldSpace)
+  end
+end
+
+
+include Teien
+
+require "teien/action_model/smooth_moving"
+
+class Sinbad < Teien::Actor
+  attr_accessor :object
+  attr_accessor :actor
+  attr_accessor :mover
+  attr_accessor :state
+
+  def initialize(sinbad_info)
+    @base_object_manager = Teien::get_component("base_object_manager")
+
+    build_object(sinbad_info)
+
+    @mover = SmoothMoving.new(@object.name)
+    @mover.acceleration = 50
+
+    @state = SinbadState.new(self)
+  end
+
+  def finalize()
+    @base_object_manager.objects.delete(@object.name)
+    @base_object_manager.objects.delete("SinbadSword1")
+    @base_object_manager.objects.delete("SinbadSword2")
+    @object.finalize()
+  end
+
+
+  def dump_event()
+    return Event::SyncSinbad.new(self)
+  end
+
+
+  def self.load_event(base_object_manager, actors, event)
+    actor = actors[event.actor_name]
+    if actor == nil
+      actor = Sinbad.new(base_object_manager, event.actor_name)
+    else
+      actor = actors[event.actor_name]
+    end
+
+    return actor
+  end
+
+  def build_object(sinbad_info)
+    @name = sinbad_info.actor_name
+
+    if sinbad_info.object_name
+      @object = @base_object_manager.objects[sinbad_info.object_name]
+      @animation = Teien::get_component("animation_manager").animations[@object.name]
+    else
+      object_info = MeshBBObjectInfo.new("sinbad.mesh", Vector3D.new(1.0, 1.0, 1.0))
+      object_info.scale = Vector3D.new(1.0 / 2.0, 1.0 / 2.0, 1.0 / 2.0)
+      object_info.physics_offset = Vector3D.new(0, 1.0, 0)
+      object_info.view_offset = Vector3D.new(0, 2.5, 0)
+      object_info.view_rotation = Quaternion.new(Vector3D.new(0, 1, 0), Ogre::Degree.new(180.0).value_radians)
+      physics_info = PhysicsInfo.new(1.0)
+      physics_info.angular_factor = 0
+      physics_info.restitution = 0.5
+      physics_info.friction = 0.5
+      physics_info.linear_damping = 0.5
+      physics_info.angular_damping = 0
+      @object = @base_object_manager.create_object(@name, object_info, physics_info)
+      @object.set_position(Vector3D.new(0, 0, 0))
+
+      event = Teien::Event::BaseObject::SyncObject.new(@object)
+      Teien::get_component("event_router").send_event(event)
+      
+      @animation = Teien::get_component("animation_manager").create_animation(@object.name)
+      @animation.create_operator("TopAnim", "IdeleTop", 1.0, true)
+      @animation.create_operator("BaseAnim", "IdleBase", 1.0, true)
+      @animation.create_operator("HandsAnim", "HandsRelaxed", 1.0, true)
+
+      event = Teien::Event::Animation::SyncAnimation.new(@object.name, @animation)
+      Teien::get_component("event_router").send_event(event)
+    end
+
+
+    # swords
+    object_info = MeshObjectInfo.new("Sword.mesh")
+    object_info.scale = Vector3D.new(1.0 / 2.0, 1.0 / 2.0, 1.0 / 2.0)
+    @sword1 = @base_object_manager.create_object("SinbadSword1", object_info)
+    @object.attach_object_to_bone("Sheath.L", @sword1)
+
+    object_info = MeshObjectInfo.new("Sword.mesh")
+    object_info.scale = Vector3D.new(1.0 / 2.0, 1.0 / 2.0, 1.0 / 2.0)
+    @sword2 = @base_object_manager.create_object("SinbadSword2", object_info)
+    @object.attach_object_to_bone("Sheath.R", @sword2)
+  end
+
+  def receive_event(event, from)
+  end
+
+  def update(delta)
+      @state.update(delta) if @state
+  end
+
+  def check_on_ground()
+    rayCallback = ClosestNotMe.new(@object.physics_object.rigid_body)
+    rayCallback.m_closestHitFraction = 1.0
+    src = @object.get_position() + Vector3D.new(0, 0.1, 0)
+    tgt = src + Vector3D.new(0, -0.2, 0)
+
+#    puts "src(#{src.x}, #{src.y}, #{src.z})"
+#    puts "tgt(#{tgt.x}, #{tgt.y}, #{tgt.z})"
+
+    @base_object_manager.physics.dynamics_world.ray_test(src, tgt, rayCallback)
+    return true if (rayCallback.has_hit())
+    return false
+  end
+
+  def set_forward_direction(dir)
+    @mover.set_forward_direction(dir)
+  end
+
+  def move_forward(bl)
+    @mover.move_forward(bl)
+  end
+
+  def move_backward(bl)
+    @mover.move_backward(bl)
+  end
+
+  def move_left(bl)
+    @mover.move_left(bl)
+  end
+
+  def move_right(bl)
+    @mover.move_right(bl)
+  end
+
+  def jump(bl)
+    if bl
+      unless @state.state?("JumpLoop")
+        @state.set_state("Jump")
+      end
+    end
+  end
+
+  def action_left()
+    @object.detach_object_from_bone(@sword1)
+    #@state.set_state("Kick")
+  end
+
+  def action_right
+    @state.set_state("Attack")
+  end
+
+  def play_top_animation(name, loop = true)
+    @animation.operators["TopAnim"].name = name
+    @animation.operators["TopAnim"].loop = loop
+  end
+
+  def play_base_animation(name, loop = true)
+    @animation.operators["BaseAnim"].name = name
+    @animation.operators["BaseAnim"].loop = loop
+  end
+
+  def play_hands_animation(name, loop = true)
+    @animation.operators["HandsAnim"].name = name
+    @animation.operators["HnadsAnim"].loop = loop
+  end
+end