Nick's Ace of Coders code

pointsMap = self.getControlPointsMap()

towardsB = Vector.add(self.pos, Vector.limit(Vector.subtract(pointsMap.nearB.pos, self.pos), 4.5))
self.buildXY("archer", towardsB.x, towardsB.y)
self.command(self.built[0], "move", pointsMap.nearB.pos)
towardsA = Vector.add(self.pos, Vector.limit(Vector.subtract(pointsMap.nearA.pos, self.pos), 4.5))
self.buildXY("archer", towardsA.x, towardsA.y)
self.command(self.built[1], "move", pointsMap.nearA.pos)

centerPos = self.getControlPointsMap().center.pos
self.hurl(self, centerPos)
loop:
    missiles = [m for m in self.findEnemyMissiles() if m.type is 'shell' and m.velocity.z < 0 or m.type is 'boulder']
    missiles = missiles.concat([m for m in self.findFriendlyMissiles() if m.type is 'shell' and m.velocity.z < 0])
    buildArmy(missiles)
    commandArmy(missiles)
    controlHero()

def buildArmy(missiles):
    for missile in missiles:
        # Don't build if a boulder/shell is about to land
        if self.distanceTo(missile.targetPos) < 10:
            return
    type = "archer"
    enemyArtillery = [a for a in self.findByType("artillery", self.findEnemies()) if self.distanceTo(a) > 25 and a.health > 60]
    enemyTowers = self.findByType("arrow-tower", self.findEnemies())
    nearestTower = self.findNearest(enemyTowers)
    if not len(self.findByType("artillery", self.findFriends())) and (len(enemyArtillery) or len(enemyTowers) > 1 and nearestTower.health > 400 and self.distanceTo(nearestTower) > 10):
        type = 'artillery'
    if self.gold >= self.costOf(type):
        #self.summon(type)
        buildPos = Vector.add(self.pos, Vector.limit(Vector.subtract(centerPos, self.pos), 4.5))  # towards center
        enemyHero = self.findByType("goliath")[0]
        if enemyHero and buildPos.distance(enemyHero.pos) < 10:
            awayFromEnemyHero = Vector.limit(Vector.subtract(self.pos, enemyHero.pos), 4.5)
            if enemyHero.distanceTo(centerPos) < self.distanceTo(centerPos):
                # We will probably fling hero towards where we would otherwise build the unit soon, so rotate it
                angle = Math.PI / 2
                if len(self.built) % 2:
                    angle *= -1
                awayFromEnemyHero = Vector.rotate(awayFromEnemyHero, angle)
            buildPos = Vector.add(self.pos, awayFromEnemyHero)
        if type is 'artillery':
            self.summon(type)
        else:
            self.buildXY(type, buildPos.x, buildPos.y)

