compute.js

var utility = require('./utility');
var mode = utility.mode;
var max = utility.max;
var min = utility.min;
var isRadiant = utility.isRadiant;
var generatePositionData = utility.generatePositionData;
var generatePlayerAnalysis = require('./analysis');
var constants = require('./constants.js');
var sentiment = require('sentiment');
var benchmarks = require('./benchmarks');
var async = require('async');
var ancients = {
    npc_dota_neutral_black_drake: 1,
    npc_dota_neutral_black_dragon: 1,
    npc_dota_neutral_blue_dragonspawn_sorcerer: 1,
    npc_dota_neutral_blue_dragonspawn_overseer: 1,
    npc_dota_neutral_granite_golem: 1,
    npc_dota_neutral_elder_jungle_stalker: 1,
    npc_dota_neutral_rock_golem: 1,
    npc_dota_neutral_small_thunder_lizard: 1,
    npc_dota_neutral_jungle_stalker: 1,
    npc_dota_neutral_big_thunder_lizard: 1,
};
var specific = {
    "npc_dota_beastmaster_boar_#": "Boar",
    "npc_dota_lesser_eidolon": "Eidolon",
    "npc_dota_eidolon": "Eidolon",
    "npc_dota_greater_eidolon": "Eidolon",
    "npc_dota_dire_eidolon": "Eidolon",
    "npc_dota_invoker_forged_spirit": "Forged Spirit",
    "npc_dota_furion_treant_large": "Greater Treant",
    "npc_dota_beastmaster_hawk_#": "Hawk",
    "npc_dota_lycan_wolf#": "Lycan Wolf",
    "npc_dota_neutral_mud_golem_split_doom": "Doom Shard",
    "npc_dota_broodmother_spiderling": "Spiderling",
    "npc_dota_broodmother_spiderite": "Spiderite",
    "npc_dota_furion_treant": "Treant",
    "npc_dota_unit_undying_zombie": "Zombie",
    "npc_dota_unit_undying_zombie_torso": "Zombie",
    "npc_dota_brewmaster_earth_#": "Earth Brewling",
    "npc_dota_brewmaster_fire_#": "Fire Brewling",
    "npc_dota_lone_druid_bear#": "Spirit Bear",
    "npc_dota_brewmaster_storm_#": "Storm Brewling",
    "npc_dota_visage_familiar#": "Familiar",
    "npc_dota_warlock_golem_#": "Warlock's Golem",
    "npc_dota_warlock_golem_scepter_#": "Warlock's Golem",
    "npc_dota_witch_doctor_death_ward": "Death Ward",
    "npc_dota_tusk_frozen_sigil#": "Frozen Sigil",
    "npc_dota_juggernaut_healing_ward": "Healing Ward",
    "npc_dota_techies_land_mine": "Land Mine",
    "npc_dota_shadow_shaman_ward_#": "Mass Serpent Ward",
    "npc_dota_pugna_nether_ward_#": "Nether Ward",
    "npc_dota_venomancer_plague_ward_#": "Plague Ward",
    "npc_dota_rattletrap_cog": "Power Cog",
    "npc_dota_templar_assassin_psionic_trap": "Psionic Trap",
    "npc_dota_techies_remote_mine": "Remote Mine",
    "npc_dota_techies_stasis_trap": "Stasis Trap",
    "npc_dota_phoenix_sun": "Supernova",
    "npc_dota_unit_tombstone#": "Tombstone",
    "npc_dota_treant_eyes": "Eyes in the Forest",
    "npc_dota_gyrocopter_homing_missile": "Homing Missile",
    "npc_dota_weaver_swarm": "The Swarm"
};
var expanded = {};
for (var key in specific)
{
    for (var i = 1; i < 5; i++)
    {
        expanded[key.replace("#", i)] = specific[key];
    }
}

