spark.rb

rcssserver3d Robocup 3D比赛官方指定平台

#
# spark.rb, setup kerosin application framework
#

#
# define constants used to setup spark
#

# scene and server path
$scenePath = '/usr/scene/'
$serverPath = '/sys/server/'

# (Inputsystem)
#

# the default InputSystem used to read keyboard, mouse and timer input
$defaultInputSystem = 'InputSystemSDL'

# the name of the default bundle that contains the default InputSystem
$defaultInputSystemBundle = 'inputsdl'

# (OpenGL rendering)
#

# the default OpenGLSystem used for rendering
$defaultOpenGLSystem = 'OpenGLSystemSDL'

# the name of the bundle that contains the default OpenGLSystem
$defaultOpenGLBundle = 'openglsyssdl'

#
# (AgentControl) constants
#
$agentStep = 0.02
$agentType = 'tcp'
$agentPort = 3100

# (MonitorControl) constants
#

# define the monitor update interval in cycles
$renderStep = 0.04
$monitorLoggerStep = 0.2;
$monitorStep = 0.04
$serverType = 'tcp'
$serverPort = 3200

# (SparkMonitorClient) constants
#
$monitorServer = '127.0.0.1'
$monitorPort = 3200
# socket type ('tcp' or 'udp')
$monitorType = 'tcp'

# (Global Physics / World) constants
#
$physicsGlobalCFM = 0.00001
$physicsGlobalGravity = -9.81

#
# below is a set of utility functions for the user app
#

# return the existing instance or create a new one
def sparkGetOrCreate(className, path)
  obj = get(path)

  if (obj != nil)
    return obj
  end

  #print "(spark.rb) creating "
  #print className
  #print " instance at "
  #print path
  #print "\n"

  return new(className, path)
end

# delete any existing instance and create a new one
def sparkCreate(className, path)
  delete(path)

  #print "(spark.rb) creating "
  #print className
  #print " instance at "
  #print path
  #print "\n"

  return new(className, path)
end

def sparkGetMonitorServer
  return sparkGetOrCreate('oxygen/MonitorServer', $serverPath+'monitor')
end

def sparkGetPhysicsServer
  return sparkGetOrCreate('oxygen/PhysicsServer', $serverPath+'physics')
end

def sparkGetSceneServer
  return sparkGetOrCreate('oxygen/SceneServer', $serverPath+'scene')
end

def sparkGetGameControlServer
  return sparkGetOrCreate('oxygen/GameControlServer', $serverPath+'gamecontrol')
end

def sparkGetSimulationServer
  return sparkGetOrCreate('oxygen/SimulationServer', $serverPath+'simulation')
end

def sparkGetGeometryServer
  return sparkGetOrCreate('oxygen/GeometryServer', $serverPath+'geometry')
end

def sparkGetMaterialServer
  return sparkGetOrCreate('kerosin/MaterialServer', $serverPath+'material')
end

def sparkGetOpenGLServer
  return sparkGetOrCreate('kerosin/OpenGLServer', $serverPath+'opengl')
end

def sparkGetInputServer
  return sparkGetOrCreate('kerosin/InputServer', $serverPath+'input')
end

def sparkGetFontServer
  return sparkGetOrCreate('kerosin/FontServer', $serverPath+'font')
end

def sparkGetRenderServer
  return sparkGetOrCreate('kerosin/RenderServer', $serverPath+'render')
end

def sparkGetImageServer
  return sparkGetOrCreate('kerosin/ImageServer', $serverPath+'image')
end

def sparkGetTextureServer
  return sparkGetOrCreate('kerosin/TextureServer', $serverPath+'texture')
end


# rebuild scene and update all cached references
def sparkResetScene
  scene = get($scenePath)
  if (scene != nil)
    scene.unlinkChildren()
  end

  # (re-)create world and space aspects
  world = new('oxygen/World', $scenePath+'world')
  world.setGravity(0.0, 0.0, $physicsGlobalGravity)
  world.setCFM($physicsGlobalCFM)
  world.setAutoDisableFlag(true)             #not in simspark
  world.setContactSurfaceLayer(0.001)	     #not in simspark

  new('oxygen/Space', $scenePath+'space')

  # invalidate all cached references
  scriptServer = get($serverPath+'script')
  if (scriptServer != nil)
    scriptServer.updateCachedAllNodes()
  end

  # force update references to scene objects (world, space etc.)
  sceneServer = sparkGetSceneServer()
  if (sceneServer != nil)
    sceneServer.setActiveScene($scenePath)
  end

  # reset material definitions
  materialServer = sparkGetMaterialServer()
  materialServer.resetMaterials()

  # reset simulation time
  simulationServer = sparkGetSimulationServer()
  if (simulationServer != nil)
    simulationServer.resetTime()
  end
