C++ GenericModule::getItem方法代码示例

int32 ModuleManager::Activate(uint32 itemID, std::string effectName, uint32 targetID, uint32 repeat)
{
    SysLog::Debug("Activate","Needs to be implemented");
    //return 1;

    GenericModule * mod = m_Modules->GetModule(itemID);
    if( mod != NULL )
    {
		if(effectName == "online")
		{
			//ModuleCommand cmd = _translateEffectName(effectName);		// GET RID of this function, effectName should be passed into the module's calls
			mod->online();

			// We should check for "online" here or something else, then either call the mod->Online() or mod->Activate()
			//if(cmd == ONLINE)
		    //    mod->Online();     // this currently fails since m_selectedEffect and m_defaultEffect in the ModuleEffect class are undefined
			//there needs to be more cases here i just don't know what they're called yet
		}
		else
		{
			SystemEntity * targetEntity = this->m_Ship->GetOperator()->GetDestiny()->GetCurrentBubble()->GetEntity(targetID);
			mod->activate(targetEntity);
			m_pLog->Log("ModuleManager::Activate()", "Module '%s' Activating...", mod->getItem()->itemName().c_str());
		}
    }

    return 1;
}

void ModuleManager::DamageModule(uint32 itemID, EvilNumber val)
{
    GenericModule * mod = m_Modules->GetModule(itemID);
    if( mod != NULL)
    {
        mod->getItem()->setAttribute(AttrHp, val);
    }
}

void ModuleManager::Offline(uint32 itemID)
{
    GenericModule * mod = m_Modules->GetModule(itemID);
    if( mod != NULL )
	{
        mod->offline();
		m_pLog->Log("ModuleManager::Offline()", "Module '%s' going Offline", mod->getItem()->itemName().c_str());
	}
}

void ModuleManager::Deactivate(uint32 itemID, std::string effectName)
{
    GenericModule * mod = m_Modules->GetModule(itemID);
    if( mod != NULL )
    {
        ModuleCommand cmd = _translateEffectName(effectName);
        mod->getItem()->PutOffline();
        //if(cmd == OFFLINE)
        //    mod->Offline();     // this currently fails since m_selectedEffect and m_defaultEffect in the ModuleEffect class are undefined
        //there needs to be more cases here i just don't know what they're called yet
    }
}

int32 ModuleManager::Activate(uint32 itemID, std::string effectName, uint32 targetID, uint32 repeat)
{
    //sLog.Debug("Activate","Needs to be implemented");
    //return 1;

    GenericModule * mod = m_Modules->GetModule(itemID);
    if( mod != NULL )
    {
        ModuleCommand cmd = _translateEffectName(effectName);
        mod->getItem()->PutOnline();
        //if(cmd == ONLINE)
        //    mod->Online();     // this currently fails since m_selectedEffect and m_defaultEffect in the ModuleEffect class are undefined
        //there needs to be more cases here i just don't know what they're called yet
    }

    return 1;
}

void ModuleManager::Deactivate(uint32 itemID, std::string effectName)
{
    GenericModule * mod = m_Modules->GetModule(itemID);
    if( mod != NULL )
    {
		if(effectName == "online")
		{
			//ModuleCommand cmd = _translateEffectName(effectName);		// GET RID of this function, effectName should be passed into the module's calls
			mod->offline();

			// We should check for "online" here or something else, then either call the mod->Offline() or mod->Deactivate()
			//if(cmd == OFFLINE)
			//    mod->Offline();     // this currently fails since m_selectedEffect and m_defaultEffect in the ModuleEffect class are undefined
			//there needs to be more cases here i just don't know what they're called yet
		}
		else
		{
			mod->deactivate();
			m_pLog->Log("ModuleManager::Deactivate()", "Module '%s' Deactivating...", mod->getItem()->itemName().c_str());
		}
    }
}

void ModuleManager::_processExternalEffect(SubEffect * s)
{
    //50-50 it's targeting a specific module ( i'm assuming here )
    GenericModule * mod = m_Modules->GetModule(s->TargetItemID());
    if( mod != NULL)
    {
        auto item = mod->getItem();
        //calculate new attribute
        item->setAttribute(s->AttributeID(),
                           CalculateNewAttributeValue(item->getAttribute(s->AttributeID()),
                                                                       s->AppliedValue(), s->CalculationType()));
    }
    else if( s->TargetItemID() == m_Ship->itemID() ) //guess it's not, but that means it should be targeting our ship itself
    {
        //calculate new attribute
        m_Ship->setAttribute(s->AttributeID(),
                             CalculateNewAttributeValue(m_Ship->getAttribute(s->AttributeID()),
                                                                             s->AppliedValue(), s->CalculationType()));
    }
    else //i have no idea what their targeting X_X
        SysLog::Error("ModuleManager", "Process external effect inconsistency.  This shouldn't happen");

}