def commandArmy(missiles):
    friends = self.built
    enemies = self.findEnemies()
    enemyHero = self.findByType("goliath")[0]
    archers = self.findByType("archer", enemies)
    artillery = self.findByType("artillery", enemies)
    towers = self.findByType("arrow-tower", enemies)
    soldiers = self.findByType("soldier", enemies)
    points = self.getControlPoints()
    for i, friend in enumerate(friends):
        if friend.health <= 0: continue
        if self.health < 1500 and enemyHero and (self.health < enemyHero.health + 500 or enemyHero.health < 750) and (friend.type != 'arrow-tower' or friend.distanceTo(enemyHero) < 30):
            self.command(friend, "attack", enemyHero)
            continue
        if i < 2:
            target = friend.findNearestEnemy()
            if target and target.distanceTo(friend) < 25:
                self.command(friend, "attack", target)
            else:
                self.command(friend, "move", points[i + 1].pos)
            continue
        tower = friend.findNearest(towers)
        enemyArtillery = friend.findNearest(artillery)
        archer = friend.findNearest(archers)
        soldier = friend.findNearest(soldiers)
        if friend.type == "arrow-tower":
            targets = [archer, enemyArtillery, tower, soldier, enemyHero]
            for target in targets:
                if not target: continue
                if target.distanceTo(friend) < 30:
                    self.command(friend, "attack", target)
                    break
            continue
        if friend.type == "artillery":
            targets = [enemyArtillery, tower, enemyHero, archer, soldier]
            for target in targets:
                if not target: continue
                if friend.distanceTo(target) < 15: continue
                self.command(friend, "attack", target)
                break
            continue
        # Archer logic
        commanded = False
        targets = [archer, enemyArtillery, tower]
        for target in targets:
            if not target: continue
            if target.distanceTo(friend) < 30:
                self.command(friend, "attack", target)
                commanded = True
                break
        if commanded: continue
        for missile in missiles:
            d = friend.distanceTo(missile.targetPos)
            if missile.type is 'boulder' and d < 15 or missile.type is 'shell' and d < 20:
                flee = boundFlee(Vector.add(friend.pos, Vector.multiply(Vector.normalize(Vector.subtract(friend.pos, missile.targetPos)), 20)))
                if friend.distanceTo(flee) > 4:
                    self.command(friend, "move", flee)
                    commanded = True
                    break
        for meleeTarget in [soldier, enemyHero, tower]:
            if not meleeTarget: continue
            if self.now() > 120: continue
            d = meleeTarget.distanceTo(friend)
            if ((meleeTarget.type is 'goliath' and d < 15) or (meleeTarget.type is 'soldier' and d < 12) or (meleeTarget.type is 'arrow-tower' and d < 35)):
                flee = boundFlee(Vector.add(friend.pos, Vector.multiply(Vector.normalize(Vector.subtract(friend.pos, meleeTarget.pos)), 40)))
                if friend.distanceTo(flee) > 4:
                    self.command(friend, "move", flee)
                    commanded = True
                    break
                else:
                    d = 10
            if d < 15:
                self.command(friend, "attack", meleeTarget)
                commanded = True
                break
        if commanded: continue
        if enemyArtillery and friend.distanceTo(enemyArtillery) < 40:
            self.command(friend, "attack", enemyArtillery)
            continue

        point = points[i % len(points)]
        if point.name is 'farCorner':
            point = pointsMap['center']
        elif point.team is self.team and friend.distanceTo(point.pos) > 10:
            point = pointsMap['center']
        fighting = self.now() > 120 or self.health < 2000
        if not fighting:
            self.command(friend, "defend", point.pos)
        else:
            self.command(friend, "attack", friend.findNearest(enemies))

def boundFlee(flee):
    flee.x = Math.min(Math.max(flee.x, 6), 114)
    flee.y = Math.min(Math.max(flee.y, 6), 94)
    if flee.x < 30 and flee.y > 74:
        flee.x = 30
        flee.y = 74
    if flee.x > 90 and flee.y < 26:
        flee.x = 90
        flee.y = 26
    return flee

def controlHero():
    enemies = self.findEnemies()
    nearestEnemy = self.findNearest(enemies)
    if not nearestEnemy: return
    tower = self.findNearest(self.findByType("arrow-tower", enemies))
    rangedAttacker = self.findNearest(self.findByType("archer", enemies))
    if not rangedAttacker or self.distanceTo(rangedAttacker) > self.throwRange:
        rangedAttacker = self.findNearest(self.findByType("artillery", enemies))
    if not rangedAttacker or self.distanceTo(rangedAttacker) > self.throwRange:
        rangedAttacker = tower
    if rangedAttacker and self.distanceTo(rangedAttacker) < 25 and self.isReady("throw") and rangedAttacker.health >= 30:
        self.throw(rangedAttacker)
    elif tower and self.distanceTo(tower) < 30 and tower.distanceTo(centerPos) < 30:
        self.attack(tower)
    elif self.isReady("hurl") and nearestEnemy.type in ['goliath', 'ice-yak'] and self.distanceTo(nearestEnemy) < 8.00000000:
        if nearestEnemy.distanceTo(pointsMap.farCorner.pos) < nearestEnemy.distanceTo(pointsMap.nearCorner.pos):
            self.hurl(nearestEnemy, pointsMap.farCorner.pos)
        else:
            self.hurl(nearestEnemy, pointsMap.nearCorner.pos)
    elif self.isReady("stomp") and self.distanceTo(nearestEnemy) < 6:
        self.stomp(nearestEnemy)
    elif self.health < 2000:
        self.attack(self.findByType("goliath")[0] or nearestEnemy)
    elif self.distanceTo(centerPos) < 1 and self.distanceTo(nearestEnemy, True) < 5:
        self.attack(nearestEnemy)
    else:
        #self.move([map['nearB'].pos, map['nearA'].pos, map['center'].pos, map['farA'].pos][Math.floor(self.now() / 15) % 4])
        self.move(centerPos)