void TestDetector::detectOneObject() { InternalMessage("Model","Model::TestDetector::detectOneObject entering") ; /*! We create a ship with a detector and a second object to detect. */ std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestDetector::detectOneObject")) ; model->init() ; Kernel::Object* system = model->createObject() ; Kernel::Object* ship = system->createObject() ; ship->addTrait(new Positioned()) ; ship->addTrait(new Oriented()) ; ship->addTrait(new Mobile()) ; ship->addTrait(new Solid(Mesh("test_ship.mesh"))) ; ship->addTrait(new Massive(Mass::Kilogram(1000))) ; ship->addTrait(new Computer()) ; ship->addTrait(new Detector()) ; Detector::connect(ship,ship) ; Kernel::Object* ship2 = system->createObject() ; ship2->addTrait(new Positioned(Position::Meter(0,0,500))) ; ship2->addTrait(new Massive(Mass::Kilogram(1000))) ; ship2->addTrait(new Oriented()) ; ship2->addTrait(new Mobile()) ; ship2->addTrait(new Solid(Mesh("test_ship.mesh"))) ; std::set<Kernel::Object*> detected(ship->getTrait<Computer>()->getDetectedObjects()) ; CPPUNIT_ASSERT(!detected.empty()) ; CPPUNIT_ASSERT(detected.find(ship2) != detected.end()) ; InternalMessage("Model","Model::TestDetector::detectOneObject leaving") ; }
void TestMenu::mouseCursor() { InternalMessage("Input","Input::TestMenu::mouseCursor entering") ; std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestMenu::mouseCursor")) ; model->init() ; Kernel::Object* menu = model->createObject() ; menu->addTrait(new Model::Menu("Demo7Windows.layout")) ; Kernel::Object* observer = model->createObject() ; observer->addTrait(new Model::Observer()) ; observer->addTrait(new Model::Player()) ; observer->addTrait(new Model::Positionned()) ; Kernel::Timer timer ; Kernel::Timer global_timer ; while (global_timer.getSecond() < 20) { float seconds = timer.getSecond() ; if (seconds != 0) { timer.reset() ; } model->update(seconds) ; } InternalMessage("Input","Input::TestMenu::mouseCursor leaving") ; }
void TestLaser::beamEnergy() { InternalMessage("Model","Model::TestLaser::beamEnergy entering") ; // we construct a complete system std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestLaser::testFire")) ; model->init() ; // should be a PhysicalWorld Kernel::Object* system = model->createObject() ; CPPUNIT_ASSERT(system->getTrait<PhysicalWorld>()) ; Kernel::Object* ship = system->createObject() ; ship->addTrait(new Positionned()) ; ship->addTrait(new Oriented()) ; ship->addTrait(new Mobile()) ; ship->addTrait(new Massive(Mass::Kilogram(1000))) ; ship->addTrait(new Laser(Position(),Orientation(),Energy::Joule(10))) ; CPPUNIT_ASSERT(ship->getTrait<PhysicalObject>()) ; CPPUNIT_ASSERT(ship->getTrait<PhysicalWorld>()) ; CPPUNIT_ASSERT(system->getChildren().size()==1) ; InternalMessage("Model","built ship") ; ship->call("fire") ; InternalMessage("Model","fire") ; CPPUNIT_ASSERT(system->getDescendants<LaserBeam>().size()==1) ; CPPUNIT_ASSERT(system->getDescendants<Shot>().size()==1) ; std::set<LaserBeam*> beams = system->getDescendants<LaserBeam>() ; LaserBeam* beam = *(beams.begin()) ; CPPUNIT_ASSERT(beam->getEnergy().Joule()==10) ; }
void TestAgent::steeringFullBackShouldTurn() { std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestAgent::steeringFullBackShouldTurn")) ; model->init() ; Kernel::Object* system = model->createObject() ; system->addTrait(new Model::StellarSystem()) ; system->addTrait(new Model::Positioned()) ; Kernel::Object* ship = Model::createShip(system) ; Kernel::Object* agent = Model::createAI(ship) ; Implementation::Agent* agent_controler = getAgentController(agent) ; /* should perform a full turn : <-- --> ship steering => x or y command should be not null. */ // agent_controler->m_steering = Ogre::Vector3::UNIT_Z ; Ogre::Vector3 command(agent_controler->calculateSteeringCommands(0.1)) ; CPPUNIT_ASSERT_MESSAGE("ship should turn",command.x != 0 || command.y != 0) ; }
void TestDetector::testComputerDestruction() { InternalMessage("Model","Model::TestDetector::testComputerDestruction entering") ; /*! We create a ship with a detector and a second object to detect. */ std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestDetector::testComputerDestruction")) ; model->init() ; Kernel::Object* system = model->createObject() ; Kernel::Object* ship = system->createObject() ; ship->addTrait(new Positioned()) ; ship->addTrait(new Oriented()) ; ship->addTrait(new Mobile()) ; ship->addTrait(new Solid(Mesh("test_ship.mesh"))) ; ship->addTrait(new Massive(Mass::Kilogram(1000))) ; ship->addTrait(new Computer()) ; ship->addTrait(new Detector()) ; Detector::connect(ship,ship) ; Kernel::Object* ship2 = system->createObject() ; ship2->addTrait(new Positioned(Position::Meter(0,0,500))) ; ship2->addTrait(new Massive(Mass::Kilogram(1000))) ; ship2->addTrait(new Oriented()) ; ship2->addTrait(new Mobile()) ; ship2->addTrait(new Solid(Mesh("test_ship.mesh"))) ; InternalMessage("Model","Model::TestDetector::testComputerDestruction destroying computer") ; ship->destroyTrait(ship->getTrait<Computer>()) ; model->update(0.1) ; InternalMessage("Model","Model::TestDetector::testComputerDestruction leaving") ; }
void TestAgent::isTargetedByTarget() { std::auto_ptr<Kernel::Model> model(new Kernel::Model()) ; model->init() ; Kernel::Object* system = model->createObject() ; system->addTrait(new Model::StellarSystem()) ; system->addTrait(new Model::Positioned()) ; Kernel::Object* ship1 = Model::createShip(system) ; Kernel::Object* agent = Model::createAI(ship1) ; Model::TargetingSystem* targeting_system1 = ship1->getChild<Model::TargetingSystem>() ; Kernel::Object* ship2 = Model::createShip(system) ; Model::TargetingSystem* targeting_system2 = ship2->getChild<Model::TargetingSystem>() ; Implementation::Agent* agent_controller = getAgentController(agent) ; targeting_system1->selectTarget(ship2) ; CPPUNIT_ASSERT(!agent_controller->isTargetedByTarget()) ; targeting_system2->selectTarget(ship1) ; CPPUNIT_ASSERT(agent_controller->isTargetedByTarget()) ; }
void TestGuidanceControl::basicTest() { InternalMessage("Model","Model::TestGuidanceControl::basicTest entering") ; /// we construct a complete system on a ship std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestGuidanceControl::basicTest")) ; /// should be a PhysicalWorld Kernel::Object* system = model->createObject() ; CPPUNIT_ASSERT(system->getTrait<PhysicalWorld>()) ; Kernel::Object* ship = system->createObject() ; ship->addTrait(new Positionned()) ; ship->addTrait(new Oriented()) ; ship->addTrait(new Mobile()) ; ship->addTrait(new Massive(Mass::Kilogram(1000))) ; CPPUNIT_ASSERT(ship->getTrait<PhysicalObject>()) ; Kernel::Object* stick = ship->createObject() ; stick->addTrait(new Oriented()) ; Kernel::Object* guidance_system = ship->createObject() ; guidance_system->addTrait(new GuidanceSystem(1)) ; Kernel::Object* guidance_control = ship->createObject() ; guidance_control->addTrait(new GuidanceControler()) ; connectStickControler(stick,guidance_control) ; connectControlerGuidanceSystem(guidance_control,guidance_system) ; /// now we can test the control... { /// variables redefines to have direct access to interesting traits GuidanceSystem* guidance_system_trait = guidance_system->getTrait<GuidanceSystem>() ; CPPUNIT_ASSERT(guidance_system_trait) ; GuidanceControler* guidance_control_trait = guidance_control->getTrait<GuidanceControler>() ; CPPUNIT_ASSERT(guidance_control_trait) ; Oriented* stick_trait = stick->getTrait<Oriented>() ; CPPUNIT_ASSERT(stick_trait) ; /// basic init check CPPUNIT_ASSERT(guidance_system_trait->NewtonMeter() == Ogre::Vector3(0,0,0)) ; Ogre::Quaternion orientation(0,1,0,0) ; stick_trait->setOrientation(orientation) ; CPPUNIT_ASSERT(equal(guidance_system_trait->NewtonMeter().x,pi) && equal(guidance_system_trait->NewtonMeter().y,pi) && equal(guidance_system_trait->NewtonMeter().z,0)) ; /// reorient ship... ship->getTrait<Oriented>()->setOrientation( Ogre::Quaternion(sqrt(0.5),0,sqrt(0.5),0)) ; CPPUNIT_ASSERT(equal(guidance_system_trait->NewtonMeter().x,0) && equal(guidance_system_trait->NewtonMeter().y,pi) && equal(guidance_system_trait->NewtonMeter().z,-pi)) ; } }
void TestMovingObject::moveParentSource() { std::cerr << "TestMovingObject::moveParentSource" << std::endl ; std::cerr.flush() ; // we construct a complete system std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestMovingObject::basicTest")) ; model->init() ; Kernel::Object* system = model->createObject() ; system->addTrait(new Model::Positionned()) ; system->addTrait(new Model::Oriented()) ; Kernel::Object* listener = system->createObject() ; listener->addTrait(new Model::Listener()) ; Model::Positionned* listenerPos = new Model::Positionned(); listener->addTrait(listenerPos) ; listener->addTrait(new Model::Oriented()) ; listener->addTrait(new Model::Mobile()); Kernel::Object* ship = system->createObject() ; Model::Positionned* ship_positionned = new Model::Positionned(Model::Position::Meter(0,0,-50)); ship->addTrait(ship_positionned); ship->addTrait(new Model::Oriented()) ; ship->addTrait(new Model::Mobile()); Kernel::Object* engine = ship->createObject() ; engine->addTrait(new Model::Engine(Model::Force::Newton(10,10,10))) ; Kernel::ViewPoint* viewpoint = model->getViewPoint<Implementation::OpenAL::RealWorldViewPoint>() ; CPPUNIT_ASSERT(engine->getTrait<Implementation::Engine>() ->getView<Implementation::OpenAL::Engine>(viewpoint)) ; ALuint engine_source = engine->getTrait<Implementation::Engine>() ->getView<Implementation::OpenAL::Engine>(viewpoint)->m_source ; Kernel::Timer global_timer ; Kernel::Timer timer ; float expected_position_x = 0 ; float expected_position_y = 0 ; float expected_position_z = -50 ; checkSourcePosition(engine_source, expected_position_x, expected_position_y, expected_position_z) ; ship_positionned->setPosition(ship_positionned->getPosition()+Model::Position::Meter(0,0,-0.01)); expected_position_z -= 0.01 ; checkSourcePosition(engine_source, expected_position_x, expected_position_y, expected_position_z) ; }
void TestMovingObject::moveParentAndListenerHasPosition() { std::cerr << "TestMovingObject::moveParentAndListenerHasPosition" << std::endl ; std::cerr.flush() ; // we construct a complete system std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestMovingObject::moveParentAndListenerHasPosition")) ; model->init() ; Kernel::Object* system = model->createObject() ; system->addTrait(new Model::Positionned()) ; system->addTrait(new Model::Oriented()) ; Kernel::Object* listener_ship = system->createObject() ; Model::Positionned* listener_ship_positionned = new Model::Positionned(); listener_ship->addTrait(listener_ship_positionned) ; Kernel::Object* listener = listener_ship->createObject() ; listener->addTrait(new Model::Positionned()) ; listener->addTrait(new Model::Listener()) ; listener->addTrait(new Model::Oriented()) ; listener->addTrait(new Model::Mobile()); Kernel::Object* ship = system->createObject() ; Model::Positionned* ship_positionned = new Model::Positionned(Model::Position::Meter(0,0,-50)); ship->addTrait(ship_positionned); ship->addTrait(new Model::Oriented()) ; ship->addTrait(new Model::Mobile()); Kernel::Object* engine = ship->createObject() ; engine->addTrait(new Model::Engine(Model::Force::Newton(10,10,10))) ; engine->addTrait(new Model::Positionned()) ; Kernel::Timer global_timer ; Kernel::Timer timer ; float listener_position_x ; float listener_position_y ; float listener_position_z ; float expected_listener_position_x = 0 ; float expected_listener_position_y = 0 ; float expected_listener_position_z = 0 ; alGetListener3f(AL_POSITION,&listener_position_x,&listener_position_y,&listener_position_z) ; CPPUNIT_ASSERT_DOUBLES_EQUAL(expected_listener_position_x,listener_position_x,delta) ; CPPUNIT_ASSERT_DOUBLES_EQUAL(expected_listener_position_y,listener_position_y,delta) ; CPPUNIT_ASSERT_DOUBLES_EQUAL(expected_listener_position_z,listener_position_z,delta) ; listener_ship_positionned->setPosition(listener_ship_positionned->getPosition()+Model::Position::Meter(0,0,-1)); expected_listener_position_z -= 1 ; alGetListener3f(AL_POSITION,&listener_position_x,&listener_position_y,&listener_position_z) ; CPPUNIT_ASSERT_DOUBLES_EQUAL(expected_listener_position_x,listener_position_x,delta) ; CPPUNIT_ASSERT_DOUBLES_EQUAL(expected_listener_position_y,listener_position_y,delta) ; CPPUNIT_ASSERT_DOUBLES_EQUAL(expected_listener_position_z,listener_position_z,delta) ; }
void Collision::onInit() { InternalMessage("Model","Collision::onInit entering") ; m_beam = NULL ; m_destroyable = NULL ; /* if one object is a laser beam - destroy it and if the other is destroyable - manage damage */ LaserBeam* beam1 = getTrait()->getObject1()->getTrait<LaserBeam>() ; LaserBeam* beam2 = getTrait()->getObject2()->getTrait<LaserBeam>() ; Destroyable* destroyable1 = getTrait()->getObject1()->getTrait<Destroyable>() ; Destroyable* destroyable2 = getTrait()->getObject2()->getTrait<Destroyable>() ; if (beam1) { m_beam = beam1 ; getTrait()->getObject1()->destroyObject() ; } if (beam2) { m_beam = beam2 ; getTrait()->getObject2()->destroyObject() ; } if (destroyable1) { m_destroyable = destroyable1 ; } if (destroyable2) { m_destroyable = destroyable2 ; } // handle beam/destroyable collision if (m_beam && m_destroyable) { InternalMessage("Model","Collision::onInit damaging " + Kernel::toString(m_beam->getEnergy().Joule())) ; m_destroyable->damage(m_beam->getEnergy()) ; Kernel::Object* hit = m_destroyable->getObject()->createObject() ; hit->addTrait(new Hit()) ; Position position(getRelativePosition(getObject(),m_destroyable->getObject())) ; InternalMessage("Model","Collision::onInit creating hit at " + ::Ogre::StringConverter::toString(position.Meter())) ; hit->addTrait(new Positioned(position)) ; hit->addTrait(new WithLifetime(Duration::Second(0))) ; hit->addTrait(new Sized(Distance(Distance::_Meter,60))) ; hit->addTrait(new Oriented(Orientation(position))) ; } InternalMessage("Model","Collision::onInit leaving") ; }
void TestDemonstration::oneShip() { InternalMessage("Sound","entering TestDemonstration::oneShip") ; std::cerr << "TestDemonstration::oneShip" << std::endl ; std::cerr.flush() ; std::auto_ptr<Kernel::Model> model(new Kernel::Model()) ; model->init() ; Kernel::Object* root = model->createObject() ; Kernel::Object* universe = root->createObject() ; universe->addTrait(new Model::Universe()) ; universe->addTrait(new Model::Positioned()) ; universe->setName("universe") ; Kernel::Object* system = universe->createObject() ; system->addTrait(new Model::StellarSystem()) ; system->addTrait(new Model::Positioned()) ; system->setName("system") ; // Kernel::Object* ship = Model::loadShip("test_ship",system) ; Kernel::Object* pilot = system->createObject() ; pilot->addTrait(new Model::Listener()) ; pilot->addTrait(new Model::Positioned()) ; pilot->addTrait(new Model::Oriented()) ; pilot->addTrait(new Model::Player()) ; pilot->addTrait(new Model::Observer()) ; pilot->addTrait(new Model::Active()) ; pilot->addTrait(new Model::Mobile()) ; Kernel::Object* ship2 = Model::loadShip("test_ship",system) ; Model::Positioned* ship2_positioned = ship2->getTrait<Model::Positioned>() ; ship2_positioned->setPosition(Model::Position::Meter(0,0,200)) ; ship2->getTrait<Model::Mobile>()->setSpeed(Model::Speed::MeterPerSecond(0,0,-50)) ; Kernel::Timer global_timer ; Kernel::Timer timer ; std::set<Model::Throttle*> throttles = ship2->getChildren<Model::Throttle>() ; (*throttles.begin())->set(100) ; while (global_timer.getSecond() <= 4) { float seconds = timer.getSecond() ; if (seconds > 0) { timer.reset() ; ship2_positioned->setPosition(ship2_positioned->getPosition()+Model::Position::Meter(0,0,-50*seconds)) ; model->update(seconds) ; } } InternalMessage("Sound","leaving TestDemonstration::oneShip") ; }
void TestBackgroundSound::basicTest() { /*! - build a background sound object wih a ogg - build an event colision with a wav (default sound.wav in OpenAL::colision.cpp code) - build a listener - destroy the event before the end of the sound - update the module for streaming during 10secondes -destroy all and clean sound module */ // we construct a complete system std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestBackgroundSound::basicTest")) ; model->init() ; Kernel::Object* system = model->createObject() ; system->addTrait(new Model::Positionned()) ; system->addTrait(new Model::Oriented()) ; Kernel::Object* listener = system->createObject() ; listener->addTrait(new Model::Listener()) ; listener->addTrait(new Model::Positionned()) ; listener->addTrait(new Model::Oriented()) ; listener->addTrait(new Model::Mobile()); Kernel::Object* emmiter = system->createObject() ; emmiter->addTrait(new Model::BackgroundSound("pu_comm_essai_1.ogg")) ; emmiter->addTrait(new Model::Positionned()) ; emmiter->addTrait(new Model::Oriented()) ; Kernel::Object* elm1 = system->createObject() ; Kernel::Object* elm2 = system->createObject() ; Kernel::Object* collision = system->createObject() ; const Model::Position& posRef = Model::Position(); collision->addTrait(new Model::Collision(elm1, elm2, posRef)) ; InternalMessage("Sound","fin definition world") ; model->destroyObject(collision) ; InternalMessage("Sound","after destroy colision") ; Kernel::Timer global_timer ; Kernel::Timer timer ; int i = 0 ; while(global_timer.getSecond() <= 10.0) { ++i ; float seconds = timer.getSecond() ; timer.reset() ; model->update(seconds) ; } InternalMessage("Sound","i=" + Kernel::toString(i)) ; }
void TestMenu::customMission() { InternalMessage("GUI","GUI::TestMenu::customMission entering") ; try { std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestMenu::customMission")) ; model->init() ; Kernel::Object* mission = model->createObject() ; mission->addTrait(new Model::CustomMission("test",NULL,NULL)) ; mission->addTrait(new Model::Edited()) ; Kernel::Object* team1 = mission->createObject() ; team1->addTrait(new Model::Team("team 1")) ; Kernel::Object* team2 = mission->createObject() ; team2->addTrait(new Model::Team("team 2")) ; Kernel::Object* team3 = mission->createObject() ; team3->addTrait(new Model::Team("team 3")) ; Kernel::Timer timer ; Kernel::Timer global_timer ; float test_duration = 0 ; try { test_duration = Kernel::Parameters::getValue<float>("GUI","Test.PlayerConfiguration.Duration") ; } catch(...) { test_duration = 5 ; } while (global_timer.getSecond() < test_duration) { float seconds = timer.getSecond() ; if (seconds != 0) { timer.reset() ; } model->update(seconds) ; } } catch( ::CEGUI::Exception& exception) { std::cout << exception.getMessage() << std::endl ; throw ; } InternalMessage("GUI","GUI::TestMenu::customMission leaving") ; }
Kernel::Object* DisplayTestFixture::createUniverseAndSystem(Kernel::Model* model) const { Kernel::Object* universe = model->createObject() ; universe->addTrait(new Model::Universe()) ; universe->addTrait(new Model::Positioned()) ; Kernel::Object* system = universe->createObject() ; system->addTrait(new Model::StellarSystem()) ; system->addTrait(new Model::Positioned()) ; return system ; }
Kernel::Object* DisplayTestFixture::createObserver(Kernel::Object* parent) const { Kernel::Object* observer = parent->createObject() ; observer->addTrait(new Model::Observer()) ; observer->getTrait<Model::Observer>()->setFieldOfView(::Ogre::Degree(70)) ; observer->addTrait(new Model::Player()) ; observer->addTrait(new Model::Active()) ; observer->addTrait(new Model::Positioned()) ; observer->addTrait(new Model::Oriented()) ; return observer ; }
void CustomMission::load() { // setup the system Kernel::Object* universe = getObject()->createObject() ; universe->addTrait(new Universe()) ; universe->addTrait(new Positioned()) ; universe->setName("universe") ; m_system = universe->createObject() ; m_system->addTrait(new StellarSystem()) ; m_system->addTrait(new Positioned()) ; m_system->setName("system") ; }
void TestMenu::testFullMenu() { InternalMessage("GUI","GUI::TestMenu::testFullMenu entering") ; std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestMenu::testFullMenu")) ; model->init() ; Kernel::Object* root = model->createObject() ; root->addTrait(new Model::State()) ; root->addTrait(new Model::Active()) ; Kernel::Object* main_menu = root->createObject() ; main_menu->setName("main_menu") ; main_menu->addTrait(new Model::Menu("main_menu.layout")) ; main_menu->addTrait(new Model::State()) ; main_menu->getTrait<Model::State>()->addCommandAlias("configure","push(player_configuration,Edited)") ; Kernel::Object* player_configuration = Model::createDefaultPlayerConfiguration(main_menu) ; player_configuration->setName("player_configuration") ; player_configuration->addTrait(new Model::State()) ; root->getTrait<Model::State>()->changeState(main_menu,new Model::Displayed()) ; Kernel::Timer timer ; Kernel::Timer global_timer ; float test_duration = 0 ; try { test_duration = Kernel::Parameters::getValue<float>("GUI","Test.PlayerConfiguration.Duration") ; } catch(...) { test_duration = 5 ; } while (global_timer.getSecond() < test_duration) { float seconds = timer.getSecond() ; if (seconds != 0) { timer.reset() ; } model->update(seconds) ; } InternalMessage("GUI","GUI::TestMenu::testFullMenu leaving") ; }
void TestSoundEvent::smallCollision() { std::cerr << "TestSoundEvent::smallCollision" << std::endl; std::cerr.flush() ; std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestSoundEvent::collision")); model->init() ; Kernel::Object* system = model->createObject() ; system->addTrait(new Model::Positioned()) ; system->addTrait(new Model::Oriented()) ; Kernel::Object* listener = system->createObject() ; listener->addTrait(new Model::Listener()) ; listener->addTrait(new Model::Positioned()) ; listener->addTrait(new Model::Oriented()) ; listener->addTrait(new Model::Mobile()); Kernel::Object* collision = system->createObject() ; collision->addTrait(new Model::Collision(system,listener,Model::Energy::Joule(100))) ; collision->addTrait(new Model::Positioned(Model::Position::Meter(10,10,10))) ; Implementation::OpenAL::Collision* sound = collision->getView<Implementation::OpenAL::Collision>(model->getViewPoint<Implementation::OpenAL::RealWorldViewPoint>()) ; CPPUNIT_ASSERT(sound) ; Kernel::Timer timer; Kernel::Timer global_timer; while (global_timer.getSecond() <= 1) { float seconds = timer.getSecond() ; timer.reset() ; model->update(seconds) ; } }
void TestSoundEvent::farCollision() { std::cerr << "TestSoundEvent::farCollision" << std::endl; std::cerr.flush() ; std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestSoundEvent::farCollision")); model->init() ; Kernel::Object* system = model->createObject() ; system->addTrait(new Model::Positioned()) ; system->addTrait(new Model::Oriented()) ; Kernel::Object* listener = system->createObject() ; listener->addTrait(new Model::Listener()) ; listener->addTrait(new Model::Positioned()) ; listener->addTrait(new Model::Oriented()) ; listener->addTrait(new Model::Mobile()); Kernel::Object* collision = system->createObject() ; collision->addTrait(new Model::Collision(system,listener,Model::Energy::Joule(200))) ; collision->addTrait(new Model::Positioned(Model::Position::Meter(0,0,100))) ; Kernel::Timer timer; Kernel::Timer global_timer; while (global_timer.getSecond() <= 1) { float seconds = timer.getSecond() ; timer.reset() ; model->update(seconds) ; } }
void TestConeProperty::basicTest() { /*! - build a engine - build a listener - move the listener in a circle around the engine to heard the variation with the angle. */ std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestConeProperty::basicTest")) ; model->init() ; Kernel::Object* system = model->createObject() ; system->addTrait(new Model::Positionned()) ; system->addTrait(new Model::Oriented()) ; Kernel::Object* listener = system->createObject() ; listener->addTrait(new Model::Listener()) ; Model::Positionned* listenerPos = new Model::Positionned(Model::Position::Meter(0,0,0)); listener->addTrait(listenerPos) ; listener->addTrait(new Model::Oriented(Model::Orientation(Ogre::Quaternion(1.0, 0.0, 10.0, 0.0)))) ; listener->addTrait(new Model::Mobile()); Kernel::Object* engine = system->createObject() ; engine->addTrait(new Model::Engine(Model::Force::Newton(10,10,10))) ; Model::Positionned* enginePos = new Model::Positionned(Model::Position::Meter(0,0,0)); engine->addTrait(enginePos); engine->addTrait(new Model::Oriented(Model::Orientation(Ogre::Quaternion(1.0, 0.0, -10.0, 0.0)))) ; engine->addTrait(new Model::Mobile()); Kernel::Timer timer ; float angle = 0; int tour = 0; while (tour < 1) { //variation between 0 and 100% of 2PI angle += 0.00005; if (angle > 1) { angle = 0; tour++; } listenerPos->setPosition(Model::Position::Meter(0.0,5*std::cos(angle*2*PI),5*std::sin(angle*2*PI))); float seconds = timer.getSecond() ; timer.reset() ; model->update(seconds) ; } }
void TestGuidanceControl::fullRigth() { InternalMessage("Model","Model::TestGuidanceControl::basicTest entering") ; /// we construct a complete system on a ship std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestGuidanceControl::basicTest")) ; /// should be a PhysicalWorld Kernel::Object* system = model->createObject() ; CPPUNIT_ASSERT(system->getTrait<PhysicalWorld>()) ; Kernel::Object* ship = system->createObject() ; ship->addTrait(new Positionned()) ; ship->addTrait(new Oriented()) ; ship->addTrait(new Mobile()) ; ship->addTrait(new Massive(Mass::Kilogram(1000))) ; CPPUNIT_ASSERT(ship->getTrait<PhysicalObject>()) ; Kernel::Object* stick = ship->createObject() ; stick->addTrait(new Stick()) ; Kernel::Object* guidance_system = ship->createObject() ; guidance_system->addTrait(new GuidanceSystem(1)) ; Kernel::Object* guidance_control = ship->createObject() ; guidance_control->addTrait(new GuidanceControler()) ; connectStickControler(stick,guidance_control) ; connectControlerGuidanceSystem(guidance_control,guidance_system) ; // 100 on yaw means go rigth stick->call("Yaw",100) ; stick->getTrait<Stick>()->updateOrientation() ; CPPUNIT_ASSERT(guidance_system->getTrait<GuidanceSystem>()->NewtonMeter().x == 0) ; CPPUNIT_ASSERT(guidance_system->getTrait<GuidanceSystem>()->NewtonMeter().z == 0) ; CPPUNIT_ASSERT(guidance_system->getTrait<GuidanceSystem>()->NewtonMeter().y < 0) ; stick->call("Yaw",0) ; stick->getTrait<Stick>()->updateOrientation() ; CPPUNIT_ASSERT(guidance_system->getTrait<GuidanceSystem>()->NewtonMeter().x == 0) ; CPPUNIT_ASSERT(guidance_system->getTrait<GuidanceSystem>()->NewtonMeter().z == 0) ; CPPUNIT_ASSERT(guidance_system->getTrait<GuidanceSystem>()->NewtonMeter().y == 0) ; // 100 on pitch measn go down stick->call("Pitch",100) ; stick->getTrait<Stick>()->updateOrientation() ; CPPUNIT_ASSERT(guidance_system->getTrait<GuidanceSystem>()->NewtonMeter().x < 0) ; CPPUNIT_ASSERT(guidance_system->getTrait<GuidanceSystem>()->NewtonMeter().z == 0) ; CPPUNIT_ASSERT(guidance_system->getTrait<GuidanceSystem>()->NewtonMeter().y == 0) ; }
void Laser::fire() { InternalMessage("Model","entering fire") ; // handle firing rate if (m_time_to_fire.Second() > 0) return ; Positioned* positioned = getObject()->getParent<Positioned>() ; Oriented* oriented = getObject()->getParent<Oriented>() ; PhysicalObject* object = getObject()->getParent<PhysicalObject>() ; PhysicalWorld* world = object ? object->getObject()->getAncestor<PhysicalWorld>() : NULL ; if (world && positioned && oriented) { InternalMessage("Model","firing") ; // create a laser beam object Kernel::Object* beam = world->getObject()->createObject() ; // should apply local rotation to have correct local position.. Orientation orientation_of_laser = oriented->getOrientation(world->getObject()) ; Position position_of_the_beam = positioned->getPosition(world->getObject()) + m_out_position*orientation_of_laser ; beam->addTrait(new Positioned(position_of_the_beam)) ; Orientation orientation_of_the_beam = orientation_of_laser*m_out_orientation ; beam->addTrait(new Oriented(orientation_of_the_beam)) ; // orientation gives speed vector // basic_speed(full Z oriented) * orientation Speed speed = Speed::MeterPerSecond(0,0,-getLaserSpeedMeterPerSecond())*orientation_of_the_beam ; // maybe we should add the object speed ?? (i.e. the speed of the ship) beam->addTrait(new Mobile(speed)) ; beam->addTrait(new Massive(Mass(m_laser_beam_energy,speed))) ; beam->addTrait(new LaserBeam(object->getObject(),m_beam_length,m_beam_radius)) ; beam->addTrait(new WithLifetime(getLaserBeamLifeDuration())) ; // shot Kernel::Object* shot = world->getObject()->createObject() ; shot->addTrait(new Positioned(position_of_the_beam)) ; shot->addTrait(new Shot()) ; // re-init timer m_time_to_fire = m_time_between_shots ; // done } // else : not much sense thus do nothing InternalMessage("Model","leaving fire") ; }
void TestMenu::basicTest() { InternalMessage("GUI","GUI::TestMenu::basicTest entering") ; try { std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestMenu::basicTest")) ; model->init() ; std::string menu_name ; menu_name = Kernel::Parameters::getValue<std::string>("GUI","Test.BasicTest.Name","main_menu.layout") ; Kernel::Object* menu = model->createObject() ; menu->addTrait(new Model::Menu(menu_name)) ; menu->addTrait(new Model::Displayed()) ; Kernel::Timer timer ; Kernel::Timer global_timer ; float test_duration = 0 ; test_duration = Kernel::Parameters::getValue<float>("GUI","Test.BasicTest.Duration",5) ; while (global_timer.getSecond() < test_duration) { float seconds = timer.getSecond() ; if (seconds != 0) { timer.reset() ; } model->update(seconds) ; } } catch( ::CEGUI::Exception& exception) { std::cout << exception.getMessage() << std::endl ; throw ; } InternalMessage("GUI","GUI::TestMenu::mouseCursor leaving") ; }
void TestAgent::obstacles() { std::auto_ptr<Kernel::Model> model(new Kernel::Model()) ; model->init() ; Kernel::Object* system = model->createObject() ; system->addTrait(new Model::StellarSystem()) ; system->addTrait(new Model::Positioned()) ; Kernel::Object* ship1 = Model::createShip(system) ; Kernel::Object* agent1 = Model::createAI(ship1) ; Kernel::Object* ship2 = Model::createShip(system) ; Kernel::Object* agent2 = Model::createAI(ship2) ; Implementation::Agent* agent_controller1 = getAgentController(agent1) ; std::set<Implementation::Vehicle*> obstacles(agent_controller1->getObstacles()) ; CPPUNIT_ASSERT_EQUAL((unsigned int)1,obstacles.size()) ; Implementation::Agent* agent_controller2 = getAgentController(agent2) ; CPPUNIT_ASSERT(agent_controller2->getVehicle()) ; CPPUNIT_ASSERT(obstacles.find(agent_controller2->getVehicle())!=obstacles.end()) ; }
void TestAgent::applyOnlyToAI() { std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestModelControler::attackAllEnemies")) ; model->init() ; Kernel::Object* system = model->createObject() ; system->addTrait(new Model::StellarSystem()) ; system->addTrait(new Model::Positioned()) ; Kernel::ObjectReference ship1 ; { Kernel::Object* ship = Model::createShip(system) ; ship->getTrait<Model::Positioned>()->setPosition(Model::Position::Meter(0,0,0)) ; ship1 = ship ; } { Kernel::Object* ship = Model::createShip(system) ; ship->getTrait<Model::Positioned>()->setPosition(Model::Position::Meter(1000,0,0)) ; } ship1->call(Model::TargetingSystem::SelectNextTarget) ; }
void TestInputSystem::testKeyboardAutoRepeat() { InternalMessage("Input","Input::TestInputSystem::testKeyboardAutoRepeat entering") ; std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestPlayerConfiguration::testKeyboardAutoRepeat")) ; model->init() ; Kernel::ControlerSet* controler_set = model->getControlerSet<Implementation::OIS::InputControlerSet>() ; controler_set->setTimeStep(0.01) ; Kernel::Object* root = model->createObject() ; root->addTrait(new Keyboard()) ; Implementation::OIS::Keyboard* keyboard = Implementation::OIS::getKeyboard() ; if (!keyboard) { std::cout << "warning : no keyboard found, skipping test" ; return ; } // send a key pressed ::OIS::KeyEvent keyboard_event(getOISKeyboard(),::OIS::KC_0,(unsigned int)'0') ; keyboard->keyPressed(keyboard_event) ; // count the actual interpreted key pressed events... Kernel::Timer global_timer ; Kernel::Timer timer ; const float simulation_time = 2 ; while (global_timer.getSecond() < simulation_time) { if (timer.getSecond() > 0.1) { model->update(timer.getSecond()) ; timer.reset() ; } } CPPUNIT_ASSERT_EQUAL((unsigned int)(simulation_time/ Kernel::Parameters::getValue<float>( "Input", "AutoRepeatDelay", Implementation::OIS::default_autorepeat_delay)), KeyboardListener::m_count) ; InternalMessage("Input","Input::TestInputSystem::testKeyboardAutoRepeat leaving") ; }
void TestBackgroundSound::wavSound() { std::cerr << "TestBackgroundSound::wavSound" << std::endl ; std::cerr.flush() ; InternalMessage("Sound","Enter TestBackgroundSound::wavSound") ; // we construct a complete system std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestBackgroundSound::basicTest")); model->init() ; Kernel::Object* system = model->createObject() ; system->addTrait(new Model::Positionned()) ; system->addTrait(new Model::Oriented()) ; Kernel::Object* listener = system->createObject() ; listener->addTrait(new Model::Listener()) ; listener->addTrait(new Model::Positionned()) ; listener->addTrait(new Model::Oriented()) ; listener->addTrait(new Model::Mobile()); Kernel::Object* emmiter = system->createObject() ; emmiter->addTrait(new Model::BackgroundSound("test.wav")) ; emmiter->addTrait(new Model::Positionned()) ; emmiter->addTrait(new Model::Oriented()) ; Kernel::Timer global_timer; Kernel::Timer timer; int i = 0; while (global_timer.getSecond() <= 2.0) { ++i; float seconds = timer.getSecond() ; timer.reset() ; model->update(seconds) ; } InternalMessage("Sound","Leave TestBackgroundSound::wavSound") ; }
void TestInputSystem::testJoystickAutoRepeat() { InternalMessage("Input","Input::TestInputSystem::testJoystickAutoRepeat entering") ; std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestPlayerConfiguration::testJoystickAutoRepeat")) ; model->init() ; Kernel::Object* root = model->createObject() ; root->addTrait(new Joystick()) ; Implementation::OIS::Joystick* joystick = Implementation::OIS::getJoystick() ; if (!joystick) { std::cout << "warning : no joystick found, skipping test" ; return ; } // send a button pressed ::OIS::JoyStickEvent joystick_event(NULL,::OIS::JoyStickState()) ; joystick->buttonPressed(joystick_event,1) ; // count the actual interpreted key pressed events... Kernel::Timer global_timer ; Kernel::Timer timer ; const float simulation_time = 2 ; while (global_timer.getSecond() < simulation_time) { if (timer.getSecond() > 0.1) { model->update(timer.getSecond()) ; timer.reset() ; } } CPPUNIT_ASSERT_EQUAL((unsigned int)(simulation_time/ Kernel::Parameters::getValue<float>( "Input", "AutoRepeatDelay", Implementation::OIS::default_autorepeat_delay)), JoystickListener::m_count) ; InternalMessage("Input","Input::TestInputSystem::testJoystickAutoRepeat leaving") ; }
void TestSoundEvent::collision() { std::cerr << "TestSoundEvent::collision" << std::endl; std::cerr.flush() ; /*! - build an event object plays sound and destroy it - check that the sound is still playing */ std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestSoundEvent::collision")); model->init() ; Kernel::Object* system = model->createObject() ; system->addTrait(new Model::Positioned()) ; system->addTrait(new Model::Oriented()) ; Kernel::Object* listener = system->createObject() ; listener->addTrait(new Model::Listener()) ; listener->addTrait(new Model::Positioned()) ; listener->addTrait(new Model::Oriented()) ; listener->addTrait(new Model::Mobile()); Kernel::Object* collision = system->createObject() ; collision->addTrait(new Model::Collision(system,listener,Model::Energy::Joule(200))) ; collision->addTrait(new Model::Positioned(Model::Position::Meter(10,10,10))) ; Kernel::Timer timer; Kernel::Timer global_timer; while (global_timer.getSecond() <= 1) { float seconds = timer.getSecond() ; timer.reset() ; model->update(seconds) ; } }
void TestMenu::playerConfiguration() { InternalMessage("GUI","GUI::TestMenu::playerConfiguration entering") ; std::auto_ptr<Kernel::Model> model(new Kernel::Model("TestMenu::playerConfiguration")) ; model->init() ; Kernel::Object* option = model->createObject() ; Kernel::Object* configuration = Model::createDefaultPlayerConfiguration(option) ; configuration->addTrait(new Model::Edited()) ; Kernel::Timer timer ; Kernel::Timer global_timer ; float test_duration = 0 ; try { test_duration = Kernel::Parameters::getValue<float>("GUI","Test.PlayerConfiguration.Duration") ; } catch(...) { test_duration = 5 ; } while (global_timer.getSecond() < test_duration) { float seconds = timer.getSecond() ; if (seconds != 0) { timer.reset() ; } model->update(seconds) ; } InternalMessage("GUI","GUI::TestMenu::playerConfiguration leaving") ; }