/**
* \param an agent
* \return a pair of (timeNeeded, necessaryRes) where the necessary time and resources to make the device and its components, if the agent is not able to buy any components.
*/
pair<double, vector<int> > Device::worstCaseConstruction(Agent &agent)
{
/*
* If the memory of this calculation that the agent has is valid, return
* the value in memory
*/
if (agent.devProp[type][use].worstCaseConstructionMemoryValid) {
return agent.devProp[type][use].worstCaseConstructionMemory;
} else {
/*
* highOrderNeeded will be a list of the number of typeToCheck
* devices needed for the corresponding resId
*/
vector<int> highOrderNeeded(glob.NUM_RESOURCES, 0);
/*
* Begin by requiring one device of the type that is currently under
* consideration
*/
highOrderNeeded[use] = 1;
/* typeToCheck begins as the type of device under consideration */
device_name_t typeToCheck = type;
/* compType is the component type of typeToCheck */
device_name_t compType = componentType;
/*
* timeNeeded will be the total, worst case time for this device and
* its components.
*/
double timeNeeded = 0.0;
if (devDevice != NO_DEVICE &&
agent.devProp[devDevice][use].deviceHeld > 0.0) {
timeNeeded = agent.deviceEffortCalc(use, type) / agent.getDeviceFactor(devDevice);
} else {
timeNeeded = agent.deviceEffortCalc(use, type);
}
/*
* Loop through so that typeToCheck and compType become lower and
* lower order device types; stop when there are no more lower order
* devices to consider.
*/
while (compType != NO_DEVICE) {
/*
* Given the number of typeToCheck devices in highOrderNeeded,
* compNeeded is the number of compType devices needed for each
* corresponding resId.
*/
vector<int> compNeeded(glob.NUM_RESOURCES, 0);
/*
* Begin by simply adding the components of devices in
* highOrderNeeded
*/
for (int resId = 0; resId < glob.NUM_RESOURCES; resId++) {
if (highOrderNeeded[resId] > 0) {
for (int i = 0; i < (int) glob.discoveredDevices[typeToCheck][resId]->components.size(); i++) {
int compId = glob.discoveredDevices[typeToCheck][resId]->components[i];
compNeeded[compId] += highOrderNeeded[resId];
}
}
}
for (int resId = 0; resId < glob.NUM_RESOURCES; resId++) {
if (compNeeded[resId] > 0) {
/*
* Remove devices from compNeeded if enough of the
* device is held by the agent; the number removed is
* the number of devices held (i.e. lifetime held
* divided by lifetime per device)
*/
compNeeded[resId] = max(0, compNeeded[resId] -
(int(agent.devProp[compType][resId].deviceHeld)
/ int(agent.getDeviceLifetime(compType))));
}
}
/*
* The time needed to make each of these components is added to
* timeNeeded
*/
for (int resId = 0; resId < glob.NUM_RESOURCES; resId++) {
if (compNeeded[resId] > 0) {
device_name_t devDevice = glob.discoveredDevices[compType][resId]->devDevice;
/*
* If the device-making device is not invented or if
* the agent doesn't hold any, the devDeviceFactor
* is 1 (i.e. no effect on production)
*/
double devDeviceFactor = 1.0;
if (devDevice != NO_DEVICE &&
agent.devProp[devDevice][resId].deviceHeld > 0.0) {
devDeviceFactor = agent.getDeviceFactor(devDevice);
}
for (int i = 0; i < compNeeded[resId]; i++) {
timeNeeded += agent.tempDeviceEffortCalc(resId, compType, i) / devDeviceFactor;
}
}
}
/*
* Once held devices have been removed from compNeeded, the
* values in highOrderNeeded become the values from compNeeded,
* and the loop starts again.
*/
for (int resId = 0; resId < glob.NUM_RESOURCES; resId++) {
highOrderNeeded[resId] = compNeeded[resId];
}
// typeToCheck and compType move one order down
typeToCheck = compType;
compType = glob.discoveredDevices[typeToCheck][use]->componentType;
}
/*
* When compType is None, typeToCheck is 'Tool', so the
* highOrderNeeded list is the list of the number of tools needed
* for each corresponding resId, so the necessary resources for this
* device is the sum of necessary resources for each tool
*/
vector<int> necessaryRes(glob.NUM_RESOURCES, 0);
for (int resIdA = 0; resIdA < glob.NUM_RESOURCES; resIdA++) {
if (highOrderNeeded[resIdA] > 0) {
vector<int> thisToolNeeds = glob.discoveredDevices[TOOL][resIdA]->necessaryResources;
for (int resIdB = 0; resIdB < glob.NUM_RESOURCES; resIdB++) {
necessaryRes[resIdB] += highOrderNeeded[resIdA] * thisToolNeeds[resIdB];
}
}
}
// Agents remember this calculated list
agent.devProp[type][use].worstCaseConstructionMemory = make_pair(timeNeeded, necessaryRes);
agent.devProp[type][use].worstCaseConstructionMemoryValid = true;
return pair<double, vector<int> >(timeNeeded, necessaryRes);
}
}
