text:
Hell0 W0rld! scored by ASCII values
Write a program that outputs Hell0 W0rld!.  It must match this output exactly, including capitalization, zeroes instead of o's, exactly one space, etc.  Trailing new lines are allowed.
Lowest score wins.  Scoring is based on the sum of the values of each character in the language's code page - otherwise Unicode values should be used.  New lines are treated as spaces.
Here are a few example scores:
abc //Score: 294

print(Hell0 W0rld!) //Score: 1597

//Score: 1454
multi
line
code

You can check your ASCII score by inputting your code here.  You can view individual ASCII values here.

Tabs are lower than spaces, but I seem to be getting a higher score using tabs. Are whitespace characters taken into account? That would shave a nice chunk off my score(s).

@ouflak Whitespace counts. Only change is that new lines count as spaces. So yes, tabs are cheaper than spaces.

@Evordor, got it. Thanks.

Lenguage, score 0
Well, this is quite boring and obvious, but it seems to achieve the perfect score (assuming I understand the challenge correctly). To fix this loophole, you should probably add the program's length to the sum of the code points; I'm pretty sure that won't break the relative order of the current answers.
The program is
2282524454641945458940768311481012240407465625061984267694778013056442426959468031225640633070772676474431950201473533908

null bytes. Fortunately, 0 multiplied by the number above is still 0.
I believe this decompresses (alternatively, it compresses) to the automatically generated (with the help of a random web page that claims "Original Java program not from me") brainfuck program:
-[------->+<]>-.-[->+++++<]>++.+++++++..[-->+<]>------.[--->++<]>.---[->+++<]>.+[-->+<]>++++.[----->+<]>++.------.--------.-[--->+<]>.