end

def sparkSetupMonitor
  print "(spark.rb) sparkSetupMonitor\n"

  # add the agent control node
  simulationServer = sparkGetSimulationServer()
  if (simulationServer != nil)
    simulationServer.setMultiThreads(false)
  end

  monitorClient = sparkCreate('SparkMonitorClient', $serverPath+'simulation/SparkMonitorClient')
  monitorClient.setServer($monitorServer)
  monitorClient.setPort($monitorPort)

  if ($monitorType == 'udp')
    monitorClient.setClientTypeUDP()
  else if ($monitorType == 'tcp')
	 monitorClient.setClientTypeTCP()
       else
	 print "(spark.rb) unknown monitor socket type "
	 print $monitorType
	 print "\n"
       end
  end

  rubySceneImporter = get($serverPath+'scene/RubySceneImporter')
  if (rubySceneImporter != nil)
    rubySceneImporter.setUnlinkOnCompleteScenes(true);
  end
end

def sparkSetupMonitorLogPlayer
  print "(spark.rb) sparkSetupMonitorLogPlayer\n"

  simulationServer = sparkGetSimulationServer()
  if (simulationServer != nil)
    simulationServer.setMultiThreads(false)

    monitorClient = sparkCreate('SparkMonitorLogFileServer', $serverPath+'simulation/SparkMonitorLogFileServer')

    monitorClient.setFileName($logPlayerFile)
    monitorClient.setStepDelay(33000)
  end

  rubySceneImporter = get($serverPath+'scene/RubySceneImporter')
  if (rubySceneImporter != nil)
    rubySceneImporter.setUnlinkOnCompleteScenes(true);
  end
end

#
# install a class below the SparkMonitorClient that implementes the
# simulation specific monitor processing
#
def sparkRegisterCustomMonitor(className)
  print "(spark.rb) sparkRegisterCustomMonitor " + className + "\n"
  sparkGetSimulationServer()
  sparkCreate(className, $serverPath+'simulation/SparkMonitorClient/'+className)
end

#
# install a class below the Spark RenderControl node that implements
# application specific render logic
#
def sparkRegisterCustomRender(className)
  print "(spark.rb) sparkRegisterCustomRender " + className + "\n"
  sparkGetSimulationServer()
  sparkCreate(className, $serverPath+'simulation/RenderControl/'+className)
end

#
# install a class below the Spark InputControl node that implements
# application specific input processing
#
def sparkRegisterCustomInput(className)
  print "(spark.rb) sparkRegisterCustomInput " + className + "\n"
  sparkGetSimulationServer()
  sparkCreate(className, $serverPath+'simulation/InputControl/'+className)
end

#
# install a class below the Spark MonitorSystem node that parses
# commands received from a monitor client
#
def sparkRegisterMonitorCmdParser(className)
  print "(spark.rb) sparkRegisterMonitorCmdParser " + className + "\n"
  sparkGetMonitorServer()
  sparkCreate(className, $serverPath+'monitor/SparkMonitor/'+className)
end

def sparkSetupServer
  print "(spark.rb) sparkSetupServer\n"

  # add the agent control node
  simulationServer = sparkGetSimulationServer()

  if (simulationServer != nil)
    simulationServer.setMultiThreads(false);
    simulationServer.initControlNode('oxygen/AgentControl','AgentControl')

    # set auto speed adjust mode.
    # a smaller value for MaxStepsPerCycle is recommended specially for slow systems
    simulationServer.setAdjustSpeed(true)
    simulationServer.setMaxStepsPerCyle(3)
  end

  # set port and socket type for agent control
  agentControl = get($serverPath+'simulation/AgentControl');

  if (agentControl != nil)
    agentControl.setServerPort($agentPort)
    agentControl.setStep($agentStep)
  end

  if ($agentType == 'udp')
	agentControl.setServerTypeUDP()
  else if ($agentType == 'tcp')
	agentControl.setServerTypeTCP()
       else
	 print "(spark.rb) unknown agent socket type "
	 print $agentType
	 print "\n"
       end
  end