function computeMatchData(match)
{
    // Compute patch based on start_time
    if (match.start_time)
    {
        var date = new Date(match.start_time * 1000);
        for (var i = 1; i < constants.patch.length; i++)
        {
            var pd = new Date(constants.patch[i].date);
            //stop when patch date is past the start time
            if (pd > date)
            {
                break;
            }
        }
        //use the value of i before the break, started at 1 to avoid negative index
        match.patch = i - 1;
    }
    if (match.cluster)
    {
        match.region = constants.cluster[match.cluster];
    }
}
/**
 * Computes additional stats from stored data for a player_match
 **/
function computePlayerMatchData(pm)
{
    //WARNING: Don't store fields that mutate based on self_hero in Cassandra.  It isn't set post-parse and the cache update will write incorrect data.
    var self_hero = constants.heroes[pm.hero_id];
    computeMatchData(pm);
    if (pm.player_slot !== undefined && pm.radiant_win !== undefined)
    {
        pm.isRadiant = isRadiant(pm);
        pm.player_win = (isRadiant(pm) === pm.radiant_win); //did the player win?
        pm.win = Number(isRadiant(pm) === pm.radiant_win);
        pm.lose = Number(isRadiant(pm) === pm.radiant_win) ? 0 : 1;
    }
    if (pm.duration)
    {
        pm.total_gold = ~~(pm.gold_per_min * pm.duration / 60);
        pm.total_xp = ~~(pm.xp_per_min * pm.duration / 60);
        pm.kills_per_min = pm.kills / (pm.duration / 60);
    }
    if (pm.kills !== undefined && pm.deaths !== undefined && pm.assists !== undefined)
    {
        pm.kda = ~~((pm.kills + pm.assists) / (pm.deaths + 1));
    }
    if (pm.leaver_status !== undefined)
    {
        pm.abandons = Number(pm.leaver_status >= 2);
    }
    if (pm.pgroup)
    {
        pm.heroes = pm.pgroup;
        pm.teammates = pm.pgroup;
    }
    if (pm.chat)
    {
        // word counts for this player and all players
        // aggregation of all words in all chat this player has experienced
        pm.all_word_counts = count_words(pm, null);
        // aggregation of only the words in all chat this player said themselves
        pm.my_word_counts = count_words(pm, pm);
    }
    if (pm.kills_log && self_hero)
    {
        //remove self kills
        pm.kills_log = pm.kills_log.filter(function(k)
        {
            return k.key !== self_hero.name;
        });
    }
    if (pm.killed)
    {
        pm.neutral_kills = 0;
        pm.tower_kills = 0;
        pm.courier_kills = 0;
        pm.lane_kills = 0;
        pm.hero_kills = 0;
        pm.observer_kills = 0;
        pm.sentry_kills = 0;
        pm.roshan_kills = 0;
        pm.necronomicon_kills = 0;
        pm.ancient_kills = 0;
        pm.specific = {};
        //expand keys in specific by # (1-4)
        //map to friendly name
        //iterate through keys in killed
        //if in expanded, put in pm.specific
        for (var key in pm.killed)
        {
            if (key in expanded)
            {
                var name = expanded[key];
                pm.specific[name] = pm.specific[name] ? pm.specific[name] + pm.killed[key] : pm.killed[key];
            }
            if (key.indexOf("creep_goodguys") !== -1 || key.indexOf("creep_badguys") !== -1)
            {
                pm.lane_kills += pm.killed[key];
            }
            if (key.indexOf("observer") !== -1)
            {
                pm.observer_kills += pm.killed[key];
            }
            if (key.indexOf("sentry") !== -1)
            {
                pm.sentry_kills += pm.killed[key];
            }
            if (key.indexOf("npc_dota_hero") === 0)
            {
                if (!self_hero || self_hero.name !== key)
                {
                    pm.hero_kills += pm.killed[key];
                }
            }
            if (key.indexOf("npc_dota_neutral") === 0)
            {
                pm.neutral_kills += pm.killed[key];
            }
            if ((key in ancients))
            {
                pm.ancient_kills += pm.killed[key];
            }
            if (key.indexOf("_tower") !== -1)
            {
                pm.tower_kills += pm.killed[key];
            }
            if (key.indexOf("courier") !== -1)
            {
                pm.courier_kills += pm.killed[key];
            }
            if (key.indexOf("roshan") !== -1)
            {
                pm.roshan_kills += pm.killed[key];
            }
            if (key.indexOf("necronomicon") !== -1)
            {
                pm.necronomicon_kills += pm.killed[key];
            }
        }
    }
    if (pm.buyback_log)
    {
        pm.buyback_count = pm.buyback_log.length;
    }
    if (pm.item_uses)
    {
        pm.observer_uses = pm.item_uses.ward_observer || 0;
        pm.sentry_uses = pm.item_uses.ward_sentry || 0;
    }
    if (pm.gold_t && pm.gold_t[10])
    {
        //lane efficiency: divide 10 minute gold by static amount based on standard creep spawn
        //var tenMinute = (43 * 60 + 48 * 20 + 74 * 2);
        //6.84 change
        var tenMinute = (40 * 60 + 45 * 20 + 74 * 2) + (600 / 0.6) + 625;
        pm.lane_efficiency = pm.gold_t[10] / tenMinute;
        pm.lane_efficiency_pct = ~~(pm.lane_efficiency * 100);
    }
    //convert position hashes to heatmap array of x,y,value
    pm.posData = generatePositionData(
    {
        "obs": true,
        "sen": true,
        //"pos": true,
        "lane_pos": true
    }, pm);
    //p.explore = p.posData.pos.length / 128 / 128;
    //compute lanes
    var lanes = [];
    for (var i = 0; i < pm.posData.lane_pos.length; i++)
    {
        var dp = pm.posData.lane_pos[i];
        for (var j = 0; j < dp.value; j++)
        {
            if (constants.lanes[dp.y])
            {
                lanes.push(constants.lanes[dp.y][dp.x]);
            }
        }
    }
    if (lanes.length)
    {
        pm.lane = mode(lanes);
        var radiant = pm.isRadiant;
        var lane_roles = {
            "1": function()
            {
                //bot
                return radiant ? 1 : 3;
            },
            "2": function()
            {
                //mid
                return 2;
            },
            "3": function()
            {
                //top
                return radiant ? 3 : 1;
            },
            "4": function()
            {
                //rjung
                return 4;
            },
            "5": function()
            {
                //djung
                return 4;
            }
        };
        pm.lane_role = lane_roles[pm.lane] ? lane_roles[pm.lane]() : undefined;
    }
    //compute hashes of purchase time sums and counts from logs
    if (pm.purchase_log)
    {
        //remove ward dispenser and recipes
        pm.purchase_log = pm.purchase_log.filter(function(purchase)
        {
            return !(purchase.key.indexOf("recipe_") === 0 || purchase.key === "ward_dispenser");
        });
        pm.purchase_time = {};
        pm.item_win = {};
        pm.item_usage = {};
        for (var i = 0; i < pm.purchase_log.length; i++)
        {
            var k = pm.purchase_log[i].key;
            var time = pm.purchase_log[i].time;
            if (!pm.purchase_time[k])
            {
                pm.purchase_time[k] = 0;
            }
            pm.purchase_time[k] += time;
            pm.item_usage[k] = 1;
            pm.item_win[k] = isRadiant(pm) === pm.radiant_win ? 1 : 0;
        }
    }
    if (pm.purchase)
    {
        //account for stacks
        pm.purchase.ward_sentry *= 2;
        pm.purchase.dust *= 2;
        pm.purchase_ward_observer = pm.purchase.ward_observer;
        pm.purchase_ward_sentry = pm.purchase.ward_sentry;
        pm.purchase_tpscroll = pm.purchase.tpscroll;
        pm.purchase_rapier = pm.purchase.rapier;
        pm.purchase_gem = pm.purchase.gem;
    }
    if (pm.actions)
    {
        var actions_sum = 0;
        for (var key in pm.actions)
        {
            actions_sum += pm.actions[key];
        }
        pm.actions_per_min = ~~(actions_sum / pm.duration * 60);
    }
    //compute throw/comeback levels
    if (pm.radiant_gold_adv)
    {
        var radiant_gold_advantage = pm.radiant_gold_adv;
        pm.throw = pm.radiant_win !== isRadiant(pm) ? (isRadiant(pm) ? max(radiant_gold_advantage) : min(radiant_gold_advantage) * -1) : undefined;
        pm.comeback = pm.radiant_win === isRadiant(pm) ? (isRadiant(pm) ? min(radiant_gold_advantage) * -1 : max(radiant_gold_advantage)) : undefined;
        pm.loss = pm.radiant_win !== isRadiant(pm) ? (isRadiant(pm) ? min(radiant_gold_advantage) * -1 : max(radiant_gold_advantage)) : undefined;
        pm.stomp = pm.radiant_win === isRadiant(pm) ? (isRadiant(pm) ? max(radiant_gold_advantage) : min(radiant_gold_advantage) * -1) : undefined;
    }
    if (pm.pings)
    {
        pm.pings = pm.pings[0];
    }
    if (pm.life_state)
    {
        pm.life_state_dead = (pm.life_state[1] || 0) + (pm.life_state[2] || 0);
    }
}
/**
 * Count the words that occur in a set of messages
 * - messages: the messages to create the counts over
 * - player_filter: if non-null, only count that player's messages
 **/
