A look into moomoo ai

[FuriousBird]

I've stumbled upon this project one year ago, but didn't know how to contribute, today i finally managed to run my modified version of the client in my browser and i'm reading through moomoo io webpacked code, i've started unobfuscating and commenting it.

Here is the code used for handling entities i would say:

Click for code

 var i = 2 * Math.PI;
    e.exports = function(agentId, t, n, s, o, Game, r, c) {
        this.sid = agentId, this.isAI = !0, this.nameIndex = o.randInt(0, Game.cowNames.length - 1), this.init = function(e, t, i, n, s) {
            this.x = e, this.y = t, this.startX = s.fixedSpawn ? e : null, this.startY = s.fixedSpawn ? t : null, this.xVel = 0, this.yVel = 0, this.zIndex = 0, this.dir = i, this.dirPlus = 0, this.index = n, this.src = s.src, s.name && (this.name = s.name), this.weightM = s.weightM, this.speed = s.speed, this.killScore = s.killScore, this.turnSpeed = s.turnSpeed, this.scale = s.scale, this.maxHealth = s.health, this.leapForce = s.leapForce, this.health = this.maxHealth, this.chargePlayer = s.chargePlayer, this.viewRange = s.viewRange, this.drop = s.drop, this.dmg = s.dmg, this.hostile = s.hostile, this.dontRun = s.dontRun, this.hitRange = s.hitRange, this.hitDelay = s.hitDelay, this.hitScare = s.hitScare, this.spriteMlt = s.spriteMlt, this.nameScale = s.nameScale, this.colDmg = s.colDmg, this.noTrap = s.noTrap, this.spawnDelay = s.spawnDelay, this.hitWait = 0, this.waitCount = 1e3, this.moveCount = 0, this.targetDir = 0, this.active = !0, this.alive = !0, this.runFrom = null, this.chargeTarget = null, this.dmgOverTime = {}
        };
        var l = 0;
        this.update = function(deltaTime) {
            if (this.active) {
                if (this.spawnCounter) return this.spawnCounter -= deltaTime, void(this.spawnCounter <= 0 && (this.spawnCounter = 0, this.x = this.startX || o.randInt(0, Game.mapScale), this.y = this.startY || o.randInt(0, Game.mapScale)));
                (l -= deltaTime) <= 0 && (this.dmgOverTime.dmg && (this.changeHealth(-this.dmgOverTime.dmg, this.dmgOverTime.doer), this.dmgOverTime.time -= 1, this.dmgOverTime.time <= 0 && (this.dmgOverTime.dmg = 0)), l = 1e3);
                var s = false;
                var speedMultiplier = 1;
                if (!this.zIndex 
                    && !this.lockMove //if can move
                    && this.y >= Game.mapScale / 2 - Game.riverWidth / 2 //below top river line
                    && this.y <= Game.mapScale / 2 + Game.riverWidth / 2 //over bottom river line
                    && (speedMultiplier = .33, this.xVel += Game.waterCurrent * deltaTime) //then set speed slower and accelerate right
                    , this.lockMove){ //then if you cannot move (see comma operator js)
                    this.xVel = 0, this.yVel = 0 //set speed to 0

            }else if (this.waitCount > 0) {
                //ai state of waiting
                if (this.waitCount -= deltaTime, this.waitCount <= 0)
                    if (this.chargePlayer) {
                        for (var h, u, d, f = 0; f < n.length; ++f) !n[f].alive || n[f].skin && n[f].skin.bullRepel || (d = o.getDistance(this.x, this.y, n[f].x, n[f].y)) <= this.viewRange && (!h || d < u) && (u = d, h = n[f]);
                        h ? (this.chargeTarget = h, this.moveCount = o.randInt(8e3, 12e3)) : (this.moveCount = o.randInt(1e3, 2e3), this.targetDir = o.randFloat(-Math.PI, Math.PI))
                    } else this.moveCount = o.randInt(4e3, 1e4), this.targetDir = o.randFloat(-Math.PI, Math.PI)
            } else if (this.moveCount > 0) {
                //ai state of moving
                var p = this.speed * speedMultiplier;
                if (this.runFrom && this.runFrom.active && (!this.runFrom.isPlayer || this.runFrom.alive) ? (this.targetDir = o.getDirection(this.x, this.y, this.runFrom.x, this.runFrom.y), p *= 1.42) : this.chargeTarget && this.chargeTarget.alive && (this.targetDir = o.getDirection(this.chargeTarget.x, this.chargeTarget.y, this.x, this.y), p *= 1.75, s = !0), this.hitWait && (p *= .3), this.dir != this.targetDir) {
                    this.dir %= i; //mod 2pi
                    var rawdelta = (this.dir - this.targetDir + i) % i, //mod 2pi (get some sort of delta to target)
                        m = Math.min(Math.abs(rawdelta - i), rawdelta, this.turnSpeed * deltaTime), //then calculate the minimum distance to turn (maximum then being turnspeed)
                        y = rawdelta - Math.PI >= 0 ? 1 : -1; //finally get a multiplier for the direction to turn
                    this.dir += y * m + i //change the direction (no idea why add 2pi???)
                }
                this.dir %= i; //make sure it's clamped between 0 and 2pi
                this.xVel += p * deltaTime * Math.cos(this.dir);
                this.yVel += p * deltaTime * Math.sin(this.dir);
                this.moveCount -= deltaTime; //remove moving time
                //wait if your moving time has ended
                this.moveCount <= 0 && (this.runFrom = null, this.chargeTarget = null, this.waitCount = this.hostile ? 1500 : o.randInt(1500, 6e3)) 
            }

            this.zIndex = 0, this.lockMove = false;
            
            //cut the movement into up to 4 pieces??
            var k = o.getDistance(0, 0, this.xVel * deltaTime, this.yVel * deltaTime), //TODO replace this with a sqrt
                w = Math.min(4, Math.max(1, Math.round(k / 40))),
                v = 1 / w;
            
            //check collisions (i think this is handled for me...)
            for (f = 0; f < w; ++f) {
                this.xVel && (this.x += this.xVel * deltaTime * v), this.yVel && (this.y += this.yVel * deltaTime * v), grid = t.getGridArrays(this.x, this.y, this.scale);
                for (var b = 0; b < grid.length; ++b)
                    for (var x = 0; x < grid[b].length; ++x) grid[b][x].active && t.checkCollision(this, grid[b][x], v)
            }


            var S, I, T;
            var M = false;
            if (this.hitWait > 0 && (this.hitWait -= deltaTime, this.hitWait <= 0)) {
                M = true;
                this.hitWait = 0;

                (this.leapForce) //if we have an amount to leap by
                && !o.randInt(0, 2) // 1/3 of the time
                && (this.xVel += this.leapForce * Math.cos(this.dir), this.yVel += this.leapForce * Math.sin(this.dir)); //jump forward

                ` var p, g, m = [];
                this.getGridArrays = function(e, t, n) {
                    u = Math.floor(e / f), d = Math.floor(t / f), m.length = 0;
                    try {
                        this.grids[u + "_" + d] && m.push(this.grids[u + "_" + d]), e + n >= (u + 1) * f && ((p = this.grids[u + 1 + "_" + d]) && m.push(p), d && t - n <= d * f ? (p = this.grids[u + 1 + "_" + (d - 1)]) && m.push(p) : t + n >= (d + 1) * f && (p = this.grids[u + 1 + "_" + (d + 1)]) && m.push(p)), u && e - n <= u * f && ((p = this.grids[u - 1 + "_" + d]) && m.push(p), d && t - n <= d * f ? (p = this.grids[u - 1 + "_" + (d - 1)]) && m.push(p) : t + n >= (d + 1) * f && (p = this.grids[u - 1 + "_" + (d + 1)]) && m.push(p)), t + n >= (d + 1) * f && (p = this.grids[u + "_" + (d + 1)]) && m.push(p), d && t - n <= d * f && (p = this.grids[u + "_" + (d - 1)]) && m.push(p)
                    } catch (e) {}
                    return m
                }`

                var grid = t.getGridArrays(this.x, this.y, this.hitRange); //no idea what this returns
                
                for (let P = 0; P < grid.length; ++P)
                    for (b = 0; b < grid[P].length; ++b)(S = grid[P][b]).health && (I = o.getDistance(this.x, this.y, S.x, S.y)) < S.scale + this.hitRange && (S.changeHealth(5 * -this.dmg) && t.disableObj(S), t.hitObj(S, o.getDirection(this.x, this.y, S.x, S.y)));
                for (b = 0; b < n.length; ++b) n[b].canSee(this) && c.send(n[b].id, "aa", this.sid)
            }
            if (s || M)
                for (f = 0; f < n.length; ++f)(S = n[f]) && S.alive && (I = o.getDistance(this.x, this.y, S.x, S.y), this.hitRange ? !this.hitWait && I <= this.hitRange + S.scale && (M ? (T = o.getDirection(S.x, S.y, this.x, this.y), S.changeHealth(-this.dmg), S.xVel += .6 * Math.cos(T), S.yVel += .6 * Math.sin(T), this.runFrom = null, this.chargeTarget = null, this.waitCount = 3e3, this.hitWait = o.randInt(0, 2) ? 0 : 600) : this.hitWait = this.hitDelay) : I <= this.scale + S.scale && (T = o.getDirection(S.x, S.y, this.x, this.y), S.changeHealth(-this.dmg), S.xVel += .55 * Math.cos(T), S.yVel += .55 * Math.sin(T)));
            //deceleration
            this.xVel && (this.xVel *= Math.pow(Game.playerDecel, deltaTime)), this.yVel && (this.yVel *= Math.pow(Game.playerDecel, deltaTime));
            var E = this.scale;
            this.x - E < 0 ? (this.x = E, this.xVel = 0) : this.x + E > Game.mapScale && (this.x = Game.mapScale - E, this.xVel = 0), this.y - E < 0 ? (this.y = E, this.yVel = 0) : this.y + E > Game.mapScale && (this.y = Game.mapScale - E, this.yVel = 0)
        }
    }, this.canSee = function(e) {
        if (!e) return false;
        if (e.skin && e.skin.invisTimer && e.noMovTimer >= e.skin.invisTimer) return false; //if invis
        var t = Math.abs(e.x - this.x) - e.scale, //distance to edge of circle
            i = Math.abs(e.y - this.y) - e.scale; //distance to edge of circle
        return t <= Game.maxScreenWidth / 2 * 1.3 && i <= Game.maxScreenHeight / 2 * 1.3
    };
    var h = 0,
        u = 0;
    this.animate = function(e) {
        this.animTime > 0 && (this.animTime -= e, this.animTime <= 0 ? (this.animTime = 0, this.dirPlus = 0, h = 0, u = 0) : 0 == u ? (h += e / (this.animSpeed * Game.hitReturnRatio), this.dirPlus = o.lerp(0, this.targetAngle, Math.min(1, h)), h >= 1 && (h = 1, u = 1)) : (h -= e / (this.animSpeed * (1 - Game.hitReturnRatio)), this.dirPlus = o.lerp(0, this.targetAngle, Math.max(0, h))))
    }, this.startAnim = function() {
        this.animTime = this.animSpeed = 600, this.targetAngle = .8 * Math.PI, h = 0, u = 0
    }, this.changeHealth = function(e, t, i) {
        if (this.active && (this.health += e, i && (this.hitScare && !o.randInt(0, this.hitScare) ? (this.runFrom = i, this.waitCount = 0, this.moveCount = 2e3) : this.hostile && this.chargePlayer && i.isPlayer ? (this.chargeTarget = i, this.waitCount = 0, this.moveCount = 8e3) : this.dontRun || (this.runFrom = i, this.waitCount = 0, this.moveCount = 2e3)), e < 0 && this.hitRange && o.randInt(0, 1) && (this.hitWait = 500), t && t.canSee(this) && e < 0 && c.send(t.id, "t", Math.round(this.x), Math.round(this.y), Math.round(-e), 1), this.health <= 0 && (this.spawnDelay ? (this.spawnCounter = this.spawnDelay, this.x = -1e6, this.y = -1e6) : (this.x = this.startX || o.randInt(0, Game.mapScale), this.y = this.startY || o.randInt(0, Game.mapScale)), this.health = this.maxHealth, this.runFrom = null, t && (r(t, this.killScore), this.drop))))
            for (var n = 0; n < this.drop.length;) t.addResource(Game.resourceTypes.indexOf(this.drop[n]), this.drop[n + 1]), n += 2
    }
}

[FuriousBird]

Managed to create and send ai objects, i've decided to make them inherit from the Entity class: they will be named "Agents".