/** * \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); } }