function count_words(player_match, player_filter)
{
    var messages = player_match.chat;
    // extract the message strings from the message objects
    // extract individual words from the message strings
    var chat_words = [];
    messages.forEach(function(message)
    {
        // if there is no player_filter, or if the passed player's player_slot matches this message's parseSlot converted to player_slot, log it
        var messageParseSlot = message.slot < 5 ? message.slot : message.slot + (128 - 5);
        if (!player_filter || (messageParseSlot === player_filter.player_slot))
        {
            chat_words.push(message.key);
        }
    });
    chat_words = chat_words.join(' ');
    var tokens = utility.tokenize(chat_words);
    // count how frequently each word occurs
    var counts = {};
    for (var i = 0; i < tokens.length; i++)
    {
        //ignore the empty string
        if (tokens[i])
        {
            if (!counts[tokens[i]])
            {
                counts[tokens[i]] = 0;
            }
            counts[tokens[i]] += 1;
        }
    }
    // return the final counts
    return counts;
}
/**
 * Renders display-only data for a match (doesn't need to be aggregated)
 **/
function renderMatch(m)
{
    //do render-only processing (not needed for aggregation, only for match display)
    m.players.forEach(function(player_match, i)
    {
        //converts hashes to arrays and sorts them
        var targets = ["ability_uses", "item_uses", "damage_inflictor"];
        targets.forEach(function(target)
        {
            if (player_match[target])
            {
                var t = [];
                for (var key in player_match[target])
                {
                    var a = constants.abilities[key];
                    var i = constants.items[key];
                    var def = {
                        img: "/public/images/default_attack.png"
                    };
                    def = a || i || def;
                    var result = {
                        img: def.img,
                        name: key === "undefined" ? "Auto Attack/Other" : key,
                        val: player_match[target][key],
                        className: a ? "ability" : i ? "item" : "img-sm"
                    };
                    if (player_match.hero_hits)
                    {
                        result.hero_hits = player_match.hero_hits[key];
                    }
                    t.push(result);
                }
                t.sort(function(a, b)
                {
                    return b.val - a.val;
                });
                player_match[target + "_arr"] = t;
            }
        });
        //filter interval data to only be >= 0
        if (player_match.times)
        {
            var intervals = ["lh_t", "gold_t", "xp_t", "times"];
            intervals.forEach(function(key)
            {
                player_match[key] = player_match[key].filter(function(el, i)
                {
                    return player_match.times[i] >= 0;
                });
            });
        }
        //compute damage to towers/rax/roshan
        if (player_match.damage)
        {
            //npc_dota_goodguys_tower2_top
            //npc_dota_goodguys_melee_rax_top
            //npc_dota_roshan
            //npc_dota_neutral_giant_wolf
            //npc_dota_creep
            player_match.objective_damage = {};
            for (var key in player_match.damage)
            {
                var identifier = null;
                if (key.indexOf("tower") !== -1)
                {
                    identifier = key.split("_").slice(3).join("_");
                }
                if (key.indexOf("rax") !== -1)
                {
                    identifier = key.split("_").slice(4).join("_");
                }
                if (key.indexOf("roshan") !== -1)
                {
                    identifier = "roshan";
                }
                if (key.indexOf("fort") !== -1)
                {
                    identifier = "fort";
                }
                player_match.objective_damage[identifier] = player_match.objective_damage[identifier] ? player_match.objective_damage[identifier] + player_match.damage[key] : player_match.damage[key];
            }
        }
    });
    console.time("generating player analysis");
    m.players.forEach(function(player_match, i)
    {
        player_match.analysis = generatePlayerAnalysis(m, player_match);
    });
    console.timeEnd("generating player analysis");
    if (m.chat)
    {
        //make a list of messages and join them all together for sentiment analysis
        var chat_words = m.chat.map(function(message)
        {
            return message.key;
        }).join(' ');
        m.sentiment = sentiment(chat_words,
        {
            "report": -2,
            "commend": 2,
            "noob": -2,
            "ff": -1,
            "bg": -1,
            "feed": -1,
            "ty": 1,
            "thanks": 1,
            "wp": 1,
            "end": -1,
            "garbage": -1,
            "trash": -1,
            "throw": -1,
            "salt": -1,
            "ez": -1,
            "mad": -1,
            "hero": 0,
            "salty": -1,
            "autist": -1,
            "autism": -1
        });
    }
    //create gold breakdown data
    if (m.players[0] && m.players[0].gold_reasons)
    {
        m.incomeData = generateIncomeData(m);
        //m.treeMapData = generateTreemapData(m);
    }
    //create graph data
    if (m.players[0] && m.players[0].gold_t)
    {
        m.graphData = generateGraphData(m);
    }
    //create heatmap data
    m.posData = m.players.map(function(p)
    {
        return p.posData;
    });
    //process objectives
    if (m.objectives)
    {
        m.objectives.forEach(function(entry)
        {
            entry.objective = constants.objectives[entry.subtype] || entry.subtype;
            var p = m.players[entry.slot];
            if (p)
            {
                entry.team = entry.team === 2 || entry.key < 64 || p.isRadiant ? 0 : 1;
                entry.hero_img = constants.heroes[p.hero_id] ? constants.heroes[p.hero_id].img : "";
            }
        });
    }
    //process teamfight data
    if (m.teamfights)
    {
        m.teamfights.forEach(function(tf)
        {
            tf.posData = [];
            tf.radiant_gold_delta = 0;
            tf.radiant_xp_delta = 0;
            tf.radiant_participation = 0;
            tf.radiant_deaths = 0;
            tf.dire_participation = 0;
            tf.dire_deaths = 0;
            tf.players.forEach(function(p)
            {
                //lookup starting, ending level
                p.level_start = getLevelFromXp(p.xp_start);
                p.level_end = getLevelFromXp(p.xp_end);

                function getLevelFromXp(xp)
                {
                    for (var i = 0; i < constants.xp_level.length; i++)
                    {
                        if (constants.xp_level[i] > xp)
                        {
                            return i;
                        }
                    }
                    return constants.xp_level.length;
                }
            });
            //add player's hero_id to each teamfight participant
            m.players.forEach(function(p, i)
            {
                var tfplayer = tf.players[p.player_slot % (128 - 5)];
                tfplayer.hero_id = p.hero_id;
                tfplayer.player_slot = p.player_slot;
                tfplayer.isRadiant = isRadiant(p);
                tfplayer.personaname = p.personaname;
                tfplayer.account_id = p.account_id;
                tfplayer.participate = tfplayer.deaths > 0 || tfplayer.damage > 0;
                if (!p.teamfights_participated)
                {
                    p.teamfights_participated = 0;
                }
                p.teamfights_participated += tfplayer.participate ? 1 : 0;
                //compute team gold/xp deltas
                if (isRadiant(p))
                {
                    tf.radiant_gold_delta += tfplayer.gold_delta;
                    tf.radiant_xp_delta += tfplayer.xp_delta;
                    tf.radiant_participation += tfplayer.participate ? 1 : 0;
                    tf.radiant_deaths += tfplayer.deaths ? 1 : 0;
                }
                else
                {
                    tf.radiant_gold_delta -= tfplayer.gold_delta;
                    tf.radiant_xp_delta -= tfplayer.xp_delta;
                    tf.dire_participation += tfplayer.participate ? 1 : 0;
                    tf.dire_deaths += tfplayer.deaths ? 1 : 0;
                }
                //convert 2d hash to array
                tfplayer.posData = generatePositionData(
                {
                    deaths_pos: 1
                }, tfplayer);
                //console.log(player);
                //add player hero id to each death, push into teamfight death position array
                tfplayer.posData.deaths_pos.forEach(function(pt)
                {
                    pt.hero_id = tfplayer.hero_id;
                    tf.posData.push(pt);
                });
            });
        });
    }
}
/**
 * Generates data for c3 charts in a match
 **/
