C++ Agent::deviceEffortCalc方法代码示例

/**
 * \param agent
 * \return The estimated construction time of the device and its components, if the agent is able to buy some components
 */
double Device::expectedConstructionTime(Agent &agent)
{
    /*
     * if the agent believes that it can buy the device, the expected time
     * to build the device is 0.
     */
    if (agent.canBuy(*this).first) {
        return 0.0;
    }
    /*
     * If the agent does not believe it can buy the device, it calculates
     * the time required to make the device based on its experience and 
     * whether or not it has a device-making device, then it recursively
     * adds the expected construction time of each of the components
     */
    device_name_t bestDevDevice = agent.bestDevDevice(type, use);
    double time;
    if (bestDevDevice != NO_DEVICE) {
        time = agent.deviceEffortCalc(use, type) / agent.getDeviceFactor(bestDevDevice);
    } else {
        time = agent.deviceEffortCalc(use, type);
    }

    for (int i = 0; i < (int) components.size(); i++) {
        int comp = components[i];
        time += glob.discoveredDevices[componentType][comp]->expectedConstructionTime(agent);
    }
    return time;
}

/**
 * \param agent
 * \return the sum of the costs of the components to the agent
 */
double Device::costs(Agent &agent)
{
    if (agent.devProp[type][use].costOfDeviceMemoryValid) {
        return agent.devProp[type][use].costOfDeviceMemory;
    } else {
        /* canBuy returns a boolean and a double */
        pair<bool, double> buy = agent.canBuy(*this);
        /*
         * canBuy is the boolean; it indicates whether or not the agent
         * believes it is able to buy the device
         */
        bool canBuy = buy.first;
        /*
         * If the agent believes it is able to buy the device, the price (in
         * utils) that it expects to pay is avgPrice
         * So, if the agent believes it is able to buy the device, the cost
         * is avgPrice.
         */
        double avgPrice = buy.second;
        if (canBuy) {
            return avgPrice;
            /*
             * If the agent does not believe that it can buy the device, it
             * calculates the cost of the device as the time required to make
             * this device plus the cost of all the components of this device
             * (so the cost function gets called recursively on lower and lower
             * order devices)
             */
        } else {
            /*
             * First the agent calculates the time required to make the
             * device based on the agent's experience and whether or not it
             * has a device-making device
             */
            double time;
            device_name_t bestDevDevice = agent.bestDevDevice(type, use);
            if (bestDevDevice != NO_DEVICE) {
                time = agent.deviceEffortCalc(use, type) / agent.getDeviceFactor(bestDevDevice);
            } else {
                time = agent.deviceEffortCalc(use, type);
            }
            /*
             * The initial cost is the required time multiplied by the gain
             * per minute that the agent was getting at the end of the last
             * work day
             */
            double cost = time * agent.endDayGPM;
            
            /*
             * Then, the agent adds the cost of each of the components of
             * this device.
             */
            for (int i = 0; i < (int) components.size(); i++) {
                int comp = components[i];
                cost += glob.discoveredDevices[componentType][comp]->costs(agent);
            }
            agent.devProp[type][use].costOfDeviceMemory = cost;
            agent.devProp[type][use].costOfDeviceMemoryValid = true;
            return cost;
        }
    }
}

/**
 * \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;
                    }
                }
//.........这里部分代码省略.........