It almost certainly could be golfed (but I haven't tried), but that is unnecessary.

Since the JavaScript submission was not a serious contender, I've edited it out of the answer.

05AB1E, score 513 252
-261 points thanks to @Dorian
Posting this separately from my other answer, as this one is arguably less cheating. I've been waiting for somebody else to do this for a while, but nobody did. I tried multiple languages. Pyth has extremely short code for this (Cl"...", if I remember correctly), but it turned out it can't input null bytes, and most other golfing languages I found have painfully large char codes for quotes (and I couldn't write this piece of code in the rest).
"ǝǝǝǝǝǝǝǝǝǝǝǝ...ǝǝǝǝǝ"gтB

Where there are 174047470094320053473995 ǝ characters, that conveniently happen to have a value of 0 in the code page.
Explanation:
"ǝǝǝǝǝǝǝǝǝǝǝǝ...ǝǝǝǝǝ"        push the long string
                      g       pop and get its length
                       тB     push 100 and convert to that base

You definitely shouldn't try the full version online, but you can try online the version with the length finding part skipped.

I make this one 513 too. (I went with the same approach in Jelly for 998 - two different ways. Expensive quotes indeed.)

You can also use B to convert the number directly to a string. That will lead to a score of only 252 "ǝǝǝ...ǝǝ"gтB. Try it online

@Dorian Are you sure that can produce a space character? I tried that. UPD: turns out it can; will update slightly later.

7, 41 characters, code point sum 81
32002453003001200522231203103002440537403
Try it online!
Unlike with many of my 7 programs, there's nothing particularly clever going on here; this basically just prints a string in the simplest possible way (which in 7 involves encoding the string into a piece of source code, evaluating it, analysing the resulting stack element to figure out what source code is most likely to have created it, and then giving the resulting source code directly to the output routines).
The reason this scores so well is that 7 has a code page consisting of only 8 characters, and the code that's used to represent string literals tends to use only 0, 1, 2, 3, 4, 5 (as those commands have much easier-to-analyse effects on the stack than 6 and 7 do, so it's more likely that the original source will be accurately reproduced by the 6 command). This means that none of the code points in the bulk of the program will go above 5 (the assignment of code points to characters in 7 is the obvious one), leading to an average code point value of around 2½ (for this program, happenstance means it's more like 2). Thus, although there are a lot of characters in the program, the sum of the codepoints continues to stay low. (Unlike the Lenguage answer, the code point sum + character count is also very low, so this answer isn't even really cheating.)

COW, Score: 117799
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MoO MoO
MoO MoO MoO MoO MoO Moo Moo OOO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MOo MOo MOo
MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo Moo MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MOo MOo MOo MOo MOo
MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo
MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo
MOo MOo MOo MOo Moo MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MOo MOo MOo
MOo MOo MOo Moo MOo MOo MOo MOo MOo MOo MOo MOo Moo OOO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO
MoO MoO Moo

Try it online!
My cow could not understand that the lower score in this challenge is better, so they scored very high! I kept telling them: "Please score lower, it is better", but they kept responding: "MoO"!

But the score is a perfect sample input for Is It Double Speak!

HTML, Score: 959

Hell0
W0rld!

If newlines (\r and \n) would have been count as their ASCII code (10 and 13) the score would be 937 or 940 because in HTML, new lines in "inline" elements are rendered as space.

How does one "run" a html page? This is the browser parsing a file, not your code actually doing anything :/

@RobQuist, so isn't the browser interpreting my HTML code?

@RobQuist, also please see this: "Answering in non-programming languages is allowed"

In my opinion, no, since its not a programming language but markup.

Keg, sum = 966 868 853 843
� +HOO��� +�UOG�(�+"

Try it online!
-15 score from cutting out the 0 (with a bit of help from the awful old Python script).
-10 score from A__'s idea to use " and implicit print over the costlier ,.
Based on a comment by Night2, as well as Jo King's old 32-byte quine.
� +HOO��� +�UOG�(�+"        Push the shifted codepoints beginning-first.
� +     � +                 ('H' and 'W' are pushed as sums,
                             because '+' is cheaper than '\'.)
                  +         Add
                 �          29
                   "        then rotate the stack
                (           once for every item on the stack.

If newlines weren't treated as spaces for scoring, this would be 832:

 +GNN���TNF�� +(�+"

Try it online!

Ah, thanks for catching that--my guess was it was some sort of CRLF issue but that didn't explain why the difference is 22.

Score: 843. TIO

MineFriff, Score: 3725
Cff3,a*a,9*c,a*b4,6*8,8*a7,ff2,8*6,9*c,:a*a1,9*8,`
>l?#;o~

Try it online!
This ain't winning any competitions any time soon I tell you (I dread seeing what Scratch's score would be...). I'll post an image of what this looks like in-game soon, but first I have to actually re-install the python-in-minecraft mod and actually get it all working first.
See y'all soon! (I hope...)
Actual In-Game Progess Report
10 mins in

I managed to finally get Forge opened on my mac. That really shouldn't have taken 10 minutes but it did
Minecraft 1.8 (unmodded) still hasn't launched/finished downloading.
Still downloading the actual mod
All star seems like a nice song to listen to while doing this

14 mins in

Minecraft 1.8 finally opened
Mod finally downloaded
All star finished playing
Moving on to actually using forge

17 mins in

Forge successfully has installed and I'm loading in the mod now
Jake Paul is apparently number one. Send help please.

20 mins in

Help received. No longer listening to cringey songs
I think I've properly installed the mod. No clue if it works because minecraft doesn't want to load.

23 mins in

And I downloaded the wrong version of the mod. Oops. Nothing broken, just wasted, oh, I don't know, 6 minutes. Sigh.

27 mins in

I still can't read the documentation. Apparently, I needed to drag all the folders from the extracted zip into the mods folder
Starting to think about downloading the minefriff world

30 mins in

MOD IS FINALLY INSTALLED
Thank goodness. Robbie Rotten is now number one. No help needed this time.
Time to see if everything still works.

34 mins in

About to test if actual interpreter works in-game. Wish me luck!

36 mins in

Nup. Game crashed. :(

Tomorrow

I'll be trying 1.10 instead of 1.8

Next day, 1 min in

Minecraft 1.10 has somehow deleted itself from my list of available installations. Now I have to manually find it somewhere and then somehow get Forge to make a 1.10 profile. Problem is, I won't be able to work on it for another 4 hours. See y'all then!

Boy, what a journey

Cliffhanger!!!!

PHP, Score: 959
"Classic" answer. PHP outputs by default.
Hell0 W0rld!

Try it online!

Polyglot with Carrot and Canvas and Charcoal

Bash,  score: 1360
echo    Hell0   W0rld!

Try it online!

If you can replace the spaces with tabs, you can save 23*2 = 46 points: https://tio.run/##S0oszvj/PzU5I5/TIzUnx4Az3KAoJ0Xx/38A - Bash word-splits on any whitespace char.

@DigitalTrauma Thanks for the improvment

Keg, Score: 1051
Hell0 W0rld\!

Try it online!

Zsh, Score 1207
<<<"Hell0 W0rld!"

Try it online, with a self-scorer!
Using <<<Hell0\ W0rld! is shorter, but more expensive: \ = 92, but 2⨯" = 68.

Forth (gforth), Score: 1105
." Hell0 W0rld!"

Try it online!
Prints the given string to stdout.

bit**, Score: 2519
#72/#101/#108/#108/#48/#32/#87/#48/#114/#108/#100/#33/

Try it online!

Japt, Score: 863
")FMM8SME"c+#

Test it

C (gcc), Score: 2021
Thanks to GammaFunction
A(){puts("Hell0 W0rld!");}

Also, just for fun, here is a C program that had a score of 1 using overflow.
It's a base64 encoded rar file
https://pastebin.com/SJMcRnLj
Try it online!

Trailing newlines are allowed, so puts saves a bit. Also, functions are allowed by default unless "full program" is specified in the challenge.

@GammaFunction how would I make it into a function?

Like this, using the footer to call the function. I called it A because it's the least expensive valid C identifier.

what an interesting year for me to see this answer in

Jelly, Score:1213
Just the string. Nothing interesting.
“Hell0 W0rld!

Score: 1744
Simply a compression.
“ØƲṡhḍḊF®Ḍ?»

Try it online!
Code page summator

Turing Machine Code, Score: 7105 6279 5175
0   _   !   l   !
!   _   d   l   "
"   _   l   l   #
#   _   r   l   $
$   _   0   l   %
%   _   W   l   &
&   _   _   l   '
'   _   0   l   (
(   _   l   l   )
)   _   l   l   +
+   _   e   l   ,
,   _   H   l   -

Implemented suggestions by Naruyoko
Shaved off another 1100+ using tabs instead of spaces
Try it online!
Turing Machine But Way Worse, Score: 69695 55343
0   0   0   1   1   0   0
0   1   1   1   2   0   0
0   2   0   1   3   0   0
0   3   0   1   4   0   0
0   4   1   1   5   0   0
0   5   0   1   6   0   0
0   6   0   1   7   0   0
0   7   0   1   8   1   0
0   8   0   1   9   0   0
0   9   1   1   10  0   0
0   10  1   1   11  0   0
0   11  0   1   12  0   0
0   12  0   1   13  0   0
0   13  1   1   14  0   0
0   14  0   1   15  0   0
0   15  1   1   16  1   0
0   16  0   1   17  0   0
0   17  1   1   18  0   0
0   18  1   1   19  0   0
0   19  0   1   20  0   0
0   20  1   1   21  0   0
0   21  1   1   22  0   0
0   22  0   1   23  0   0
0   23  0   1   24  1   0
0   24  0   1   25  0   0
0   25  1   1   26  0   0
0   26  1   1   27  0   0
0   27  0   1   28  0   0
0   28  1   1   29  0   0
0   29  1   1   30  0   0
0   30  0   1   31  0   0
0   31  0   1   32  1   0
0   32  0   1   33  0   0
0   33  0   1   34  0   0
0   34  1   1   35  0   0
0   35  1   1   36  0   0
0   36  0   1   37  0   0
0   37  0   1   38  0   0
0   38  0   1   39  0   0
0   39  0   1   40  1   0
0   40  0   1   41  0   0
0   41  0   1   42  0   0
0   42  1   1   43  0   0
0   43  0   1   44  0   0
0   44  1   1   45  0   0
0   45  1   1   46  0   0
0   46  0   1   47  0   0
0   47  0   1   48  1   0
0   48  0   1   49  0   0
0   49  0   1   50  0   0
0   50  1   1   51  0   0
0   51  0   1   52  0   0
0   52  0   1   53  0   0
0   53  0   1   54  0   0
0   54  0   1   55  0   0
0   55  0   1   56  1   0
0   56  0   1   57  0   0
0   57  1   1   58  0   0
0   58  0   1   59  0   0
0   59  1   1   60  0   0
0   60  0   1   61  0   0
0   61  1   1   62  0   0
0   62  1   1   63  0   0
0   63  1   1   64  1   0
0   64  0   1   65  0   0
0   65  0   1   66  0   0
0   66  1   1   67  0   0
0   67  1   1   68  0   0
0   68  0   1   69  0   0
0   69  0   1   70  0   0
0   70  0   1   71  0   0
0   71  0   1   72  1   0
0   72  0   1   73  0   0
0   73  1   1   74  0   0
0   74  1   1   75  0   0
0   75  1   1   76  0   0
0   76  0   1   77  0   0
0   77  0   1   78  0   0
0   78  1   1   79  0   0
0   79  0   1   80  1   0
0   80  0   1   81  0   0
0   81  1   1   82  0   0
0   82  1   1   83  0   0
0   83  0   1   84  0   0
0   84  1   1   85  0   0
0   85  1   1   86  0   0
0   86  0   1   87  0   0
0   87  0   1   88  1   0
0   88  0   1   89  0   0
0   89  1   1   90  0   0
0   90  1   1   91  0   0
0   91  0   1   92  0   0
0   92  0   1   93  0   0
0   93  1   1   94  0   0
0   94  0   1   95  0   0
0   95  0   1   96  1   0
0   96  0   1   97  0   0
0   97  0   1   98  0   0
0   98  1   1   99  0   0
0   99  0   1   100 0   0
0   100 0   1   101 0   0
0   101 0   1   102 0   0
0   102 0   1   103 0   0
0   103 1   1   104 1   1

Tabs instead of spaces, saving over 14,000
Try it online!

You could probably improve by changing the state name to a much earlier character, and move left instead of right.

@Naruyoko, Done, and added a couple of other improvements as well.

Charcoal, score 722
⍘Ｌ”y；；；(...231699726063762276300861 in total...)；；；”γ

Port of @someone's 05AB1E answer. Explanation: If you convert 231699726063762276300861 to base 95 using the printable ASCII character set then you get the desired output. Only printable ASCII characters are automatically turned into string literals, so our null bytes have to be quoted with ”y”. Using Charcoal's code page, the special characters have the byte values 148 + 204 + 9 + 121 + 0 + ... + 0 + 9 + 231 = 722.
As proof of concept, you can see it just for the letters He: Try it online!

Malbolge, Score: 6087
Just because I can.
('<;_#!7[}4{2VxTv-QsqNo'K+k)"Fgf|Bcc>=O<;(Kq7XXm3TjSng-x+)((`%d#"E~Y|{{>g,;;ut

6081 is (presumably) your score, but it's not in bytes.  You could list the byte count separately for interest if you wanted, or just remove that word.

Whoops, that was a typo, thanks for noting.

x86-64 machine code (Linux executable w/ system calls), score 1508
274 bytes: 18 code bytes, 12 data bytes, and 244 zero-padding bytes to make a rel32 = 00 01 00 00 instead of some larger number in the lowest byte.
The natural character-set of x86 machine code is 1 binary byte.  No argument can be made for word, unlike with a RISC with fixed-length instructions.
Hexdump of the .text section of the executable (actually from assembling the same thing into a flat binary for hexdump -C).  I'm not counting the metadata bytes of the whole executable emitted by the linker.
00000000  8d 35 00 01 00 00 5f 04  0c 92 04 01 0f 05 04 30  |.5...._........0|
00000010  0f 05 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00000100  00 00 00 00 00 00 48 65  6c 6c 30 20 57 30 72 6c  |......Hell0 W0rl|
00000110  64 21                                             |d!|
00000112

Disassembly (objdump -d -Mintel).
0000000000400080 <_start>:            # Entry point
  400080:       8d 35 00 01 00 00       lea    esi,[rip+0x100]        # 400186 <msg>

0000000000400086 <_start.lea_ref>:
  400086:       5f                      pop    rdi      # fd = argc = 1
  400087:       04 0c                   add    al,0xc
  400089:       92                      xchg   edx,eax
  40008a:       04 01                   add    al,0x1
  40008c:       0f 05                   syscall         # write(argc=edi, msg=rsi, msglen=rdx) leaves RAX=msglen
  40008e:       04 30                   add    al,0x30
  400090:       0f 05                   syscall         # exit(edi=1)
        ... (a bunch of 00 bytes)

0000000000400186 <msg>:
         48 65  6c 6c 30 20 57 30 72 6c 64 21    db "Hell0 W0rld!"

Note that Linux static executables start with all registers = 0 (except RSP which points to argc on the stack).
add al, imm8 has opcode 04, and is the lowest opcode that takes an immediate.  Using that to turn a 0 into a number we want, and xchg-with-eax for another zero, is the best way I've found to construct small numbers under these scoring rules.  push imm8/pop is somewhat worse, and mov reg,imm8 has a high opcode.
The opcode map at http://ref.x86asm.net/coder64.html was very useful for this.

Built with nasm -felf64 hell0.asm && ld -o hell0 hell0.o from this source: (Including a mess of commented out possibilities, many with their instruction bytes to remind me why I didn't use them.)
If MSGXOR is %defined to a non-zero value, link with ld -N (aka --omagic) to make .text read+write.  In that case, the %if includes a loop that XORs every byte of the string.  0x60 and 0x64 are both equal.  Subtraction with 0x30 doesn't save enough, and subtraction with larger values wraps around for too many bytes creating larger bytes.
BITS 64                     ; for flat binary.
%define MSGXOR 0x60

default rel
_start:
    lea    esi,[rel msg]  ; small positive offset.  Truncating the address to 32-bit is ok in a non-PIE
;    mov esi, msg         ; better than   rsi, msg  or strict qword
 .lea_ref:

;    add    al, 1        ; nr_write.  04  add al, imm8 is the lowest-opcode immediate instruction
    ;cmovnz edi, eax     ; 0f 45 f8    RDI is the highest-numbered register, and mode=11 is killer in ModRM
;    xchg   edi, eax          ; 9x
;    mov    edi, [rsp]        ; 8b 3c 24
    pop    rdi                ; 5f      fd = argc=1

;    lea    edx, [rax+msglen]     ; 8d 50 0d
    add    al, msglen
    xchg   edx, eax                ; len = msglen

%if 0
    lea    edi, [rax]   ; 8d 38
    add    edi, eax
    mov    esi, eax
%endif
;    push  "Hell"  ; 68 48 65 6c 6c  ; then would need to deal with 64-bit addresses

;    add cl, msglen    ; 80 c1 0c
;    mov cl, msglen    ; b1 0d

%if MSGXOR != 0
    add al, msglen-2      ; last byte is a '!' which grows when XORed with 0x60
.loop:
    xor byte [rsi+rax], MSGXOR
    sub eax, strict dword 1      ; longer immediate makes the backwards jcc farther from FF
        ;sub al, 1; 2c 01
    jnc  .loop                   ; }while(rax>=0); jnc has a lower opcode than jge or jns

;    lea ecx, [.loop]     ; at the top: 8d 0d 00 00 00 00       ; loop back with an indirect jump so the loop exit can jump forwards?
;        push  rcx    ; 51
;        ret          ; c3
;       jmp  rcx    ; ff e1   nope, doesn't look good.  Just have to eat the nearly-FF rel8

;    loop .loop   ; e2 f2
.break:
;;; AL = -1     after the loop
   add    eax, strict dword 2
%else
   add    al, 1                  ; RAX = 1 = _NR_write
%endif
; %else EAX = 0 still

;    add    al, 1 + !!MSGXOR      ; RAX = 1 = _NR_write
;    mov    al, 1
    syscall                      ; write(argc, msg, msglen) returns RAX=msglen

;    xor    al, 60 ^ msglen
    add    al, 60-msglen       ; or sub to wrap to 231 _NR_exit_group?
;    or     al, 60
;    mov    al, 60     ; exit.
;    mov    eax, 60
    syscall

 padbytes equ 0x100 - ($ - .lea_ref)
 times padbytes   db 0

; in the same section as the code so we can control the rel32 to have one non-zero byte of 01
X equ MSGXOR
;msg: db "Hell0 W0rld!"
msg: db 'H'^X, 'e'^X, 'l'^X, 'l'^X, '0'^X, ' '^X, 'W'^X, '0'^X, 'r'^X, 'l'^X, 'd'^X, '!'  ; last byte not XORed
msglen equ $-msg
;ml: db msglen

;msg: db 0x28, 0x5, 0xc, 0xc, 0x50, 0x40, 0x37, 0x50, 0x12, 0xc, 0x4, 0x41   ; with ^0x60

Score counted with hexdump | awk with a custom format to dump bytes in decimal, and awk to add them up.
nasm hell0.asm -o hell0.bin &&
 <hell0.bin hexdump -e '32/1 "%d " "\n"' |
 awk '{for(i=1; i<=NF; i++)tot+= $i;} END{printf "score = %#x = %d\n", tot, tot}'

With MSGXOR = 0x60, score = 1668,  the loop does not pay for itself with this short message, especially with 0 digits instead of o lower-case ASCII.  cmp al,imm8 is 3C, but cmp/jcc and counting up towards mslen-1 instead of materializing msglen and msglen-2 separately might help.  But it wouldn't help enough; we're 160 score away from break-even.
# with MSGXOR = 0x60
0000000000400080 <_start>:
  400080:       8d 35 00 01 00 00       lea    esi,[rip+0x100]        # 400186 <msg>

0000000000400086 <_start.lea_ref>:
  400086:       5f                      pop    rdi
  400087:       04 0c                   add    al,0xc
  400089:       92                      xchg   edx,eax
  40008a:       04 0a                   add    al,0xa

000000000040008c <_start.loop>:
  40008c:       80 34 06 60             xor    BYTE PTR [rsi+rax*1],0x60
  400090:       2d 01 00 00 00          sub    eax,0x1
  400095:       73 f5                   jae    40008c <_start.loop>

0000000000400097 <_start.break>:
  400097:       05 02 00 00 00          add    eax,0x2
  40009c:       0f 05                   syscall
  40009e:       04 30                   add    al,0x30
  4000a0:       0f 05                   syscall
        ...

0000000000400186 <msg>:
  400186:       28 05 0c 0c 50 40      # not really instructions, deleted disassembly
  40018c:       37
  40018d:       50
  40018e:       12 0c 04
  400191:       21                      .byte 0x21

I can't find a way to jump backwards that isn't horrible.  Register-indirect jump sucks, and short displacements need a 0xF? byte.  Padding with any non-zero byte to change the displacement costs at least as much as it reduces the rel8 displacement, and 00 00 is add [rax], al.  Hmm, Possibly with a 256-byte-aligned address in RAX, we could pad with 00 00 without modifying memory?  But xchg with EAX is a 9? byte and getting an address into RAX is costly.
But if we have a pointer in RAX, we can't use add al, 1 or sub al, 1 to loop.  In 32-bit code we'd have 4? inc/dec, but not RIP-relative addressing.  x86-64 inc/dec are terrible, using the ff /0 modrm encoding.
(I considered using a linker script to set the absolute virtual address to something even lower, but LEA's opcode is lower than mov r32, imm32.  Hrm, for EAX there is 05 add eax, imm32 with an absolute address.  So looping another reg with inc or dec might be viable.  Or looping EAX with a pointer-compare, especially if I can make the absolute data address something like 00 00 01 00 just outside the low 64k where Linux disallows memory-mapping by default.  But then I'd feel like I had to count the linker script or its resulting metadata.  Or if I'm messing around with the metadata (ELF headers) in the executable, maybe have to count the whole thing instead of just the .text section.)
32-bit code needs int 0x80 for system calls, not 0f 05 syscall.

(On 2nd thought, you could maybe argue for scoring x86 instructions as variable-length integers, presumably little-endian.)

J, Score: 1452
echo'Hell0 W0rld!'

Try it online!

evil, Score: 12853
Hard-code the characters
zaeeeaeeewzaeeaeeaeawzuueeueueawzuueeueueawzaeeeaeewzaeeeeewzaeeeeeuewzaeeeaeewzuueeueeaaawzuueeueueawzaeeaeeaewzaeeeeeaw

Try it online!

Labyrinth, Score:2151
72.101.108.108.48.32.87.48.114.108.100.33.@

Explanation
72                                          Push ord code of 'H'
  .                                         Output
   101.108.108.48.32.87.48.114.108.100.33.  And so on
                                          @ And exit.

Try it online!

MSM, Score: 1465
!dlr0W 0lleH...........

It is great that ! is not an MSM instruction. Half of the program pushes onto stack, half of it concatenates them.

HTML, score: 936

Hell0 W0rld!

HTML treats any whitespace as a space.

brainfuck, score: 5822
++++++++++[>+++++++>++++++++++>+++++++++++>+++++>+++>+++++++++<<<<<<-]>++.>+.>--..>--.>++.>---.<<.<++++++.------.<-.>>>+.

Try it online!

Befunge, Score: 1385
"!dlr0W 0lleH">:#,_@

This is my first legitimate code golf so it's probably not the best. Still not sure how the scoring system works. Is lower or higher better?

Lower score is better.

@pppery thanks, I'm guessing it's the addition of all the ASCII values?

That understanding is correct.

80186 machine code (MS-DOS .COM format), score: 1799 (2061 bytes)
Nothing particularly special about this except that I used literal values on the stack to save score over MOV statements. To be able to use the same value for the function number and string location, I used just a little bit of padding.
68 00 09 58 50 5A CD 21 C3
(2039 zeroes) 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
48 65 6C 6C 30 20 57 30 72 6C 64 21 24

TASM (ideal mode) source
IDEAL
P186

MODEL TINY
CODESEG
ORG 100H

MAIN:
    PUSH 0900H
    POP  AX
    PUSH AX
    POP  DX
    INT  21H
    RET

PADDING DB 7F7H DUP (0)
HELLO   DB "Hell0 W0rld!$"

END MAIN
ENDS

Oh the luxury of having a system call that takes implicit-length strings :) Related: my x86-64 Linux version, score 1508.  For this, can't you arrange for the offset of HELLO to be 0200h or something, and save 7 score?  Also, if your AX has a known value on process entry, you can use 05 add ax, imm16 instead of mov or push.

Isn't MOV AX, 0900H(B8 00 09) smaller?

Python 2, Score:1584
Prints the string...
print"Hell0 W0rld!"

Try it online!

Ruby, Score:1245
$><<"Hell0 W0rld!"

Try it online!

I think the quotes means it doesn't match the output exactly and is thus invalid. You probably have to go with the score 1245 solution $><<"Hell0 W0rld!" instead...

shortC, Score:1166
ShortC version of this.
AJ"Hell0 W0rld!"

Try it online!

Scratch 3, score: 2908 2012
In ScratchBlocks Syntax.
define
say[Hell0 W0rld!

Defines an anonymous function. When called, it returns Hell0 W0rld!.
http://scratchblocks.github.io/#?style=scratch3&script=define%0Asay%5BHell0%20W0rld!%5D

JavaScript, Score: 1644
alert("Hell0 W0rld!")

You can't really do much with JavaScript.

ink, Score: 959
Hell0 W0rld!

Try it online!

str, Score: 1081
`(ELL7RLD`32+o;

There are a lot of unprintable characters that don't show up above, see the TIO link for the full code.
Adds 32 to each character to get a lower score (the naive solution has a score of 1321)
Try it online!

Runic Enchantments, Score: 1091
"Hell0 W0rld!"@

Try it online!
I honestly can't find a way to do this cheaper. The costs of string manipulation are just not worth the savings that can be gained. Eg. subtrating 30 from each character the output string saves 360 but costs 289 to undo plus another 165 in control logic (454 total). Encoding the operational part of the program inside the string saves 32 (one fewer ") but costs 187.

Jelly, Score 998
“¡¡¡...(22405534226214299955809248283 more ¡'s)...¡¡¡‘Lb⁹Ọ

\$254 + 0 + 0 + \cdots + 0 +252 + 76 + 98 + 137 + 181 = 998\$
Proof of concept A
\$35 \times 256 + 33=8993\$ ¡'s prints #!
Proof of concept B
\$22405534226214299955809248289\$ ¡'s would print Hell0 W0rld!
(just a few too many characters for TIO)
How?
“¡¡¡...¡¡¡‘Lb⁹Ọ - Main Link: no arguments
“¡¡¡...¡¡¡‘     - list of code-page indices = [0,0,0,...,0,0,0]
           L    - length = 22405534226214299955809248289
             ⁹  - literal 256
            b   - to base = [72,101,108,108,48,32,87,48,114,108,100,33]
              Ọ - to characters = "Hell0 W0rld!"

Base decompression using Jelly's code-page as digits would also score 998:
“¡¡¡...(22716232902740826769901577500 more ¡'s)...¡¡¡‘LṃØJ

\$254+0+0+⋯+0+252+76+219+18+179=998\$

Assembly (nasm, x64, Linux), score: 9942 (114 bytes)
extern puts
global main
section .data
a: db "Hell0 W0rld!",0
section .text
main:
mov rdi,a
call puts wrt ..plt
ret

Try it online!
Simple assembler code which does the job (taken from original NASM's 64-bit hello-world, with unnecessary things being cut and some labels renamed to minimise the score). Probably can be golfed further.

Normally I'd golf in machine code, not asm source.  But sure, it's just as valid as other languages.  Yes as you suspected you're missing some optimizations.  If you link into a non-PIE executable, you don't need wrt ..plt.  And you can tailcall puts with jmp puts instead of call/ret.  You also don't need to put the string in a separate section from main.  (And if you did, the default section is .text so you could have just put the data after).  You do need extern puts and global main, though, for NASM.  With GAS syntax you wouldn't need extern.

68 bytes: https://tio.run/##Jcs7DsIwEEXR3qt49Bi5DhtgBzQUGcejZGD8UWxIWL1RRHOrc6lWjl6/NlGN/QqV9MImbQEwTxNsyrYIY2FVd8md98ZrQnm3ambNnhSRJJkjQ8wfcJAzmWcsf0ND8OPtmHF3q4bTw429/wA I'll leave it to you to calc the score.  Note the removal of the space after a:, and the newline after main:.  Also the space after db.  And using backticks instead of double quotes around the string for \0.  I tried omitting the \0 to depend on whatever's after it in the .text section, but I didn't get lucky with zero padding.  Anyway, it links fine with nasm -felf64 hell0.asm && gcc -no-pie hell0.o

Hmm, I forgot about the scoring system for a minute.  Note that uppercase letters have lower codepoints, so MOV EDI,A / JMP puts.  And EXTERN puts / GLOBAL main.  And A:DB"Hell0 W0rld!",0.  Also use tabs instead of spaces, and tab instead of : on labels.  But double-quotes with ,0 is better than backticks with \0.  IDK what I was thinking there, it's not even a saving in bytes.  https://tio.run/##SywuTs1NyqnUzUsszv1vrZCTmZetUJ5ZkqGgoJCenKygm5evW5CZqpCRmpNjoJf/3zUixDXIT6GgtKSYy93H38nRRyE3MTOPC0Rw@vqHcbq6eOo4cnn5BnCC1ThyujgpeYA0K4QbFOWkKCrpGPz/DwA

///, Score 959
Hell0 W0rld!

Try it online!

International Phonetic Esoteric Language, Score: 1192 (WIP language) (OLD)
<Hell0 W0rld!>o

No TIO interpreter yet, but is runnable by cloning the repository above, and calling python3 main.py "code here".
<Hell0 W0rld!>o

<Hell0 W0rld!>  ;push string "Hell0 W0rld!"
              o ;pop, print

R, Score: 1420

Boring answer coming through. One thing to note, using " instead of ' saved 10 score points.
cat("Hell0 W0rld!")

Try it online!

Whitespace, score: 2438 (118 bytes)
[S S T  T   S S S T S S N
_Push_-68_!][S S T  T   N
_Push_-1_d][S S S T T   T   N
_Push_7_l][S S S T  T   S T N
_Push_13_r][S S T   T   T   S T S T N
_Push_-53_0][S S T  T   T   T   S N
_Push_-14_W][S S T  T   S S S T S T N
_Push_-69_space][S T    S S T   S N
_Copy_0-based_2nd_-53_0][S S S S T  T   T   N
_Push_7_l][S N
S _Duplicate_top_7_l][S S S N
_Push_0_e][S S T    T   T   T   S T N
_Push_-29_H][N
S S N
_Create_Label_LOOP][S S S T T   S S T   S T N
_Push_constant_101][T   S S S _Add_top_two][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Try it online (with raw spaces, tabs and new-lines only).
Uses this Whitespace tip of mine to print the output. The optimal constant is generated by this Java program. In addition, I use one duplicate for the ll and one copy for the 0 to save bytes/score.

Rust, score: 2788
fn    main(){print!("Hell0 W0rld!")}

I was able to save some score by using a tab, but it's hard to make a short answer in Rust.

x86 machine code - 72 bytes, score : 9253
I'm using write() syscall for printing a string.
     1                                  global _start
     2                                  section .data
     3 00000000 48656C6C                msg db  "Hell"
     4
     5                                  section .text
     6                                  _start:
     7
     8 00000000 8D0D[00000000]              lea ecx, [rel msg]
     9 00000006 43                          inc ebx
    10 00000007 80C204                      add dl, 4
    11 0000000A B004                        mov al, 4
    12 0000000C CD80                        int 0x80
    13 0000000E 80EA03                      sub dl, 3
    14 00000011 C60100                      mov byte [ecx + 0 - 0], 0
    15 00000014 800130                      add byte [ecx + 0 - 0], "0"
    16 00000017 B004                        mov al, 4
    17 00000019 CD80                        int 0x80
    18 0000001B C60120                      mov byte [ecx + 0 - 0], 0x20
    19 0000001E B004                        mov al, 4
    20 00000020 CD80                        int 0x80
    21 00000022 42                          inc edx
    22 00000023 66C7015730                  mov word [ecx+ 1 - 1], "W0"
    23 00000028 B004                        mov al, 4
    24 0000002A CD80                        int 0x80
    25 0000002C 80C203                      add dl, 3
    26 0000002F C701726C6421                mov dword [ecx + 3 - 3], "rld!"
    27 00000035 B004                        mov al, 4
    28 00000037 CD80                        int 0x80
    29 00000039 99                          cdq
    30 0000003A 42                          inc edx
    31 0000003B C6010A                      mov byte [ecx + 0 - 0], 0x0a
    32 0000003E B004                        mov al, 4
    33 00000040 CD80                        int 0x80
    34
    35 00000042 31DB                        xor ebx, ebx
    36 00000044 B001                        mov al, 1
    37 00000046 CD80                        int 0x80
    38
    39
    40 00000048 48                      .size: db $ - _start

Output : Hell0 W0rld!

PowerShell, 13 bytes, 1027 score
"Hell0 W0rld"

Try it online!

80186, score 1727
A:  org  $0100
    mov  sp, $0200
    popa
    int  $21
    ret

    db $200-$ dup 0
    dw $0000  ; DI
    dw $0000  ; SI
    dw $0000  ; BP
    dw $0000  ; Ignored
    dw $0000  ; BX
    dw $0300  ; DX
    dw $0000  ; CX
    dw $0900  ; AX
    dw $0000  ; IP for RET

    db $300-$ dup 0
    db "Hell0 W0rld!$"
B:

Try it online!

Pascal, 884 ≥ 3387 (ASCII) ≥ 6645 (EBCDIC)
The programming language Pascal is independent from any “code page”.
The Pascal ISO standards call this circumstance “implementation-defined”.
The theoretical minimum score should be about 900.
If you tailored your source code to ASCII, you’ll capitalize keywords and identifiers and use tabs as token separators (the blanks outside the string are meant to be tabs):
PROGRAM A(OUTPUT);BEGIN WRITE('Hell0 W0rld!')END.

If you tailored your source code to EBCDIC, you’ll keep keywords and identifiers lower-case and also use tabs:
program a(output);begin write('Hell0 W0rld!')end.

In yet another character encoding other letters may be particularly “expensive” and you might trade longer code for “cheaper” letters.

Io, score: 1584
Thanks to its lightweight syntax, we can get rid of the parentheses.
"Hell0 W0rld!"print

Try it online!

VBScript, 1523 score
MSGBOX "Hell0 W0rld!"

Windows Batch, 1278 score
ECHO Hell0 W0rld

Noether, Score: 1107
"Hell0 W0rld!"P

Try it online!

Bits, score: 3973
1001000000101001100001100111110000001111110101111111100000010010001100000100011101

If you're interested, this is 82 bits = 10.25 bytes.
Explanation
1001000    // H
000101     // e
001100     // l
001100     // l
1111100000 // 0
011111     //
1010111    // W
1111100000 // 0
010010     // r
001100     // l
000100     // d
011101     // !
           // [Implicit join and output]


text:
KILL ALIENS NOW!
The world has been invaded by aliens. They are everywhere killing people and taking over the world. You are hiding with your friend.
They have one weakness - the high pitched sounds.
You can't go yell at them, because you'd get caught before, so you remember the state had a conveniently made machine that emits a high pitched sound all over the earth, which will get rid of the aliens. The only problem is the aliens are guarding the place where the machine is and you can't possibly go there.
As your friend is an hacker, they created a program that activates the machine if you type the string KILL ALIENS NOW!. While they were about to type it, an alien discovered and caught 'em, throwing the querty keyboard on the floor. The keyboard is as show in the picture.

Somehow it still works!...well, kinda...when you type a character, the character on its right also types. So if you type 5, it will type 56. The keyboard arrows work normally and all the keys in the numpad and meta keys (print screen, etc) also work well and do nothing else.
The delete and backspace keys don't work.
Typing shift left arrow for example, will delete a character of code and replace it with a z.
Typing j does not type k, for example (this behaviour is the same for the other borbidden keys).
If you type right shift you will click in the up arrow too, for example.
The letters k, i, l, a and n don't work (how convenient, huh).
You decide to program the KILL ALIENS NOW! output, but if you do it in a lot of bytes the aliens will discover that someone is trying to break into the machine.
How will you type the string with that stupid keyboard?
Summary of the rules
Make a program with any programming language you wish without the letters k, i, l, a and n, but if you type a character, it will type the one on the right too, that outputs the string KILL ALIENS NOW! with the least size of bytes possible for it to not appear in the alien's database as the current top action.

What happens if you type a key at the edge of the keyboard? Also, what are the effects of meta-characters like "Delete". Ex, if I want a \ in my program, it would have to be followed by a Delete key. Does that delete key get echoed as an unprintable character? Does it delete the \ I just typed? Does it do nothing?

The Backspace key is followed by Print Screen, which won't affect our code. So we can always just backspace the extra character. To type the forbidden characters, we type the key to the left, use Left Arrow (the subsequent Down Arrow won't do anything), Backspace, Right Arrow (types a 0), Backspace. Is there a better way to do this?

Also, is the score the number of bytes or the number of keypresses?

Nice catch! Updated it now. Delete and backspace don't work. Typing shift left arrow for example, will delete a character of code and replace it with a z. Clicking the character j for example, does not type k

The score is the number of bytes, as if you have a lot of them, it will appear on top of the current actions, meaning the aliens will find out about it.

How do you type programs containing unprintable characters?

That's up to you to discover!

If I press Shift-L, does that mean a ; or a : is the next character typed? Or would the result be L;z?

Also, what happens if the keys used aren't on a standard keyboard? For that matter, what if they aren't on any keyboard at all?

You only have the keyboard shown in the image. If you type shift-l ; it will type :z

Why is shift treated like it is being pressed second? Shouldn't shift g for example be treated as shift z and g h, resulting in ZGH?

Befunge-98 (PyFunge), 92 bytes
1290/zx:"())_QWCV*(P[CVNM	QRTUI*(RTRT	QAS:"cv'
1290/zx#$J:"12-=!@!@j!@780-m,45hjvbvbvbvbvb<>

19/ (the Shiftkey that results from this can be ignored since shift by itself does nothing) zRight ShiftDown Arrow (to deselect anything that may have been selected by Shift and its implicit Up Arrow);90qc8pcnTabru8rrTaba;(release Shift)c'19/zRight ShiftDown Arrow3j(k is a forbidden character so is not generated);(release Shift)1-Right ShiftDown Arrow11(release Shift)jRight ShiftDown Arrow1(release Shift)70m4hvvvvvRight ShiftDown Arrow,
Note the literal tab characters on the first line.
Try it online!

Brainfuck, 538 221 byte
++++++++++[z>?+++++++>?++++++++++>?+++>?+<z<z<z<z-]\>?+++++./-=-=./+++././<z++++++++++++++++++++++++++++++++./>?-=-=-=-=-=-=-=-=-=-=-=./+++++++++++./-=-=-=./-=-=-=-=./+++++++++./+++++./<z./>?-=-=-=-=-=./+./++++++++./<z+./

Try it online!
I hope it is correct...

@wizzwizz4 when i understand it right i only need the z character when i delete another and in this code i dind't delet any character but it can be that i made a mistake...

Oh, wait; right-shift exists. My bad!

After each period (.) there should be a / no?

sry my bad forget them :D

@DuarteArribas should be better now

ah! even less bytes too!

... but still over twice the size of my answer.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Write a bot to play Grid Game
This is the Grid Game:

It's a game based on cellular automata, where the aim is to remove all of the pieces belonging to your opponent.
How it works:

There are two kinds of piece in the game, cities and walkers.
Each player starts with one city (marked with C and a number, which is it's health), which will regularly send out walkers (marked with a number, initially the number 1) in a given direction.
The player can change the direction of all of their walkers to be north, south, east or west at any time.
When walkers can't go any further, they will stay still and can be joined by other walkers, increasing their number.
When 10 or more walkers join up, they become another city. All new cities have 10 health.
When walkers meet walkers or cities belonging to the opponent, they deal damage to the opponent equal to their number, and take damage equal to the opponent's number.
Damage is dealt to all adjacent opponent pieces.
There is no way to replenish the health of a city.
The game ends when either player has no pieces remaining, or when a clear stale-mate is reached.

Because this question is already very long, I've attempted to write a more detailed description of the game, addressing specific queries about it in this wiki page.
The Challenge
To write a bot to play Grid Game, and defeat as many rival bots as possible.

A bot is some code which will be run on each turn of the game.
It can only be JavaScript, sorry.
The size of the code is immaterial.
An object named api will be provided as an interface to the player from your bot.
In this iteration of the challenge, there is no way for your bot to know what it's opponent is doing. The challenge is to write a proactive (not reactive) strategy.

Forbidden:

Interacting with GridGame except via the documented api methods.

The API

api.turn() - Returns the numbered turn the game is on.
api.towardsX() - Aim your walkers towards the opponent on the East-West axis.
api.towardsY() - Aim your walkers towards the opponent on the North-South axis.
api.awayX() - Aim your walkers away from the opponent on the East-West axis.
api.awayY() - Aim your walkers away from the opponent on the North-South axis.
api.random_direction() - Aim your walkers in a randomly selected direction.
api.north() - Alias of awayY. North for green player, South for red player.
api.south() - Alias of towardsY. South for green player, North for red player.
api.east() - Alias of towardsX. East for green player, West for red player.
api.west() - Alias of AwayX. West for green player, East for red player.
api.wait(turns) - Your bot code will not be run again until turns turns after this method is called.
api.spawning_turn() - Returns a boolean which if true if the Cities are going to send out a Walker this turn.

Notes:

The last direction function called will define the next direction the walkers move in from that turn until a different direction is called.
If no direction function is called walkers will continue in their current direction.
Please do not set global variables, as these may conflict with those used by oponents, instead use this.variable_name to communicate between method calls.

How to write a bot
Note: I recommend playing a manual game or two first; to do this, grab a friend to play against and select 'Manual (simple)' in the footer.

Go to https://ajfaraday.github.io/grid_game/
Select a default bot as your base (in the green or red box)
Click Edit Code in the same coloured box.
Click Use when you're happy with it.

To test it:

Select an opponent bot as the other colour (or 'Manual' if you'd like to challenge it yourself.
Open the developer console (f12) in case of errors in your code.
Click Start.
Watch the game unfold.
Click Reset and repeat the process as desired.

How to deploy your bot
Once you've written a boss you'd like to keep:

Go to https://gist.github.com
Log in, if not already logged in.
(The default page is the form to create a new gist, this is where we want to be.)
Name the file 'bot.js'
Copy the code into bot.js
Save the gist
Copy the gist ID (an alphanumeric string found after the last forward slash in the URL).

This Gist ID can now be used to import your bot into Grid Game at any time:

Select Gist Id in a coloured box.
Paste the ID into the field which appears.

You will need to include this gist ID in your answer.
Note: Grid Game will use the most recent version of bot.js in the gist, updating the gist will update your answer.
Answer Format
Your answer will consist of:

A Title consisting of

A name for your bot
The gist ID (which should be a link the gist).

A brief description of the bot's strategy.
Any notes you wish to include.

Note: I would like to include answers in the respository's code, partly to sidestep rate limiting on github's gist and partly to include more interesting bots for future users to challenge or modify. Please clearly indicate if you consent to your bot becoming a part of the game code or not.
Example answer:
### The Faraday Cage - d9eb9a70ad0dc0fb1885be0fce032adc

The Faraday Cage is an arrangement of four cities in the player's starting corner, which this bot will attempt to build, which then allows it to repeatedly send two 9's towards the opponent.

* This is named after Alan Faraday, the elder brother of the game creator, who discovered it while playing the game manually.
* It has proven difficult to defeat.

Please include this in the repository.

The Tournament
The competition will involve running a match for every permutation of two of the available bots.
There are three possible outcomes to a match:

Outright win - A player is completely removed from the board. 3 points to the winner.
Timeout win - The game will end if it reaches 3,000 turns. At this point, the winner is determined by the total health count. 2 points to the winner.
Draw - If the game reaches 3,000 and the bots have an identical total health, it's a draw. Both players get 1 point.

Notes:

The below scores are from the very first working tournament runner. I hope to present the results better in future.
Currently this is a single match for each permutation. There will likely be multiple matches in future to smooth out the results for bots which use random functions.
I also want to present the results of specific matches in future.
I'll try to run it again for new bots, please alert me to changes in existing bots to request a re-run.

Current scores
(Run at 2019/11/12 09:15 UTC)
Detailed results (with links to replay matches) can be found at https://ajfaraday.github.io/grid_game/results/rankings.html
Avi - Intercept and Destroy              60
Brilliand - Line Drive                   60
Brilliand - Galeforce                    57
Brilliand - CBC Goes With Everything     55
william porter - Twin Citites            54
Brilliand - CBC Forever                  51
Brilliand - Feint                        51
Brilliand - Cage Bar Cutter              49
Brilliand - Parry and Slice              48
Avi - Hocus Pocus(!?)                    48
Alion - Evolvor: First Encounter         47
Alion - Evolvor: Overnight               45
Brilliand - Backstabber                  42
BradC - Sweeping Endgame                 36
BradC - Quad Rush                        35
Alion - Doombeam                         33
Alion - Slideout                         31
AJFaraday - Faraday Cage                 28
Alion - Zerg Rush                        25
BradC - Double Barrel                    22
Alion - Weirdflow                        21
Alion - Rushdown                         15
AJFaraday - Rotate                       12
AllirionX - 3 Base rush                   9
AJFaraday - Orbit                         8
AJFaraday - All Towards                   3

(Thanks to @brilliand for correcting the unexpected interactions between bots in the tournament runner.)
——
Chat room for this challenge

Since we're using computers and they are fast, does the tournament really have to be single-elimination?

Based on running a sample game, a few questions: walkers spawn every 3 ticks, yeah? Walkers are stopped by their own cities, yeah? What happens if there's two green cities in a row and try to spawn? Is one walker lost? Two walkers collide and they do damage orthogonally  or diagonally?

Is the bots' starting position always 2 cells away from their corners? Are they always at opposite corners?

I think your "rotate" example bot writes to the global variable n, leading to weird results when competing with self.

This seems to be missing a lot of critical information: for a start, how initial board positioning works, what stops walkers going any further, how turns work (simultaneous or sequential? What's the API which a bot must implement to be invoked each turn?), and the full signatures for the methods in the controller's API.

The question should be self-contained. If we have to reverse engineer the controller to learn how to write an answer, the question has failed to fulfil its purpose.

I'm highly against a single-elimination tournament. I'd much rather have a reliable ranking than uncertain short-lived enjoyment.

@AJFaraday I'd recommend looking at past KotHs. I am biased, but Formic Functions is a good example of a relatively well-handled ranking system, though here it could be simplified significantly, since it's a series of 1v1 games. Having a livestream is unheard of. It doesn't sound like too bad of an idea initially, but considering the fact that you should mark an answer at the end really makes it suboptimal.

@AJFaraday You might be best off just sticking to the 3000 turn limit.

Let us continue this discussion in chat.

This challenge is all about maximizing spawning, if there was a bit more board information available, this would've been a lot more interesting. Something like last board state, and current board state, even if it just showed your own cities and walkers.

@AJFaraday I look forward to it, and I really like your online editor for the bots. +1

What happens when 3 walkers (2 green and 1 red) end up on the same cell within a single turn? Moreover, what happens when the 2 green ones have a value total >= 10?

@AJFaraday Oh, my bad. The moment I started drawing the case I realized it couldn't be reached in normal gameplay due to the damage phase, because whenever greens and reds are adjacent, at least one color must disappear completely before the movement phase starts.

If more than 10 walkers join up, do they become a City with more than 10 health?  For example, if a pair of 9-walkers from a City met up, would that become an 18-city?  (i.e. Current rules only say "When 10 walkers join up, they become another city" - nothing about whether it has to be exactly 10 walkers, nor the health of the resulting city)

Tournament rules for a corner switch? Except for Doombeam, no other solution has active targeting, and when you play off any of the other's (well any of the other answers by @Alion as of now) against FCage, the just end up exchanging corners and chill out with no changes

If the team starting on the west builds a city on the east, and their original city is destroyed, then does the meaning of "toward" and "away" update? What if there are multiple cities? Which one is "toward"?

Doombeam - 496367ff51c27dc62ebdc473cd14f333
Time for a tryhard entry. Sets up a massive 12-city railgun and fires it off straight at the spawn point. Even if some of the cities get destroyed before the setup is complete, it still has enough firepower to devastate everything in its path. Additionally, after the far corner is filled with its cities to the brim, it clears up any potential leftovers, as a countermeasure to entries that escape the spawn point.
const turn = api.turn();
if (turn === 0) {
    this.generator = (function* () {
        yield* [[0, 30], [1, 30]];

        for (let i = 0; i < 10; ++i) {
            yield* [[2], [0, 2]];
        }

        for (let i = 0; i < 4; ++i) {
            yield* [[3], [1, 2]];
        }

        yield* [[3], [2, 4], [1, 4]];

        while (true) {
            for (let i = 0; i < 30; ++i) {
                yield* [[3], [2, 2]];
            }

            for (let i = 0; i < 3; ++i) {
                yield [1, 42];
                yield [0, 51];
            }
        }
    })();

    this.nextCall = 0;
}
if (turn === this.nextCall) {
    const [dir, delay = 1] = this.generator.next().value;
    [api.awayX, api.awayY, api.towardsX, api.towardsY][dir].bind(api)();
    this.nextCall += delay;
}

I do consent to the inclusion of this bot in the repository.

Wow! This is brilliant!

The "build a wall then fire diagonally" strategy seems very effective, since it attacks  the enemy "base" so directly and so quickly. Nice work.

Cage Bar Cutter - 49d7afbe8bb6d542acc871ac40d12e83
No more faraday cages!
Similar to Zerg Rush, but tuned to prevent Faraday Cages from growing at all (in either direction).  In the spirit of this being a trivial bot, it makes no attempt to clean up bots that escape to the corners (but most can't manage that anyway).
const turn = api.turn();
const opening = "EEESSSEEESSEEEEEEEEEESSSEEESSSENEEENSNSSSSEEEEEEEEESSSEEESSEEEESE";
if(turn < opening.length) {
    switch (opening[turn]) {
        case 'W':
            api.awayX();
            break;
        case 'N':
            api.awayY();
            break;
        case 'E':
            api.towardsX();
            break;
        case 'S':
            api.towardsY();
            break;
    }
} else if(turn >= 120) {
    if(api.spawning_turn()) api.towardsY();
    else api.towardsX();
}

I do consent to the inclusion of this bot in the repository.

This is scary effective, not only against Cage-likes.

Remarkable! Fantastic work!

Very good at what its designed to do.

Double Barrel - 7d0a88c1533fc89b2ee26484bbcafc59
Makes a second city and immediately opens fire diagonally, catches lots of bots during setup.
if (api.turn() < 29) {
   api.awayY();
} else if (api.turn() % 3 == 2) {
   api.towardsY();
} else {
   api.towardsX();
}

You can include this bot in your code if desired.

Slideout - 056b16e0dc85ee2f13cc6061cf8162ca
Builds on the Faraday Cage idea by increasing the total amount of walkers generated per 3 turns to 6.
const turn = api.turn();
if (turn === 0) {
    this.generator = (function*() {
        yield* [0, 1, 3].map(i => [i, 30]);

        while (true) {
            yield* [[2, 25], [3, 8]];
        }
    })();

    this.nextCall = 0;
}
if (turn === this.nextCall) {
    const [dir, delay] = this.generator.next().value;
    [api.awayX, api.awayY, api.towardsX, api.towardsY][dir].bind(api)();
    this.nextCall += delay;
}

I do not consent to the inclusion of this bot in the repository.

I was wondering why all the current submissions looked so similar. Then I realized that it was all by the same user

@EmbodimentofIgnorance Sorry, I got a bit carried away :P Hopefully others join in soon.

I had to learn this to beat Faraday's Cage by hand. Name proposal - Davy's Cannon

This bot is underrated - it is the only one consistently giving my new ideas trouble. I think it is the larger runners you build up then send around the edges.

Zerg Rush - 1f8b3963656f9e15577f886e0125a343
Oh boy, here we go... Of course a Zerg Rush would work. Why wouldn't it, right? It makes me feel incredibly dirty, but it had to be done.
const turn = api.turn();
if (turn === 0) {
    this.generator = (function* () {
        while (true) {
            yield* [[3], [2, 2]];
        }
    })();

    this.nextCall = 0;
}
if (turn === this.nextCall) {
    const [dir, delay = 1] = this.generator.next().value;
    [api.awayX, api.awayY, api.towardsX, api.towardsY][dir].bind(api)();
    this.nextCall += delay;
}

I do not consent to the inclusion of this bot in the repository.

Strangely, this will consistently draw against “always towards”, but the other will have a 6 behind Zerg Rushes base.

@AJFaraday what do you mean '6 behind'?

@VaradMahashabde Play this bot against "All Toward" in the demo, one of the bots slips 6 runners past the other before the runners start colliding and cancelling out.

@BradC ZergRush attacks on a more direct angle, so gets to AllTowards quickly

@BradC exactly what I meant. Thanks for clarifying

Twin Cities - 46b9d27b1994c35a8ef214c1b2067609
Starts off with a corner start and then makes use of how attacks work to return fire before building up it's own forces. Beats most bots, loses to others.
//Twin Cities
const turn = api.turn();

if (turn < 31) {
    switch(turn % 2) {
        case 0:
            api.awayY();
            break;
        case 1:
            api.awayX();
            break;
    }
} else if (turn < 80) {
    switch(turn % 3) {
        case 0:
            api.towardsY();
            break;
        case 1:
            api.towardsX();
            break;
        case 2:
            api.towardsX();
            break;
    }
} else if (turn < 127) {
    api.towardsX();
} else if (turn < 246) {
    api.towardsY();
} else if (turn < 350) {
    api.awayX();
} else if (turn < 400) {
    api.towardsY();
} else if (turn < 500) {
    api.towardsX();
} else {
    const late = turn % 200;
    if (late < 50) {
        api.awayY();
    } else if (late < 100) {
        api.awayX();
    } else if (late < 150) {
        api.towardsY();
    } else if (late < 200) {
        api.towardsX();
    }
}

Feel free to include it in your repository.
Edited: Simpler initial phase, also dodges feint and hocus pocus now.

Welcome to the fray! I'm at work right now, but I'll try and re-run the tournament before I head home so we can see how it does.

Very good start, joint second! If you're interested, here's it's results for every match... https://ajfaraday.github.io/grid_game/results/bot_46b9d27b1994c35a8ef214c1b2067609.html

@AJFaraday It seems to show quad rush as a loss, but the match show differently?

Some bots have old versions cached on the repo to avoid github rare limiting. The tournament was played with the latest version.

ah, that explains it.

Sorry about that, for the time bring the work around is to copy-paste the code from the answer.

I've just updated the cache, it should be up to date now.

@AJFaraday Updated for your next run + cache, should now beat feint and hocus pocus.

Intercept and Destroy - 3dcc9463f47626a217a5a51762f02fe6
An improved version of Cage Bar Cutter, intercepting creation of Faraday Cage-like structures. After attempting interception, escape to the corner and attempt to build on the opponent's side. Aggressive attackers will not target themselves, so you can build up there. Non-aggressive builders will have been reasonably interrupted by the interception attempt. After some buildup, turn around and destroy everything.
At the moment of posting, this bot achieves a win against every other posted bot in under 1000 turns. Weirdflow has the dubious distinction of lasting the most turns (808) against this strategy.
const turn = api.turn();
if (turn === 0) {
    this.generator = (function*() {
        yield* [[2, 3], [3, 3], [2, 3], [3, 2], [2, 10], [3, 3], [2, 3], [3, 3], [2, 1], [1, 1], [2, 3], [1, 1], [3, 1], [1, 1], [3, 4], [2, 9], [3, 3], [2, 3], [3, 2], [2, 4], [3, 1]];
        yield* [0, 3, 2].map(i => [i, 36]);

        while (true) {
            for(let i = 0; i < 4; i++)
            {
                yield* [[2, 25], [3, 8]];
            }
            for(let i = 0; i < 4; i++)
            {
                yield* [[0, 25], [1, 8]];
            }
            yield* [[1, 50]];
        }
    })();

    this.nextCall = 0;
}
if (turn === this.nextCall) {
    const [dir, delay] = this.generator.next().value;
    [api.awayX, api.awayY, api.towardsX, api.towardsY][dir].bind(api)();
    this.nextCall += delay;
}

As another fun little thing, here's what happens when you run this bot against itself for 4492 turns:

I do consent to the inclusion of this bot in the repository.

Nice work. Looks very effective.

It even takes out Cage Bar Cutter itself :)

Well done on currently being in the lead.

Now I’m trying to work out which flag it draws :p

Sweeping Endgame - 3f69bdf2be37886ff396d0c485007e80
More complex bot, with a setup phase, a sweeping mid-game strategy, and an endgame that covers all corners and directions.
//Sweeping Endgame v2
this.t = api.turn();

//initial city setup
if (this.t < 29) {
   api.awayY();
} else if (this.t < 59) {
   api.awayX();

//mid-game loop, now attempts to put cities in the two off-corners
} else if (this.t < 400) {
  if (this.t % 200 < 14) {
     api.towardsY();
  } else if (this.t % 200 > 13 && this.t % 200 < 17) {
     api.awayX();
  } else if (this.t % 200 > 100 && this.t % 200 < 122) {
     api.towardsX();
  } else if (this.t % 200 > 121 && this.t % 200 < 126) {
     api.awayY();
  } else if ((this.t % 8) % 3 == 1) {
     api.towardsY();
  } else {
     api.towardsX();
  }

//endgame, now sequential, not random
} else {
   if (this.t % 200 < 40) {
      api.awayY()
   } else if (this.t % 200 < 50) {
      if (this.t % 2 == 0) {
        api.towardsY();
      } else {
        api.awayX();
      }
   } else if (this.t % 200 < 90) {
     api.towardsX()
   } else if (this.t % 200 < 100) {
      if (this.t % 2 == 0) {
        api.awayY();
      } else {
        api.awayX();
      }
   } else if (this.t % 200 < 140) {
     api.towardsY()
   } else if (this.t % 200 < 150) {
      if (this.t % 2 == 0) {
        api.awayY();
      } else {
        api.towardsX();
      }
   } else if (this.t % 200 < 190) {
     api.awayX()
   } else {
      if (this.t % 2 == 0) {
        api.towardsY();
      } else {
        api.towardsX();
      }
   }
}

v2 makes the following changes:

Mid-game now deliberately attempts to get a couple of cities in the off-corners. This is crucial to "get behind enemy lines" for simple bots like Quad Rush.
End game is no longer random, instead it goes through a prescribed sequence of straight and diagonal moves to clean up the board.

Quad Rush is another bot this is losing to.

@NumLock Updated to v2, now beats Quad Rush, and most others (except for Slideout, still)

Line Drive - 54e4de5b03423cc19a1ec0e22f32a981
Attempts to occupy an entire column of the grid, then unleash an unstoppable barrage in the x-direction.
EDIT: Now biases its barrage toward one wall and changes direction more rapidly, allowing it to beat some bots that the previous version couldn't beat.
const turn = api.turn();
if (turn === 0) {
    this.generator = (function* () {
        yield* [[0, 24], [1], [0], [3], [0, 3]];

        for (let i = 0; i < 9; ++i) {
            yield* [[1], [2], [0]];
        }
        yield [1, 3];

        for (let i = 0; i < 10; ++i) {
            yield* [[3], [1, 2]];
        }

        for (let i = 0; i < 4; ++i) {
            yield* [[2], [0, 2]];
        }

        yield* [[2], [3, 4], [0, 4]];

        for (let i = 0; i < 4; ++i) {
            yield* [[2], [0, 2]];
        }

        yield* [[2], [3, 2], [0], [3, 2], [0], [3, 2], [0, 3]];

        while (true) {
            for (let i = 0; i < 60; ++i) {
                yield* [[2, 2], [1]];
            }
            for (let i = 0; i < 40; ++i) {
                yield* [[3, 2], [2]];
            }
            for (let i = 0; i < 60; ++i) {
                yield* [[0, 2], [3]];
            }
            for (let i = 0; i < 40; ++i) {
                yield* [[1, 2], [0]];
            }
        }
    })();

    this.nextCall = 0;
}
if (turn === this.nextCall) {
    const [dir, delay = 1] = this.generator.next().value;
    [api.awayX, api.awayY, api.towardsX, api.towardsY][dir].bind(api)();
    this.nextCall += delay;
}

I do consent to the inclusion of this bot in the repository.

I'm having trouble loading this entry from its gist ID. The file is named LineDrive.js instead of bot.js.

@Brilliand I'm afraid the name bot.js is significant.

@AJFaraday I've changed the filename.

@Brilliand great! I’ll include it in the cache when i look at it next.

@Brilliand It's a bit complex, I found in early tests that it's quite easy to hit the 50 calls to the gist site and then break the app for the next hour. Not great. Use Custom for dev purposes and I'll update the cache when I can. I'm in the chat now if you want to discuss further.

Evolvor: First Encounter - c0382c11979adc1f47773714ffc8376f
This is the first in what I hope becomes a series of bots that result from a genetic algorithm. Does some really weird things which result in tons of cities and then... usually can't convert it into a victory.
switch ("WNSNNNWSNWNWNWNWWNNWWNWNNNWWWNEENNNWWNNWWWWWNWWNWNWWSWENEENNENNESSSSWSWWSWWSWWSSWSNWSWWSWSSWWSWWSWWEESESSEESESSESSESWESSEWWESWESSSSSNNWNWWSWWNNWNWWEWWSWSEWWNWEEENEESEENEEEEEEEEEEENEEEEEEEESEENESEENEEESEEEEEEENEEEEEEEESEESEENEEEEEEEEENEEEESEEENEEEEEEEEEEEEEEEEESEENEENENEEESEEEEESENEEESENEEEEEESEENEEEENEEEEESEENEEEEEENEEEESEEEEENEEENENEEEEESEENEEEEEEEEESNEEEESEEEEEEENEENEEEEEWEEENEEEEENEWSEEEENNENEENEESEENEEWNEEEEEEEEWENSEENEESEEEEENENEEESEESEENEEENESENEESEWSNEENEWSENEEEEENSEEEENEEEEEENEESENEESNENWEENENSEEEENNNEEESWESWEESENENESNEEEENSNEEESEEEEEEESSEESEEEEEEESNENEEWENENNSEENEEWEEEEENWEESENNEESENNENSENWENEENWESENENNNNEENEWSENEENEEWWEEWENNWNNEEEEWSEEWESESESEEEENNWEWSSSENSENEEESESEENNNSEEEEESESSEEENENENEWEWNWSEESSENNNESSSENNENWEEEWNWNENSEWESESSEEEEENWSENEESEWNEEEWEWSEEWNNEEEENSENNESNNESNEENSEENWNNESESSWWWENEWENNSSENEESNSWWNNNWENWNNESEENEEENEESNEWSSENWWWNEEEESESWSSEWNNENWENNWNSESEEESESNSSESENWSESENNEWENNEENEESSNENEESSNWNESNENSESWWEENWWNEEEENESSEEESWWSWWEESWWEWSEENWEWEWNNSESSSNEESESNSEESSEEEEWSSSNSNSSSNNSESESSSESNWWEWENNENNNNWWEENWSNWWWSWNWWSEEEWEEWWEWENNSSEEEESNSESWENNNWENSWWNNENEESEWEWSEESEWEEWENSWNNSNENSWNWSENNENNNESNEWSEENSNNEWEENNSEEESSNEENWEESWEEWSEWWEWWWESESSSESEWEEWEESNNSNWWSNNENSSESWEEWNESENSEEEESEENEWENWSEEEEEWWEEESSNSWSEENWSESEWEWEESSNSNNNSWNWEWSWEESWSEWSNNWNNENNNNSESENNWEENSWWENSWNESNNSENWWWNESSSSENENWNENNEEEESWSWWNSEEWNNESENSENSWNWSNWNSSSSSSESSNESEWNESEWWNEWNENNESWSSEEWEEWNSENENESWEENESWWNESNEEWSSEWENEWEESSSENNWNNNESWEWWSESWNSSNENWEWWESSESSNEENNSSSSESNWEENSWSWEWEEWEWWSSESSNEWWEENWSSENWENSSWNSENSEEWNWENWNWENEENWWWEEWNWEWWNNNSSNWENWNENENNWNNWSESSESWNNENENWSSESWEEWEESNSWENEENSSWESEENWWEWNNEEENEESWENESNWNWEEWNWEESWWEEESWENENSSWENNWSWWNSWNSESESSNEENEWEENWENNWWWNSWWEESSWNNNSWNWESEESENEESEENWNNWWESSSSESNESWNSWWNSNEWEWEENSEWSESSENSWNENSESNNSWWSWEEESSNSESNEEEWEEWNSWNEENSENSWENESEESNNNEESWSNNSNWNSSSSEEESWSSSSNSNSESENENSNESSNWNSWNSSENESSSWEWNSWENSEWWSWNNWEEESESENSNNNSWNENNSSSNEWSSWEEWWWEWNSWNNEWWWENENENWSWWWEESEENWSWENESEESWNEWEESEWEWNESEWWNWWSWWNWSEEEWNSNNSENWSWSWSSWWNWWSESSSNEESWENNEENEEWEWNSENWSNSWNNSWSWSESWEWNNSNNNEWWWNWSNNENSNENNNNWNWESWWEEWNNWWNNEEWNSNNNNSNWSSSNEWEWWENNESNWNNNSWNWEWWSSSWSEWWESEEWSNNSESEEWEEWSNWENWWWSNWSESNENNEESENSNWWNWNNWEWSSWSSSNSEESNSNNSEEWNSSWWWEEWWNNESNWENSWNEWNSEWWEWESNWWNENWWEWNEWEESNNEEESNENESWEEWNSSNESSENWSENSWWEEWSSWWEWSNESSENWESSSSWWENSSENWNNWEESWWNNNSEEESSSENSESSNSSSSSWNWENESNWNESWNSNESSENESSSWWNEWNESSENNWNEEEEEWNSWWSWWSSNEWEESSWESENSWEESNWEWNEENSENESNNSEEEWENESENWWNSESENWWSWESNSWSESEWSENEWEWEWSENESSSENSNEEWESSNNESENEWENWEEEESWWNESNESSSNNEWNNENEESEESNENSWESNNWWSENNWNNNWWEESESNNWNWENNEWSSSNSNNENNNWSSWWSNWSNEWNNWSEEWNNWESNNNWENWNSENNWENWENSWNNWNWNENNWSNNWWWWWSESWWEEEEESEENESEENEENWWNWEENESSSWSSSNNWWENSWNWWENSESSSSSSWENSNWSWENEWENNWNWNSWWNNSWSWSWWWNWEEWNNESSSWSEEENEWSNWWEWEWENWWEENESNWWNSEWNEENNSNEWSWESESSWEWWWEWWWNWNESSNNWSENWSNNSENSSESWWWSSESESWWSESSSENSENEWESSWESSNNWNSEWWWWWNWSEWSENNESWNEEWWEENNNEESWSWSESNESWNSNNSWWSENEENENSSWWWWEEEWWNEEEWENNSWEEWNWWNSNSNWSNNEENESSWEENNNEEEENNWSSWENSSNWSSNSNWNENESEWNWWEEENEEWESNESNEES"[api.turn()]) {
    case 'W':
        api.awayX();
        break;
    case 'N':
        api.awayY();
        break;
    case 'E':
        api.towardsX();
        break;
    case 'S':
        api.towardsY();
        break;
}

I do not consent to the inclusion of this bot in the repository.

I fixed some obvious early inefficiency and this beat both Line Drive and Sweeping Endgame, so this bot is viable already.  (It looks like it may have hit upon a more efficient way to build a line drive.)

Hocus Pocus(!?) - 966e8f3ad189b9535c2e1fad3ffc065a
Weird strategy that I'm unable to describe - it's probably(?!) an amalgam of Feint, Two Cities (??!) and whatever else I can't remember. At the moment of posting, (I think it?) beats everything but the Evolvors and Intercept & Destroy. Uses anti-CBC at the beginning, then hocus pocus(!?) strategy.
Edit: Also loses to Backstabber
const turn = api.turn();
if (turn === 0) {
    this.generator = (function*() {
        yield* [[3, 8], [2, 16], [3], [0], [1], [0, 27]];
        while (true) {
            yield* [[3, 36], [2, 36], [1, 36], [0, 36]];
            for (let i = 0; i < 20; ++i) {
                yield* [[2, 2], [1]];
            }
            for (let i = 0; i < 20; ++i) {
                yield* [[2, 2], [3]];
            }
            for (let i = 0; i < 20; ++i) {
                yield* [[0, 2], [1]];
            }
            for (let i = 0; i < 20; ++i) {
                yield* [[0, 2], [3]];
            }
            for (let i = 0; i < 10; ++i) {
                yield* [[1], [3, 2]];
                yield* [[2], [0, 2]];
                yield* [[3], [1, 2]];
                yield* [[0], [2, 2]];
            }
        }
    })();

    this.nextCall = 0;
}
if (turn === this.nextCall) {
    const [dir, delay = 1] = this.generator.next().value;
    [api.awayX, api.awayY, api.towardsX, api.towardsY][dir].bind(api)();
    this.nextCall += delay;
}

I do consent to the inclusion of this bot in the repository.

Nice to see folks being honest about uncertainty :p

Likes having nice staring contests with Doombeam. They don't end well for Doombeam.

This is really quite entertaining to watch. Close call with Doombeam, and it dances when pitted against itself.

Weirdflow - 8f82f8a5fd15fc29e60b9cce4343309c
This was an attempt at a very clean bot that turned into an incredibly sloppy counter to Rushdown.
const turn = api.turn();
if (turn === 0) {
    this.generator = (function*() {
        for (let i = 0; i < 10; ++i) {
            yield* [[0], [2, 2]];
        }

        for (let i = 0; i < 5; ++i) {
            yield* [[1, 2], [0]];
        }

        yield* [[3, 2], [0, 4]];

        while (true) {
            for (let i = 0; i < 5; ++i) {
                yield* [[1], [3, 2]];
            }
            yield* [[2, 3], [3, 3], [0, 6]];
        }
    })();

    this.nextCall = 0;
}
if (turn === this.nextCall) {
    const [dir, delay = 1] = this.generator.next().value;
    [api.awayX, api.awayY, api.towardsX, api.towardsY][dir].bind(api)();
    this.nextCall += delay;
}

I do not consent to the inclusion of this bot in the repository.

I like the look of this. If it could go on the offensive when there’s 3 or 4 rows of cities, it could be a massive offensive. (I was watching it against the Faraday Cage)

As OP said, this has potential, but Faraday's Cage just doesn't take no prisoners, and this smells of a person who farms to a lvl10 Town Hall in Clash of Clans

Quad Rush - a0a4a9f3c8b8863392f109fdfd52af00
Double barrel x2.
EDIT: Changed the cadence so we end up with a [2] runner and two [1] instead of four [1], which makes a difference in some matchups.
if (api.turn() < 29) {
   api.awayY();
} else if (api.turn() < 59) {
   api.awayX();
} else if (api.turn() % 3 == 0) {
   api.towardsY();
} else {
   api.towardsX();
}

You can include this bot in your code if desired.

3 Base rush - 3f6d1a1461564ace3d7e22cedba08c20
A bot building three cities before launching an indirect attack and proceeding to lose.
if (api.turn() < 29) {
   api.awayX();
} else if(api.turn() < 40) {
    api.awayY();
} else if(api.turn() < 42) {
    api.awayX();
} else if(api.turn() == 42) {
    api.awayY();
} else if(api.turn() < 45) {
    api.towardsX();
} else if(api.turn()<48) {
    api.awayY();
} else if (api.turn() % 2 == 1) {
   api.towardsY();
} else {
   api.towardsX();
}

This bot is not to be included in the repository, as it is only a stepping stone to explore 3 cities openings.

I edited the title to match the format asked by OP and also added highlighting for your code using <!-- language-all: lang-javascript -->.

@Night2 I didn't know you could do that. It's pretty.

Nice start; just switching api.turn() % 2 to api.turn() % 3 makes this bot substantially more effective.

@BradC Well, the attack part is not designed yet, but attacking only diagonally does not allow you to protect from attack on your weak side. This was a poor attempt at improving the defence.

Galeforce - 294c357b051e6e165d18657748d02cfe
Sets up 8 cities, then sprays walkers in various directions.  Looks a bit like a Doombeam followed by a Line Drive (and the Galeforce vs. Doombeam matchup comes down to persistence).
const turn = api.turn();
if (turn === 0) {
    this.generator = (function* () {
        yield* [[1, 24], [0], [1], [2], [1, 3]];

        for (let i = 0; i < 9; ++i) {
            yield* [[0], [3], [1]];
        }
        yield [0, 3];

        for (let i = 0; i < 10; ++i) {
            yield* [[2], [0, 2]];
        }

        for (let i = 0; i < 20; ++i) {
            yield* [[3], [2, 2]];
        }

        while (true) {
            for (let i = 0; i < 20; ++i) {
                yield* [[3, 2], [2]];
            }
            for (let i = 0; i < 20; ++i) {
                yield* [[3, 2], [0]];
            }
            for (let i = 0; i < 20; ++i) {
                yield* [[2, 2], [1]];
            }
            for (let i = 0; i < 20; ++i) {
                yield* [[2, 2], [3]];
            }
            for (let i = 0; i < 20; ++i) {
                yield* [[1, 2], [0]];
            }
            for (let i = 0; i < 20; ++i) {
                yield* [[1, 2], [2]];
            }
            for (let i = 0; i < 20; ++i) {
                yield* [[0, 2], [3]];
            }
            for (let i = 0; i < 20; ++i) {
                yield* [[0, 2], [1]];
            }
        }
    })();

    this.nextCall = 0;
}
if (turn === this.nextCall) {
    const [dir, delay = 1] = this.generator.next().value;
    [api.awayX, api.awayY, api.towardsX, api.towardsY][dir].bind(api)();
    this.nextCall += delay;
}

I do consent to the inclusion of this bot in the repository.

Backstabber - 2d632fb11ea1a7b1b73788d396a6a45d
After making Galeforce, I got to wondering if anything could beat a really persistent Doombeam - one that never stopped firing.  None of the existing bots seemed to be able to.
This bot can do it, though, and it beats most of the other bots too!
const turn = api.turn();
if (turn === 0) {
    this.generator = (function*() {
        yield* [[0, 24], [1], [0], [3], [0, 3]];

        for(let i = 0; i < 40; i++) {
            yield* [[1], [2, 2]];
        }

        while (true) {
            for(let i = 0; i < 40; i++) {
                yield* [[3, 2], [2]];
            }
            for(let i = 0; i < 40; i++) {
                yield* [[0, 2], [1]];
            }
            for(let i = 0; i < 40; i++) {
                yield* [[3], [0, 2]];
            }
            for(let i = 0; i < 40; i++) {
                yield* [[0, 2], [3]];
            }
            for(let i = 0; i < 40; i++) {
                yield* [[1], [0, 2]];
            }
        }
    })();

    this.nextCall = 0;
}
if (turn === this.nextCall) {
    const [dir, delay = 1] = this.generator.next().value;
    [api.awayX, api.awayY, api.towardsX, api.towardsY][dir].bind(api)();
    this.nextCall += delay;
}

I do consent to the inclusion of this bot in the repository.

Evolvor: Overnight - 7512fcfcef33bff323d5cdaf1bb833ff
This is utilizing exactly the same evolution code as Evolvor: First Encounter, but with a significant increase to the time provided. As of the time of posting, this only loses to 4 entries - two of them mine (whoops) and all of them rushy. I hope to be able to fix this issue soon.
switch ("NEWWNSNWEWWNNEWWNNNWWWNNNNNNSWWEWNNWNWENWWNWWEWNNNNENNWWNSESSSESESSWWSNSESSSWESWNSWWENNSSESSNSWESWWSWSESWSSWSWSSSNSWEENWEWEEWWSWSSWWSWNEWWEESEESEESEESEEEENEEESEEEEEEEEEEEEENEEEEEEEENEESEEEEENEEEEEEEEEEEEEENEENEEEEEEEEEEEEEEEEENNENEEEEEEEENEEEEEEEEEEEEEENNENNENNENNNNNENEEEEENEEEEEEEEWEEEEEEEEWEENEENEEESEEWEEEESEENWESEESEENEEEEEWEEESNNNENNENNEENENEENENNEENNNNEENNENEEENNNENNEENNENNEENESEEWEEEEEEEEEEEEEENNEENESSEWSENEEWSESEESSESSESSWNNNNENNNNENNNNNENNNNNNENNENNENENNNNNENNNNNNENENNNNNNENENNENNENNNENNENENNNNNENNNNNENNNNNNENENNNWNENNNNNNENNWNENNENNNWNENNENNNNENNNSWEENWNENENNENNNWNWNNENNEWNNNWENWNNNWNEENNWWNWNSSNSNSSEESSWNWESWSSWSESESSESESSSESEESSESNESSESEESESEEESSESEESSESSNSEESEEESSSSWNEESNNNESESSSESEEESEWSSSSSESESSNSNWENESNSESSSSSSSESSSSSWSSNNWSSNESSENSSESEESEWSEENSESWSSSNWESEWENSENNENNWNSSSEWNWWSSSNSESSWSNENSEEENNNNNNENSSNWEWWSSEWSSWNEEWEENSEWNESNESWNSSWWENWSENSWNNNWNNWESESEWWNNNWNWNNEWWSNWNNSWWNWWSENWNSNSWNWSNEWNNNNNNWWWWWSNWNWSSNENWSNNNSNWSNWWNNWWNNWNNSWWNNWWNENNWWSSWWNNNSWENNWWWWWWSWSWSNWNNSSNNNNNSWENWNWWEWNWNNNNWWWNSWWENNNNWNWNSWWWNNSSWNSSNWWNENNNWNWWNNWSESNNNNWWSNNWSWSWEWWNEWWWWWWSNWNNNWWWWNNEWWSEESNSWWWNNENNWWNSNWWNNWEWSWNWEWNWWSENNNWEWWSNWENWSWWWWNNSSENWSWNSNWSWWNNNNESWWNSWNNNWNWWNSWSNNENNSSWWWENSSENWNWWSSWSWWWEWSNEWWNEWWSWWSSSNWSNWEWEEWNNSWESSEESNNWWWWNSNSSNWSSWSNNSNNWSNWNWSWWSWNWEWEEWNNWNEWNSWWWWWSWNEEWWNNNSSNWWNNWWNWSNNWWNEEWESWNNNEWWWWSWWWNNSSWWNNSWSWEWSWWNSNWNESESWWEEWESSSNWEWENWSNNWNSESEEWWWWSWNNNSWNWWNWWWESSWNWNWNWEEWENEWNWSNNSNNWWWSSNNNWNNNSWNNNWSSWEWWENWNSNENEWESWNSWNEWENENSSEWSNNSNNSNNSSWSEWESSEWWSWWNSNNNNEWNWNESEENENNWSENEWNWWSNEENNSNWNNWNNNNWWWENNNEEWWENWWNNENWNNSWNNNEEWSSSSEESWWNESWNWNSWENEESENSENNNWESSNNSNWNSESESNEEENSSWENWEWNSENEENNSNWEEWNWNNEWNENNSSWWNSWSWSENENWENNWNEWWNNWSSSSESWNESSSNSWWNEESNWNNWESWENSWWNWESSWSNEWEENWESWWWSWSEWENNNNEEESSWWWNSWSNSWNSEESSSNEEWNNSSSWSSSWSNWSSSNSWNESWENNWWENNENWSWEWSEWSNWEWWESEWEEESSNEENNSWNWWWSWESSNSSSNNEWENENWNNWSSSWWESNWWSSEWSWEWNWNWSNSNEWEWEENEEWWESSENSSNNNNESNEWSNSSWENNSNNENEWNESNWNWESSWNNSWNNSWEWESSNWEWNWENEWEWESWSNNEWSWSWNEWEWSSWNWSWNSNSWESWNNWWNWNSENWNEWSWNNWNENWNENEEWSNSSSSEWSNNESNSSESESSSWWNWSESSNSSWWWWWSNWNEWESEWNEWESSNENEESNSEEWNSNNEWWWWESESSNEWWSSSNWSSWWNSSSSEWSWWWWSSNWSNWNWEEWSEWESWSENWNSWSSSSSWNWSNEWNWSSSWEWWEWNENESNNSWSSWNWNWNWNWSSSESSSWSWSWSSWSWESWSEESWEENSNNSSNNSSSWWEWSNEWWNNEENNNWSSEWWSESSNWNSEWNWNNNWNESSSSNEEWWENNEESESSNEEWEWEWSWSEWWNEWENWNEWNWENSNNEWSENESSSEESSWENNWESESSSWNNNWWNSNWEWWWEWSWSWESSENWWSENSEWSEWNSWNEENWNWWNSEEWWSWWWWWWNESEESSWEWENNSWWSNWWNSSWWNWNWNWNEWWWSWNNEESWSWWWESSEWNWSWEEWWNSENSWSWNSWWSSEWNEWWWNSNEENEWNNWNWWNSNNSWNWSNWSNNWWEWNWWWNESESNSEWWNENNSEWWWNWWWENWWNSSSEWNWEEEENWSSESEWESWWNSSWEEEEENSNWSWSEWESESSNWNWSENSSSENWWWNWWNENSSENWNWWWEWEENEENEWEWNSENENSSSWNWWSWWSNSESENESENWSSWWEENWWWWWEWSSSWSWESNSEWSSNWSWWWSSEWWEWWWSSSNEWWWWEENNSEEWWESWSSNESEENNSNENSWNNNNEENEWWWEWSEEWWEENWNSSSSWWNNENWNEWSSNENNNENSWSESSWSNENNWSWWWSESESENSNSSENWWSEENWWNSEWSEWNNWSENSNWEWWWNSSESESWSNSSEESWNEEENEEWSNNSWSESENNNWESWSWNNWESEENWWWENWWEWSSWSESWEWENSNEEEESSNWSSWSSNEENNEEEESSWWNWENSWESEWSESNE"[api.turn()]) {
    case 'W':
        api.awayX();
        break;
    case 'N':
        api.awayY();
        break;
    case 'E':
        api.towardsX();
        break;
    case 'S':
        api.towardsY();
        break;
}

I do consent to the inclusion of this bot in the repository.

CBC Forever - 9c65942bf924d9bb09e99d22daf0d8d0
An endless loop of inverse CBC.  After a while it starts cycling walkers around behind it, to clean up any enemy cities that got into its corner.
This is partly intended as a demonstration of how to do a long inverse CBC, but of course it beats a lot of stuff in its own right.
const turn = api.turn();
const opening =
    "SSSEEESSSEEEEEEEEEESSEEE"+
    "SSSEEESSSEEEEEEESSEEEEEE"+
    "SSSEEESSSEEEESSEEEEEEEEE"+
    "SSSEEESSSESSEEEEEEEEEEEE";
const pattern = "NWSSSSEEESSSWNEESSEEEEEEEEEEEE";
if(turn < opening.length) {
    switch (opening[turn]) {
        case 'W':
            api.awayX();
            break;
        case 'N':
            api.awayY();
            break;
        case 'E':
            api.towardsX();
            break;
        case 'S':
            api.towardsY();
            break;
    }
} else {
    switch (pattern[(turn-opening.length)%pattern.length]) {
        case 'W':
            api.awayX();
            break;
        case 'N':
            api.awayY();
            break;
        case 'E':
            api.towardsX();
            break;
        case 'S':
            api.towardsY();
            break;
    }
}

I do consent to the inclusion of this bot in the repository.

Rushdown - 5a989c80bf1bbef32c848f248aa55dcb
Focuses on building up a bit of firepower and then rushes down what it expects to be the enemy base. Made as a counter to the Faraday Cage and similar. As a bonus, it looks like it's shuffling a deck of cards during the first phase.
const turn = api.turn();
if (turn === 0) {
    this.generator = (function*() {
        for (let i = 0; i < 5; ++i) {
            for (let j = 1; j <= 2; ++j) {
                yield* [[2, j], [0, j]];
            }
        }

        while (true) {
            yield* [[3, 34], [1, 1], [2, 16]];
        }
    })();

    this.nextCall = 0;
}
if (turn === this.nextCall) {
    const [dir, delay] = this.generator.next().value;
    [api.awayX, api.awayY, api.towardsX, api.towardsY][dir].bind(api)();
    this.nextCall += delay;
}

I do not consent to the inclusion of this bot in the repository.

CBC Goes With Everything - f904da9534cf91ff2d5d399f59757ebc
Repeats the CBC pattern 5 times, then proceeds to build its own Faraday Cage and perform a stock Galeforce.
6 appears to be the maximum number before it starts losing to variants of itself for being "too persistent"; I picked 5 'cause it's a nice round number close to that.
const turn = api.turn();
const opening = "EEESSSEEESSEEEEEEEEEESSSEEESSSENEEENSNSSSSEEEEEEEEESSSEEESSEEEESE";
if(turn < opening.length*5) {
    switch (opening[turn%opening.length]) {
        case 'W':
            api.awayX();
            break;
        case 'N':
            api.awayY();
            break;
        case 'E':
            api.towardsX();
            break;
        case 'S':
            api.towardsY();
            break;
    }
}
if (turn === opening.length*5) {
    this.generator = (function* () {
        yield* [[0, 30], [1, 30], [2, 30]];

        for (let i = 0; i < 20; ++i) {
            yield* [[3], [2, 2]];
        }

        while (true) {
            for (let i = 0; i < 20; ++i) {
                yield* [[3, 2], [2]];
            }
            for (let i = 0; i < 20; ++i) {
                yield* [[3, 2], [0]];
            }
            for (let i = 0; i < 20; ++i) {
                yield* [[2, 2], [1]];
            }
            for (let i = 0; i < 20; ++i) {
                yield* [[2, 2], [3]];
            }
            for (let i = 0; i < 20; ++i) {
                yield* [[1, 2], [0]];
            }
            for (let i = 0; i < 20; ++i) {
                yield* [[1, 2], [2]];
            }
            for (let i = 0; i < 20; ++i) {
                yield* [[0, 2], [3]];
            }
            for (let i = 0; i < 20; ++i) {
                yield* [[0, 2], [1]];
            }
        }
    })();

    this.nextCall = turn;
}
if (turn === this.nextCall) {
    const [dir, delay = 1] = this.generator.next().value;
    [api.awayX, api.awayY, api.towardsX, api.towardsY][dir].bind(api)();
    this.nextCall += delay;
}

You can include this in the repository if you want to, but it's just two of my other bots grafted together.

Well, it was always going to come down to bots based on other bots. We can probably keep it out of copyright court :p

Feint - cb68f09d808b5de34daf5c45b46f2bea
Briefly dips into a reverse Cage Bar Cutter, then jumps to a corner and tries to get behind the opponent before switching to the main circling strategy.
const turn = api.turn();
if (turn === 0) {
    this.generator = (function* () {
        yield* [[3, 8], [2, 16], [3], [0], [1], [0, 27]];

        let laps = 1;
        while(true) {
            for (let i = 0; i < laps*10; ++i) {
                yield* [[3, 2], [0]];
            }
            laps++;
            for (let i = 0; i < laps*10; ++i) {
                yield* [[2, 2], [3]];
            }
            laps++;
            for (let i = 0; i < laps*10; ++i) {
                yield* [[1, 2], [2]];
            }
            laps++;
            for (let i = 0; i < laps*10; ++i) {
                yield* [[0, 2], [1]];
            }
            laps++;
        }
    })();

    this.nextCall = 0;
}
if (turn === this.nextCall) {
    const [dir, delay = 1] = this.generator.next().value;
    [api.awayX, api.awayY, api.towardsX, api.towardsY][dir].bind(api)();
    this.nextCall += delay;
}

I do consent to the inclusion of this bot in the repository.

Orbit - 1ec7b9413c34cd8cd66d5bf28a9537ef
Just quickly threw this together on a whim but...
The concept was to have the first walker keep ringing round the first city and see what happens. Uninterrupted, it keeps a pile of quite high-value walkers floating around until they build a few cities at once. Then keeps building, gradually creeping towards the enemy.
I expect it will do very badly in the tournament. ¯\_(ツ)_/¯
if(api.turn() == 0) {
  api.towardsX()
} else if (api.turn() == 1) {
  api.towardsY()
} else {
  var dirs = ['awayX', 'awayY', 'towardsX', 'towardsY']
  if (typeof api.dir == 'undefined') {
    api.dir = 0;
  }
  if ((api.turn() + 1) % 2) {
    //next dir
    api[dirs[api.dir]]();
    api.dir += 1;
    api.dir = api.dir % 4;
  }
}

I'd like this in the repo, regardless.

I find it odd that it doesn't mirror itself  when I run it against itself.

Ah, I’ve fallen in to the javascript trap of using ‘this’, ever. If you change ‘this.n’ to ‘api.n’ it will mirror again.

Parry and Slice - 472a33460a33c1785a28190c9406e36e
Defends against CBC with a small stack of walkers, then goes for a 3-city buildup because nothing else is fast enough after spending time on shielding.  It then moves into a Backstabber variant.
Lategame, it throws in an occasional buildup phase to recover from situations where one of the endless rushers almost finished it off.
const turn = api.turn();
if (turn === 0) {
    this.generator = (function*() {
        for(let i = 0; i < 5; i++) {
            yield* [[3], [1, 2]];
        }

        yield* [[0, 30]];

        for(let i = 0; i < 5; i++) {
            yield* [[1], [0, 2]];
        }

        for(let i = 0; i < 12; i++) {
            yield* [[2], [1], [2, 4]];
        }

        while (true) {
            for(let i = 0; i < 40; i++) {
                yield* [[3, 2], [2]];
            }
            for(let i = 0; i < 20; i++) {
                yield* [[1, 2], [2]];
            }
            for(let i = 0; i < 30; i++) {
                yield* [[0, 2], [1]];
            }
            for(let i = 0; i < 30; i++) {
                yield* [[3], [0, 2]];
            }
            for(let i = 0; i < 40; i++) {
                yield* [[0, 2], [3]];
            }
            for(let i = 0; i < 30; i++) {
                yield* [[1], [0, 2]];
            }
            for(let i = 0; i < 10; i++) {
                yield* [[0], [2, 2]];
            }
        }
    })();

    this.nextCall = 0;
}
if (turn === this.nextCall) {
    const [dir, delay = 1] = this.generator.next().value;
    [api.awayX, api.awayY, api.towardsX, api.towardsY][dir].bind(api)();
    this.nextCall += delay;
}

I do consent to the inclusion of this bot in the repository.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/