function generateGraphData(match)
{
    //compute graphs
    var goldDifference = ['Gold'];
    var xpDifference = ['XP'];
    goldDifference = goldDifference.concat(match.radiant_gold_adv);
    xpDifference = xpDifference.concat(match.radiant_xp_adv);
    var time = ["time"].concat(match.players[0].times);
    var data = {
        difference: [time, xpDifference, goldDifference],
        gold: [time],
        xp: [time],
        lh: [time]
    };
    match.players.forEach(function(p, i)
    {
        var hero = constants.heroes[p.hero_id] ||
        {};
        hero = hero.localized_name;
        data.gold.push([hero].concat(p.gold_t));
        data.xp.push([hero].concat(p.xp_t));
        data.lh.push([hero].concat(p.lh_t));
    });
    return data;
}

function generateIncomeData(match)
{
    //data for income chart
    var gold_reasons = [];
    var columns = [];
    var categories = [];
    var imgs = [];
    var orderedPlayers = match.players.slice(0);
    orderedPlayers.sort(function(a, b)
    {
        return b.gold_per_min - a.gold_per_min;
    });
    orderedPlayers.forEach(function(player)
    {
        var hero = constants.heroes[player.hero_id] ||
        {};
        categories.push(hero.localized_name);
        imgs.push(hero.img);
    });
    for (var key in constants.gold_reasons)
    {
        var reason = constants.gold_reasons[key].name;
        gold_reasons.push(reason);
        var col = [reason];
        orderedPlayers.forEach(function(player)
        {
            var g = player.gold_reasons;
            col.push(g ? g[key] : 0);
        });
        columns.push(col);
    }
    return {
        cats: categories,
        goldCols: columns,
        gold_reasons: gold_reasons,
        imgs: imgs
    };
}

function generateTreemapData(match)
{
    var data = [];
    match.players.forEach(function(player)
    {
        var hero = constants.heroes[player.hero_id] ||
        {};
        data.push(
        {
            name: hero.localized_name,
            id: player.hero_id.toString(),
            value: ~~(player.gold_per_min * match.duration / 60)
        });
    });
    for (var key in constants.gold_reasons)
    {
        var reason = constants.gold_reasons[key].name;
        match.players.forEach(function(player)
        {
            var g = player.gold_reasons;
            data.push(
            {
                name: reason,
                parent: player.hero_id.toString(),
                value: g[key] || 0
            });
        });
    }
    return data;
}
module.exports = {
    renderMatch: renderMatch,
    computeMatchData: computeMatchData,
    computePlayerMatchData: computePlayerMatchData,
};