C++ String::compare方法代码示例

Ogre::String ConfigManager::getFullscreenStr() const
{
  Ogre::String str = cf.getSetting("Fullscreen", "Settings", "false");
  if (str.compare("false") == 0)
    return Ogre::String("No");
  else if (str.compare("true") == 0)
    return Ogre::String("Yes");
  return Ogre::String("No");
}

void HealthManager::receive(const HitEvent &event)
{
    std::cout<<"ricevuto"<<std::endl;
    entityx::ptr<entityx::EntityManager> entities = ScreenManager::getPtr()->getCurrentEntities();
    for(auto entity : entities->entities_with_components<Destroyable, Renderable>())
    {
        ptr<Destroyable> points = entity.component<Destroyable>();
        std::string entName = entity.component<Name>()->name;
        Ogre::String name;

        if(entName != "Block"){
            ptr<Children> child = entity.component<Children>();
            name = child->children["body"].component<Renderable>()->sceneNode->getName();
        }else{
            ptr<Renderable> rend = entity.component<Renderable>();
            name = rend->sceneNode->getName();
        }

        std::cout<<"name: "<<name<<std::endl;


        int max = points->maxHealth;

        if(name.compare(event.targetName)==0)
        {
            points->health-=event.points;
            if(points->health<=0)
            {
                MessageManager::getPtr()->emit<ObjectDestroyed>(entity);
                if(entity.valid()){
                    if(entity.component<Name>()->name == "Block")
                    {
                        MapManager::getPtr()->deletePosition(entity.component<Position>()->position);
                        RenderManager::getPtr()->getSceneManager()->destroySceneNode(entity.component<Renderable>()->sceneNode);
                        entity.destroy();
                    }else{
                        entity.assign<Position>(MapManager::getPtr()->getFreePos());
                        entity.assign<Destroyable>(max,max);
                    }
                }
                return;
            }else{
                std::cout<<"punti"<<points->health<<std::endl;
                entity.assign<Destroyable>(points->health,max);
            }
            return;
        }

    }
    return;
}

 bool ConfigurationManager::shouldUseStaticGeometry()
 {
     Ogre::String mode = getSystemConfig()->getSetting( "use_static_geometry" );
     
     if( mode == Ogre::StringUtil::BLANK )
         mode = "auto";
     
     if( mode.compare("yes") == 0 )
     {
         return true;
     }
     else if( mode.compare("no") == 0 )
     {
         return false;
     }        
     else
     {
         // Überprüfen ob der Renderer VertexBuffer unterstützt
         return Ogre::Root::getSingleton().getRenderSystem()
             ->getCapabilities()->hasCapability( Ogre::RSC_VBO );
     }
     
 }

	/// __DATE__ sieht ca. so aus : Nov 08 2005
	long parseDate(char* date)
	{   
		Ogre::String dateStr = Ogre::String(date);
		Ogre::String monthStr = dateStr.substr(0,3);
		int day = Ogre::StringConverter::parseInt( dateStr.substr(4,2) );
		int year = Ogre::StringConverter::parseInt( dateStr.substr(7,4) );
		int month = 0;

		while( month < 12 && monthStr.compare(sMonths[month]) != 0 )
			month++;

		return /* Jahr */		  year * 100000 +
			   /* Monat */	 (month+1) * 1000 + 
			   /* Tag */		   day * 10 + 
			   /* Sub-Version */	 0;	
	}

