bool RamProxyService::_Calculate(const Call_InstallJob &args, InventoryItemRef installedItem, Client *const c, Rsp_InstallJob &into) {
if(!m_db.GetAssemblyLineProperties(args.installationAssemblyLineID, into.materialMultiplier, into.timeMultiplier, into.installCost, into.usageCost))
return false;
const ItemType *productType;
// perform some activity-specific actions
switch(args.activityID) {
/*
* Manufacturing
*/
case ramActivityManufacturing: {
BlueprintRef bp = BlueprintRef::StaticCast( installedItem );
productType = &bp->productType();
into.productionTime = bp->type().productionTime();
into.materialMultiplier *= bp->materialMultiplier();
into.timeMultiplier *= bp->timeMultiplier();
into.charMaterialMultiplier = c->GetChar()->GetAttribute(AttrManufactureCostMultiplier).get_float();
into.charTimeMultiplier = c->GetChar()->GetAttribute(AttrManufactureTimeMultiplier).get_float();
switch(productType->race()) {
case raceCaldari: into.charTimeMultiplier *= double(c->GetChar()->GetAttribute(AttrCaldariTechTimePercent).get_int()) / 100.0; break;
case raceMinmatar: into.charTimeMultiplier *= double(c->GetChar()->GetAttribute(AttrMinmatarTechTimePercent).get_int()) / 100.0; break;
case raceAmarr: into.charTimeMultiplier *= double(c->GetChar()->GetAttribute(AttrAmarrTechTimePercent).get_int()) / 100.0; break;
case raceGallente: into.charTimeMultiplier *= double(c->GetChar()->GetAttribute(AttrGallenteTechTimePercent).get_int()) / 100.0; break;
case raceJove: break;
case racePirate: break;
}
break;
}
/*
* Time productivity research
*/
case ramActivityResearchingTimeProductivity: {
BlueprintRef bp = BlueprintRef::StaticCast( installedItem );
productType = &installedItem->type();
into.productionTime = bp->type().researchProductivityTime();
into.charMaterialMultiplier = double(c->GetChar()->GetAttribute(AttrResearchCostPercent).get_int()) / 100.0;
into.charTimeMultiplier = c->GetChar()->GetAttribute(AttrManufacturingTimeResearchSpeed).get_float();
break;
}
/*
* Material productivity research
*/
case ramActivityResearchingMaterialProductivity: {
BlueprintRef bp = BlueprintRef::StaticCast( installedItem );
productType = &installedItem->type();
into.productionTime = bp->type().researchMaterialTime();
into.charMaterialMultiplier = double(c->GetChar()->GetAttribute(AttrResearchCostPercent).get_int()) / 100.0;
into.charTimeMultiplier = c->GetChar()->GetAttribute(AttrMineralNeedResearchSpeed).get_float();
break;
}
/*
* Copying
*/
case ramActivityCopying: {
BlueprintRef bp = BlueprintRef::StaticCast( installedItem );
productType = &installedItem->type();
// no ceil() here on purpose
into.productionTime = (bp->type().researchCopyTime() / bp->type().maxProductionLimit()) * args.licensedProductionRuns;
into.charMaterialMultiplier = double(c->GetChar()->GetAttribute(AttrResearchCostPercent).get_int()) / 100.0;
into.charTimeMultiplier = c->GetChar()->GetAttribute(AttrCopySpeedPercent).get_float();
break;
}
default: {
productType = &installedItem->type();
into.charMaterialMultiplier = 1.0;
into.charTimeMultiplier = 1.0;
break;
}
}
if(!m_db.MultiplyMultipliers(args.installationAssemblyLineID, productType->groupID(), into.materialMultiplier, into.timeMultiplier))
return false;
// calculate the remaining things
into.productionTime *= static_cast<int32>(into.timeMultiplier * into.charTimeMultiplier * args.runs);
into.usageCost *= ceil(into.productionTime / 3600.0);
into.cost = into.installCost + into.usageCost;
// I "hope" this is right, simple tells client how soon will his job be started
// Unfortunately, rounding done on client's side causes showing "Start time: 0 seconds" when he has to wait less than minute
// I have no idea how to avoid this ...
into.maxJobStartTime = m_db.GetNextFreeTime(args.installationAssemblyLineID);
return true;
}
void RamProxyService::_VerifyInstallJob_Call(const Call_InstallJob &args, InventoryItemRef installedItem, const PathElement &bomLocation, Client *const c) {
// ACTIVITY CHECK
// ***************
const ItemType *productType;
switch(args.activityID) {
/*
* Manufacturing
*/
case ramActivityManufacturing: {
if(installedItem->categoryID() != EVEDB::invCategories::Blueprint)
throw(PyException(MakeUserError("RamActivityRequiresABlueprint")));
BlueprintRef bp = BlueprintRef::StaticCast( installedItem );
if(!bp->infinite() && (bp->licensedProductionRunsRemaining() - args.runs) < 0)
throw(PyException(MakeUserError("RamTooManyProductionRuns")));
productType = &bp->productType();
break;
}
/*
* Time/Material Research
*/
case ramActivityResearchingMaterialProductivity:
case ramActivityResearchingTimeProductivity: {
if(installedItem->categoryID() != EVEDB::invCategories::Blueprint)
throw(PyException(MakeUserError("RamActivityRequiresABlueprint")));
BlueprintRef bp = BlueprintRef::StaticCast( installedItem );
if(bp->copy())
throw(PyException(MakeUserError("RamCannotResearchABlueprintCopy")));
productType = &bp->type();
break;
}
/*
* Copying
*/
case ramActivityCopying: {
if(installedItem->categoryID() != EVEDB::invCategories::Blueprint)
throw(PyException(MakeUserError("RamActivityRequiresABlueprint")));
BlueprintRef bp = BlueprintRef::StaticCast( installedItem );
if(bp->copy())
throw(PyException(MakeUserError("RamCannotCopyABlueprintCopy")));
productType = &bp->type();
break;
}
/*
* The rest
*/
case ramActivityResearchingTechnology:
case ramActivityDuplicating:
case ramActivityReverseEngineering:
case ramActivityInvention: /* {
if(installedItem->categoryID() != EVEDB::invCategories::Blueprint)
throw(PyException(MakeUserError("RamActivityRequiresABlueprint")));
Blueprint *bp = (Blueprint *)installedItem;
if(!bp->copy())
throw(PyException(MakeUserError("RamCannotInventABlueprintOriginal")));
uint32 productTypeID = m_db.GetTech2Blueprint(installedItem->typeID());
if(productTypeID == NULL)
throw(PyException(MakeUserError("RamInventionNoOutput")));
productType = m_manager->item_factory.type(productTypeID);
break;
} */
default: {
// not supported
throw(PyException(MakeUserError("RamActivityInvalid")));
//throw(PyException(MakeUserError("RamNoKnownOutputType")));
}
}
if(!m_db.IsProducableBy(args.installationAssemblyLineID, productType->groupID()))
throw(PyException(MakeUserError("RamBadEndProductForActivity")));
// JOBS CHECK
// ***********
if(args.activityID == ramActivityManufacturing) {
uint32 jobCount = m_db.CountManufacturingJobs(c->GetCharacterID());
if(c->GetChar()->GetAttribute(AttrManufactureSlotLimit).get_int() <= jobCount) {
std::map<std::string, PyRep *> exceptArgs;
exceptArgs["current"] = new PyInt(jobCount);
exceptArgs["max"] = c->GetChar()->GetAttribute(AttrManufactureSlotLimit).GetPyObject();
throw(PyException(MakeUserError("MaxFactorySlotUsageReached", exceptArgs)));
}
} else {
uint32 jobCount = m_db.CountResearchJobs(c->GetCharacterID());
if(c->GetChar()->GetAttribute(AttrMaxLaborotorySlots).get_int() <= jobCount) {
std::map<std::string, PyRep *> exceptArgs;
exceptArgs["current"] = new PyInt(jobCount);
exceptArgs["max"] = c->GetChar()->GetAttribute(AttrMaxLaborotorySlots).GetPyObject();
throw(PyException(MakeUserError("MaxResearchFacilitySlotUsageReached", exceptArgs)));
}
}
// INSTALLATION CHECK
// *******************
uint32 regionID = m_db.GetRegionOfContainer(args.installationContainerID);
if(regionID == 0)
throw(PyException(MakeUserError("RamIsNotAnInstallation")));
if(c->GetRegionID() != regionID)
throw(PyException(MakeUserError("RamRangeLimitationRegion")));
// RamStructureNotInSpace
// RamStructureNotIsSolarsystem
// RamRangeLimitation
// RamRangeLimitationJumps
// RamRangeLimitationJumpsNoSkill
// ASSEMBLY LINE CHECK
// *********************
uint32 ownerID;
double minCharSec, maxCharSec;
EVERamRestrictionMask restrictionMask;
EVERamActivity activity;
// get properties
if(!m_db.GetAssemblyLineVerifyProperties(args.installationAssemblyLineID, ownerID, minCharSec, maxCharSec, restrictionMask, activity))
throw(PyException(MakeUserError("RamInstallationHasNoDefaultContent")));
// check validity of activity
if(activity < ramActivityManufacturing || activity > ramActivityInvention)
throw(PyException(MakeUserError("RamAssemblyLineHasNoActivity")));
// check security rating if required
if((restrictionMask & ramRestrictBySecurity) == ramRestrictBySecurity) {
if(minCharSec > c->GetSecurityRating())
throw(PyException(MakeUserError("RamAccessDeniedSecStatusTooLow")));
if(maxCharSec < c->GetSecurityRating())
throw(PyException(MakeUserError("RamAccessDeniedSecStatusTooHigh")));
// RamAccessDeniedCorpSecStatusTooHigh
// RamAccessDeniedCorpSecStatusTooLow
}
// check standing if required
if((restrictionMask & ramRestrictByStanding) == ramRestrictByStanding) {
// RamAccessDeniedCorpStandingTooLow
// RamAccessDeniedStandingTooLow
}
if((restrictionMask & ramRestrictByAlliance) == ramRestrictByAlliance) {
// if(...)
throw(PyException(MakeUserError("RamAccessDeniedWrongAlliance")));
} else if((restrictionMask & ramRestrictByCorp) == ramRestrictByCorp) {
if(ownerID != c->GetCorporationID())
throw(PyException(MakeUserError("RamAccessDeniedWrongCorp")));
}
if(args.isCorpJob) {
if((c->GetCorpRole() & corpRoleFactoryManager) != corpRoleFactoryManager)
throw(PyException(MakeUserError("RamCannotInstallForCorpByRoleFactoryManager")));
if(args.activityID == ramActivityManufacturing) {
if((c->GetCorpRole() & corpRoleCanRentFactorySlot) != corpRoleCanRentFactorySlot)
throw(PyException(MakeUserError("RamCannotInstallForCorpByRole")));
} else {
if((c->GetCorpRole() & corpRoleCanRentResearchSlot) != corpRoleCanRentResearchSlot)
throw(PyException(MakeUserError("RamCannotInstallForCorpByRole")));
}
}
// INSTALLED ITEM CHECK
// *********************
// ownership
if(args.isCorpJob) {
if(installedItem->ownerID() != c->GetCorporationID())
throw(PyException(MakeUserError("RamCannotInstallItemForAnotherCorp")));
} else {
if(installedItem->ownerID() != c->GetCharacterID())
throw(PyException(MakeUserError("RamCannotInstallItemForAnother")));
}
// corp hangar permission
if( (installedItem->flag() == flagCorpSecurityAccessGroup2 && (c->GetCorpRole() & corpRoleHangarCanTake2) != corpRoleHangarCanTake2)
|| (installedItem->flag() == flagCorpSecurityAccessGroup3 && (c->GetCorpRole() & corpRoleHangarCanTake3) != corpRoleHangarCanTake3)
|| (installedItem->flag() == flagCorpSecurityAccessGroup4 && (c->GetCorpRole() & corpRoleHangarCanTake4) != corpRoleHangarCanTake4)
|| (installedItem->flag() == flagCorpSecurityAccessGroup5 && (c->GetCorpRole() & corpRoleHangarCanTake5) != corpRoleHangarCanTake5)
|| (installedItem->flag() == flagCorpSecurityAccessGroup6 && (c->GetCorpRole() & corpRoleHangarCanTake6) != corpRoleHangarCanTake6)
|| (installedItem->flag() == flagCorpSecurityAccessGroup7 && (c->GetCorpRole() & corpRoleHangarCanTake7) != corpRoleHangarCanTake7)
)
throw(PyException(MakeUserError("RamAccessDeniedToBOMHangar")));
// large location check
if(IsStation(args.installationContainerID)) {
if(/*args.isCorpJob && */installedItem->flag() == flagCargoHold)
throw(PyException(MakeUserError("RamCorpInstalledItemNotInCargo")));
if(installedItem->locationID() != (uint32)args.installationContainerID) {
if((uint32)args.installationContainerID == c->GetLocationID()) {
std::map<std::string, PyRep *> exceptArgs;
exceptArgs["location"] = new PyString(m_db.GetStationName(args.installationContainerID));
if(args.isCorpJob)
throw(PyException(MakeUserError("RamCorpInstalledItemWrongLocation", exceptArgs)));
else
throw(PyException(MakeUserError("RamInstalledItemWrongLocation", exceptArgs)));
} else
throw(PyException(MakeUserError("RamRemoteInstalledItemNotInStation")));
} else {
if(args.isCorpJob) {
if(installedItem->flag() < flagCorpSecurityAccessGroup2 || installedItem->flag() > flagCorpSecurityAccessGroup7) {
if((uint32)args.installationContainerID == c->GetLocationID()) {
std::map<std::string, PyRep *> exceptArgs;
exceptArgs["location"] = new PyString(m_db.GetStationName(args.installationContainerID));
throw(PyException(MakeUserError("RamCorpInstalledItemWrongLocation", exceptArgs)));
} else
throw(PyException(MakeUserError("RamRemoteInstalledItemNotInOffice")));
}
} else {
if(installedItem->flag() != flagHangar) {
if((uint32)args.installationInvLocationID == c->GetLocationID()) {
std::map<std::string, PyRep *> exceptArgs;
exceptArgs["location"] = new PyString(m_db.GetStationName(args.installationContainerID));
throw(PyException(MakeUserError("RamInstalledItemWrongLocation", exceptArgs)));
} else {
throw(PyException(MakeUserError("RamRemoteInstalledItemInStationNotHangar")));
}
}
}
}
} else if((uint32)args.installationContainerID == c->GetShipID()) {
if(c->GetChar()->flag() != flagPilot)
throw(PyException(MakeUserError("RamAccessDeniedNotPilot")));
if(installedItem->locationID() != (uint32)args.installationContainerID)
throw(PyException(MakeUserError("RamInstalledItemMustBeInShip")));
} else {
// here should be stuff around POS, but I dont certainly know how it should work, so ...
// RamInstalledItemBadLocationStructure
// RamInstalledItemInStructureNotInContainer
// RamInstalledItemInStructureUnknownLocation
}
// BOM LOCATION CHECK
// *******************
// corp hangar permission
if( (bomLocation.flag == flagCorpSecurityAccessGroup2 && (c->GetCorpRole() & corpRoleHangarCanTake2) != corpRoleHangarCanTake2)
|| (bomLocation.flag == flagCorpSecurityAccessGroup3 && (c->GetCorpRole() & corpRoleHangarCanTake3) != corpRoleHangarCanTake3)
|| (bomLocation.flag == flagCorpSecurityAccessGroup4 && (c->GetCorpRole() & corpRoleHangarCanTake4) != corpRoleHangarCanTake4)
|| (bomLocation.flag == flagCorpSecurityAccessGroup5 && (c->GetCorpRole() & corpRoleHangarCanTake5) != corpRoleHangarCanTake5)
|| (bomLocation.flag == flagCorpSecurityAccessGroup6 && (c->GetCorpRole() & corpRoleHangarCanTake6) != corpRoleHangarCanTake6)
|| (bomLocation.flag == flagCorpSecurityAccessGroup7 && (c->GetCorpRole() & corpRoleHangarCanTake7) != corpRoleHangarCanTake7)
)
throw(PyException(MakeUserError("RamAccessDeniedToBOMHangar")));
}