bool ModuleManager::_fitModule(InventoryItemRef item, EVEItemFlags flag)
{
    bool verifyFailed = false;
	GenericModule * mod;

	// First, check to see if this module item is already fitted, and if so, let's instruct ModuleContainer to move the module
	GenericModule * existingMod = m_Modules->GetModule(item->itemID());

	if( existingMod != NULL )
	{
		if( m_Modules->isSlotOccupied(flag) )
		{
			throw PyException( MakeUserError( "SlotAlreadyOccupied" ) );
			verifyFailed = true;
		}

		m_Modules->RemoveModule( existingMod->flag() );		// Remove this module from existing slot
		existingMod->getItem()->SetFlag( flag );			// Change item's flag to the NEW slot flag
		m_Modules->AddModule( flag, existingMod );			// Add this module back to the container at the NEW slot location
	}
	else
	{
		mod = ModuleFactory(item, ShipRef(m_Ship));

		// Set module's pointer to its owner ModuleManager's log object:
		mod->setLog(m_pLog);

		// Check for max turret modules allowed:
		if( mod->isTurretFitted() && (m_Modules->GetFittedTurretCount() == m_Ship->GetMaxTurrentHardpoints().get_int()) )
		{
			//std::map<std::string, PyRep *> args;
			//args["typename"] = new PyString(item->itemName().c_str());
			//args["portion"] = new PyInt(item->type().portionSize());

			throw PyException( MakeUserError( "NotEnoughTurretSlots" ) );
			verifyFailed = true;
		}
		// Check for max launcher modules allowed:
		if( mod->isLauncherFitted() && (m_Modules->GetFittedLauncherCount() == m_Ship->GetMaxLauncherHardpoints().get_int()) )
		{
			//std::map<std::string, PyRep *> args;
			//args["typename"] = new PyString(item->itemName().c_str());
			//args["portion"] = new PyInt(item->type().portionSize());

			throw PyException( MakeUserError( "NotEnoughLauncherSlots" ) );
			verifyFailed = true;
		}
		// Check for max modules of group allowed:
		else if( mod->isMaxGroupFitLimited() && (m_Modules->GetFittedModuleCountByGroup(item->groupID()) == mod->getItem()->GetAttribute(AttrMaxGroupFitted).get_int()) )
		{
			//std::map<std::string, PyRep *> args;
			//args["typename"] = new PyString(item->itemName().c_str());
			//args["portion"] = new PyInt(item->type().portionSize());

			throw PyException( MakeUserError( "CantFitTooManyByGroup" ) );
			verifyFailed = true;
		}
		else
		{
			// Fit Module now that all checks have passed:
			m_Modules->AddModule(flag, mod);
		}
	}

    if( verifyFailed )
    {
        if( mod != NULL )
			delete mod;
        return false;
    }
    else
        return true;
}

bool ModuleManager::_fitModule(InventoryItemRef item, EVEItemFlags flag)
{
    bool verifyFailed = false;
    GenericModule * mod = ModuleFactory(item, ShipRef(m_Ship));

    // Check for max turret modules allowed:
    if( mod->isTurretFitted() && (m_Modules->GetFittedTurretCount() == m_Ship->GetMaxTurrentHardpoints().get_int()) )
    {
        //std::map<std::string, PyRep *> args;
        //args["typename"] = new PyString(item->itemName().c_str());
        //args["portion"] = new PyInt(item->type().portionSize());

        throw PyException( MakeUserError( "NotEnoughTurretSlots" ) );
        verifyFailed = true;
    }
    // Check for max launcher modules allowed:
    if( mod->isLauncherFitted() && (m_Modules->GetFittedLauncherCount() == m_Ship->GetMaxLauncherHardpoints().get_int()) )
    {
        //std::map<std::string, PyRep *> args;
        //args["typename"] = new PyString(item->itemName().c_str());
        //args["portion"] = new PyInt(item->type().portionSize());

        throw PyException( MakeUserError( "NotEnoughLauncherSlots" ) );
        verifyFailed = true;
    }
    // Check for max modules of group allowed:
    else if( mod->isMaxGroupFitLimited() && (m_Modules->GetFittedModuleCountByGroup(item->groupID()) == mod->getItem()->GetAttribute(AttrMaxGroupFitted).get_int()) )
    {
        //std::map<std::string, PyRep *> args;
        //args["typename"] = new PyString(item->itemName().c_str());
        //args["portion"] = new PyInt(item->type().portionSize());

        throw PyException( MakeUserError( "CantFitTooManyByGroup" ) );
        verifyFailed = true;
    }
    else
    {
        // Fit Module now that all checks have passed:
        //m_Modules->AddModule(mod->flag(), mod);
        m_Modules->AddModule(flag, mod);
    }

    if( verifyFailed )
    {
        delete mod;
        return false;
    }
    else
        return true;
}