Complete TCPR documentation

Nice to see it getting some attention. I've considered on-and-off a more streamlined "external mod process" system based on stdin/stdout (KAG would start the mod process) but I'm waiting to see any serious adoption through TCPR before I bother. TCPR is hands-down the most powerful modding "level" in KAG as you can do whatever you want, do it asynchronously and leverage external libraries in whatever language you like. Writing the TCPR bridge code into KAG can be a chore but it's not too bad tbh.

The worst part is quite poor tools for parsing AS-side.


Fwiw I've kept most of my TCPR stuff in fairly high level languages, node in particular as there's a lot of libraries available to leverage very easily for things like databases, dealing with different file types, etc.

If you wanted to run on a really low spec server writing something in C++ might make sense but most of the time you wont be doing particularly heavy stuff over TCPR because you can only send so much anyway.

Some corrections (don't have time to write up a PR today):

• Exceeding the line length will cause a line to get truncated (at the limit) and the rest of the line will be interpreted as the next "line", both of which may lead to unintended effects. It's recommended to put any extensive logic on the server as a rules script and feed it a few arguments instead of sending huge swathes of script inline each time - it's much faster as not so much code needs to be loaded/compiled each time, and wastes less bandwidth as a bonus. The line length can potentially be lifted to something much higher (lines could be accumulated past the buffer length) but I don't really want to encourage sending a heap of data at once or leave the game open to crashes from sending 4gb of whitespace, no newline. If it's a blocker for someone I'm happy to negotiate though.
  
• TCP in general does not have "packets" (at least at the application level) - sockets are stream-based and separate messages might be combined (more on this later).
  
• Both \r\n and \n newlines are supported - whatever one you use to auth is the one that will be used for the rest of the session, and this can be different between separate concurrently-connected TCPR clients.
• Your example should probably accumulate received data, split on newline and only parse/handle complete lines. You've mentioned this in the paragraph above but don't practice it. It doesn't matter in your example because you're just echoing everything that you receive, but I'd expect new interested programmers reading the docs to often copy example code verbatim, so we'll have fewer confused newbies if your example handles multiple lines properly.

Shit, that's not intended at all, haha! This wasn't reported earlier :D

 

Nope there's no 16kb limit from the engine, only to the engine.

Don't think so. I think the OS you're running it on might affect that actually? Would have to test.

Code:

# read the stream
partial += sock.recv(16*1024).decode()
# if there's a newline present
if(partial.find("\n") != -1):
    # split into lines
    lines = partial.splitlines()
    # save (and remove) the remainder
    partial = lines.pop()
    # handle all lines
    for line in lines:
        # might want to trim any \r characters here maybe
        # not sure if they're sent on windows :)
        handle(line)

Like, it's not lovely but it's nothing terrible; I'm sure you worked out something similar for your example :)