00:02:31: <bvowk_> ...
04:39:26: -!- Doxin has quit (Remote host closed the connection).
06:33:10: -!- verpeteren has quit (Remote host closed the connection).
10:33:01: -!- yoR has joined #corewars.
10:52:37: <impomatic> Hi yoR :-)
11:40:20: <yoR> Hi
11:42:12: <impomatic> Are you working on anything interesting?
11:55:44: <yoR> Not really, was experimenting with indirect bombing
12:00:17: -!- Payhn has quit (Quit: ZNC - http://znc.in).
12:02:24: -!- Payhn has joined #corewars.
12:24:21: <impomatic> I've only tried indirect bombing in paper and qscan bombers
13:06:16: <yoR> Was messing with scanners, trying blurrish with an extra line, but it doesn't work really... maybe a oneshot that does 10/20 indirect bombing lines before going to the clear?
13:06:55: <yoR> If you hit a vampire and destroy the pit, or a oneshot, destroying the clear etc, it should be more effective
17:18:00: -!- yoR has quit (Ping timeout: 252 seconds).
17:26:24: -!- Doxin has joined #corewars.
17:45:15: -!- gb_master has joined #corewars.
18:24:13: <bvowk_> hrm.
18:56:49: -!- blob_ has joined #corewars.
18:57:01: <impomatic> Hi blob_ :-)
18:57:10: <blob_> hi
18:58:06: <impomatic> Are you new to Core War?
18:58:20: <blob_> Yes
18:58:42: <blob_> few days ago i had an idea for a game
18:59:49: <blob_> let two processes fight in a shared memory space...a little like the tierra agents but more like a game, u know
19:00:11: <blob_> :-D
19:00:31: <blob_> just found out the idea is not that new
19:00:39: <impomatic> I like Tierra :-) Thomas Ray used to be a member of the Core War Society back in the day :-)
19:01:08: <impomatic> The idea goes back to at least 1961 and Darwin http://corewar.co.uk/darwin.htm
19:03:00: <blob_> This is totally cool. Just looked at the instruction set and a few bots.
19:05:56: <blob_> How do the KOTH Tournaments work ? Can i just submit a bot and it will automatically evaluated against the bots on the list ?
19:07:35: <Doxin> yes
19:07:49: <Doxin> blob_: you send an email and get a result a bit later.
19:07:54: <Doxin> it's pretty fun
19:09:40: <blob_> which server would you suggest. some that are mentioned on codewar.info seem to be inactive.
19:11:12: <Doxin> oh boy, I dunno, it has been a while since I last actually did anything with corewars :P
19:11:55: <Doxin> blob_: http://www.koth.org/koth.html is still active.
19:12:31: <Doxin> blob_: you probably want to compete on the redcode-94 hill.
19:13:34: <blob_> I guess. That's the latest IS Spec, right?
19:15:54: <Doxin> right
19:16:16: <Doxin> blob_: feel free to go with any of the other hills, just keep in mind their specific rule sets
19:18:33: <blob_> Will do.
19:19:34: -!- yoR has joined #corewars.
19:22:17: <blob_> Do many people take part in CW ? All the material I read dates a few years back.
19:24:57: <impomatic> Hi yoR :-)
19:24:58: <yoR> Not a lot anymore... the art of CW is dying
19:25:54: <impomatic> But there's steady activity on the hills and a decent turnout at tournament time :-)
19:26:04: <impomatic> Just not as busy as it used to be :-(
19:26:16: <bvowk_> Well, it has been a few decades nwo.
19:27:25: <blob_> Oh man, I just found out about it
19:28:02: <impomatic> I'm working on some new docs
19:29:19: <blob_> The Tournaments are completely non-graphic ? Would be cool if you could watch it, like in the simulators.
19:30:08: <impomatic> Hmmm... so a video of a few battles?
19:30:13: <bvowk_> No graphics, just a table at the end with the results
19:34:06: <blob_> Not necessarily videos, more like implement the mars vm in server-side js and draw on an canvas element
19:34:25: <blob_> watch matches in "real time"
19:35:10: <impomatic> The problem is there are about 20 entries to a tournament and each entries plays every other for maybe 1000 rounds.
19:36:47: <blob_> How long does a match usually take, if you don't slow them down?
19:37:03: <blob_> I'm guessing microseconds
19:38:38: <impomatic> 2 microseconds on my old laptop for 1 round between two warriors.
19:41:34: -!- gb_master has quit (Ping timeout: 260 seconds).
19:44:10: <blob_> I have to do some reading up on this. Will try to come up with a simple bot.
19:44:57: <blob_> What are the state-of-the-art strategies for bots?
19:46:32: <Doxin> blob_: there's not really one best strategy
19:46:48: <Doxin> blob_: in fact a lot of warriors will switch strategy after they lose some number of rounds.
19:47:54: <blob_> I see. just looked a the basic classes so far.
19:49:20: <blob_> I guess bots can get quite elaborate, but size can be a disadvantage on the other hand.
19:51:03: <Doxin> yep
19:51:08: <Doxin> bigger means you're found easier
19:52:16: <impomatic> Bigger bots need to be faster and more aggressive that smaller bots to be competitive
19:53:06: <blob_> bots take turns after 1 instruction, right?
19:55:27: <impomatic> Yes. After the first warrior executes an instruction, the second warrior executes one. Then it's the first warriors turn again.
20:00:50: <blob_> Is this the up to date spec ? http://corewars.org/docs/94spec.html
20:01:00: <Doxin> blob_: there's threading too if you want to get fancy
20:03:04: <impomatic> blob_: the latest version of the spec is 3.3 but unfortunately not available as HTML http://corewar.co.uk/standards/icws94.txt
20:04:06: <Doxin> blob_: I assume you've found http://vyznev.net/corewar/guide.html ?
20:07:31: <blob_> Doxin: Yes found it. But i am looking for a formal specification of the vm as well. So both docs complement each other well
20:07:41: <Doxin> alright
20:07:45: <Doxin> just making sure
20:08:42: <Doxin> impomatic: so why the line numbers in the spec?
20:12:45: <yoR> Was probably easier to refer to when discussing things/writing the spec (?)
20:13:54: <Doxin> I suppose
20:18:24: <blob_> Do you know this guy? https://github.com/termie/corewarjs
20:19:08: <blob_> \cite The eventual goal of this project is to provide a website arena to host battles.\cite
20:20:05: <blob_> but last updated 5 years ago
20:20:35: <Doxin> writing a MARS is susprisingly hard.
20:21:17: <Doxin> getting everything parsed is hard enough, but then you realize there's effectively thousands of different opcodes :P
20:33:36: <blob_> Well, in general i'd say mars asm should be easier to parse than high level languages, but i have to admit i've never written an asm parser before
20:33:58: <blob_> so basically i have no idea what i'm talking about
20:37:02: <Doxin> blob_: actually a higher level language is easier to interpret imo
20:38:24: <Doxin> 18 opcodes, 8 addressing modifiers, 7 opcode modifiers. 8064 different possible opcodes.
20:40:37: <blob_> Doxin: You are probably right.
20:40:55: <Doxin> I mean it can mostly be handled by generic code, I just haven't figured out how yet :P
20:41:50: <blob_> have you looked at the reference implementation in the doc?
20:42:58: <Doxin> nah, not yet. I will soonish.
20:44:27: <blob_> <1000 loc c. I'm reformating it right now (stripping leading line numbers etc.)
20:44:57: <blob_> Could send you the c file if you are interested
20:45:12: <Doxin> nah that's fine.
20:45:21: <Doxin> I'm not in the mood to continue on that project right now
20:47:03: <blob_> Okay
21:06:15: <yoR> Addressing is just that, once resolved you can apply the operation, the modifier does make things a little different though
21:23:46: <Doxin> eh, adressing is deceptively tricky :P
21:44:54: <yoR> Yes, but can be processed separately from the operation, addressing is the same for each op, the tricky part is the op-modifiers which change the workings of the operation, A to B, B to A, A to A, B to B, F and X (both fields!?), I in some cases...
22:24:22: -!- Doxin has quit (Read error: No route to host).
22:32:26: -!- Doxin has joined #corewars.
22:41:54: -!- john_metcalf has joined #corewars.
23:15:25: <blob_> yoR: Exactly. In the reference implementation this is handeled in a 900loc function with 3 nested levels of control flow. Pretty repetative, but changing ever so slightly, that it is hard to factor sth out.
23:15:52: <blob_> Not particularly easy on the eyes.
23:20:33: <Doxin> I figured a neat-ish solution would be to implement some sort of microcode
23:26:07: <blob_> my knowledge of micro code is pretty vague. As I understand it, micro-ops are combined to build larger ops, right?
23:27:38: <blob_> In an all-software solution would this mean sth like factor sequences of ops into functions ?
23:49:49: <Doxin> right
23:49:52: <Doxin> essentially
23:59:54: -!- Doxin has quit (Remote host closed the connection).