spark.rb

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

  monitorControl = sparkCreate('oxygen/MonitorControl',$serverPath+'simulation/MonitorControl')
  monitorControl.setStep($monitorStep)
  monitorControl.setServerPort($serverPort)

  if ($serverType == 'udp')
    monitorControl.setServerTypeUDP()
  else if ($serverType == 'tcp')
	 monitorControl.setServerTypeTCP()
       else
	 print "(spark.rb) unknown monitor socket type "
	 print $serverType
	 print "\n"
       end
  end

  #
  # log recording setup

  if ($recordLogfile == true)
    print "(spark.rb) recording Logfile as 'sparkmonitor.log'\n"
    monitorLogger = sparkCreate('oxygen/MonitorLogger', $serverPath+'simulation/MonitorLogger')
    monitorLogger.setStep($monitorLoggerStep)
  end
end

def sparkSetupRendering(openGLSystem = $defaultOpenGLSystem)
  print "(spark.rb) sparkSetupRendering\n"
  print "(spark.rb) using OpenGLSystem '" + openGLSystem + "'\n"

  #
  # setup the kerosin render framework

  openGLServer = sparkGetOpenGLServer()

  if (openGLSystem == $defaultOpenGLSystem)
    importBundle($defaultOpenGLBundle)
  end

  openGLServer.init(openGLSystem)

  sparkGetRenderServer()
  sparkGetImageServer()
  sparkGetTextureServer()

  #
  # setup the InputServer

  # create the InputServer and use a german keyboard layout
  inputServer = sparkGetInputServer()
  inputServer.setScanCodeMapping('german.scan.rb');

  # setup the FontServer
  sparkGetFontServer()

  #
  # register render control node to the simulation server
  simulationServer = sparkGetSimulationServer()

  if (simulationServer != nil)
    simulationServer.initControlNode('kerosin/RenderControl','RenderControl')
  end

  renderControl = get($serverPath+'simulation/RenderControl')
  if (renderControl != nil)
    renderControl.setStep($renderStep)
  end
end

def sparkSetupInput(inputSystem = $defaultInputSystem)
  print "(spark.rb) sparkSetupInput\n"
  print "(spark.rb) using InputSystem '" + inputSystem + "'\n"

  # setup the SDL input system
  if (inputSystem == $defaultInputSystem)
    importBundle($defaultInputSystemBundle)
  end

  inputServer = sparkGetInputServer()
  if (inputServer != nil)
    inputServer.init(inputSystem)

    # add devices
    inputServer.createDevice('Timer')
    inputServer.createDevice('Keyboard')
    inputServer.createDevice('Mouse')
  end

  #
  # register input control node to the simulation server

  simulationServer = sparkGetSimulationServer()
  if (simulationServer != nil)
    # add the input control node
    simulationServer.initControlNode('kerosin/InputControl','InputControl')
  end
end

def sparkSetupTrain()
  print "(spark.rb) sparkSetupTrain\n"
  #
  # register train control node to the simulation server

  simulationServer = sparkGetSimulationServer()
  if (simulationServer != nil)
    # add the train control node
    simulationServer.initControlNode('oxygen/TrainControl','TrainControl')
  end
end

# add a camera with an FPS Controller to the scene at path
def sparkAddFPSCamera(
		      path,
		      x = 0.0, y = 0.0, z = 4,
		      vAngle = 45.0,
                      hAngle = 10.0,
		      maxSpeed = 15.0,
		      accel = 40.0,
		      drag = 4,
		      addCollider = false,
		      colliderRadius = 2.0,
                      znear = 0.1
		      )

  print "(spark.rb) sparkAddFPSCamera at " + path + "\n"

  # add a camera. The camera movement is controlled using an
  # FPSController.
  cameraTransform = sparkCreate('oxygen/Transform',path)
  cameraTransform.setLocalPos(x,y,z)
  camera = new('oxygen/Camera',path+'/camera')
  camera.setZNear(znear)

  # the camera is not affected by gravity but restricted to a maximum
  # speed
  body = new('oxygen/Body',path+'/physics')
  body.useGravity(false);
  velCtr = new('oxygen/VelocityController',path+'/physics/velctr')
  velCtr.setMaxVelocity(maxSpeed)

  # add an FPSController to move the camera and set the applied
  # acceleration
  fpsController = new('oxygen/FPSController',path+'/physics/controller')
  fpsController.setAcceleration(accel)
  fpsController.setVAngle(vAngle)
  fpsController.setHAngle(hAngle)

  inputControl = get($serverPath+'simulation/InputControl')
  if (inputControl != nil)
    inputControl.setFPSController(path+'/physics/controller')
  end

  # add an DragController to work against the camera acceleration
  dragController = new('oxygen/DragController',path+'/physics/drag')
  dragController.setLinearDrag(drag)

  if addCollider
    # add an Collider that allows the camera to push objects
    collider = new('oxygen/SphereCollider', path+'/geometry')
    collider.setRadius(colliderRadius)

    handler = new('oxygen/ContactJointHandler', path+'geometry/contact')
    handler.setContactBounceMode true
    handler.setMinBounceVel 2
  end
