コード例 #1
0
void ObjectController::_handleHealWound(uint64 targetId,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
    PlayerObject* Medic = dynamic_cast<PlayerObject*>(mObject);
    PlayerObject* Target = dynamic_cast<PlayerObject*>(Medic->getHealingTarget(Medic));

    std::string messageResponse = gMedicManager->handleMessage(message,"(action|constitution|health|quickness|stamina|strength)");
    if (messageResponse.length() == 0)
    {
        //you must specify a valid wound type
        gMessageLib->SendSystemMessage(::common::OutOfBand("healing_response", "healing_response_65"), Medic);
    }
    else
    {
        //check Medic has enough Mind
        Ham* ham = Medic->getHam();
        if(ham->checkMainPools(0, 0, 140))
        {
            if (gMedicManager->CheckMedicine(Medic, Target, cmdProperties, messageResponse))
            {
                //call the event
                gMedicManager->startWoundTreatmentEvent(Medic);
                return;
            }
        }
        else
            gMessageLib->SendSystemMessage(::common::OutOfBand("healing_response", "not_enough_mind"), Medic);

    }
}
コード例 #2
0
ファイル: ArtisanManager.cpp プロジェクト: ANHcRush/mmoserver
bool	ArtisanManager::getRadioactiveSample(PlayerObject* player, CurrentResource* resource, SurveyTool* tool)
{
    uint32					resType			= resource->getType()->getCategoryId();
    uint16					resPE			= resource->getAttribute(ResAttr_PE);
    
    //these are the radioactive types
    if(resType == 477 || resType == 476 /* || resType == 475*/)
    {
        //did we already warn the player on the wounds ???
        if(!player->getSampleData()->mPassRadioactive)
        {
            //UI Integration

            WindowAsyncContainerCommand* asyncContainer = new  WindowAsyncContainerCommand(Window_Query_Radioactive_Sample);
            asyncContainer->PlayerId		= player->getId();
            asyncContainer->ToolId			= tool->getId();
            asyncContainer->CurrentResource	= resource;

            gUIManager->createNewMessageBox(this,"radioactiveSample","@survey:radioactive_sample_t","@survey:radioactive_sample_d",player,SUI_Window_SmplRadioactive_MsgBox, SUI_MB_YESNO,asyncContainer);
            //Pause Sampling
            player->getSampleData()->mPendingSample = false;
            return true;
        }
        Ham* hamz = player->getHam();
        uint32 playerBF = hamz->getBattleFatigue();
        
        uint32 woundDmg = 50*(1 + (playerBF/100)) + (50*(1 + (resPE/1000)));
        uint32 bfDmg    = static_cast<uint32>(0.075*resPE);
        uint32 hamReduc = 100*(2+ (resPE/1000));

        if(resPE >= 500)
        {
            //wound and BF dmg
            hamz->updateBattleFatigue(bfDmg);
            hamz->updatePropertyValue(HamBar_Health,HamProperty_Wounds, woundDmg); 
            hamz->updatePropertyValue(HamBar_Action,HamProperty_Wounds, woundDmg);
            hamz->updatePropertyValue(HamBar_Mind,HamProperty_Wounds, woundDmg);
        }
        
        //this should be a timed debuff per instance -- Do not cause wounds unless potential energy >= 500
        // each time a radioactive is sampled, there is a 5 minute debuff
        // this currently doesn't work properly as when the debuff wears off, the buff class doesn't ensure 
        // we don't have more ham than we should.
        
        BuffAttribute* healthdebuffAttribute = new BuffAttribute(attr_health, -(int)hamReduc,0,hamReduc); 
        Buff* healthdebuff = Buff::SimpleBuff(player, player, 300000,0, gWorldManager->GetCurrentGlobalTick());
        healthdebuff->AddAttribute(healthdebuffAttribute);	
        player->AddBuff(healthdebuff,true);

        healthdebuffAttribute = new BuffAttribute(attr_action, -(int)hamReduc,0,hamReduc); 
        healthdebuff = Buff::SimpleBuff(player, player, 300000, 0, gWorldManager->GetCurrentGlobalTick());
        healthdebuff->AddAttribute(healthdebuffAttribute);	
        player->AddBuff(healthdebuff,true);
    }
    else
        return false;

    return true;
}
コード例 #3
0
ファイル: ArtisanManager.cpp プロジェクト: ANHcRush/mmoserver
bool	ArtisanManager::stopSampling(PlayerObject* player, CurrentResource* resource, SurveyTool* tool)
{
    Ham* ham = player->getHam();
    bool stop = false;

    if(!resource || !tool || !player->isConnected() || !player->getSamplingState()||player->getSurveyState())
    {
        stop = true;
    }		 
    // you can't take sample while under attack!
    if(player->states.checkState(CreatureState_Combat))
    {
         gMessageLib->SendSystemMessage(::common::OutOfBand("survey", "sample_cancel_attack"), player);
        return false;
    }
    Inventory* inventory = dynamic_cast<Inventory*>(player->getEquipManager()->getEquippedObject(CreatureEquipSlot_Inventory));
    if(!inventory)
    {
        gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "sample_gone"), player);
        stop = true;
    }

    tool		= dynamic_cast<SurveyTool*>(inventory->getObjectById(tool->getId()));
    if(!tool)
    {
        gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "sample_gone"), player);
        stop = true;
    }

    uint32 actionCost = mSampleActionCost;

    if(!ham->checkMainPools(0,actionCost,0))
    {		
        //return message for sampling cancel based on HAM
        if(ham->mAction.getCurrentHitPoints() < (int32)actionCost)
        {
            gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "sample_mind"), player);
            stop = true;
        }
    }

    if (stop)
    {
        player->setSamplingState(false);
        gStateManager.setCurrentPostureState(player, CreaturePosture_Upright);
    }
    return stop;
}
コード例 #4
0
void WorldManager::savePlayerSync(uint32 accId,bool remove)
{
    PlayerObject* playerObject = getPlayerByAccId(accId);
    Ham* ham = playerObject->getHam();

    mDatabase->destroyResult(mDatabase->executeSynchSql("UPDATE characters SET parent_id=%"PRIu64",oX=%f,oY=%f,oZ=%f,oW=%f,x=%f,y=%f,z=%f,planet_id=%u WHERE id=%"PRIu64"",playerObject->getParentId()
                             ,playerObject->mDirection.x,playerObject->mDirection.y,playerObject->mDirection.z,playerObject->mDirection.w
                             ,playerObject->mPosition.x,playerObject->mPosition.y,playerObject->mPosition.z
                             ,mZoneId,playerObject->getId()));
   

    mDatabase->destroyResult(mDatabase->executeSynchSql("UPDATE character_attributes SET health_current=%u,action_current=%u,mind_current=%u"
                             ",health_wounds=%u,strength_wounds=%u,constitution_wounds=%u,action_wounds=%u,quickness_wounds=%u"
                             ",stamina_wounds=%u,mind_wounds=%u,focus_wounds=%u,willpower_wounds=%u,battlefatigue=%u,posture=%u,moodId=%u,title=\'%s\'"
                             ",character_flags=%u,states=%"PRIu64",language=%u, group_id=%"PRIu64" WHERE character_id=%"PRIu64"",
                             ham->mHealth.getCurrentHitPoints() - ham->mHealth.getModifier(), //Llloydyboy Added the -Modifier so that when buffs are reinitialised, it doesn't screw up HAM
                             ham->mAction.getCurrentHitPoints() - ham->mAction.getModifier(), //Llloydyboy Added the -Modifier so that when buffs are reinitialised, it doesn't screw up HAM
                             ham->mMind.getCurrentHitPoints() - ham->mMind.getModifier(),	 //Llloydyboy Added the -Modifier so that when buffs are reinitialised, it doesn't screw up HAM
                             ham->mHealth.getWounds(),
                             ham->mStrength.getWounds(),
                             ham->mConstitution.getWounds(),
                             ham->mAction.getWounds(),
                             ham->mQuickness.getWounds(),
                             ham->mStamina.getWounds(),
                             ham->mMind.getWounds(),
                             ham->mFocus.getWounds(),
                             ham->mWillpower.getWounds(),
                             ham->getBattleFatigue(),
                             playerObject->states.getPosture(),
                             playerObject->getMoodId(),
                             playerObject->getTitle().getAnsi(),
                             playerObject->getPlayerFlags(),
							 playerObject->states.getAction(),
                             playerObject->getLanguage(),
                             playerObject->getGroupId(),
                             playerObject->getId()));

    gBuffManager->SaveBuffs(playerObject, GetCurrentGlobalTick());
    if(remove)
        destroyObject(playerObject);
}
コード例 #5
0
void ObjectController::_handleQuickHeal(uint64 targetId,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
    PlayerObject* Medic = dynamic_cast<PlayerObject*>(mObject);
    PlayerObject* Target = dynamic_cast<PlayerObject*>(Medic->getHealingTarget(Medic));

    //check Medic has enough Mind
    Ham* ham = Medic->getHam();
    if(ham->checkMainPools(0, 0, cmdProperties->mMindCost))
    {
        if (gMedicManager->HealDamage(Medic, Target, 0, cmdProperties, "quickHeal"))
        {
            ham->updatePropertyValue(HamBar_Focus ,HamProperty_Wounds, 10);
            ham->updatePropertyValue(HamBar_Willpower ,HamProperty_Wounds, 10);
            ham->updateBattleFatigue(2, true);
            //call the event
            gMedicManager->startQuickHealInjuryTreatmentEvent(Medic);
            return;
        }
    }
    else
        gMessageLib->SendSystemMessage(::common::OutOfBand("healing_response", "not_enough_mind"), Medic);
}
コード例 #6
0
void ObjectController::_handleTendWound(uint64 targetId,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
    PlayerObject* Medic = dynamic_cast<PlayerObject*>(mObject);
    PlayerObject* Target = dynamic_cast<PlayerObject*>(Medic->getHealingTarget(Medic));
    //TODO:: add medic droid
    /*EMLocationType loc = Medic->getPlayerLocation();
    if(loc != EMLocation_Cantina || loc != EMLocation_Camp || loc != EMLocation_PlayerStructure)
    {
        return;
    }*/
    std::string messageResponse = gMedicManager->handleMessage(message,"(action|constitution|health|quickness|stamina|strength)");
    if (messageResponse.length() == 0)
    {
        //you must specify a valid wound type
        gMessageLib->SendSystemMessage(::common::OutOfBand("healing_response", "healing_response_65"), Medic);
    }
    else
    {
        //check Medic has enough Mind
        Ham* ham = Medic->getHam();
        if(ham->checkMainPools(0, 0, 500))
        {
            if (gMedicManager->HealWound(Medic, Target, 0, cmdProperties, messageResponse + "tendwound"))
            {
                ham->updatePropertyValue(HamBar_Focus ,HamProperty_Wounds, 5);
                ham->updatePropertyValue(HamBar_Willpower ,HamProperty_Wounds, 5);
                ham->updateBattleFatigue(2, true);
                //call the event
                gMedicManager->startWoundTreatmentEvent(Medic);
                return;
            }
        }
        else
            gMessageLib->SendSystemMessage(::common::OutOfBand("healing_response", "not_enough_mind"), Medic);

    }

}
コード例 #7
0
ファイル: CampRegion.cpp プロジェクト: Arnold47525/mmoserver
void	CampRegion::applyHAMHealing(Object* object)
{
	PlayerObject* player = dynamic_cast<PlayerObject*>(object);

	//Make sure it's a player.
	if(player == NULL)
		return;

	Ham* hamz = player->getHam();

	//Heal the Ham
	int32 HealthRegenRate = hamz->getHealthRegenRate();
	int32 ActionRegenRate = hamz->getActionRegenRate();
	int32 MindRegenRate = hamz->getMindRegenRate();

	//Because we tick every 2 seconds, we need to double this.
	HealthRegenRate += (int32)(HealthRegenRate * mHealingModifier) * 2;
	ActionRegenRate += (int32)(ActionRegenRate * mHealingModifier) * 2;
	MindRegenRate	+= (int32)(MindRegenRate * mHealingModifier) * 2;

	if(hamz->mHealth.getModifiedHitPoints() - hamz->mHealth.getCurrentHitPoints() > 0)
	{
		//Regen Health
		int32 oldVal = hamz->mHealth.getCurrentHitPoints();
		hamz->updatePropertyValue(HamBar_Health,HamProperty_CurrentHitpoints, HealthRegenRate);
		mHealingDone += hamz->mHealth.getCurrentHitPoints() - oldVal;
	}
	
	if(hamz->mAction.getModifiedHitPoints() - hamz->mAction.getCurrentHitPoints() > 0)
	{
		//Regen Action
		int32 oldVal = hamz->mAction.getCurrentHitPoints();
		hamz->updatePropertyValue(HamBar_Action,HamProperty_CurrentHitpoints, ActionRegenRate);
		mHealingDone += hamz->mAction.getCurrentHitPoints() - oldVal;
	}

	if(hamz->mMind.getModifiedHitPoints() - hamz->mMind.getCurrentHitPoints() > 0)
	{
		//Regen Mind
		int32 oldVal = hamz->mMind.getCurrentHitPoints();
		hamz->updatePropertyValue(HamBar_Mind, HamProperty_CurrentHitpoints, MindRegenRate);
		mHealingDone += hamz->mMind.getCurrentHitPoints() - oldVal;
	}

}
コード例 #8
0
ファイル: CampRegion.cpp プロジェクト: Arnold47525/mmoserver
void	CampRegion::applyWoundHealing(Object* object)
{
	PlayerObject* player = dynamic_cast<PlayerObject*>(object);

	//gLogger->logMsg("APPLYING WOUND HEALING!");

	//Make sure it's a player.
	if(player == NULL)
		return;

	Ham* hamz = player->getHam();

	if(hamz->mHealth.getWounds() > 0)
	{
		hamz->updatePropertyValue(HamBar_Health ,HamProperty_Wounds, -1);
		mHealingDone++;
	}

	if(hamz->mStrength.getWounds() > 0)
	{
		hamz->updatePropertyValue(HamBar_Strength ,HamProperty_Wounds, -1);
		mHealingDone++;
	}

	if(hamz->mConstitution.getWounds() > 0)
	{
		hamz->updatePropertyValue(HamBar_Constitution ,HamProperty_Wounds, -1);
		mHealingDone++;
	}

	if(hamz->mAction.getWounds() > 0)
	{
		hamz->updatePropertyValue(HamBar_Action ,HamProperty_Wounds, -1);
		mHealingDone++;
	}

	if(hamz->mQuickness.getWounds() > 0)
	{
		hamz->updatePropertyValue(HamBar_Quickness ,HamProperty_Wounds, -1);
		mHealingDone++;
	}

	if(hamz->mStamina.getWounds() > 0)
	{
		hamz->updatePropertyValue(HamBar_Stamina ,HamProperty_Wounds, -1);
		mHealingDone++;
	}

	if(hamz->mMind.getWounds() > 0)
	{
		hamz->updatePropertyValue(HamBar_Mind ,HamProperty_Wounds, -1);
		mHealingDone++;
	}

	if(hamz->mFocus.getWounds() > 0)
	{
		hamz->updatePropertyValue(HamBar_Focus ,HamProperty_Wounds, -1);
		mHealingDone++;
	}

	if(hamz->mWillpower.getWounds() > 0)
	{
		hamz->updatePropertyValue(HamBar_Willpower ,HamProperty_Wounds, -1);
		mHealingDone++;
	}

}
コード例 #9
0
//=============================================================================
//commits the changes of the ID session
//
void EntertainerManager::commitIdChanges(PlayerObject* customer,PlayerObject* designer, BString hair, uint32 amount,uint8 statMigration, BString holoEmote,uint8 flagHair)
{
    Ham* ham = designer->getHam();
    if(ham->checkMainPools(0,0,66))
    {
        //int32 mindCost = 66;
        designer->getHam()->updatePropertyValue(HamBar_Mind,HamProperty_CurrentHitpoints,-(66));
    }


    const PlayerObjectSet* const inRangePlayers	= customer->getKnownPlayers();
    PlayerObjectSet::const_iterator	itiR			= inRangePlayers->begin();

    int8 sql[1024];
    EntertainerManagerAsyncContainer* asyncContainer;

    //money
    if(amount >0)
        applyMoney(customer,designer,amount);


    ////////
    //Hair//
    ///////
    if(flagHair)
        applyHair(customer,hair);



    ////////////
    //attributes
    ///////////
    int8						mySQL[2048];
    AttributesList*				aList			 = customer->getIdAttributesList();
    AttributesList::iterator	it				 = aList->begin();
    BString						data;
    bool						firstUpdate		 = true;

    sprintf(mySQL,"UPDATE character_appearance set ");

    while(it != aList->end())
    {
        gLogger->log(LogManager::DEBUG,"ID apply changes : attribute : %s crc : %u", it->first.getAnsi(),it->first.getCrc());
        //apply the attributes and retrieve the data to update the db
        if(it->first.getCrc() != BString("height").getCrc())
        {
            data = commitIdAttribute(customer, it->first, it->second);
        }
        else
        {
            data = commitIdheight(customer, it->second);
        }


        if (firstUpdate)
        {
            sprintf(mySQL,"%s %s",mySQL,data.getAnsi());
            firstUpdate = false;
        }
        else
            sprintf(mySQL,"%s, %s",mySQL,data.getAnsi());

        ++it;
    }

    //colors
    ColorList* cList = customer->getIdColorList();
    ColorList::iterator cIt = cList->begin();
    while(cIt != cList->end())
    {
        gLogger->log(LogManager::DEBUG,"ID apply changes : attribute : %s crc : %u",cIt->first.getAnsi(),cIt->first.getCrc());
        data = commitIdColor(customer, cIt->first, cIt->second);
        if(data.getLength())
        {
            if (firstUpdate)
            {
                sprintf(mySQL,"%s %s",mySQL,data.getAnsi());
                firstUpdate = false;
            }
            else
                sprintf(mySQL,"%s, %s",mySQL,data.getAnsi());
        }


        ++cIt;
    }

    //do we have actual data or only the primer ??? "UPDATE character_appearance set "
    if(strlen(mySQL) > 33)
    {
        sprintf(sql,"%s where character_id = '%"PRIu64"'",mySQL,customer->getId());
        gLogger->log(LogManager::DEBUG,"ID apply changes : sql: %s ",sql);
        asyncContainer = new EntertainerManagerAsyncContainer(EMQuery_NULL,0);
        mDatabase->ExecuteSqlAsync(this,asyncContainer,sql);
        
    }




    //build plus send customization
    //please note that hair object customizatio is send updated and maintained b ycommitIdColor
    customer->buildCustomization(customer->getCustomization());

    gMessageLib->sendCustomizationUpdateCreo3(customer);
    gMessageLib->sendScaleUpdateCreo3(customer);

    //Holoemotes
    if(holoEmote.getLength())
        applyHoloEmote(customer,holoEmote);

    //statmigration
    if(statMigration)
    {
        //xp in case of statmigration will be handled by the callback
        int8 sql[256];
        asyncContainer = new EntertainerManagerAsyncContainer(EMQuery_IDMigrateStats,0);
        asyncContainer->customer = customer;
        asyncContainer->performer = designer;

        sprintf(sql,"SELECT target_health, target_strength, target_constitution, target_action, target_quickness, target_stamina, target_mind, target_focus, target_willpower FROM swganh.character_stat_migration where character_id = %"PRIu64"", customer->getId());
        mDatabase->ExecuteSqlAsync(this,asyncContainer,sql);
        
    }
    else
    {
        //XP does not stack. So in the case of statmigration only 2000xp will be given
        //otherwise xp will be determined here
        //
        uint32		xP		= 0;
        uint32		tempXP	= 0;

        it = aList->begin();
        while(it != aList->end())
        {
            tempXP = getIdXP(it->first, static_cast<uint16>(it->second));
            if(tempXP > xP)
                xP = tempXP;

            ++it;
        }

        cIt = cList->begin();
        while(cIt != cList->end())
        {
            tempXP = getIdXP(cIt->first, cIt->second);
            if(tempXP > xP)
                xP = tempXP;

            ++cIt;
        }

        if(flagHair)
        {
            tempXP = 50;
            if(tempXP > xP)
                xP = tempXP;
        }

        //only half XP if you design yourself
        if(designer == customer)
            gSkillManager->addExperience(XpType_imagedesigner,(uint32)(xP/2),designer);
        else
            gSkillManager->addExperience(XpType_imagedesigner,(uint32)xP,designer);
    }

    //empty the attribute lists
    aList->clear();
    cList->clear();

}
コード例 #10
0
ファイル: ArtisanManager.cpp プロジェクト: ANHcRush/mmoserver
bool ArtisanManager::handleRequestSurvey(Object* playerObject,Object* target,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
    PlayerObject*		player = dynamic_cast<PlayerObject*>(playerObject);
    std::shared_ptr<SimpleEvent> start_survey_event = nullptr;

    if(cmdProperties)
        mSurveyMindCost = cmdProperties->mMindCost;

    // don't allow survey in buildings
    if(player->getParentId())
    {
        gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "survey_in_structure"), player);
        return false;
    }
    if(player->getPerformingState() != PlayerPerformance_None)
    {
        gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "wrong_state"), player);
        return false;
    }
    if(player->getSurveyState())
    {
        gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "survey_cant"), player);
        return false;
    }
    if(player->getSamplingState())
    {
        gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "survey_sample"), player);
        return false;
    }

    SurveyTool*			tool			= dynamic_cast<SurveyTool*>(target);
    CurrentResource*	resource		= NULL;
    BString				resourceName;

    message->getStringUnicode16(resourceName);
    resourceName.convert(BSTRType_ANSI);

    resource = reinterpret_cast<CurrentResource*>(gResourceManager->getResourceByNameCRC(resourceName.getCrc()));

    if(tool && resource)
    {
        player->setSurveyState(true);

        // play effect
        std::string effect = gWorldManager->getClientEffect(tool->getInternalAttribute<uint32>("survey_effect"));
        gMessageLib->sendPlayClientEffectLocMessage(effect,player->mPosition,player);

        PlayerObjectSet*			playerList	= player->getKnownPlayers();
        PlayerObjectSet::iterator	it			= playerList->begin();

        while(it != playerList->end())
        {
            gMessageLib->sendPlayClientEffectLocMessage(effect,player->mPosition,(*it));

            ++it;
        }
        uint32 mindCost = mSurveyMindCost;
        Ham* hamz = player->getHam();
        //are we able to sample in the first place ??
        if(!hamz->checkMainPools(0,0,mindCost))
        {
            
            int32 myMind = hamz->mAction.getCurrentHitPoints();		
            
            //return message for sampling cancel based on HAM
            if(myMind < (int32)mindCost)
            {
                gMessageLib->SendSystemMessage(::common::OutOfBand("error_message", "sample_mind"), player);
            }

            //message for stop sampling
            gMessageLib->SendSystemMessage(::common::OutOfBand("survey", "sample_cancel"), player);

            player->getSampleData()->mPendingSurvey = false;

            hamz->updateRegenRates();
            player->updateMovementProperties();
            return false;
        }

        hamz->performSpecialAction(0,0,(float)mindCost,HamProperty_CurrentHitpoints);
        // send system message
        resourceName.convert(BSTRType_Unicode16);
        gMessageLib->SendSystemMessage(::common::OutOfBand("survey", "start_survey", L"", L"", resourceName.getUnicode16()), player);

        // schedule execution
        start_survey_event = std::make_shared<SimpleEvent>(EventType("start_survey"),0, 5000, 
            std::bind(&ArtisanManager::surveyEvent, this, player, resource, tool));
        
    }
    else
    {
        gMessageLib->SendSystemMessage(::common::OutOfBand("ui","survey_nothingfound"));
        return false;
    }
    // notify any listeners
    if (start_survey_event)
        gEventDispatcher.Notify(start_survey_event);
    return true;
}
コード例 #11
0
ファイル: ArtisanManager.cpp プロジェクト: ANHcRush/mmoserver
void ArtisanManager::handleUIEvent(uint32 action,int32 element,BString inputStr,UIWindow* window)
{
    PlayerObject* player = window->getOwner();
    std::shared_ptr<SimpleEvent> sample_UI_event = nullptr;
    if(!player)
    {
        return;
    }

    Inventory* inventory = dynamic_cast<Inventory*>(player->getEquipManager()->getEquippedObject(CreatureEquipSlot_Inventory));			
    if(!inventory)
    {
        return;
    }
    
    WindowAsyncContainerCommand* asyncContainer = (WindowAsyncContainerCommand*)window->getAsyncContainer();
    if(!asyncContainer)
        return;

    Ham* ham = player->getHam();
    
    switch(window->getWindowType())
    {
        // Sampling Radioactive Msg Box
        case SUI_Window_SmplRadioactive_MsgBox:
        {
            //we stopped the sampling
            if(action == 1)
            {
                player->getSampleData()->mPassRadioactive = false;
                player->getSampleData()->mPendingSample = false;
                gStateManager.setCurrentPostureState(player, CreaturePosture_Upright);
                return;
            }
            else
            {    
                player->getSampleData()->mPassRadioactive = true;
                player->getSampleData()->mPendingSample = true;
                
                if(ham->checkMainPools(0,mSampleActionCost*2,0))
                {

                    SurveyTool*			tool					= dynamic_cast<SurveyTool*>(inventory->getObjectById(asyncContainer->ToolId));
                    CurrentResource*	resource				= (CurrentResource*)asyncContainer->CurrentResource;
                    player->getSampleData()->mNextSampleTime	= Anh_Utils::Clock::getSingleton()->getLocalTime() + 4000;

                    sample_UI_event = std::make_shared<SimpleEvent>(EventType("sample_radioactive"),0, 4000, 
                        std::bind(&ArtisanManager::sampleEvent,this, player, resource, tool));

                }
                else
                {
                    gMessageLib->SendSystemMessage(::common::OutOfBand("survey", "gamble_no_action"), player);
                    return;
                }
            }
        }
        break;

        case SUI_Window_SmplGamble_ListBox:
        {
            //action == 1 is cancel
            if(action == 1)
            {
                player->getSampleData()->mPendingSample = false;
                player->getSampleData()->mSampleGambleFlag = false;
                gStateManager.setCurrentPostureState(player, CreaturePosture_Upright);
                player->updateMovementProperties();
                gMessageLib->sendUpdateMovementProperties(player);
                gMessageLib->sendPostureAndStateUpdate(player);
                gMessageLib->sendSelfPostureUpdate(player);
                return;

            }
            else
            {
                if(element == 0)
                {
                    player->getSampleData()->mPendingSample = true;
                    player->getSampleData()->mSampleGambleFlag = false;

                    SurveyTool*			tool		= dynamic_cast<SurveyTool*>(inventory->getObjectById(asyncContainer->ToolId));
                    CurrentResource*	resource	= (CurrentResource*)asyncContainer->CurrentResource;
                    player->getSampleData()->mNextSampleTime = Anh_Utils::Clock::getSingleton()->getLocalTime() + 1000;
                
                    sample_UI_event = std::make_shared<SimpleEvent>(EventType("sample_gamble"),0, 1000, 
                        std::bind(&ArtisanManager::sampleEvent,this, player, resource, tool));
                    
                }
                else
                {
                    //action costs
                    if(!ham->checkMainPools(0,mSampleActionCost*2,0))
                    {
                        gStateManager.setCurrentPostureState(player, CreaturePosture_Upright);
                        player->getSampleData()->mSampleEventFlag = false;
                        player->getSampleData()->mSampleGambleFlag = false;
                        gMessageLib->SendSystemMessage(::common::OutOfBand("survey", "gamble_no_action"), player);
                        return;
                    }
                    player->getSampleData()->mPendingSample = true;

                    //determine whether gamble is good or not
                    int32 gambleRoll = int(gRandom->getRand()%2) + 1;

                    if(gambleRoll == 1)
                    {
                        player->getSampleData()->mSampleEventFlag = true;
                        player->getSampleData()->mSampleGambleFlag = true;
                    }
                    else
                    {
                        player->getSampleData()->mSampleEventFlag = false;
                        player->getSampleData()->mSampleGambleFlag = false;
                        gMessageLib->SendSystemMessage(::common::OutOfBand("survey", "gamble_fail"), player);
                    }
        
                    SurveyTool*			tool		= dynamic_cast<SurveyTool*>(inventory->getObjectById(asyncContainer->ToolId));
                    CurrentResource*	resource	= (CurrentResource*)asyncContainer->CurrentResource;
                    player->getSampleData()->mNextSampleTime = Anh_Utils::Clock::getSingleton()->getLocalTime() + 1000;
                    
                    sample_UI_event = std::make_shared<SimpleEvent>(EventType("sample_gamble"),0, 1000, 
                        std::bind(&ArtisanManager::sampleEvent,this, player, resource, tool));
                    
                }
            }
        }
        break;

        case SUI_Window_SmplWaypNode_ListBox:
        {
            if(action == 0)
            {
                //we hit ok and went for the wp
                if(element == 1)
                {				
                    player->getSampleData()->mPendingSample	= false;
                    player->getSampleData()->mSampleNodeFlag = true;
                    
                    player->getSampleData()->Position.x = player->mPosition.x +(((gRandom->getRand()%50)+1));
                    player->getSampleData()->Position.z = player->mPosition.z +(((gRandom->getRand()%50)+1));
                    player->getSampleData()->zone		= gWorldManager->getZoneId();
                    player->getSampleData()->resource	= (CurrentResource*)asyncContainer->CurrentResource;

                    
                    Datapad* datapad			= player->getDataPad();
                    datapad->requestNewWaypoint("Resource Node", player->getSampleData()->Position ,static_cast<uint16>(gWorldManager->getZoneId()),Waypoint_blue);
                    gMessageLib->SendSystemMessage(::common::OutOfBand("survey", "node_waypoint"), player);

                    gStateManager.setCurrentPostureState(player, CreaturePosture_Upright);
                    return;
                }
                //we ignored the node - so continue sampling
                if(element == 0)
                {				
                    player->getSampleData()->mPendingSample = true;
                    player->getSampleData()->mSampleGambleFlag = false;

                    SurveyTool*			tool		= dynamic_cast<SurveyTool*>(inventory->getObjectById(asyncContainer->ToolId));
                    CurrentResource*	resource	= (CurrentResource*)asyncContainer->CurrentResource;
                    player->getSampleData()->mNextSampleTime = Anh_Utils::Clock::getSingleton()->getLocalTime() + 10000;
                    
                    sample_UI_event = std::make_shared<SimpleEvent>(EventType("sample_continue"),0, 10000, 
                        std::bind(&ArtisanManager::sampleEvent,this, player, resource, tool));
                    
                }
            }
            else
            {
                player->getSampleData()->mPendingSample = false;
                player->getSampleData()->mSampleNodeFlag = false;
                player->getSampleData()->Position.x = 0;
                player->getSampleData()->Position.z = 0;
                player->getSampleData()->resource	= NULL;
                player->getSampleData()->zone		= 0;

                gStateManager.setCurrentPostureState(player, CreaturePosture_Upright);
                return;				
            }
        }
        break;
    }
    //notify the listeners
    if (sample_UI_event)
        gEventDispatcher.Notify(sample_UI_event);
    SAFE_DELETE(asyncContainer);
}
コード例 #12
0
//=============================================================================
//
// database callback
//
void ObjectController::handleDatabaseJobComplete(void* ref,DatabaseResult* result)
{
    ObjControllerAsyncContainer* asyncContainer = reinterpret_cast<ObjControllerAsyncContainer*>(ref);

    switch(asyncContainer->mQueryType)
    {
    case OCQuery_StatRead:
    {
        if(!asyncContainer->playerObject)
            break;

        Ham* ourHam = asyncContainer->playerObject->getHam();

        StatTargets theTargets;

        DataBinding* binding = mDatabase->createDataBinding(9);
        binding->addField(DFT_uint32,offsetof(StatTargets,TargetHealth),4,0);
        binding->addField(DFT_uint32,offsetof(StatTargets,TargetStrength),4,1);
        binding->addField(DFT_uint32,offsetof(StatTargets,TargetConstitution),4,2);
        binding->addField(DFT_uint32,offsetof(StatTargets,TargetAction),4,3);
        binding->addField(DFT_uint32,offsetof(StatTargets,TargetQuickness),4,4);
        binding->addField(DFT_uint32,offsetof(StatTargets,TargetStamina),4,5);
        binding->addField(DFT_uint32,offsetof(StatTargets,TargetMind),4,6);
        binding->addField(DFT_uint32,offsetof(StatTargets,TargetFocus),4,7);
        binding->addField(DFT_uint32,offsetof(StatTargets,TargetWillpower),4,8);

        uint64	count	= result->getRowCount();
        //make sure we have some values set in case the statmigration table wont hold anything on us
        if(count != 1)
        {
            ourHam->setTargetStatValue(HamBar_Health,ourHam->getPropertyValue(HamBar_Health,HamProperty_BaseHitpoints));
            ourHam->setTargetStatValue(HamBar_Strength,ourHam->getPropertyValue(HamBar_Strength,HamProperty_BaseHitpoints));
            ourHam->setTargetStatValue(HamBar_Constitution,ourHam->getPropertyValue(HamBar_Constitution,HamProperty_BaseHitpoints));

            ourHam->setTargetStatValue(HamBar_Action,ourHam->getPropertyValue(HamBar_Action,HamProperty_BaseHitpoints));
            ourHam->setTargetStatValue(HamBar_Quickness,ourHam->getPropertyValue(HamBar_Quickness,HamProperty_BaseHitpoints));
            ourHam->setTargetStatValue(HamBar_Stamina,ourHam->getPropertyValue(HamBar_Stamina,HamProperty_BaseHitpoints));

            ourHam->setTargetStatValue(HamBar_Mind,ourHam->getPropertyValue(HamBar_Mind,HamProperty_BaseHitpoints));
            ourHam->setTargetStatValue(HamBar_Focus,ourHam->getPropertyValue(HamBar_Focus,HamProperty_BaseHitpoints));
            ourHam->setTargetStatValue(HamBar_Willpower,ourHam->getPropertyValue(HamBar_Willpower,HamProperty_BaseHitpoints));

        }
        else
        {
            result->getNextRow(binding,&theTargets);
            ourHam->setTargetStatValue(HamBar_Health,theTargets.TargetHealth);
            ourHam->setTargetStatValue(HamBar_Strength,theTargets.TargetStrength);
            ourHam->setTargetStatValue(HamBar_Constitution,theTargets.TargetConstitution);

            ourHam->setTargetStatValue(HamBar_Action,theTargets.TargetAction);
            ourHam->setTargetStatValue(HamBar_Quickness,theTargets.TargetQuickness);
            ourHam->setTargetStatValue(HamBar_Stamina,theTargets.TargetStamina);

            ourHam->setTargetStatValue(HamBar_Mind,theTargets.TargetMind);
            ourHam->setTargetStatValue(HamBar_Focus,theTargets.TargetFocus);
            ourHam->setTargetStatValue(HamBar_Willpower,theTargets.TargetWillpower);
        }

        mDatabase->destroyDataBinding(binding);
        gMessageLib->sendStatMigrationStartMessage(asyncContainer->playerObject);
    }
    break;

    case OCQuery_FindFriend:
    {
        DataBinding* binding = mDatabase->createDataBinding(1);
        binding->addField(DFT_uint64,0,8);

        uint64	ret		= 0;
        uint64	count	= result->getRowCount();

        result->getNextRow(binding,&ret);

        mDatabase->destroyDataBinding(binding);
        if(count == 0)
            ret = 0;

        _handleFindFriendDBReply(ret,asyncContainer->mString);

    }
    break;

    case OCQuery_AddFriend:
    {
        DataBinding* binding = mDatabase->createDataBinding(1);
        binding->addField(DFT_uint32,0,4);

        uint32	ret		= 0;
        //uint64	count	= result->getRowCount();

        result->getNextRow(binding,&ret);

        mDatabase->destroyDataBinding(binding);

        _handleAddFriendDBReply(ret,asyncContainer->mString);
    }
    break;

    case OCQuery_RemoveFriend:
    {
        DataBinding* binding = mDatabase->createDataBinding(1);
        binding->addField(DFT_uint32,0,4);

        uint32	ret		= 0;
        //uint64	count	= result->getRowCount();

        result->getNextRow(binding,&ret);

        mDatabase->destroyDataBinding(binding);

        _handleRemoveFriendDBReply(ret,asyncContainer->mString);
    }
    break;

    case OCQuery_AddIgnore:
    {
        DataBinding* binding = mDatabase->createDataBinding(1);
        binding->addField(DFT_uint32,0,4);

        uint32	ret		= 0;
        //uint64	count	= result->getRowCount();

        result->getNextRow(binding,&ret);

        mDatabase->destroyDataBinding(binding);

        _handleAddIgnoreDBReply(ret,asyncContainer->mString);
    }
    break;

    case OCQuery_RemoveIgnore:
    {
        DataBinding* binding = mDatabase->createDataBinding(1);
        binding->addField(DFT_uint32,0,4);

        uint32	ret		= 0;
        //uint64	count	= result->getRowCount();

        result->getNextRow(binding,&ret);

        mDatabase->destroyDataBinding(binding);

        _handleRemoveIgnoreDBReply(ret,asyncContainer->mString);
    }
    break;

    case OCQuery_CloneAtPreDes:
    {
        if (!asyncContainer->playerObject)
            break;

        if (!result->getRowCount()) {
        	break;
        }

        DataBinding* binding = mDatabase->createDataBinding(9);
        binding->addField(DFT_uint32,offsetof(PlayerObject,mHam.mHealth.mWounds),4,0);
        binding->addField(DFT_uint32,offsetof(PlayerObject,mHam.mStrength.mWounds),4,1);
        binding->addField(DFT_uint32,offsetof(PlayerObject,mHam.mConstitution.mWounds),4,2);
        binding->addField(DFT_uint32,offsetof(PlayerObject,mHam.mAction.mWounds),4,3);
        binding->addField(DFT_uint32,offsetof(PlayerObject,mHam.mQuickness.mWounds),4,4);
        binding->addField(DFT_uint32,offsetof(PlayerObject,mHam.mStamina.mWounds),4,5);
        binding->addField(DFT_uint32,offsetof(PlayerObject,mHam.mMind.mWounds),4,6);
        binding->addField(DFT_uint32,offsetof(PlayerObject,mHam.mFocus.mWounds),4,7);
        binding->addField(DFT_uint32,offsetof(PlayerObject,mHam.mWillpower.mWounds),4,8);

        result->getNextRow(binding,asyncContainer->playerObject);

        // Update HAM
        // asyncContainer->playerObject->getHam()->calcAllModifiedHitPoints();
        asyncContainer->playerObject->getHam()->updateAllWounds(0);

        // Invoke the actual cloning process.
        SpawnPoint* sp = reinterpret_cast<SpawnPoint*>(asyncContainer->anyPtr);
        if (sp)
        {
            asyncContainer->playerObject->clone(sp->mCellId,sp->mDirection,sp->mPosition,true);
        }

        mDatabase->destroyDataBinding(binding);
    }
    break;

    default:
    {
    }
    break;
    }

    mDBAsyncContainerPool.free(asyncContainer);
}