bool SceneLoader::parseNode(TiXmlElement *XMLNode)
{
	TiXmlElement *XMLRotation;
	TiXmlElement *XMLPosition;
	TiXmlElement *XMLEntity;
	TiXmlElement *XMLScale;
	TiXmlElement *XMLProperty;

	Ogre::String  nodeName;
	Ogre::String  meshName;
	Ogre::String  meshFile;
	Ogre::Vector3 vec3Position;
	Ogre::Vector3 vec3Scale;
	Ogre::Quaternion quatRotation;

	Ogre::Entity *ent;


	//Get the name of the node
	nodeName = XMLNode->Attribute("name");
	std::cout << "NodeName: " << nodeName << std::endl;

	//Get the position element;
	XMLPosition = XMLNode->FirstChildElement("position");
	vec3Position.x = Ogre::StringConverter::parseReal(XMLPosition->Attribute("x"));
	vec3Position.y = Ogre::StringConverter::parseReal(XMLPosition->Attribute("y"));
	vec3Position.z = Ogre::StringConverter::parseReal(XMLPosition->Attribute("z"));
	//Debug text
	std::cout << "Position: " << "x: " << XMLPosition->Attribute("x");
	std::cout << " y: " << XMLPosition->Attribute("y");
	std::cout << " z: " << XMLPosition->Attribute("z") << std::endl;

	//Get the rotation
	XMLRotation = XMLNode->FirstChildElement("quaternion");
	quatRotation.x = Ogre::StringConverter::parseReal(XMLRotation->Attribute("x"));
	quatRotation.y = Ogre::StringConverter::parseReal(XMLRotation->Attribute("y"));
	quatRotation.z = Ogre::StringConverter::parseReal(XMLRotation->Attribute("z"));
	quatRotation.w = Ogre::StringConverter::parseReal(XMLRotation->Attribute("w"));
	//Debug text
	std::cout << "Quat: " << "qx: " << XMLRotation->Attribute("x");
	std::cout << "qy: " << XMLRotation->Attribute("y");
	std::cout << "qz: " << XMLRotation->Attribute("z");
	std::cout << "qw: " << XMLRotation->Attribute("w") << std::endl;

	//Get the scale
	XMLScale = XMLNode->FirstChildElement("scale");
	vec3Scale.x = Ogre::StringConverter::parseReal(XMLScale->Attribute("x"));
	vec3Scale.y = Ogre::StringConverter::parseReal(XMLScale->Attribute("y"));
	vec3Scale.z = Ogre::StringConverter::parseReal(XMLScale->Attribute("z")); 
	//Degub text
	std::cout << "Scale: " << "x: " << XMLScale->Attribute("x");
	std::cout << " y: " << XMLScale->Attribute("y");
	std::cout << " z: " << XMLScale->Attribute("z") << std::endl;



	//Get the entity
	XMLEntity = XMLNode->FirstChildElement("entity");
	meshName = XMLEntity->Attribute("name");
	meshFile = XMLEntity->Attribute("meshFile");
	std::cout << "meshname: " << meshName << " meshFile: " << meshFile << std::endl;

	//Create the entity
	ent = mvpSceneMgr->createEntity(meshName,meshFile);
	//if(Ogre::StringConverter::parseBool(XMLEntity->Attribute("castShadows")))
	ent->setCastShadows(false);
	//if(ent->getCastShadows())
	//	std::cout << "ent casts shadows"<< std::endl;
	std::cout << "nodeName + Node";
	Ogre::String str = nodeName;
	str += "Node";
	
	//vec3Position.y = mvpTerrain->getHeightAtWorldPosition(vec3Position);
	//vec3Position.y -= 0.3; //@todo wtf!
	Ogre::SceneNode *node = mvpSceneMgr->getRootSceneNode()->createChildSceneNode(str,vec3Position,quatRotation);
	std::cout << "createChildNode";
	node->scale(vec3Scale);
	std::cout << "scale";
	node->attachObject(ent);

	//Get physicsproperties
	std::vector<Ogre::Vector3> posList;

	TiXmlElement * XMLUserData = XMLNode->FirstChildElement("userData");
	XMLProperty = XMLUserData->FirstChildElement("property");
	bool EntityIsStatic = false;
	int collisionGroup;
	int mass  = 0;
	Ogre::String posString;
	Ogre::Vector3 tempVec(0,0,0);
	Ogre::Real speed;
	double tempDouble;
	while(XMLProperty)
	{
		Ogre::String propName = XMLProperty->Attribute("name");
		if (propName.compare("isStatic") == 0)
			if (Ogre::StringConverter::parseInt(XMLProperty->Attribute("data")) == 1)
				EntityIsStatic = true;

		if (propName.compare("mass") == 0)
//.........这里部分代码省略.........

    void Actor::doAttach(
        Actor* actor,
        const Ogre::String& slot, 
        const Ogre::String& childSlot, 
        const Ogre::Vector3& offsetPosition,
        const Ogre::Quaternion& offsetOrientation ) 
    {
        Ogre::Vector3 offsetPositionMod = offsetPosition;
        Ogre::Quaternion offsetOrientationMod = offsetOrientation;

        if( actor == NULL )
            Throw(NullPointerException, 
            "Aktor "+mName+": Der anzufügende Aktor darf nicht NULL sein." );
        if( actor->mParent != NULL )
            Throw(NullPointerException, 
            "Aktor "+mName+": Der Aktor ist bereits an einen anderen Aktor angefügt." );

        // Verschiebung durch den Child-Slot berechnen
        // Ist es ein nicht Standard-Slot && Kontrolliert der Aktor ein Objekt && Ist dieses ein Mesh
        if( childSlot.compare(DEFAULT_SLOT_NAME) != 0 &&
            actor->getControlledObject() != NULL && 
            actor->getControlledObject()->isMeshObject() )
        {
            Entity* ent = dynamic_cast<MeshObject*>(actor->getControlledObject())->getEntity();

            // Braucht ein Skelett
            if( !ent->hasSkeleton() )
                Throw(IllegalArgumentException, 
                "Aktor "+mName+": Das kontrollierte MeshObject des ChildAktor hat kein Skeleton." );

            // Der Slot muss existieren
            try
            {
                Bone* bone = ent->getSkeleton()->getBone( childSlot );

                Vector3 vec = bone->_getDerivedPosition();
                Quaternion quat = bone->_getDerivedOrientation();

                // Durch den Bone ExtraOffset hinzufügen
                offsetOrientationMod = offsetOrientation *  quat;
                offsetPositionMod = ( offsetOrientationMod * (-vec) ) + offsetPosition;
            }
            catch (Ogre::Exception) {
                Throw(IllegalArgumentException, 
                    "Aktor "+mName+": Der geforderte Slot '"+childSlot+"' am ChildAktor existiert nicht." );
            }
        }

        // Das wirkliche Anfügen
        // Ist es ein nicht Standard-Slot && Kontrolliert der Aktor ein Objekt && Ist dieses ein Mesh
        if( slot.compare(DEFAULT_SLOT_NAME) != 0 && 
            getControlledObject() != NULL && 
            getControlledObject()->isMeshObject() )
        {
            if( actor->getControlledObject() == NULL )
                Throw(IllegalArgumentException, 
                "Aktor "+mName+": Der zu befestigende Aktor darf bei SLOTs nicht leer sein." );

            MovableObject* movObj = actor->getControlledObject()->getMovableObject();
            Entity* ent = dynamic_cast<MeshObject*>(getControlledObject())->getEntity();

            // Braucht ein Skelett
            if( !ent->hasSkeleton() )
                Throw(IllegalArgumentException, 
                "Aktor "+mName+": Das kontrollierte MeshObject hat kein Skeleton." );

            // Der Slot muss existieren
            try
            {
                ent->getSkeleton()->getBone( slot );
            }
            catch (Ogre::Exception) {
                Throw(IllegalArgumentException, 
                    "Aktor "+mName+": Der geforderte Slot '"+slot+"' existiert nicht." );
            }

            // Am Bone befestigen
            ent->attachObjectToBone( slot, movObj, offsetOrientationMod, offsetPositionMod );
            // Der Aktor wurde an einem Bone befestigt
            actor->mBone = ent->getSkeleton()->getBone( slot );

            return;
        }
        // Wenn hier kein MeshObjekt dran ist, trotzdem irgendwie zusammenfügen
        else
        {
            actor->placeIntoNode( mSceneNode,  offsetPositionMod, offsetOrientationMod );

            // Der Aktor wurde nicht an einem Bone befestigt
            actor->mBone = 0;
            return;      
        }
    }