end

#
# registers a new logTarget to the LogServer
#
# valid logTarget value are ':cout' and ':cerr' for stdout and stderr
# output, as well as any other file name, e.g. 'log.txt'
#
# logType denotes the debug to be attached to the
# logtarget. Valid streams are 'eNone', 'eDebug' and 'eWarning'
#
def sparkEnableLog(logTarget, logType)
  print "(spark.rb) sparkEnableLog logTarget="+logTarget+" logType="+logType+"\n"

  logServer = get($serverPath+'log')
  if (logServer != nil)
    logServer.addStream(logTarget, logType)
  end
end

# deregisters all output stream
def sparkResetLogging()
  print "(spark.rb) sparkResetLogging removing all log targets\n";

  logServer = get($serverPath+'log')
  if (logServer != nil)
    logServer.removeAllStreams()
  end
end


# logs all error output to cerr
def sparkLogErrorToCerr()
  sparkEnableLog(':cerr', 'eError')
end

# logs all debug output to cerr
def sparkLogDebugToCerr()
  sparkEnableLog(':cerr', 'eDebug')
end

# logs all output to cerr
def sparkLogAllToCerr()
  sparkEnableLog(':cerr', 'eAll')
end

# logs all error output to 'fileName'
def sparkLogErrorToFile(fileName)
  sparkEnableLog(fileName, 'eError')
end

# logs all debug output to 'fileName'
def sparkLogDebugToFile(fileName)
  sparkEnableLog(fileName, 'eDebug')
end

# logs all output to 'fileName'
def sparkLogAllToFile(fileName)
  sparkEnableLog(fileName, 'eAll')
end

# register an integrated agent
def addIntegratedAgent(agentType, number)
  sparkGetOrCreate(agentType, "/usr/agent/behavior#{number}")
end

#
# setup spark
#

print "(spark.rb) setup\n"

#
# set up logging
logServer = get($serverPath+'log')

if (logServer != nil)
  logServer.addStream(':cerr', 'eError')
end

#
# setup the PhysicsServer
sparkGetPhysicsServer()

#
# setup the SceneServer
sceneServer = sparkGetSceneServer()
sceneServer.createScene($scenePath)

#
# setup the GeometryServer
importBundle 'voidmeshimporter'
importBundle 'objimporter'

geometryServer = sparkGetGeometryServer()
geometryServer.initMeshImporter("VoidMeshImporter");
geometryServer.initMeshImporter("ObjImporter");

# use the ruby scene importer to import scenes
importBundle 'rubysceneimporter'
sceneServer.initSceneImporter("RubySceneImporter");

# use the ros scene importer to import scenes
importBundle 'rosimporter'
sceneServer.initSceneImporter("RosImporter");

#
# setup the MaterialServer
sparkGetMaterialServer()

#
# setup the MonitorServer
monitorServer = sparkGetMonitorServer()

# register the SparkMonitor system
importBundle 'sparkmonitor'
monitorServer.registerMonitorSystem('SparkMonitor')

#
# setup the GameControlServer
gameControlServer = sparkGetGameControlServer()

# register the s-expression parser to the GameControlServer
importBundle "sexpparser"
gameControlServer.initParser('SexpParser')

# register the SceneEffector to the GameControlServer
importBundle "sceneeffector"
gameControlServer.initEffector('SceneEffector')

# prepare scene
sparkResetScene()

#
# import the spark perceptors and effector set
importBundle "sparkagent"

#
importBundle "gyrorateperceptor"

#
importBundle "collisionperceptor"