Task.js

'use strict';
const CM = require('CostMatrix');

const Task = {};

Task.CAPACITY = 1000;

/**
 * Create a new task with given params
 * @param source {RoomObject}
 * @param targets {({obj: RoomObject, amount: number})[]}
 * @param type {string}
 * @param parent {undefined | Object} parent task of this transport task
 * @return {{source: string, sourcePos: string, targets: ({obj: string, pos: string, amount: number})[], type: string, amount: number}}
 */
Task.create = function(source, targets, type, parent=undefined) {
    let obj =  {
        source: serialize(source),
        sourcePos: serialize(source.pos),
        targets: _.map(targets, (t) => {
            return {
                obj: serialize(t.obj),
                pos: serialize(t.obj.pos),
                amount: t.amount
            };
        }),
        type: type,
        amount: _.sum(targets, (s) => s.amount),
        id: Creep.getId()
    };
    obj.totalAmount = obj.amount;
    if(parent) obj.parent = parent;
    Task.sortTargetsAndFindLength(obj);
    if(source.room.allTasks){
        source.room.allTasks.push(obj);
    }
    return obj;
};

Task.getTarget = function (task) {
    // TODO implement pb getTarget later
    return deserialize(task.obj, RoomObject);
};

Task.getTargetPos = function(task){
    return deserialize(task.pos, RoomPosition)
};

/**
 * execute the task assigned to the creep
 * @param creep {Creep}
 */
Task.execute = function(creep){
    if(!creep.memory.task){
        return
    }
    if(creep.memory.task.done) {
        creep.memory.task = undefined;
        return;
    }
    let task = creep.memory.task;
    if(!task.currentIndex){
        task.currentIndex = 0;
    }
    let withdrawing = creep.store[task.type] < task.amount;
    if(withdrawing){
        let targetPos = deserialize(task.sourcePos, RoomPosition);
        if(creep.pos.getRangeTo(targetPos) > 1){
            creep.moveTo(targetPos, {range: 1});
            return;
        }else{
            let target = deserialize(task.source, RoomObject);
            if(!target || creep.withdraw(target, task.type, task.amount) !== OK){
                return;
            }
        }
    }
    let moved = false;
    let transferred = false;
    while(!moved || !transferred){
        let currentTarget = task.targets[task.currentIndex];
        if(!currentTarget){
            //task is done
            creep.memory.task.done = true;
            Task.onComplete(task);
            creep.memory.task = undefined;
            return;
        }
        if(!transferred && creep.transfer(deserialize(currentTarget.obj, RoomObject),
            task.type, currentTarget.amount) === OK){
            task.amount -= currentTarget.amount;
            transferred = true;
            task.currentIndex ++;
        }else{
            if(moved){break;}
            creep.moveTo(deserialize(currentTarget.pos, RoomPosition), {range: 1});
            moved = true;
            break;
        }
    }
};

Task.assign = function(creep, task){
    // precondition: canComplete returns true
    creep.memory.task = task;
    //removes the task from list of tasks
};

/**
 * determines if the creep can complete the task
 * @param creep {Creep}
 * @param task
 * @return {boolean}
 */
Task.canComplete = function (creep, task) {
    if(creep.memory.task){return false;}
    let source = deserialize(task.source, RoomObject);
    if(!source || source.store[task.type] < task.amount){
        return false;
    }
    let hasValidTarget = false;
    for(const target of task.targets){
        if(deserialize(target.obj, RoomObject).store.getFreeCapacity(task.type) >= target.amount){
            hasValidTarget = true;
        }
    }
    if(!hasValidTarget){
        return false;
    }
    let timeToStart = PathFinder.search(creep.pos, {
        pos: deserialize(task.sourcePos, RoomPosition),
        range: 1
        }, {
        roomCallback: CM.getDefaultCostMatrix, plainCost: 2, swampCost: 1
    }).cost;
    const weight = 1.1; // constant to take into blocking etc.
    let totalTime = (timeToStart + task.cost) * weight + 10;
    return creep.ticksToLive >= totalTime;
};

Task.sortTargetsAndFindLength = function(task){
    let targets = task.targets;
    let sortedTargets = [];
    let pos = deserialize(task.sourcePos, RoomPosition);
    let totalCost = 0;
    // use greedy heuristics to find solution for a route
    while(targets.length > 0){
        let targetPos = _.map(targets, (t) => {
            return {pos: deserialize(t.pos, RoomPosition), range: 1};
        });
        let {path, cost} = PathFinder.search(pos, targetPos, {
            roomCallback: (roomName) => CM.getDefaultCostMatrix(roomName),
            plainCost: 2,
            swampCost: 10,
        });
        let finalPos = path[path.length - 1] || pos;
        let reached = finalPos.findInRange(_.map(targets, (t) => {
            return deserialize(t.pos, RoomPosition);
        }), 1);
        totalCost += cost;
        let itemsRemoved = [];
        for(let p of reached){
            let i = _.findIndex(targets, (t) => {return deserialize(t.pos, RoomPosition).isEqualTo(p)});
            if(true){
                itemsRemoved.push(targets[i]);
                targets.splice(i, 1);
            }
        }
        sortedTargets = sortedTargets.concat(itemsRemoved);
        pos = finalPos;
    }
    task.cost = totalCost;
    task.targets = sortedTargets;
};

Task.getTasksFrom = function(fromObj, includeCreeps = false){
    let tasks = fromObj.room.getTasks();
    if(includeCreeps){
        tasks = tasks.concat(_.map(_.filter(fromObj.room.getCreeps(),
            (c) => c.memory.task), (c) => c.memory.task))
    }
    return _.filter(tasks, (t) => t.source === serialize(fromObj));
};

Task.getAllTasks = function(room){
    if(!room.allTasks){
        room.allTasks = room.getTasks().concat(_.map(_.filter(room.getCreeps(),
            (c) => c.memory.task), (c) => c.memory.task));
    }
    return room.allTasks;
};

Task.onComplete = function(task){
    if(task.parent){
        let roomName = deserialize(task.sourcePos, RoomPosition).roomName;
        let transportTask = Memory.rooms[roomName].tn[task.parent];
        if(transportTask){
            transportTask.memory.remainingAmount -= task.totalAmount;
            let tasks = transportTask.memory.tasks;
            tasks.splice(tasks.indexOf(task.id), 1);
        }
    }
};

module.exports = Task;