Market.js

'use strict';
// market module
const Market = {
    EXPIRE_TIME: 5000,
    price: {},
    _updatePrice(resourceType, buy, sell){
        return this.price[resourceType] = {
            buy: buy,
            sell: sell,
            expireTime: Game.time + 5000
        }
    },
    getPrice(resourceType, orderType=undefined){
        let price = this.price[resourceType];
        if(!price || price.expireTime < Game.time){
            price = this._calculatePrice(resourceType);
        }
        if(orderType === undefined){
            if(price.buy === -Infinity && price.sell === Infinity){
                return undefined; // cannot calculate price
            }
            if(price.buy === -Infinity){
                return price.sell;
            }
            if(price.sell === Infinity){
                return price.buy;
            }
            return (price.sell + price.buy) / 2;
        }
        return price[orderType];
    },

    _calculatePrice(resourceType){
        let orders = Game.market.getAllOrders({
            resourceType: resourceType
        });
        let buyOrders = _.sortBy(_.filter(orders, (o) => o.type === ORDER_BUY),
            (o) => -o.price);
        let sellOrders = _.sortBy(_.filter(orders, (o) => o.type === ORDER_SELL),
            (o) => o.price);
        let r = {};
        if(buyOrders[0]){
            r.buy = buyOrders[0].price;
        }else{
            r.buy = -Infinity
        }
        if(sellOrders[0]){
            r.sell = sellOrders[1].price;
        }else{
            r.sell = Infinity
        }
        return this._updatePrice(resourceType, r.buy, r.sell);
    },

    _bestEnergyOrder(roomName){
        let energyOrders = Game.market.getAllOrders({
            type: ORDER_SELL,
            resourceType: RESOURCE_ENERGY
        });
        let batteryOrders = Game.market.getAllOrders({
            type: ORDER_SELL,
            resourceType: RESOURCE_BATTERY
        });
        return _.min(energyOrders.concat(batteryOrders), (o) => energyPrice(o, roomName) || Infinity);
    },

    _bestEnergyPrice(roomName){
        return energyPrice(Market._bestEnergyOrder(roomName), roomName) || Infinity;
    },


    /**
     *
     * @param resourceType {string}
     * @param orderType {string}
     * @param roomName {string}
     * @return {*}
     */
    bestOrder(resourceType, orderType, roomName){
        if(resourceType === RESOURCE_ENERGY) return Market._bestEnergyOrder(roomName);
        let energyPrice = Market._bestEnergyPrice(roomName);
        let orders = Game.market.getAllOrders({
            type: orderType,
            resourceType: resourceType
        });
        if(orders.length === 0){
            if(orderType === ORDER_BUY) return Infinity; else return -Infinity;
        }
        let bestOrder;
        if(orderType === ORDER_BUY){
            bestOrder =  _.max(orders, (o) => getPrice(o, energyPrice, roomName, orderType));
        }else{
            bestOrder =  _.min(orders, (o) => getPrice(o, energyPrice, roomName, orderType));
        }
        return bestOrder;
    },

    bestOrderPrice(resourceType, orderType, roomName){
        return getPrice(Market.bestOrder(resourceType, orderType, roomName),
            Market._bestEnergyPrice(roomName), roomName, orderType);
    },

    preferCompressed(resourceType, orderType, roomName){
        if(!_.keys(COMPRESSION).includes(resourceType)) return false;
        let compressedType = COMPRESSION[resourceType];
        let uncompressedOrder = Market.bestOrder(resourceType, orderType, roomName);
        let compressedOrder = Market.bestOrder(compressedType, orderType, roomName);

        let uncompressedEnergy = energyCostPercent(roomName, uncompressedOrder.roomName);
        let compressedEnergy = energyCostPercent(roomName, uncompressedOrder.roomName);
        if(resourceType !== RESOURCE_ENERGY){
            compressedEnergy += 2;
        }
        let energyPrice = Market._bestEnergyPrice(roomName);
        if(orderType === ORDER_BUY){
            let uncompressedPrice = uncompressedOrder.price - uncompressedEnergy * energyPrice;
            let compressedPrice = compressedOrder.price - compressedEnergy * energyPrice;
            compressedPrice /= (resourceType === RESOURCE_ENERGY ? 6 : 5);
            return uncompressedPrice < compressedPrice
        }else{
            let uncompressedPrice = uncompressedOrder.price + uncompressedEnergy * energyPrice;
            let compressedPrice = compressedOrder.price + compressedEnergy * energyPrice;
            compressedPrice /= 5;
            return uncompressedPrice >= compressedPrice
        }
    }

};

function energyPrice(order, roomName){
    if(!order) return undefined;
    let percent = Math.exp(-Game.map.getRoomLinearDistance(order.roomName, roomName, true)/30);
    let unitPrice = order.price;
    if(order.resourceType === RESOURCE_BATTERY){
        percent = 1 - (1 - percent) / 10;
        unitPrice /= 10;
    }
    return unitPrice / percent;
}


/**
 *
 * @param order {*}
 * @param energyPrice {number}
 * @param roomName {string}
 * @param orderType {string}
 * @return {number}
 */
function getPrice(order, energyPrice, roomName, orderType){
    if(energyPrice === Infinity) energyPrice = order.price;
    let energyCost = energyPrice * energyCostPercent(roomName, order.roomName);
    if(orderType === ORDER_BUY){
        return order.price - energyCost;
    }else{
        return order.price + energyCost;
    }

}

function energyCostPercent(fromRoom, targetRoom){
    return 1 - Math.exp(Game.map.getRoomLinearDistance(fromRoom, targetRoom, true))
}

const COMPRESSION = {
    energy: RESOURCE_BATTERY,
    H: RESOURCE_REDUCTANT,
    O: RESOURCE_OXIDANT,
    U: RESOURCE_UTRIUM_BAR,
    L: RESOURCE_LEMERGIUM_BAR,
    K: RESOURCE_KEANIUM_BAR,
    Z: RESOURCE_ZYNTHIUM_BAR,
    G: RESOURCE_GHODIUM_MELT,
    X: RESOURCE_PURIFIER,
};

Market.COMPRESSION = COMPRESSION;

module.exports = Market;