←2009-05-26 2009-05-27 2009-05-28→ ↑2009 ↑all
00:03:33 <ehird> if you tall likk thii, all worr can be redd to fouu lett.
00:05:20 <AnMaster> um... shouldn't that be "cann", "beee" and "tooo"?
00:05:50 <AnMaster> oh and alll, ifff (stands for: if and only iff)
00:06:08 <AnMaster> night
00:06:44 -!- oerjan has joined.
00:07:19 <ehird> AnMaster: only words >=4 letters
00:08:06 <AnMaster> ah
00:08:08 <AnMaster> still, I like ifff
00:08:12 <ehird> iffffffffffffffffffff
00:09:02 <AnMaster> indeed! :D
00:12:09 -!- KingOfKarlsruhe has quit (Remote closed the connection).
00:13:02 <pikhq> I like using punctuation at random."“»›‹¡¿‽’—–
00:13:19 <ehird> ‽‽‽‽‽“º-ß•ªˆ´•¶þ̂‡†›‹̂†‡°̂*(~↙‽↘⁴⁵⁴⁵
00:13:35 <pikhq> Touché.
00:13:45 <pikhq> (douché)
00:14:29 <ehird> New favourite word: Douché
00:14:42 <ehird> French
00:14:42 <ehird> [edit]Verb
00:14:43 <ehird> douché
00:14:45 <ehird> Past participle of doucher.
00:14:47 <ehird> "To shower"
00:14:54 <ehird> pikhq: you've showered?
00:14:57 <ehird> *you
00:15:07 <pikhq> LMAO
00:19:06 * oerjan tends to smirk whenever he sees the company name Deloitte Touche
00:19:18 <oerjan> the reason, now, should be obvious.
00:20:09 <pikhq> LMAO
00:21:03 * oerjan didn't know about the tohmatsu at the end. it doesn't really help.
00:23:30 <pikhq> Touché, douch险®.
00:25:01 * oerjan notes that he is not alone
00:25:32 <pikhq> Indeed. Ørjan.
00:25:54 * oerjan gives pikhq a spelling bee medal
00:26:25 <pikhq> SPËLLÏNG BËË!
00:26:54 * pikhq has been abusing the Compose key
00:28:52 <oerjan> Höw rúdê
00:31:06 <ehird> Ï’ḿ ābüßïñg tḧẽ őþtıøñ ké¥
00:55:29 -!- Patashu has joined.
01:06:20 -!- nescience has joined.
01:07:20 -!- inurinternet has quit (No route to host).
01:14:50 <nescience> in this bfjoust thing, values are 8 bits right? (256 = 0)
01:15:03 <ehird> yes
01:15:11 <ehird> nescience: http://codu.org/eso/bfjoust/report.txt
01:15:16 <ehird> and !bfjoust name program
01:15:21 <ehird> omit your name, it adds it automatically
01:15:35 <ehird> nescience: program sources at http://codu.org/eso/bfjoust/in_egobot/
01:15:41 <nescience> i submitted it already
01:15:43 <nescience> :>
01:15:43 <ehird> ah
01:15:45 <ehird> i didn't notice :)
01:15:50 <nescience> but i apparently miscalculated
01:15:57 <nescience> i need more details on how [] works
01:16:03 <ehird> ehm
01:16:09 <ehird> [a] is while (*ptr) a
01:16:16 <ehird> as in, while the current cell is not 0, run a
01:16:20 <nescience> my understanding was that when it reaches ] it checks if 0
01:16:23 <ehird> nescience: a loop takes two iterations, iirc
01:16:29 <ehird> so [a][a][a]
01:16:38 <nescience> so if it was 0 when it executes [, it will still execute the code inside the brackets, yes?
01:16:39 <ehird> that is, ] jumps back to [ if the cell isn't 0, I believe
01:16:42 <ehird> nescience: no
01:16:45 <nescience> whoops
01:16:48 <nescience> :P
01:16:50 <ehird> both [ and ] could be said to check
01:17:02 <nescience> annoying, ok trying again
01:17:03 <ehird> nescience: let's say your a runs 3 times before setting it to 0
01:17:05 <ehird> the cycles used are:
01:17:13 <ehird> [a][a][a]b
01:17:15 <ehird> where b is the program after
01:17:17 <ehird> I believe.
01:17:24 <ehird> that's only relevant if you're counting cyclse
01:17:25 <ehird> *cycles
01:17:38 <nescience> if [ checks, that explains what happened
01:17:42 <nescience> fixing now :>
01:17:52 <nescience> so wait
01:17:55 <nescience> if your poiner is on a 0
01:18:06 <nescience> and your code is [+], for example
01:18:10 -!- Corun has changed nick to Corun|away.
01:18:12 <nescience> nothing gets incremented, and it takes one cycle?
01:18:18 <oerjan> ehird: not two iterations, the ] jumps to _after_ the [
01:18:27 <ehird> oerjan: oh, right
01:18:32 <ehird> nescience: it'd use [a]a]a]b
01:18:38 * nescience nods
01:18:38 <ehird> nescience: and correct
01:18:48 <nescience> ok
01:18:55 <nescience> i can remove one wait instruction at least then :)
01:19:04 <ehird> if your code is [-] and your pointer is 3, [-]-]-] is executed
01:19:21 <nescience> i'm just wanting to know about the case where pointer is 0 atm
01:19:34 <ehird> nescience: then [ is executed
01:19:44 <nescience> but not +]
01:20:06 <nescience> and the 0-check, for the purposes of both programs executing at once, happens before instructions are executed
01:20:28 <ehird> nescience: here's some exact semantics for you
01:20:37 <ehird> note that these all happen on the tick - nothing happens before or after a tick
01:20:48 <ehird> [ if the current cell is 0, jump to the instruction after the matching ]. otherwise, nop.
01:20:56 <ehird> ] if the current cell is 0, nop. otherwise, jump to the instruction after the matching [.
01:21:03 <nescience> thanks
01:21:12 <ehird> welcome
01:21:47 <nescience> knowing my luck the 'fixed' version will probably score worse, but we'll see
01:21:49 -!- Corun|away has changed nick to Corun.
01:22:01 <nescience> nope, did better :>
01:22:19 <nescience> and beats defend6, like it was supposed to
01:22:19 <ehird> nescience: btw, you should try it in channel
01:22:23 <nescience> that chart is hard to read
01:22:23 <ehird> as it reports the score immediately
01:22:28 <nescience> ah
01:22:40 <nescience> it only runs one matchup?
01:22:41 <ehird> and it saves us going to the file list :-)
01:22:45 <ehird> nescience: right, then updates the report
01:23:06 <nescience> since the board is random, that seems like a bad idea
01:23:15 <ehird> nescience: 'the board is random'?
01:23:15 <nescience> err, the "tape"
01:23:17 <ehird> ah
01:23:19 <ehird> not really
01:23:23 <ehird> it doesn't change the scores much.
01:23:26 <ehird> no, wait
01:23:27 <nescience> the length of the playing field
01:23:28 <ehird> nescience: it runs many matchups
01:23:32 <ehird> but only (yourprog,*)
01:23:36 <ehird> the actual report has to run (*,*)
01:23:39 <ehird> although it -does- cache
01:23:40 <nescience> mk
01:23:51 <nescience> thought that would be how it works, but i don't get the +/- then
01:23:58 <oerjan> ehird: it didn't cache before today, at least
01:24:02 <nescience> i guess it just tells you overall if you won >50% or something?
01:24:03 <oerjan> reruns all matches
01:24:08 <ehird> nescience: + is "won against this program"
01:24:11 <ehird> - is "lost against this program"
01:24:18 <ehird> 0 is "draw"
01:24:21 <ehird> space is "this IS that prorgam!"
01:24:24 <ehird> oerjan: it doesn ow
01:24:34 <ehird> nescience: a random tape length is picked for each matchup
01:24:54 <nescience> yes, the "won" or "lost" was apparent, but made it seem like each pair only battled once
01:24:59 <ehird> nescience: they do
01:25:00 <nescience> which, for a random length field seems like a bad idea
01:25:04 <nescience> ah.
01:25:05 <ehird> why?
01:25:09 <ehird> it doesn't matter in 90% of cases
01:25:14 <ehird> nescience: it's just to stop this degenerate strategy:
01:25:18 <nescience> because either 1) random length doesn't matter, in which case it shouldn't be random
01:25:19 <ehird> (>)*tapelength[-]
01:25:29 <ehird> nescience: which is provably perfect for a given constant tapelength N
01:25:31 <nescience> or 2) it matters, which means it affects the outcome and you can get "lucky"
01:25:42 <nescience> yeah, i follow
01:25:52 <ehird> nescience: you can get lucky ONCE by guessing the tape length correctly in advance. However, that length will be different for every other matchup.
01:26:02 <nescience> i don't mean get lucky that way
01:26:04 <ehird> And the probability is incredibly high that it will fail hard on the others.
01:26:10 <nescience> i mean, some strategies are likely to be faster or slower than others
01:26:20 <nescience> and thus the tape length might cause a given matchup to win or lose
01:26:22 <ehird> nescience: Yes, but the statistical difference is incredibly minimal.
01:26:37 <nescience> it doesn't seem fair to give only one chance if the random selection is what determines the outcome
01:26:39 * nescience shrugs
01:26:40 <ehird> +/- 10 points in one uncommon case in my tests.
01:26:44 <ehird> er, score
01:26:57 <ehird> which is just 10% error, really quite irrelevant
01:27:02 <ehird> nescience: remember that whenever someone adds a new warrior,
01:27:04 <nescience> well since there's <10 points difference between the top entries.. :P
01:27:06 <ehird> it will battle against every one
01:27:08 <ehird> with a new tape length
01:27:23 <ehird> nescience: remember, that was an odd cas
01:27:23 <ehird> e
01:27:29 <ehird> I imagine +/- 3-5 points is the most common case
01:27:32 <ehird> it's Good Enough
01:27:33 <nescience> yes, i'm doing a lot of remembering :)
01:27:37 <oerjan> if caching is working, then it would be feasible to battle _all_ possible tape lengths
01:27:42 <nescience> and if #1 is -5 and #2 is +5?
01:27:50 <oerjan> and take the average
01:27:54 <nescience> oerjan: that would be pretty nice
01:28:11 <ehird> oerjan: that would be over 10x slower
01:28:17 <nescience> i didn't really consider that the randomness is so narrow that an exhaustive test is feasible
01:28:18 <ehird> as there is over 10 variations in tape length
01:28:21 <ehird> it's slow enough as is
01:28:24 <ehird> ANYWAY
01:28:27 <ehird> This really doesn't matter.
01:28:29 <nescience> seemed pretty fast to me :P
01:28:38 <nescience> do like corewars stuff and queue up the entries, who cares about instant results!
01:28:44 <nescience> hehe
01:28:52 <oerjan> ehird: 10..30 isn't it? so only 20 times, which is half made up for by the hill now caching the rest
01:28:57 <ehird> nescience: it took ~25-35 seconds to generate the report previously
01:28:59 <ehird> which is lame
01:29:09 <ehird> (w/o caching)
01:29:20 <oerjan> ok i guess that's not so nice
01:29:47 <nescience> 25-35 seconds to run 10 battles
01:29:55 <nescience> so it'd take a minute to run 20, w
01:29:59 <nescience> not that bad :P
01:30:01 <ehird> !bfjoust et_tu_brute (>)*9((-)*128.>)*20
01:30:06 <EgoBot> Score for ehird_et_tu_brute: 12.0
01:30:13 <ehird> hm that did really terribly
01:30:16 <ehird> -7 points
01:30:19 <ehird> I wonder why?
01:30:36 <ehird> It goes the minimum length, then bruteforcedly decrements 128, sleeps a cycle, then steps onward.
01:30:51 <ehird> !bfjoust et_tu_brute (>)*9((-)*128.>)*21
01:30:53 <EgoBot> Score for ehird_et_tu_brute: 12.0
01:30:55 <oerjan> ehird: because you don't stop when it gets to 0?
01:31:02 <nescience> run off the end
01:31:07 <ehird> no no no
01:31:09 <nescience> maybe
01:31:23 <ehird> nescience: it decrements 128 (the default tape value, and nobody seems to tamper with it), then sleeps one cycle
01:31:27 <nescience> yeah, i can see it
01:31:34 <ehird> so if it hits the opponents' flag, it wins immediately
01:31:37 <ehird> as long as it's 128
01:31:46 <nescience> seems like some sort of bug
01:31:55 <ehird> oerjan: stop when it gets to 0? I don't follow
01:32:00 <ehird> it sleeps one cycle after decimating
01:32:01 <nescience> well, defend6 will beat it
01:32:07 <ehird> so it wins, if it's got the opponent's flag
01:32:15 <ehird> and it's 128 beforehand
01:32:15 <nescience> i haven't read all the rest but most of them don't "turn back" and do anything
01:32:16 <oerjan> ehird: it will be horrible for all spots that _aren't_ 128
01:32:25 <nescience> yeah, i guess it just takes too long
01:32:29 <ehird> oerjan: ah, probably
01:32:29 <nescience> since it doesn't skip over the 0s fast
01:32:40 * ehird looks up the "if not 0" thing on the wiki
01:32:51 <nescience> oh? i'm interested
01:32:58 <nescience> i was just pondering that earlier
01:33:07 <oerjan> hm...
01:33:14 <ehird> nescience: http://esolangs.org/wiki/Brainfuck_algorithms#if_.28x_.3D.3D_0.29_.7B_code_.7D
01:33:16 <ehird> you need two temporaries
01:33:18 <ehird> which is a pain
01:34:04 <ehird> ooh
01:34:25 <ehird> nescience: http://esolangs.org/wiki/Brainfuck_algorithms#x_.3D_not_x_.28boolean.2C_logical.29
01:34:28 <ehird> perhaps
01:34:48 <ehird> argh
01:34:50 <ehird> it's inefficient
01:35:05 <nescience> i kinda like my solution, it exploits defend6 and makes it kill itself :>
01:35:33 <nescience> i score less than impomatic's though
01:35:40 <nescience> and i have 2 losses and a tie, while his has 3 losses
01:35:42 <nescience> i r confus?
01:36:28 <oerjan> !bfjoust mi_fili (>)*9(+[--[(-)*127]]>)*21
01:36:42 <ehird> !bfjoust et_tu_brute (>)*9(>[-]>[-]<<[>+>+<<-]>[<+>-]+>[<->[-]]<[<(-)*128.>-])*19
01:36:44 <EgoBot> Score for ehird_et_tu_brute: 12.0
01:36:49 <ehird> haha bollocks.
01:36:50 <EgoBot> Score for oerjan_mi_fili: 14.9
01:36:54 <oerjan> oh wait
01:36:57 <ehird> I BEAT OERJAN YAY
01:36:58 <nescience> what is this stuff on the wiki
01:37:05 <oerjan> i'm not checking it it's _already_ 0
01:37:05 <ehird> nescience: whatya mean
01:37:05 <nescience> temp0[-]
01:37:13 <ehird> In the interest of generality, the algorithms will use variable names in place of the < and > instructions. Temporary cells are denoted "temp". When using an algorithm in a program, replace the variable names with the correct number of < or > instructions to position the pointer at the desired memory cell.
01:37:14 <ehird> Example:
01:37:16 <ehird> If "a" is designated to be cell 1, "b" is cell 4, and the pointer is currently at cell 0, then:
01:37:18 <ehird> nescience: that
01:37:24 <ehird> so, if you say x=cell 0, temp0=cell 1, temp1=cell 2
01:37:31 <ehird> x temp0 x temp1
01:37:32 <ehird> would be
01:37:34 <nescience> ah
01:37:36 <ehird> (starting on cell 1)
01:37:42 <ehird> <><>>
01:37:44 <oerjan> !bfjoust mi_fili2 (>)*9([+[--[(-)*127]]]>)*21
01:37:47 <ehird> (>)*9(>[-]>[-]<<[>+>+<<-]>[<+>-]+>[<->[-]]<[<(-)*128.>-])*19
01:37:48 <ehird> should be
01:37:48 <nescience> i follow
01:37:49 <EgoBot> Score for oerjan_mi_fili2: 41.0
01:37:54 <oerjan> huh
01:37:59 <oerjan> O_O
01:38:06 <nescience> woot 2nd place
01:38:08 <nescience> ZR
01:38:10 <nescience> :P
01:38:21 * nescience studies the competition
01:38:24 <ehird> "Go right 9 times. cell = (cell == 0) (using temps cell+1, cell+2). If it is not zero, decrement 128.
01:38:25 <ehird> hm wait
01:38:27 <ehird> I may have it the other way around
01:38:28 <ehird> whatever
01:38:44 <ehird> http://codu.org/eso/bfjoust/in_egobot/impomatic_kicks_ehird.bfjoust
01:38:48 <ehird> nescience: oerjan: try and beat t hat one
01:38:51 <ehird> it's really good for some reason
01:39:13 <ehird> it was just designed to beat http://codu.org/eso/bfjoust/in_egobot/ehird_flux_a_counteracting_monomorphism_cocktails.bfjoust, which is my copy of impomatic_flux.bfjoust swapping + and -
01:39:24 <nescience> !bfjoust creep (>-+[-].++>-+[-].--)*15
01:39:25 <EgoBot> Score for nescience_creep: 64.0
01:39:44 <nescience> wait what just happened
01:39:51 <nescience> 824.69-5nescience_creep.bfjoust
01:39:57 <ehird> ha
01:39:59 <nescience> also i think i musta had a bug
01:40:02 <ehird> nescience: tape length dependent?
01:40:05 <nescience> no
01:40:13 <nescience> that as the 2nd plac entry, just changed to decs instead of incs
01:40:20 <nescience> 'cause impomatic's leaves cells with 1
01:40:28 <nescience> lemme think for a sec
01:40:52 <nescience> i dunno, putting it back :P
01:40:58 <nescience> !bfjoust creep (>-+[+].++>-+[+].--)*15
01:41:00 <EgoBot> Score for nescience_creep: 24.7
01:41:04 <ehird> !bfjoust flux_a_revolutionary_perspective_and_et_tu_brute (>)*8(>[(+)*128.])*21
01:41:06 <nescience> the bot says the old score
01:41:07 <EgoBot> Score for ehird_flux_a_revolutionary_perspective_and_et_tu_brute: 24.0
01:41:07 <nescience> not the new one
01:41:17 <nescience> now i was at 4th plac
01:41:18 <ehird> nescience: it takes a little to generate the report.
01:41:20 <nescience> on the same hill
01:41:20 <ehird> refresh
01:41:28 <nescience> talk about random lengths not affecting it eh? :)
01:41:38 <ehird> !bfjoust flux_a_revolutionary_perspective_and_et_tu_brute (>)*8(>[(+)*255.])*21
01:41:40 <EgoBot> Score for ehird_flux_a_revolutionary_perspective_and_et_tu_brute: 24.0
01:41:55 <nescience> i wonder, maybe something's just wrong
01:42:03 <ehird> !bfjoust flux_a_revolutionary_perspective_and_et_tu_brute (>)*8([(+)*128.]>)*21
01:42:05 <EgoBot> Score for ehird_flux_a_revolutionary_perspective_and_et_tu_brute: 24.0
01:42:10 <ehird> !bfjoust flux_a_revolutionary_perspective_and_et_tu_brute (>)*8([(+)*128..]>)*21
01:42:12 <EgoBot> Score for ehird_flux_a_revolutionary_perspective_and_et_tu_brute: 24.0
01:42:18 <nescience> i assumed that submitting it would give the same result against the same hill where it was already sitting there
01:42:21 <nescience> true/not true?
01:42:28 <ehird> nescience: wut
01:42:29 <ehird> ?
01:42:56 <nescience> i'm referring to toggling between 2nd and 4th(5th? didn't get a very good look) place with the same code
01:43:04 <ehird> !bfjoust hangup >(+)*20001
01:43:12 <ehird> nescience: odd. oh well
01:43:18 <EgoBot> Score for ehird_hangup: 6.0
01:43:20 <ehird> mwahaha, hangup is the slow
01:43:24 <ehird> wow that's bad
01:43:28 <nescience> lol
01:43:36 <ehird> nescience: submit a warrior - any warrior - just to get rid of hangup :D
01:43:57 <nescience> !bfjoust hangup2 >(-)*20001
01:44:00 * nescience grins
01:44:06 <ehird> ha
01:44:12 <EgoBot> Score for nescience_hangup2: 6.0
01:44:16 <ehird> and it replaces me!
01:44:17 <ehird> !bfjoust chopsueyside (-)*128
01:44:21 <EgoBot> Score for ehird_chopsueyside: 6.0
01:44:24 <ehird> baha
01:44:26 <ehird> *bahaha
01:44:31 <ehird> i bet 6.0 is the worst possible score
01:44:39 <ehird> GregorR-L: why does it add .0 and .00 if it's always whole?
01:45:43 <nescience> !bfjoust creep (>--[+]+>--[+]-)*15
01:45:44 <EgoBot> Score for nescience_creep: 60.0
01:45:51 <nescience> didn't do much for it did it :P
01:46:09 <ehird> !bfjoust risktaker (>)*20[>[-].+]
01:46:09 <nescience> oh crap, i wanted to do slightly different
01:46:13 <nescience> but i guess we're bein all spammy in here so
01:46:13 <EgoBot> Score for ehird_risktaker: 6.0
01:46:30 <ehird> hahaha
01:46:34 <ehird> nescience: what the hell is up with my progs :)
01:46:41 <nescience> also i broke the exploitation of defend6 again
01:47:32 <ehird> !bfjoust defend6_a_parody_or_just_plain_ripoff_question_mark http://pastie.org/490821.txt?key=w47xqyyhmkklmhegqzsog
01:47:37 <nescience> !bfjoust creep (>-+[-]+>-+[+]-)*15
01:47:39 <EgoBot> Score for nescience_creep: 52.0
01:47:47 <EgoBot> Score for ehird_defend6_a_parody_or_just_plain_ripoff_question_mark: 76.0
01:47:55 <ehird> IDScorePtsProgram
01:47:55 <ehird> 276.006ehird_defend6_a_parody_or_just_plain_ripoff_question_mark.bfjoust
01:47:55 <nescience> wtfwtf
01:47:56 <ehird> 772.004impomatic_kicks_ehird.bfjoust
01:47:58 <ehird> 862.004impomatic_shortsword.bfjoust
01:48:00 <ehird> 158.001ais523_defend6.bfjoust
01:48:02 <ehird> nescience: i just swapped + to -
01:48:04 <ehird> in defend6
01:48:06 <ehird> :-D
01:48:07 <nescience> i guess i should just stick to not changing anything
01:48:08 <ehird> AND NOW I AM KING OF THE HILL!!!!
01:48:11 <nescience> har
01:48:20 <nescience> i didn't know it took a url
01:48:20 <ehird> nescience: try and beat both defend6 and defend6_a_parody_or_just_plain_ripoff_question_mark
01:48:21 <ehird> >:)
01:48:27 <nescience> luls
01:48:28 <nescience> ok
01:48:28 <ehird> and yeah, that's how ais523 entered defend6
01:48:31 <ehird> since it was too long
01:48:34 <nescience> first let me find my working code
01:48:44 <ehird> 01:45 nescience: !bfjoust creep (>--[+]+>--[+]-)*15
01:48:44 <ehird> 01:45 EgoBot: Score for nescience_creep: 60.0
01:49:02 <ehird> fun fact: flux_a_counteracting_monomorphism_cocktails did quite well
01:49:05 <ehird> when impomatic_flux was in the hill
01:49:07 <ehird> I swapped + and -
01:49:10 <ehird> just like I did with defend6
01:49:13 <ehird> it's a sure-fire strategy!
01:49:30 <nescience> but i'm writing my warrior to be sign ambiguous
01:49:31 <nescience> :>
01:50:59 <nescience> oh, i looked at the code
01:51:00 <nescience> you dick :P
01:51:22 <ehird> sry 'bout that
01:51:25 <nescience> hehe
01:51:28 <ehird> mah internet did broke
01:51:31 <nescience> no worries, i will just submit a different one
01:51:36 <nescience> that does something different!
01:51:40 <ehird> ofc since I'm on a bouncer you all didn't notice
01:51:46 <ehird> thus you, nescience, think I am referring to bf joust!
01:51:57 <ehird> 17:49:31 <nescience> :>
01:51:57 <ehird> 17:50:59 <nescience> oh, i looked at the code
01:51:59 <ehird> 17:51:00 <nescience> you dick :P
01:52:01 <ehird> didn't notice that
01:52:03 <ehird> but er I just said I did that :
01:52:05 <ehird> D
01:52:07 <nescience> aha?
01:52:07 <ehird> :D
01:52:14 <nescience> yeah, but i forgot quite what it entailed
01:52:24 <nescience> my solution can't be as elegant now
01:52:34 <nescience> or i could just submit two eaters
01:52:34 <nescience> :P
01:52:41 <Patashu> how do I look at the current hill's status?
01:52:43 <ehird> !bfjoust im_a_creep_im_a_weirdo_im_a_ripoff_lolradiohead (>--[-]->--[-]+)*15
01:52:46 <ehird> Patashu: http://codu.org/eso/bfjoust/report.txt
01:52:52 <nescience> !bfjoust creep (>-+[+]++>-+[+]--)*15
01:52:53 <EgoBot> Score for nescience_creep: 27.0
01:53:01 <EgoBot> Score for ehird_im_a_creep_im_a_weirdo_im_a_ripoff_lolradiohead: 26.0
01:53:04 <ehird> hahaha
01:53:05 <nescience> !bfjoust inverse_creep (>+-[-]++>+-[-]--)*15
01:53:10 <EgoBot> Score for nescience_inverse_creep: 58.0
01:53:12 <ehird> nescience: that's not inverse
01:53:14 <ehird> the last one should be +
01:53:15 <ehird> like mine
01:53:17 <nescience> no
01:53:37 <nescience> whatever, it doesn't matter about that part
01:53:48 <nescience> you swapped it wrong :)
01:54:11 <nescience> hehe, one beats defend6 and one beats parody
01:54:17 <nescience> i wonder if i can do em both at once though
01:54:31 <nescience> the elegant part is i didn't have to delay every step
01:54:31 <comex> !bfjoust (>>[-])*200
01:54:31 <EgoBot> Use: !bfjoust <program name> <program>
01:54:37 <comex> !bfjoust naive (>>[-])*200
01:54:39 <nescience> since i took advantage of it sitting on a 1
01:54:40 <EgoBot> Score for comex_naive: 15.0
01:54:48 <nescience> i just made mine loop around the "long way", giving it time to suicide
01:55:03 <comex> !bfjoust naive2 (>[-])*200
01:55:07 <nescience> but i can't very well do that in both directions
01:55:07 <EgoBot> Score for comex_naive2: 5.0
01:55:18 <nescience> so i'd have to delay at every step, not just the one before the winning spot (vs that warrior)
01:55:39 <nescience> or time it so that it doesn't matter
01:55:40 <Patashu> !bfjoust naiverush (>)*9([-]>)*21
01:55:42 <nescience> maybe i should do that
01:55:46 <EgoBot> Score for Patashu_naiverush: 9.0
01:55:57 <comex> !bfjoust naive2 (>-[-])*200
01:55:58 <EgoBot> Score for comex_naive2: 5.0
01:56:05 <comex> !bfjoust naive2 (>--[-])*200
01:56:06 <EgoBot> Score for comex_naive2: 5.0
01:56:08 <ehird> !bfjoust mover_is_a_groover_not_naiver_but_a_cleaver (>[-].)*30
01:56:10 <comex> !bfjoust naive2 (>--[-])*0
01:56:12 <EgoBot> Score for comex_naive2: 5.0
01:56:18 <Patashu> !bfjoust rushpolarity (>)*9([-]>[+]>)*11
01:56:25 <comex> oh, I forgot to change the name
01:56:26 <nescience> freaks :P
01:56:29 <EgoBot> Score for Patashu_rushpolarity: 13.9
01:56:29 <EgoBot> Score for ehird_mover_is_a_groover_not_naiver_but_a_cleaver: 13.2
01:56:30 <comex> !bfjoust naive3 (>--[-])*0
01:56:33 <ehird> comex: stop that
01:56:34 <ehird> use the same name
01:56:37 <ehird> otherwise you cluter the hill
01:56:37 <nescience> poor bot
01:56:39 <ehird> *clutter
01:56:44 <ehird> 01:56 EgoBot: Score for ehird_mover_is_a_groover_not_naiver_but_a_cleaver: 13.2
01:56:47 <ehird> sweet i lost awesomely
01:56:51 <ehird> whoa
01:56:52 <ehird> 12 programs
01:56:56 <comex> ehird: then why does an empty script have a score of 5
01:57:05 <ehird> comex: because some other ones are even stupider?
01:57:10 <Patashu> !bfjoust rushpolarity >++++++>------(>)*7([-]>[+]>)*11
01:57:11 <EgoBot> Score for Patashu_rushpolarity: 13.9
01:57:13 <comex> !bfjoust naive2 <
01:57:14 <EgoBot> Score for comex_naive2: 6.2
01:57:18 <comex> WAT
01:57:31 <Patashu> !bfjoust rushpolarity >++++++>------(>)*7(+[-]>-[+]>)*11
01:57:32 <EgoBot> Score for Patashu_rushpolarity: 42.1
01:57:33 <ehird> comex: off end of tape = draw
01:57:34 <ehird> i believe
01:57:36 <Patashu> aha
01:57:37 <Patashu> :)
01:57:37 <comex> !bfjoust naive4 (>-->-[-])*0
01:57:44 <ehird> !bfjoust frenchie (-)*128
01:57:44 <comex> sorry, mistake
01:57:48 <comex> !bfjoust naive2 (>-->-[-])*200
01:57:49 <EgoBot> Score for ehird_frenchie: 5.4
01:57:50 <EgoBot> Score for comex_naive4: 5.4
01:57:50 <EgoBot> Score for comex_naive2: 6.2
01:57:53 <ehird> 5.4
01:57:54 <ehird> beat that fuckers
01:57:57 <comex> !bfjoust naive2 (>-->--[-])*200
01:57:58 <EgoBot> Score for comex_naive2: 6.2
01:58:03 <Patashu> if I submit one with a name and the previous one with that name got a higher score, it stays right?
01:58:08 <comex> !bfjoust naive2 (>(-)*128)*200
01:58:09 <EgoBot> Score for comex_naive2: 6.2
01:58:10 <ehird> Patashu: no
01:58:12 <ehird> !bfjoust frenchie (-)*128
01:58:14 <EgoBot> Score for ehird_frenchie: 5.5
01:58:15 <nescience> !bfjoust beatinit [-]
01:58:20 <ehird> 45.50-10ehird_frenchie.bfjoust
01:58:22 <ehird> that's just beautiful
01:58:22 <Patashu> k
01:58:28 <ehird> beautifully terrible
01:58:29 <EgoBot> Score for nescience_beatinit: 11.0
01:58:34 <Patashu> !bfjoust rushpolarity >++++++>------(>-)*7(+[-]>-[+]>)*11
01:58:34 <nescience> WAT
01:58:35 <ehird> nescience: takes longer to suicide
01:58:36 <EgoBot> Score for Patashu_rushpolarity: 24.0
01:58:39 <comex> !bfjoust defense >[([+]+)*200]
01:58:40 <nescience> oh
01:58:42 <ehird> [-]-]-]-] etc
01:58:43 <nescience> wait
01:58:43 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(+[-]>-[+]>)*11
01:58:45 <ehird> whereas mine does ------------------------
01:58:45 <EgoBot> Score for Patashu_rushpolarity: 46.9
01:58:48 <nescience> !bfjoust beatinit <
01:58:49 <Patashu> nice
01:58:50 <EgoBot> Score for nescience_beatinit: 11.0
01:58:52 <nescience> WAT
01:58:55 <comex> !bfjoust defense >[([+]+)*200]
01:58:57 <ehird> nescience: < = draw
01:58:59 <ehird> unmatched ] = draw
01:58:59 <ehird> etc
01:59:04 <nescience> no
01:59:07 <EgoBot> Score for comex_defense: 5.8
01:59:07 <EgoBot> Score for comex_defense: 5.8
01:59:08 <ehird> win > draw > loss
01:59:08 <nescience> it only draws if they both lose
01:59:12 <Patashu> !bfjoust rushpolarity >++++>----(>)*7(+[-]>-[+]>)*11
01:59:13 <nescience> i got -11
01:59:14 <EgoBot> Score for Patashu_rushpolarity: 24.8
01:59:15 <nescience> :)
01:59:19 <nescience> all losses
01:59:19 <Patashu> !bfjoust rushpolarity >+++++>----(>)*7(+[-]>-[+]>)*11
01:59:20 <comex> how the hell is this calculated
01:59:21 <EgoBot> Score for Patashu_rushpolarity: 25.9
01:59:24 <nescience> fjear
01:59:25 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(+[-]>-[+]>)*11
01:59:26 <EgoBot> Score for Patashu_rushpolarity: 59.3
01:59:29 <Patashu> hmm
01:59:34 <ehird> comex: Wins against bad opponents count less for your score.
01:59:36 <Patashu> those decoys are really important haha
01:59:39 <ehird> Points is just wins - losses.
01:59:45 <Patashu> !bfjoust rushpolarity >+++++>----->+(>)*6(+[-]>-[+]>)*11
01:59:46 <ehird> But score is better.
01:59:47 <EgoBot> Score for Patashu_rushpolarity: 6.2
01:59:52 <Patashu> !bfjoust rushpolarity >+++++>----->+++++(>)*6(+[-]>-[+]>)*11
01:59:54 <EgoBot> Score for Patashu_rushpolarity: 19.8
01:59:56 <ehird> As you have to beat good warriors to get a high score.
02:00:01 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(+[-]>-[+]>)*11
02:00:03 <EgoBot> Score for Patashu_rushpolarity: 13.6
02:00:03 <nescience> nobody told me that
02:00:07 <ehird> nescience: now I did
02:00:11 <Patashu> huh
02:00:13 <nescience> so i guess if i beat both defend6 and its inverse i can get good points
02:00:18 <Patashu> I changed it back to an old setup and it's scoring much lower
02:00:20 <Patashu> haha
02:00:22 <ehird> Patashu: nescience: http://codu.org/eso/fyb/SCORES
02:00:23 <nescience> i could just resubmit until i get lucky
02:00:25 <nescience> >:)
02:00:27 <nescience> !bfjoust creep (>+-[-]++>-+[+]--)*15
02:00:28 <EgoBot> Score for nescience_creep: 30.9
02:00:29 <comex> !bfjoust defense (>-)*50
02:00:30 <nescience> it has one for each of them
02:00:31 <EgoBot> Score for comex_defense: 5.8
02:00:31 <ehird> applies to FYB but bfjoust is the same system
02:00:37 <comex> !bfjoust defense (>->+)*25
02:00:39 <EgoBot> Score for comex_defense: 5.0
02:00:45 <comex> why
02:00:50 <nescience> it has one for each of them
02:00:53 <nescience> wait
02:00:53 <nescience> !bfjoust creep (>+-[-]++>-+[+]--)*15
02:00:55 <comex> !bfjoust defense (>->+)*20
02:00:55 <EgoBot> Score for nescience_creep: 29.0
02:00:56 <EgoBot> Score for comex_defense: 5.0
02:01:00 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(++[-]>--[+]>)*11
02:01:01 <ehird> 02:00 comex: why
02:01:02 <EgoBot> Score for Patashu_rushpolarity: 33.0
02:01:04 <ehird> you go off the edge of the tape
02:01:07 <ehird> and never get a flag
02:01:10 <comex> how big is the tape?
02:01:12 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(+++[-]>---[+]>)*11
02:01:12 <ehird> comex: 10-30
02:01:13 <ehird> randomly
02:01:14 <EgoBot> Score for Patashu_rushpolarity: 42.0
02:01:15 <comex> oh
02:01:17 <comex> so different from agora
02:01:21 <ehird> yes...
02:01:23 <ehird> and . is a nop
02:01:23 <comex> !bfjoust defense (>->+)*5
02:01:25 <EgoBot> Score for comex_defense: 5.5
02:01:27 <comex> !bfjoust defense (>->+)*10
02:01:28 <EgoBot> Score for comex_defense: 5.5
02:01:29 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(++++[-]>----[+]>)*11
02:01:31 <ehird> we should get rid of -
02:01:31 <EgoBot> Score for Patashu_rushpolarity: 43.2
02:01:32 <ehird> and just have +
02:01:35 <ehird> to avoid trivial swaps
02:01:37 <nescience> lol you guys quit fucking up the report
02:01:41 <nescience> i wanna see if i got lucky or not
02:01:49 <nescience> damn, nope
02:01:49 <comex> !bfjoust (+)*127(>[-])*30
02:01:49 <EgoBot> Use: !bfjoust <program name> <program>
02:01:53 <nescience> !bfjoust creep (>+-[-]++>-+[+]--)*15
02:01:55 <EgoBot> Score for nescience_creep: 38.0
02:01:55 <Patashu> wow mine is doing really well o.O
02:01:56 <comex> !bfjoust naive (+)*127(>[-])*30
02:01:57 <EgoBot> Score for comex_naive: 15.0
02:02:02 <ehird> !bfjoust rushpolarity_with_reversed_polarity >----->+++++(>)*7(----[+]>++++[-]>)*11
02:02:03 <comex> !bfjoust naive (-)*127(>[-])*30
02:02:04 <EgoBot> Score for comex_naive: 7.5
02:02:08 <comex> !bfjoust naive (+)*127(>[+])*30
02:02:09 <EgoBot> Score for comex_naive: 7.5
02:02:15 <comex> !bfjoust naive (+)*127(>[--])*30
02:02:17 <EgoBot> Score for comex_naive: 7.5
02:02:18 <ehird> comstop it.
02:02:19 <nescience> ......
02:02:20 <comex> !bfjoust naive (+)*127(>[-])*30
02:02:20 <ehird> comex: stop it.
02:02:21 <EgoBot> Score for comex_naive: 7.5
02:02:22 <ehird> STOP IT
02:02:28 <comex> why did the exact same program get a different score
02:02:30 <EgoBot> Score for ehird_rushpolarity_with_reversed_polarity: 44.6
02:02:36 <ehird> comex: randomized tape lengths
02:02:43 <nescience> because the lengths are random, so sometimes it might win or lose depending on that
02:02:50 <nescience> ha
02:02:51 <comex> !bfjoust naive (>)*29(-)*128
02:02:52 <ehird> yes, but if you do, your program sux
02:02:52 <nescience> i got one that tied them both
02:02:53 <EgoBot> Score for comex_naive: 7.0
02:02:56 <Patashu> hey I have an idea
02:02:58 <nescience> but i don't want that
02:03:01 <nescience> !bfjoust creep (>+-[-]++>-+[+]--)*15
02:03:01 <Patashu> to avoid trivial swaps but keep the functionality of + and - differing
02:03:02 <EgoBot> Score for nescience_creep: 29.0
02:03:03 <nescience> BEAT THEM BOTH
02:03:03 <comex> !bfjoust naive (>)*20[-](>)*9(-)*128
02:03:04 <EgoBot> Score for comex_naive: 7.0
02:03:12 <Patashu> how about at the start of each match it randomly swaps or doesn't swap all your +s and -ses?
02:03:30 <ehird> Patashu: meh
02:03:34 <nescience> no luck
02:03:36 <comex> !bfjoust naive (>)*20--[+](>)*9(-)*128
02:03:36 <nescience> oh well
02:03:37 <EgoBot> Score for comex_naive: 8.0
02:03:46 <Patashu> well it would make a program and the program with opposite +-s functionally equivalent
02:03:51 <nescience> all of a sudden i have a bunch of losses
02:03:51 <comex> !bfjoust naive (>)*20(--[+]>)*200
02:03:53 <EgoBot> Score for comex_naive: 8.0
02:03:55 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(+++++[-]>-----[+]>)*11
02:03:56 <EgoBot> Score for Patashu_rushpolarity: 60.0
02:04:08 <ehird> !bfjoust am_i_lame_enough_to_rip_off_shortsword_yes (>-->++)*2(>)*6([+[-]]>)*20
02:04:13 <Patashu> oh aah I see why this works
02:04:17 <EgoBot> Score for ehird_am_i_lame_enough_to_rip_off_shortsword_yes: 7.0
02:04:19 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(++++++[-]>------[+]>)*11
02:04:20 <comex> !bfjoust naive (+)*127(>------)*20(--[+]>)*200
02:04:20 <ehird> haha
02:04:21 <EgoBot> Score for Patashu_rushpolarity: 57.0
02:04:21 <EgoBot> Score for comex_naive: 13.5
02:04:24 <ehird> IDScorePtsProgram
02:04:25 <ehird> 482.007ehird_defend6_a_parody_or_just_plain_ripoff_question_mark.bfjoust
02:04:29 <ehird> still chillin' at the top w/ my ripoff
02:04:29 <comex> !bfjoust naive (+)*127(>------)*20(--[+]>++[-])*200
02:04:30 <EgoBot> Score for comex_naive: 13.5
02:04:35 <ehird> comex: *200?
02:04:39 <nescience> laffo
02:04:39 <ehird> you're not even thinking about this logically
02:04:40 <ehird> also
02:04:46 <ehird> comex: the flag has to stay 0 for two generations
02:04:47 <ehird> "[-]-"
02:04:48 <ehird> Fail.
02:04:52 <Patashu> beating all but 1, 3, 4...
02:04:53 <ehird> It will never obliterate a flag.
02:04:54 <nescience> not fail
02:04:54 <comex> also a change from agora
02:04:55 <ehird> use . to nop
02:04:58 <comex> I should probably actually read the rules
02:04:59 <nescience> ] will nop
02:05:03 <nescience> according to what you said earlier
02:05:05 <ehird> nescience: oh, true
02:05:08 <ehird> still
02:05:11 <nescience> so the - will take it to 0
02:05:13 <nescience> (1 round)
02:05:17 <nescience> then the ] will nop
02:05:19 <nescience> (2 rounds)
02:05:23 <comex> !bfjoust naive (+)*127(>------)*20(--[+]>++[-])*10.
02:05:24 <EgoBot> Score for comex_naive: 40.1
02:05:29 <nescience> that's why i removed by .'s
02:05:31 <ehird> nescience: true
02:05:32 <comex> wat
02:05:42 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(+++++++[-]>-------[+]>)*11
02:05:44 <nescience> you shoudl make it take longer
02:05:44 <EgoBot> Score for Patashu_rushpolarity: 54.3
02:05:47 <nescience> do the exhaustive battle
02:05:54 <nescience> and don't let people submit more than one while it's running
02:05:58 <nescience> make em sit back and think for a while
02:06:00 <nescience> instead of spamming :P
02:06:01 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(++++++++[-]>--------[+]>)*11
02:06:03 <EgoBot> Score for Patashu_rushpolarity: 59.3
02:06:29 <ehird> !bfjoust (>)*14[>[-].+]
02:06:30 <EgoBot> Use: !bfjoust <program name> <program>
02:06:33 <ehird> !bfjoust an_thing (>)*14[>[-].+]
02:06:40 <EgoBot> Score for ehird_an_thing: 26.0
02:06:53 <Patashu> this is fun
02:07:24 <Patashu> !bfjoust rushpolarity >++++++>------(>)*7(++++++++[-]>--------[+]>)*11
02:07:26 <EgoBot> Score for Patashu_rushpolarity: 59.0
02:07:26 <GregorR-L> ehird: It didn't occur to me that it's always whole, it is because there are 10 programs ...
02:07:40 <ehird> GregorR-L: not true
02:07:44 <ehird> most often we have 11
02:07:45 <ehird> 0-11
02:07:48 <ehird> and sometimes we've had 12
02:07:50 <Patashu> !bfjoust rushpolarity >++++++>------(+>)*7(++++++++[-]>--------[+]>)*11
02:07:52 <EgoBot> Score for Patashu_rushpolarity: 51.9
02:07:55 <ehird> it doesn't seem to trim well if people submit a lot of proposals at once
02:08:00 <ehird> *warriors
02:08:02 <GregorR-L> It shouldn't always be whole then, as in that example :P
02:08:03 <ehird> atm:
02:08:03 <ehird> 638.89-3impomatic_dumb.bfjoust
02:08:04 <ehird> 538.89-3impomatic_chrome.bfjoust
02:08:06 <ehird> 217.28-6ehird_an_thing.bfjoust
02:08:09 <ehird> GregorR-L: Yes, but make it always stay at 10...
02:08:12 <Patashu> !bfjoust rushpolarity >+++++>-----(>)*7(++++++++[-]>--------[+]>)*11
02:08:13 <EgoBot> Score for Patashu_rushpolarity: 42.0
02:08:32 <Patashu> wait
02:08:33 <GregorR-L> ehird: It removes them after evaluating. 12 would be from two added at once, 11 is the "norm"
02:08:34 <Patashu> are you starting on cell 0
02:08:34 <Patashu> or 1?
02:08:50 <Patashu> like, track is 10-30 cells and you're on cell 1 right?
02:08:52 <GregorR-L> (Now that I'm thinking about the actual results of this deletion code :P )
02:08:58 <ehird> Patashu: 10-30 cells total
02:09:01 <Patashu> k
02:09:05 <ehird> but we number them from 0-29
02:09:23 <Patashu> !bfjoust rushpolarity (>)*7>++++++>------(++++++++[-]>--------[+]>)*11
02:09:25 <EgoBot> Score for Patashu_rushpolarity: 58.0
02:09:47 <ehird> !bfjoust rushpolishmenarity (>)*8>++++++>------(++++++++[-]>--------[+]>)*11
02:09:55 <EgoBot> Score for ehird_rushpolishmenarity: 28.0
02:09:58 <nescience> !bfjoust kekeke (>+>-)*4(>[[[-]]])*20
02:10:00 <ehird> !bfjoust rushpolishmenarity (>)*8>++++++>------(++++++++[-]>--------[+]>)*10
02:10:02 <Patashu> !bfjoust rushpolarity >++++++>------(>)*7(++++++++[-]>--------[+]>)*11
02:10:02 <EgoBot> Score for ehird_rushpolishmenarity: 28.0
02:10:03 <EgoBot> Score for Patashu_rushpolarity: 23.0
02:10:06 <Patashu> huh
02:10:07 <ehird> \o/
02:10:08 <Patashu> losing suddenly haha
02:10:11 <ehird> i beat you :P
02:10:22 <EgoBot> Score for nescience_kekeke: 21.0
02:10:47 <ehird> only two scores >50 now
02:10:50 <nescience> !bfjoust kekeke (>+>-)*4(>[[[+]]])*20
02:10:50 <ehird> defend6 and my ripoff
02:10:51 <EgoBot> Score for nescience_kekeke: 21.0
02:10:55 <ehird> with defend6 winning slightly
02:10:56 <ehird> the original
02:11:04 <nescience> lols
02:11:10 <Patashu> !bfjoust rushpolarity >+++++++++>---------(>)*7(+++++++[-]>-------[+]>)*11
02:11:12 <EgoBot> Score for Patashu_rushpolarity: 39.5
02:11:12 <nescience> didn't help it any :)
02:11:19 <Patashu> !bfjoust rushpolarity >+++++++++>---------(>)*7(++++++++[-]>--------[+]>)*11
02:11:21 <EgoBot> Score for Patashu_rushpolarity: 60.5
02:11:24 <Patashu> oo
02:11:32 <nescience> i wonder though why it loses to defend6
02:11:38 <nescience> the extra brackets shoul... ah
02:12:19 <ehird> !bfjoust now_is_the_time_for_all_bad_men_to_come_backwards_in_time_for_their_country [(-)*128+]
02:12:20 <Patashu> actually I should clean the code up
02:12:26 <EgoBot> Score for ehird_now_is_the_time_for_all_bad_men_to_come_backwards_in_time_for_their_country: 29.0
02:12:52 <Patashu> !bfjoust rushpolarity >(+)*9>(-)*9(>)*7((+)*8[-]>(-)*8[+]>)*11
02:12:53 <ehird> hey
02:12:54 <EgoBot> Score for Patashu_rushpolarity: 50.0
02:12:56 <ehird> only inverse creep beats my program
02:13:09 <nescience> that's because it exploits "your" program
02:13:13 <ehird> defend6 draws though
02:13:14 <nescience> !bfjoust kekeke (>+>-)*4(>[-](.)*132)*20
02:13:15 <ehird> nescience: ;P
02:13:16 <ehird> :P
02:13:16 <EgoBot> Score for nescience_kekeke: 19.8
02:13:17 <ehird> I'm going now
02:13:18 <ehird> bye
02:13:30 <nescience> bam, beats defend now
02:13:42 <nescience> AND parody
02:13:45 <nescience> do i get candy?
02:13:49 <Patashu> !bfjoust rushpolarity >(+)*9>(-)*9(>)*7((+)*7[-]>(-)*7[+]>)*11
02:13:51 <EgoBot> Score for Patashu_rushpolarity: 45.7
02:14:06 <Patashu> !bfjoust rushpolarity >(+)*9>(-)*9(>)*7((+)*9[-]>(-)*9[+]>)*11
02:14:08 <EgoBot> Score for Patashu_rushpolarity: 25.9
02:14:26 <Patashu> oo
02:14:30 <Patashu> now it says all but 1,2 beaten
02:14:33 <Patashu> which are the defend6s
02:14:35 <Patashu> how do they work? :o
02:14:43 <nescience> read them
02:15:46 <Patashu> hey if I have symbol*number without brackets
02:15:48 <Patashu> does that compile fine?
02:17:41 <nescience> !bfjoust creep >+>->+>->+>->+(>-++-.[+]++>-++-.[+]--)*15
02:17:42 <EgoBot> Score for nescience_creep: 12.0
02:18:18 <nescience> !bfjoust creep >+>->+>->+>->+(>-++-(.)*132[+]++>-++-(.)*132[-]--)*15
02:18:19 <EgoBot> Score for nescience_creep: 32.5
02:18:32 <nescience> beats both defends still hehe
02:18:34 <nescience> but too slow
02:19:37 -!- psygnisfive has joined.
02:20:32 <Patashu> wow haha
02:20:33 <Patashu> top of the hill
02:22:57 <Patashu> !bfjoust rushpolarity >(+)*9>(-)*9(>)*7((+)*9[-][>](-)*9[+][>])*11
02:22:59 <EgoBot> Score for Patashu_rushpolarity: 75.3
02:23:19 <nescience> lol broke it
02:23:23 <Patashu> huh
02:23:26 <Patashu> it said I got 75.3 score
02:23:31 <Patashu> but when I look at hte report I lost every one
02:23:31 <nescience> that was your last score
02:23:33 <nescience> refresh the table
02:23:39 <Patashu> nope
02:23:41 <Patashu> lol
02:23:53 <nescience> that was your score before submitting
02:23:56 <Patashu> !bfjoust rushpolarity >(+)*9>(-)*9(>)*7((+)*9[-][>](-)*9[+][>])*11
02:23:58 <EgoBot> Score for Patashu_rushpolarity: 0.0
02:23:59 <Patashu> okay
02:24:01 <nescience> see
02:24:02 <Patashu> ah I see
02:24:05 <Patashu> why does it do that
02:24:07 <nescience> it's broken
02:24:10 <Patashu> !bfjoust rushpolarity >(+)*9>(-)*9(>)*7((+)*9[-]>(-)*9[+]>)*11
02:24:12 <EgoBot> Score for Patashu_rushpolarity: 0.0
02:24:29 <Patashu> haha
02:24:31 <Patashu> !bfjoust rushpolarity >(+)*9>(-)*9(>)*7((+)*9[-]>(-)*9[+]>)*11
02:24:33 <EgoBot> Score for Patashu_rushpolarity: 48.1
02:24:36 <Patashu> there we go
02:24:50 <Patashu> wonder why the [>] made it worse...
02:25:00 <Patashu> oh wait
02:25:06 <Patashu> I'd need a reverse [] to do what I was thinking of
02:25:10 <Patashu> lol :)
02:25:12 <nescience> yep
02:25:31 <Patashu> loop while cell under pointer IS zero
02:27:13 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10(>)*7((+)*10[-]>(-)*10[+]>)*11
02:27:15 <EgoBot> Score for Patashu_rushpolarity: 48.1
02:27:37 <Patashu> !bfjoust rushpolarity >(+)*9>(-)*9(>)*7((+)*9[-]>(-)*9[+]>)*11
02:27:39 <EgoBot> Score for Patashu_rushpolarity: 54.3
02:27:53 <Patashu> hmm
02:28:11 <Patashu> !bfjoust rushpolarity >(+)*8>(-)*8(>)*7((+)*8[-]>(-)*8[+]>)*11
02:28:13 <EgoBot> Score for Patashu_rushpolarity: 54.3
02:28:37 <Patashu> !bfjoust rushpolarity >(+)*8>(-)*8(>)*7((+)*9[-]>(-)*9[+]>)*11
02:28:39 <EgoBot> Score for Patashu_rushpolarity: 42.0
02:29:04 <Patashu> !bfjoust rushpolarity >(+)*8>(-)*8(>)*7((+)*10[-]>(-)*10[+]>)*11
02:29:06 <EgoBot> Score for Patashu_rushpolarity: 50.6
02:29:37 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10(>)*7((+)*10[-]>(-)*10[+]>)*11
02:29:39 <EgoBot> Score for Patashu_rushpolarity: 34.6
02:30:15 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10(>)*7((+)*6[-]>(-)*6[+]>)*11
02:30:17 <EgoBot> Score for Patashu_rushpolarity: 60.5
02:30:33 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10(>)*7((+)*7[-]>(-)*7[+]>)*11
02:30:35 <EgoBot> Score for Patashu_rushpolarity: 48.1
02:30:55 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10(>)*7((+)*8[-]>(-)*8[+]>)*11
02:30:57 <EgoBot> Score for Patashu_rushpolarity: 60.5
02:31:56 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10(>)*7((+)*9[-]>(-)*9[+]>)*11
02:31:57 <EgoBot> Score for Patashu_rushpolarity: 60.5
02:32:19 <Patashu> :o
02:32:48 <Patashu> where'd everyone go anyhow
02:34:11 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>(-)*5(>)*6((+)*9[-]>(-)*9[+]>)*11
02:34:13 <EgoBot> Score for Patashu_rushpolarity: 75.3
02:34:34 <Patashu> no that's worse, hmm
02:34:59 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-]>(-)*9[+]>)*11
02:35:01 <EgoBot> Score for Patashu_rushpolarity: 49.4
02:35:25 <nescience> !bfjoust slowpoke http://pastie.org/490848.txt
02:35:28 <EgoBot> Score for nescience_slowpoke: 8.5
02:35:33 <nescience> lol
02:35:35 <nescience> must be broken
02:35:37 <Patashu> ouch
02:35:44 <Patashu> is that algorithmically generated?
02:35:51 <nescience> no
02:36:13 <nescience> oh
02:36:14 <nescience> haha
02:36:17 <nescience> i got my numbers wrong
02:36:20 <Patashu> lol
02:36:24 <nescience> it shouldn't be <*8 >*8
02:36:27 <Patashu> bfjoust magnum opus
02:36:28 <nescience> it should be <*8 >*9
02:36:49 <Patashu> this is for my bfjoust master's degree
02:38:00 <coppro> oh, things are fixed?
02:38:07 <coppro> neat!
02:38:27 <Patashu> yes
02:38:28 <Patashu> go wild
02:38:35 <coppro> !bfjoust irritating [>[-]-]
02:38:42 <EgoBot> Score for coppro_irritating: 21.5
02:38:49 <Patashu> just one glitch
02:38:54 <Patashu> the score it gives is for the LAST time you submitted a program
02:39:00 <Patashu> i.e. one submission delay
02:39:26 <nescience> !bfjoust slowpoke http://pastie.org/490854.txt
02:39:28 <EgoBot> Score for nescience_slowpoke: 8.5
02:39:41 <coppro> !bfjoust irritating [>[-]->[+]+]
02:39:42 <EgoBot> Score for coppro_irritating: 21.5
02:39:44 <nescience> lol well it still beats defendd
02:39:56 <Patashu> haha
02:40:01 <Patashu> what is it meant to do?
02:40:09 <coppro> ah, I see
02:40:11 <nescience> beat defend, and hopefully also do something interesting
02:40:23 <nescience> i have an idea
02:40:26 <nescience> lol
02:40:32 <nescience> but i guess it wouldn't matter
02:40:40 <coppro> !bfjoust beat_defenders [>[[[[[[-]]]]]]]
02:40:51 <EgoBot> Score for coppro_beat_defenders: 8.5
02:40:52 <nescience> it doesn't
02:41:03 <coppro> apparently not
02:41:19 <nescience> you'll just tie or run off the end
02:41:35 <nescience> gotta trip the tripwire and wait
02:41:39 <nescience> or skip it somehow
02:41:46 <Patashu> only ones I'm not beating are the defend6s
02:41:48 <Patashu> so :C
02:42:05 <nescience> i could be lame like ehird and just rip your code and then possibly fix it to beat them
02:42:05 <nescience> :P
02:42:22 <nescience> the thing i don't get is why you bother doing 10 +'s etc
02:42:24 <nescience> unless it's to kill time
02:42:27 <Patashu> it's because
02:42:28 <Patashu> uh
02:42:30 <Patashu> when people set decoys
02:42:38 <Patashu> they're more likely to set them to low +- numbers than high ones
02:42:42 <Patashu> or wait...
02:42:44 <Patashu> hmmm
02:42:45 <nescience> so?
02:42:52 <nescience> that doesn't help you any, since you aren't looping
02:42:53 <Patashu> well it works better when I put them in!
02:43:04 <nescience> like i said, must be killing time
02:43:06 <nescience> wonder why though
02:43:16 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5([-]>[+]>)*11
02:43:18 <EgoBot> Score for Patashu_rushpolarity: 76.0
02:43:19 <nescience> i have an inkling of an idea
02:43:23 <Patashu> let's see what happens when I take them out then
02:43:30 <Patashu> yeah it gets much worse
02:43:36 <Patashu> let's replace them with an equivalent amount of .s
02:43:39 <nescience> i meant on your decoys
02:43:46 <nescience> see one thing that happens
02:43:50 <nescience> if you have a set number of -s or +s
02:43:59 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-]>(-)*9[+]>)*11
02:44:01 <EgoBot> Score for Patashu_rushpolarity: 21.0
02:44:02 <nescience> and someone else is looping on the same position
02:44:13 <nescience> if they dec to 0, you can put them past 0
02:44:19 <nescience> and then they loop again 256 times
02:44:49 <nescience> my decoys only bother setting once because they are only going to slow down loops
02:44:57 <nescience> and for that you don't need more than one
02:44:59 <Patashu> hmm let's see
02:45:07 <Patashu> !bfjoust rushpolarity >+>->->+(>)*5((+)*9[-]>(-)*9[+]>)*11
02:45:09 <EgoBot> Score for Patashu_rushpolarity: 60.5
02:45:35 <Patashu> I was under the impression that a high finite + or - for a decoy would stop constructs that go like [+[--[+++[----[...
02:45:38 <nescience> i think you ought to study why it's working for you in detail, probably could learn something good
02:45:44 <Patashu> nope small decoys doesn't help it
02:46:03 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-]>(-)*9[+]>)*11
02:46:05 <EgoBot> Score for Patashu_rushpolarity: 34.6
02:46:13 <nescience> strange
02:46:16 <Patashu> this is ideal
02:46:20 <Patashu> beats all but defend6s
02:46:42 <nescience> all you need to do to beat the defends is delay longer before moving on
02:46:57 <nescience> you need to spend longer than 128 cycles at each location
02:47:04 <Patashu> but then I lose to everything else
02:47:05 <nescience> assuming you zero them before moving
02:47:13 <nescience> sucks eh? :)
02:47:23 <nescience> maybe you should just not care about them, apparently tripwire is not that effective a strategy
02:47:23 <Patashu> well hmm...
02:47:26 <nescience> unless it's all that's on the hill
02:47:27 <Patashu> 8 and 9 beat defend6 a parody
02:47:34 <Patashu> but 8 and 9 do poorly in general
02:47:36 <nescience> because i wrote them to
02:47:39 <Patashu> ya
02:47:42 <nescience> creep did good earlier
02:47:45 <nescience> i was 2nd
02:47:51 <Patashu> how do you make a defender? I wanna try
02:47:54 <nescience> but even then it got 3 losses
02:48:02 <nescience> what the defends are doing is
02:48:09 <nescience> 1) waiting at instruction 1 until it gets zeroed
02:48:16 <nescience> 2) going back to their flag and inc/dec'ing 128 times
02:48:26 <nescience> 3) then going back and forth across the tape alternately
02:48:50 <nescience> they keep tweaking their flag, then attacking a new location
02:49:04 <nescience> the goal is, presumably, to do like i said before
02:49:11 <nescience> let the enemy's loop hit 0 and fall through
02:49:21 <nescience> but inc/dec the flag on that same instruction so you don't lose
02:49:23 <nescience> then they run off the end
02:49:37 <Patashu> so it starts
02:49:42 <nescience> i wonder, the tripwire thing probably doesn't need to attack the opponent's flag at all
02:49:50 <Patashu> >[]<(+)*128
02:50:05 <nescience> >+[]
02:50:12 <Patashu> oh yeah
02:50:23 <Patashu> what if say your opponent -s while you +
02:50:30 <Patashu> do you alternate +ing and -ing
02:50:48 <nescience> infinite loop -> tie
02:51:06 <Patashu> !bfjoust matador >+[]<(+)*128(-)*128(>)*9(>[+])*21
02:51:10 <EgoBot> Score for Patashu_matador: 0.0
02:51:12 <Patashu> nope
02:51:43 <nescience> !bfjoust tripwire >+[]<(+)*192000
02:51:50 <nescience> whoops i needed bigger number
02:51:53 <EgoBot> Score for nescience_tripwire: 0.0
02:52:06 <Patashu> it ties the defends though lol
02:52:13 <nescience> !bfjoust tripwire >+[]<(+)*384000
02:52:15 <EgoBot> Score for nescience_tripwire: 0.0
02:52:15 <nescience> should tie everything
02:52:23 <coppro> !bfjoust morefail >+[]+[->[-]](>)*7[>[-]]
02:52:26 <EgoBot> Score for coppro_morefail: 0.0
02:52:28 <nescience> i woner why not
02:52:29 <coppro> oops
02:52:33 <Patashu> !bfjoust matador >+[]<(+)*123456(-)*123456(>)*9(>[+])*21
02:52:35 <EgoBot> Score for Patashu_matador: 0.0
02:52:35 <coppro> !bfjoust morefail >+[]+[->[-]](>)*7[>[-].]
02:52:36 <EgoBot> Score for coppro_morefail: 0.0
02:52:45 <Patashu> hmmm
02:52:52 <Patashu> !bfjoust matador >+[]<.(+)*123456(-)*123456(>)*9(>[+])*21
02:52:54 <EgoBot> Score for Patashu_matador: 0.0
02:52:55 <nescience> !bfjoust tripwire >(+)*384000
02:52:56 <EgoBot> Score for nescience_tripwire: 8.5
02:52:58 <Patashu> !bfjoust matador >+[]<.(+)*123456.(-)*123456(>)*9(>[+])*21
02:52:58 <nescience> lol
02:53:00 <EgoBot> Score for Patashu_matador: 0.0
02:53:07 <coppro> !bfjoust morefail >+[]+[->[-]](>)*7+[[-].>]
02:53:09 <EgoBot> Score for coppro_morefail: 0.0
02:53:10 <Patashu> !bfjoust matador >+[]<(+)*123456.(-)*123456(>)*9(>[+])*21
02:53:12 <EgoBot> Score for Patashu_matador: 0.0
02:53:15 <nescience> please cut the spam out, jesus
02:53:19 <nescience> at least stop and reflect on your scores
02:53:21 <coppro> never!
02:53:21 -!- Gracenotes has joined.
02:53:25 <nescience> remember the bot isn't reporting an accurate score
02:53:31 <nescience> so you have to refresh the chart at least
02:53:32 <coppro> there was an obvious bug in mine
02:53:35 <nescience> and every time you submit it blanks the chart
02:53:45 <Patashu> damn bugs
02:53:57 <nescience> it's probably my fault heh :P
02:54:00 <nescience> running out the clock
02:54:15 <Patashu> hmm that last time it beat 10 and did a whole bunch of ties
02:54:20 <coppro> rofl my new one can't win
02:54:23 <nescience> it still loses
02:54:23 <Patashu> so why is it tieing then? it kills itself or it times out?
02:54:23 <nescience> wtf
02:54:31 <nescience> tie should be time runs out
02:54:38 <nescience> oh, of course
02:54:41 <nescience> the defends don't use loops
02:54:46 <nescience> and anything that doesn't loop would win
02:54:48 <nescience> silly me
02:54:56 <Patashu> !bfjoust matador >+[]<(+)*500.(-)*500(>)*9(>[+])*21
02:54:58 <nescience> also i forgot something about my own attempt
02:54:58 <EgoBot> Score for Patashu_matador: 9.0
02:55:12 <Patashu> that beats creep and kekeke
02:55:58 <Patashu> !bfjoust matador >+[]<(++-)*256.(--+)*256(>)*9(>[+])*21
02:56:00 <EgoBot> Score for Patashu_matador: 14.0
02:56:07 <Patashu> oh-ho
02:56:11 <Patashu> beats rushpolarity XD
02:56:32 <Patashu> !bfjoust matador >+[]<(++-)*129.(--+)*129(>)*9(>[+])*21
02:56:34 <EgoBot> Score for Patashu_matador: 41.0
02:56:41 <Patashu> no that does worse
02:56:48 <Patashu> !bfjoust matador >+[]<(++-)*500.(--+)*500(>)*9(>[+])*21
02:56:50 <EgoBot> Score for Patashu_matador: 17.3
02:56:58 <Patashu> holy lol
02:57:00 <Patashu> that does real well
02:57:07 <Patashu> !bfjoust matador >+[]<(++-)*1000.(--+)*1000(>)*9(>[+])*21
02:57:09 <EgoBot> Score for Patashu_matador: 55.6
02:57:17 <nescience> !bfjoust tripwire http://pastie.org/490870.txt
02:57:19 <EgoBot> Score for nescience_tripwire: 0.0
02:57:26 <Patashu> !bfjoust matador >+[]<(.+-)*1000.(.-+)*1000(>)*9(>[+])*21
02:57:28 <EgoBot> Score for Patashu_matador: 48.1
02:57:28 <nescience> yeah, didn't think it'd do much better
02:57:39 <Patashu> !bfjoust matador >+[]<(.+-)*1000(.-+)*1000(>)*9(>[+])*21
02:57:41 <EgoBot> Score for Patashu_matador: 48.1
02:57:54 <coppro> !bfjoust watch_killer [>[[-]+>[][+]]]
02:58:08 <EgoBot> Score for coppro_watch_killer: 0.0
02:58:10 <Patashu> !bfjoust matador >+[]<(.+-)*512(.-+)*512(>)*9(>[+])*21
02:58:11 <coppro> aw
02:58:12 <EgoBot> Score for Patashu_matador: 39.5
02:58:29 <Patashu> !bfjoust matador >+[]<(.+-)*1000(.-+)*1000(>)*9(>[+])*21
02:58:31 <EgoBot> Score for Patashu_matador: 39.5
02:58:39 <Patashu> !bfjoust matador >+[]<(.+-)*1000.(.-+)*1000(>)*9(>[+])*21
02:58:41 <EgoBot> Score for Patashu_matador: 39.5
02:58:49 <Patashu> okay that . makes it win for some reason
02:58:55 <Patashu> must be a parity thing
02:59:07 <nescience> likely
02:59:20 <Patashu> hmm I wonder
02:59:20 <coppro> !bfjoust watch_killer [>[[-]+>[][+--]]]
02:59:22 <EgoBot> Score for coppro_watch_killer: 0.0
02:59:24 <nescience> still probably gonna be affected by randomness
02:59:27 <Patashu> !bfjoust matador >-[]<(.+-)*1000.(.-+)*1000(>)*9(>[+])*21
02:59:28 <EgoBot> Score for Patashu_matador: 48.1
02:59:29 <coppro> hrmm why's mine failing
02:59:44 <Patashu> what is that horrid thing doing
02:59:45 <Patashu> lol
03:00:31 <coppro> !bfjoust watch_killer [>[[-](.)*1000]]
03:00:32 <EgoBot> Score for coppro_watch_killer: 0.0
03:00:41 <coppro> oh wait I see
03:00:42 <coppro> duh
03:00:46 <coppro> !bfjoust watch_killer [>[[-]+>[][+--]]+]
03:00:46 <Patashu> mixed up what [] does?
03:00:47 <EgoBot> Score for coppro_watch_killer: 0.0
03:00:53 <coppro> hrm
03:00:54 <Patashu> oo
03:00:55 <coppro> !bfjoust watch_killer [>[[-](.)*1000]+]
03:00:56 <Patashu> it gets 31.5 now
03:00:57 <EgoBot> Score for coppro_watch_killer: 31.5
03:01:00 <coppro> there we go
03:01:01 <Patashu> don't forget to check the chart after you submit something
03:01:02 <Patashu> because
03:01:04 <Patashu> the score it gives you
03:01:05 <coppro> oh yeah
03:01:07 <coppro> right
03:01:11 <Patashu> was the score for the LAST program you submitted
03:01:12 <nescience> !bfjoust tripwire >+[]<[]+(>[+](.)*128)*29
03:01:13 <coppro> !bfjoust watch_killer [>[[-]+>[][+--]]+]
03:01:14 <EgoBot> Score for nescience_tripwire: 45.0
03:01:14 <EgoBot> Score for coppro_watch_killer: 37.0
03:01:29 <coppro> basically it tricks defenders into killing themselves
03:01:30 <nescience> can't believe i/nobody thought of that yet
03:01:40 <nescience> coppro: yes, that's what i did like two hours ago :P
03:01:46 <coppro> heh
03:01:51 <nescience> the above should beat loopers and both defenders
03:01:58 <nescience> but doesn't
03:01:59 <nescience> bugs?
03:02:12 <coppro> hmm... I've got a new one to try
03:02:14 <nescience> i wish their numbers would stay the same
03:02:17 <Patashu> !bfjoust matador >-[]<[]+-++--+++---++++----(>)*9(>[+])*21
03:02:19 <EgoBot> Score for Patashu_matador: 0.0
03:02:25 <Patashu> no good, ok
03:02:29 <Patashu> !bfjoust matador >-[]<(.+-)*1000.(.-+)*1000(>)*9(>[+])*21
03:02:30 <EgoBot> Score for Patashu_matador: 58.0
03:03:02 <coppro> hmm... it would be more interesting
03:03:10 <coppro> if you had one 0 cell beyond each flag
03:03:40 <Patashu> suggest it
03:04:01 <coppro> where?
03:04:11 <Patashu> http://esolangs.org/wiki/BF_Joust talk page
03:04:39 <nescience> !bfjoust tripwire >+[]<[]+.+(>)*9(>[.+])*29
03:04:41 <EgoBot> Score for nescience_tripwire: 0.0
03:04:49 <coppro> would allow for more interesting possibilities, because then programs could identify flags other than by hoping they don't run off the end
03:04:58 <nescience> hm, i think maybe the timing is not correct
03:05:06 <nescience> coppro: it's called "joust" not "snipe" ;)
03:05:10 <nescience> FULL SPEED AHEAD
03:05:30 <coppro> nescience: you can, of course, trick your opponent still!
03:05:51 <coppro> more importantly, it allows defensive strategies that don't need to use fixed numbers in the source
03:05:57 <nescience> !bfjoust test [>[-]+]
03:06:01 <EgoBot> Score for nescience_test: 35.0
03:06:15 <nescience> yeah
03:06:17 <nescience> timing thing
03:06:18 <Patashu> beats matador haha
03:06:19 <nescience> wtf, that might be a bug
03:06:28 <nescience> let's look at this closely
03:06:31 <nescience> >+ sets it to 1
03:06:35 <nescience> [] waits til its 0
03:06:41 <nescience> from what was described to me before
03:06:46 <nescience> no matter if it is executing [ or ]
03:06:51 <Patashu> [] loops if the cell is not 0\
03:06:53 <nescience> it will skip to <
03:06:55 <nescience> when the cell is 0
03:07:03 <nescience> then it waits on my fag
03:07:05 <nescience> flag*
03:07:07 <nescience> [] again
03:07:08 <Patashu> it will only halt if it encounters a -1 cell
03:07:19 <nescience> when the flag becomes 0 it should execute +
03:07:23 <nescience> and save m... ah
03:07:27 <nescience> but the enemy...... no
03:07:34 <nescience> 'cause the enemy should be at that point executing ]
03:07:45 <nescience> -]-]-]-]-]
03:07:50 <nescience> or +]+]+]+]+]
03:07:53 <nescience> so - makes it 0
03:07:57 <nescience> it is 0 at the start of ]
03:08:00 <nescience> loop falls through
03:08:03 <Patashu> I think I see why it beats matador
03:08:06 <nescience> for my part,
03:08:15 <nescience> it falls through a... i see
03:08:19 <nescience> that seems non optimal
03:08:28 <Patashu> !bfjoust matador >-[]<(++-)*1000.(--+)*1000(>)*9(>[+])*21
03:08:30 <EgoBot> Score for Patashu_matador: 53.1
03:08:40 <nescience> so what happens is my test doesn't work until it has been 0 for 1 round
03:08:43 <Patashu> k, fixed the vulnerability
03:09:02 <Patashu> now it only beats creep and watch kille
03:09:03 <Patashu> +r
03:09:49 <Patashu> I have an idea to tweak rushpolarity now
03:10:06 <nescience> !bfjoust tripwire >+[]<(.)*128+(>)*9(>[.+])*29
03:10:07 <EgoBot> Score for nescience_tripwire: 8.0
03:10:18 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+>(-)*9[+].->)*11
03:10:20 <EgoBot> Score for Patashu_rushpolarity: 71.0
03:10:24 <nescience> lol test still beats it
03:10:25 <nescience> hmm
03:10:32 <Patashu> k, does not help
03:10:39 <nescience> oh right
03:10:40 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-]+>(-)*9[+]->)*11
03:10:41 <nescience> timing mistake
03:10:42 <EgoBot> Score for Patashu_rushpolarity: 49.4
03:10:49 <Patashu> hmm
03:10:53 <nescience> !bfjoust tripwire >+[]<(.)*256+(>)*9(>[.+])*29
03:10:55 <EgoBot> Score for nescience_tripwire: 8.0
03:10:58 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-][+]>(-)*9[+][-]>)*11
03:11:00 <EgoBot> Score for Patashu_rushpolarity: 49.0
03:11:17 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5([-][+]>[+][-]>)*11
03:11:19 <EgoBot> Score for Patashu_rushpolarity: 45.1
03:11:28 <Patashu> no that's not doing it at all haha
03:11:31 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-]>(-)*9[+]>)*11
03:11:33 <EgoBot> Score for Patashu_rushpolarity: 29.6
03:11:34 <Patashu> back to the original spec
03:11:49 <nescience> !bfjoust tripwire >+[]<(.)*256+(>)*9(>[.+])*29
03:11:50 <EgoBot> Score for nescience_tripwire: 8.0
03:12:08 <nescience> !bfjoust tripwire >+[]<(.)*257+(>)*9(>[.+])*29
03:12:09 <EgoBot> Score for nescience_tripwire: 8.0
03:12:19 <nescience> !bfjoust tripwire >+[]<(.)*255+(>)*9(>[.+])*29
03:12:21 <EgoBot> Score for nescience_tripwire: 8.0
03:12:23 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-]+-++-->(-)*9[+]+-++-->)*11
03:12:25 <EgoBot> Score for Patashu_rushpolarity: 60.0
03:12:38 <Patashu> hmm
03:12:39 <nescience> gonna have to notepad this up and solve a simpler problem
03:12:47 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-]+-.++-->(-)*9[+]+-.++-->)*11
03:12:48 <nescience> ah there we go
03:12:49 <EgoBot> Score for Patashu_rushpolarity: 58.6
03:12:51 <nescience> it beats test
03:12:52 <nescience> lol
03:12:53 <nescience> but nothing else
03:13:03 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+-++-->(-)*9[+].+-++-->)*11
03:13:05 <EgoBot> Score for Patashu_rushpolarity: 45.1
03:13:06 <nescience> i guess nobody uses a simple attack anymore
03:13:12 <coppro> !bfjoust fooled_ya (>+>-)*4[>[-]+]
03:13:13 <Patashu> oo that's good
03:13:13 <Patashu> :)
03:13:16 <EgoBot> Score for coppro_fooled_ya: 27.5
03:13:27 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+->(-)*9[+].+->)*11
03:13:28 <EgoBot> Score for Patashu_rushpolarity: 68.5
03:13:33 <Patashu> that's not
03:13:44 <coppro> oh right, need defense protection
03:13:44 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+-++--+++--->(-)*9[+].+-++--+++--->)*11
03:13:46 <EgoBot> Score for Patashu_rushpolarity: 56.2
03:13:58 <coppro> !bfjoust fooled_ya (>+>-)*4[>[[-]+]+]
03:13:59 <EgoBot> Score for coppro_fooled_ya: 25.3
03:14:03 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+-.++-->(-)*9[+].+-.++-->)*11
03:14:04 <EgoBot> Score for Patashu_rushpolarity: 49.4
03:14:05 <coppro> !bfjoust fooled_ya (>+>-)*4[>[+[-]]+]
03:14:07 <EgoBot> Score for coppro_fooled_ya: 25.3
03:14:29 <coppro> hmm... that's better
03:14:32 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+-++-->(-)*9[+].+-++-->)*11
03:14:34 <EgoBot> Score for Patashu_rushpolarity: 58.6
03:14:35 -!- inurinternet has joined.
03:14:37 <coppro> how does the scoring system work?
03:14:44 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+-.++-->(-)*9[+].+-.++-->)*11
03:14:46 <EgoBot> Score for Patashu_rushpolarity: 48.8
03:14:50 <Patashu> you get more points for beating programs with more points
03:15:04 <coppro> !bfjoust fooled_ya (>(+)*32>(-)*32)*4[>[+[-]]+]
03:15:06 <EgoBot> Score for coppro_fooled_ya: 29.6
03:15:11 <Patashu> haha matador's falling now that it doesn't beat rushpolarity any more
03:15:14 <Patashu> :')
03:15:21 <nescience> i think the scoring system needs a little work
03:15:32 <Gracenotes> ._.
03:15:35 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5([-].+-.++-->[+].+-.++-->)*11
03:15:37 <EgoBot> Score for Patashu_rushpolarity: 63.0
03:15:44 <nescience> if you get points for beating something before its battle with you gets taken account of, then things are a little weird the first submit
03:15:45 <coppro> damn that shortswod
03:15:47 <nescience> i dunno how they work it out
03:15:48 <coppro> *shortsword
03:16:03 <coppro> I don't understand exactly how this game works well enough yet
03:16:07 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5(+[-].+-.++-->-[+].+-.++-->)*11
03:16:09 <EgoBot> Score for Patashu_rushpolarity: 45.1
03:16:16 <Gracenotes> hm? How are parens and numerical symbols determined?
03:16:21 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+-.++-->(-)*9[+].+-.++-->)*11
03:16:22 <EgoBot> Score for Patashu_rushpolarity: 45.1
03:16:23 <Gracenotes> ...is that just repeating text?
03:16:27 <coppro> yes
03:16:31 <Patashu> (foo)*num = foofoofoofoo...num times
03:16:33 <Gracenotes> ah. mak sanse.
03:16:33 <Patashu> that's it
03:16:47 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+-.++-->(-)*9[+].+-.++-->)*11
03:16:48 <nescience> !bfjoust tripwire >+[]<[-++-](>)*9(>-++-(.)*128[+])*29
03:16:49 <coppro> (some{stuff}things)*2=somesomestuffthingsthings
03:16:49 <EgoBot> Score for nescience_tripwire: 8.0
03:16:49 <EgoBot> Score for Patashu_rushpolarity: 30.9
03:17:07 <Gracenotes> how are scores done? :)
03:17:12 <nescience> hm
03:17:20 <nescience> !bfjoust tripwire >+[]<[--](>)*9(>-++-(.)*128[+])*29
03:17:21 <EgoBot> Score for nescience_tripwire: 0.0
03:17:22 <Patashu> you get points for a win
03:17:24 <nescience> ha
03:17:25 <Patashu> and the more that program had
03:17:26 <Patashu> the more you get
03:17:38 <nescience> interesting results
03:17:41 <Gracenotes> I have heard of BF jousting, but not the specifics
03:17:41 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*8[-].+-.++-->(-)*8[+].+-.++-->)*11
03:17:43 <EgoBot> Score for Patashu_rushpolarity: 45.0
03:17:50 <nescience> oh of course tripwire would always tie the defends
03:18:01 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+-.++-->(-)*9[+].+-.++-->)*11
03:18:03 <EgoBot> Score for Patashu_rushpolarity: 36.4
03:18:03 <coppro> !bfjoust tripstep [>[>[-]]+]
03:18:09 <EgoBot> Score for coppro_tripstep: 37.0
03:18:37 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-].+.--++>(-)*9[+].+.--++>)*11
03:18:39 <EgoBot> Score for Patashu_rushpolarity: 54.5
03:19:02 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-]+.--.++>(-)*9[+]+.--.++>)*11
03:19:04 <EgoBot> Score for Patashu_rushpolarity: 47.5
03:19:14 <Patashu> aha
03:19:48 <coppro> !bfjoust tripstep [>[[>[-].+]]+]
03:19:50 <EgoBot> Score for coppro_tripstep: 43.0
03:20:19 <nescience> !bfjoust test (>)*9(-++-(-)*70[+])*20
03:20:21 <EgoBot> Score for nescience_test: 22.5
03:20:44 <Patashu> !bfjoust matador >-[]<(++-)*1000.(--+)*1000(>)*9(>[+][-])*21
03:20:46 <EgoBot> Score for Patashu_matador: 29.0
03:21:06 <Patashu> !bfjoust matador >-[]<(++-)*1000(--+)*1000(>)*9(>[+][-])*21
03:21:07 <EgoBot> Score for Patashu_matador: 29.0
03:21:30 <Patashu> !bfjoust matador >-[]<(++-)*1000.(--+)*1000(>)*9(>[+][-])*21
03:21:32 <EgoBot> Score for Patashu_matador: 42.0
03:21:41 <Patashu> oop now it beats rushpolarity again
03:21:48 <Patashu> :>
03:21:58 <nescience> !bfjoust test >----->+++++>----->+++++>----->+++++>-----(>-++-(-)*70[+])*20
03:21:59 <EgoBot> Score for nescience_test: 7.5
03:22:02 <nescience> whoops forgot to put > in it
03:22:24 <Patashu> !bfjoust matador >-[]<(++-+-)*1000.(--+-+)*1000(>)*9(>[+][-])*21
03:22:25 <EgoBot> Score for Patashu_matador: 7.4
03:22:30 <nescience> beats defends and some others now
03:22:32 <nescience> heh
03:22:36 <Patashu> !bfjoust matador >-[]<(++-)*1000.(--+)*1000(>)*9(>[+][-])*21
03:22:38 <EgoBot> Score for Patashu_matador: 44.4
03:22:40 <nescience> better'n creep at least
03:23:01 <Patashu> !bfjoust matador >+[]<(++-)*1000.(--+)*1000(>)*9(>[+][-])*21
03:23:02 <EgoBot> Score for Patashu_matador: 30.9
03:23:11 <Patashu> !bfjoust matador >-[]<(++-)*1000.(--+)*1000(>)*9(>[+][-])*21
03:23:12 <EgoBot> Score for Patashu_matador: 30.9
03:23:28 <Patashu> hmm
03:23:39 <Patashu> it needs to do two fights against each program imho
03:23:43 <coppro> !bfjoust tripstep [>[+[--[>[-].+]]<+[>[-].+].+]]+]
03:23:45 <EgoBot> Score for coppro_tripstep: 0.0
03:23:49 <coppro> :(
03:23:49 <Patashu> wow look at that thing
03:23:57 <Patashu> it needs indentation
03:24:04 <Patashu> haha
03:24:07 <coppro> !bfjoust tripstep [>[+[--[>[-].+]]+[[-].>+].+]]+]
03:24:09 <EgoBot> Score for coppro_tripstep: 0.0
03:24:23 <coppro> hfm
03:26:10 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5([+[-]]+.--.++>[-[+]]+.--.++>)*11
03:26:12 <EgoBot> Score for Patashu_rushpolarity: 55.6
03:26:22 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*9[-]+.--.++>(-)*9[+]+.--.++>)*11
03:26:24 <EgoBot> Score for Patashu_rushpolarity: 30.9
03:26:36 <nescience> !bfjoust playing_the_odds (>)*13(>(-)*128.)*15
03:26:38 <EgoBot> Score for nescience_playing_the_odds: 27.0
03:26:45 <nescience> hehe
03:26:57 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*8[+[-]]+.--.++>(-)*9[-[+]]+.--.++>)*11
03:26:59 <EgoBot> Score for Patashu_rushpolarity: 55.5
03:27:01 <nescience> !bfjoust playing_the_odds (>)*13(>(-)*128.)*15
03:27:03 <EgoBot> Score for nescience_playing_the_odds: 27.0
03:27:12 <Patashu> hmm
03:27:33 <nescience> !bfjoust playing_the_odds (>+>-)*6>(>(-)*128.)*15
03:27:33 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>->+(>)*5((+)*8[+[-]]+.--.++>(-)*8[-[+]]+.--.++>)*11
03:27:34 <EgoBot> Score for nescience_playing_the_odds: 40.7
03:27:35 <EgoBot> Score for Patashu_rushpolarity: 51.9
03:28:29 <nescience> !bfjoust playing_the_odds (>+++++>-----)*2(>)*9(>(-)*128.)*15
03:28:30 <EgoBot> Score for nescience_playing_the_odds: 26.5
03:28:38 <Patashu> !bfjoust rushpolarity >(+)*10>(-)*10>-->++(>)*5((+)*8[+[-]]+.--.++>(-)*8[-[+]]+.--.++>)*11
03:28:40 <EgoBot> Score for Patashu_rushpolarity: 54.3
03:28:45 <nescience> ah well, second try was the best heh
03:29:15 <nescience> ah well, second try was the best heh
03:29:18 <nescience> !bfjoust playing_the_odds (>+++++>-----)*2(>)*9(>(-)*128.)*15
03:29:19 <EgoBot> Score for nescience_playing_the_odds: 38.3
03:29:22 <nescience> rolling for a better score!
03:29:29 <nescience> win
03:29:31 <nescience> :D
03:29:32 <nescience> cache that pls
03:29:46 <nescience> didn't quite beat both defends though
03:30:06 <nescience> that'll be an amusing one to have on the hill
03:30:11 <nescience> i wonder how long it'll stay
03:31:15 <nescience> shortsword has staying power at least
03:31:25 <coppro> here's a better one!
03:31:47 <coppro> !bfjoust (>)*15([{-}])*100
03:31:47 <EgoBot> Use: !bfjoust <program name> <program>
03:31:52 <coppro> !bfjoust dice!(>)*15([{-}])*100
03:31:53 <EgoBot> Use: !bfjoust <program name> <program>
03:31:55 <coppro> !bfjoust dice! (>)*15([{-}])*100
03:32:04 <EgoBot> Score for coppro_dice_: 0.0
03:32:09 <nescience> ...
03:32:13 <coppro> :P
03:32:41 <nescience> the hill should have an "age" parameter ala corewars hills
03:46:11 <nescience> wtf save page is failing miserably
03:46:55 <nescience> keeps giving me an 'edit conflict' error
03:47:00 <nescience> but there isn't one
03:47:54 <oerjan> on the esolang wiki?
03:48:19 <coppro> add an edit comment
03:48:30 <nescience> stupid wikis capitalizing my username
03:49:48 <nescience> well, registering fied that
03:49:57 <oerjan> nescience: if that was you on the BF Joust talk page, please sign with ~~~~
03:50:08 <nescience> how come ais523 gets a lowercase nick and i don't :(
03:50:12 <nescience> oerjan: i did
03:50:23 <nescience> i didn't have an account before
03:51:20 <oerjan> are you Myndzi?
03:51:28 <nescience> yes
03:51:42 <oerjan> were you the previous comment too?
03:51:44 <nescience> it just looks wrong with a capital M >:(
03:51:46 <nescience> no
03:51:52 <oerjan> ic
03:52:00 <nescience> my edit was only the last paragraph
03:52:01 * oerjan will add an unsigned template
03:52:24 <oerjan> assuming i can get the damn molasses to load
03:52:59 <nescience> coppro was that unsigned paragraph
03:53:25 <coppro> oh, I must have not been logged in
03:53:27 <coppro> oops
03:53:56 <oerjan> that was you? then maybe best you sign yourself
03:54:02 <oerjan> or wait
03:54:15 <oerjan> i can just change the nick
03:54:32 <coppro> mine was the comment about going past the end
03:54:41 <nescience> i don't really see how that would be useful though
03:54:47 <nescience> since you can't simply test for 0
03:54:50 <nescience> it doesn't gain you anything
03:55:26 <oerjan> coppro: actually i don't know your username
03:56:08 <coppro> oh, dear, it appears I never signed up to esolang
03:56:11 <coppro> that explains a lot
03:56:17 <oerjan> heh :D
03:56:32 <nescience> >((o> lol fish <o))<
03:56:36 <nescience> submit that!
03:56:38 <oerjan> coppro: also, whether or not you are logged in you need to use a ~~~~ command to sign (it's in the button menu)
03:56:48 <coppro> I did
03:58:23 <oerjan> nescience: dammit your decapitalization made an edit conflict :(
03:58:28 <nescience> lol
03:58:44 <nescience> now you know how i feel! :P
03:58:49 <nescience> except there actually was one
03:58:51 <nescience> o well
03:59:55 <oerjan> nescience: also the signature text can be set in preferences
04:00:24 <nescience> you mean "nickname"?
04:00:29 <oerjan> yes
04:00:33 <nescience> i thought that's what it was, but when i changed it, it didn't affect the page
04:00:37 <nescience> that's why i edited it manually
04:00:37 * oerjan changed it to use an Ø
04:00:42 <oerjan> oh
04:00:52 <oerjan> nescience: it's not your username
04:01:07 <nescience> ?
04:01:08 <oerjan> only used for signature i think
04:01:15 <nescience> right
04:01:21 <nescience> but my signature had still taken from before
04:01:26 <nescience> thus i changed it too
04:01:38 <oerjan> oh of course
04:01:45 <nescience> between wikis and muds lately, *sighs*
04:16:53 -!- Patashu has quit ("Patashu/SteampunkX - MSN = Patashu@hotmail.com , AIM = Patashu0 , YIM = Patashu2 , Googletalk = Patashu0@gmail.com .").
04:16:56 -!- GregorR has quit (anthony.freenode.net irc.freenode.net).
04:17:38 -!- GregorR has joined.
04:18:00 <nescience> !bfjoust test >+>->+>->+>->+>[[+]>-++]
04:18:01 <EgoBot> Score for nescience_test: 38.5
04:19:38 <nescience> !bfjoust test >+>->+>->+>->+>(-++-(-.)*130>)*20
04:19:40 <EgoBot> Score for nescience_test: 0.0
04:20:43 <nescience> !bfjoust test >(+)*50>(-)*50>(+)*30>(-)*30>(+)*10>(-)*10>+>(-++-(-.)*130>)*20
04:20:45 <EgoBot> Score for nescience_test: 34.6
04:27:05 <GregorR-L> I'm glad to see bfjoust is being used.
04:27:06 -!- sebbu has joined.
04:27:32 <GregorR-L> Any further complaints from anybody?
04:27:51 <pikhq> You aren't creating a digital manifestation of God.
04:27:53 <nescience> i think the game won't go all that far
04:28:14 <nescience> it's about the best it can be in its current form, but there really aren't that many options
04:28:18 <nescience> dunno though, could be wrong1
04:28:23 <nescience> there are a number of comments on the wiki talk page
04:28:37 <GregorR-L> Then try FYB instead :P
04:29:06 <nescience> heh heh
04:29:17 <nescience> i'm not a huge fan of BF in the first place
04:29:37 <GregorR-L> When is bfjoust from ... does FYB predate it?
04:29:50 <nescience> i wouldn't know
04:32:26 <nescience> i wonder
04:32:40 <nescience> in the true spirit of capture the flag, what would happen if you had to come back to your base and set your own flag back to 128? ;)
04:32:52 <nescience> too complicated surely, also nobody would be able to keep track of their flag
04:36:35 <GregorR-L> !fyb minimangler +!>
04:36:53 <EgoBot> Score for GregorR-L_minimangler: 0.0
04:37:01 <GregorR-L> Ouch :P
04:37:31 <GregorR-L> !fyb minimangler :+!>;*
04:37:33 <EgoBot> Score for GregorR-L_minimangler: 0.0
04:37:37 <GregorR-L> *shrugs*
04:39:18 <oerjan> !fyb cheers :D
04:39:28 <EgoBot> Score for oerjan_cheers: 4.5
04:39:34 <GregorR-L> lawl :P
04:41:32 <Gracenotes> :D
04:41:34 <Gracenotes> D:
04:43:03 -!- sebbu2 has quit (Read error: 110 (Connection timed out)).
04:44:51 -!- Corun has quit ("Leaving...").
04:51:13 * coppro starts working on the Evil Calculus Book of Doom
04:54:58 <oerjan> itym the Evil Doom Calculus Book of the Apocalypse
05:04:19 <coppro> sorry
05:04:39 <bsmntbombdood> so i have a dump of wikipedia
05:04:42 <bsmntbombdood> what should i do with it
05:04:43 <coppro> stupid fact that I have to do tons of coursework even though I'm challenging the course
05:04:53 <coppro> make a programming language using wikipedia links
05:07:13 <Gracenotes> bsmntbombdood: what kind of dump?
05:07:31 <Gracenotes> current pages in article namespace?
05:07:35 <bsmntbombdood> the current version of all namespace 1 pages
05:07:54 <Gracenotes> that's the talk namespace :)
05:08:05 <bsmntbombdood> nuh uh
05:09:11 <Gracenotes> article is the first namespace, but its numbering is 0
05:09:30 <Gracenotes> anyway. >_>
05:09:49 <Gracenotes> perhaps you could make a graph based on what articles link to each other?
05:10:05 <oerjan> xkcd :D
05:10:13 <Gracenotes> although there are already dumps that have that information
05:10:18 <Gracenotes> you could do lots of interesting stuff with that
05:10:33 <bsmntbombdood> you can download just the link graph actually
05:10:37 <Gracenotes> shortest path between two articles, for example
05:10:40 <pikhq> ›_›
05:10:49 <Gracenotes> ( ≖‿≖)
05:11:24 <coppro> hahaha
05:11:28 <coppro> rofl xkcd
05:12:33 <Gracenotes> oh, really?
05:12:38 <Gracenotes> that good
05:12:41 <Gracenotes> *looks*
05:13:19 <Gracenotes> heh. heh. heh heh.
05:14:27 <Gracenotes> bsmntbombdood: there's always Markov chains
05:14:34 <Gracenotes> you'll have to strip out formatting
05:14:43 <Gracenotes> lots of training text...
05:14:47 <bsmntbombdood> that just gives you pagerank
05:14:58 <bsmntbombdood> oh, markov chains of text
05:16:37 <Gracenotes> run Flesch-Kincaid maybe
05:17:17 <GregorR-L> "The logistics of who can get drunk are nontrivial."
05:17:38 <bsmntbombdood> hmmm
05:17:41 <bsmntbombdood> i need a drunk
05:17:46 <GregorR-L> I disagree.
05:17:54 <coppro> I think you've had quite enough already
05:18:37 <oerjan> bsmntbombdood: schorry, i cant 'elp chu there
05:19:30 <Gracenotes> hm. I should try implementing Flesch-Kincaid in Haskell
05:19:40 <oerjan> kinky flesh
05:19:54 <Gracenotes> down boy
05:21:59 <oerjan> the syllable part may be a bit complicated
05:22:56 -!- oerjan has quit ("leaving").
05:23:01 <Gracenotes> er
05:23:03 <Gracenotes> :.;
05:23:43 <Gracenotes> actually it's less complicated than I thought
05:23:57 <Gracenotes> http://flesh.cvs.sourceforge.net/viewvc/flesh/Flesh%201.5/FleshLogic.java?revision=1.3&view=markup#l_523
05:24:05 <Gracenotes> more of a guess... but seems accurate enough
05:24:15 <Gracenotes> might be worth it to have a special table for corner cases
05:24:47 <Gracenotes> it doesn't say whether or not this is a standard algorithm. rather specific to English anyway
05:25:26 <coppro> broken link
05:25:45 <Gracenotes> wha
05:25:56 <Gracenotes> yeah... that's messed up. it worked a second ago
05:26:28 <Gracenotes> okay, should work now
05:26:50 <Gracenotes> actually, it does screw up quite a bit: http://flesh.cvs.sourceforge.net/viewvc/flesh/Flesh%201.5/CommonMistakes.java?revision=1.3&view=markup
05:27:19 <Gracenotes> needs more English knowledge
06:01:32 <bsmntbombdood> you can get dictionary files that break it down
06:03:04 <bsmntbombdood> Flesch-Kincaid sounds like a bunch of bs anyway
06:03:17 <bsmntbombdood> who cares how long sentences or words are
06:03:45 <coppro> Floridan insurance brokers, per Wikipedia
06:05:42 <bsmntbombdood> insurance and florida, that's all you need to know about their position
06:34:38 -!- GregorR-L has quit (Remote closed the connection).
06:44:05 -!- GregorR-L has joined.
07:01:37 -!- psygnisfive has quit ("Leaving...").
07:27:17 -!- Sgeo has quit (Read error: 110 (Connection timed out)).
07:37:35 -!- coppro has quit (Read error: 60 (Operation timed out)).
07:41:32 -!- GregorR-L has quit ("Leaving").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:55:25 -!- lereah_ has joined.
09:13:01 -!- GregorR-L has joined.
09:39:50 -!- Gracenotes has quit ("brb").
09:42:44 -!- Gracenotes has joined.
09:58:01 -!- tombom has joined.
10:04:37 -!- Patashu has joined.
10:13:25 <Patashu> hmm, still on the top of the hill
10:18:27 <GregorR-L> The next challenge: DOMINATE the hill.
10:19:41 <Patashu> I have no idea how to beat the defense6s and still beat everything else
10:19:45 <Patashu> I haven't even seen their code
10:20:10 <GregorR-L> http://codu.org/eso/bfjoust/in_egobot/
10:20:23 <GregorR-L> Uncommented though :P
10:20:40 <Patashu> oh
10:20:43 <Patashu> god damn that's long rofl
10:20:49 <Patashu> I need a decompiler
10:21:22 <GregorR-L> ais posted a link to a commented version ...
10:23:23 <GregorR-L> Ah, here 'tis
10:23:24 <GregorR-L> http://pastebin.ca/1435376
10:23:55 <GregorR-L> May 26 16:29:09 <ais523> it attacks something in particular, which is the [-] or [+] loop
10:23:55 <GregorR-L> May 26 16:29:13 <ais523> nearly all programs have one
10:23:55 <GregorR-L> May 26 16:29:38 <ais523> and if they go into such a loop on its flag, then defend6 will keep them in it forever, whilst running off and sinking their flag
10:24:30 <GregorR-L> *zleep*
10:24:47 <Patashu> oh I see
10:24:54 <Patashu> and it keeps coming back incrementially to keep it off zero
10:25:16 <Patashu> so it has an ultra-huge source code since there's no construct that says 'repeat this but increase this number by x every time'
11:51:27 -!- oerjan has joined.
12:16:29 -!- oerjan has quit ("leaving").
12:24:04 -!- M0ny has joined.
12:24:55 -!- Sgeo has joined.
12:52:55 -!- AnMaster has quit (Success).
12:57:06 -!- AnMaster has joined.
13:40:23 -!- Corun has joined.
14:13:19 -!- tombom has quit ("Peace and Protection 4.22.2").
14:23:45 -!- MizardX has quit ("What are you sinking about?").
14:39:36 -!- MizardX has joined.
14:47:15 -!- Corun has changed nick to Corun|away.
14:51:09 -!- Corun|away has changed nick to Corun.
15:34:59 -!- inurinternet has quit (Success).
15:49:47 -!- inurinternet has joined.
15:54:00 -!- impomatic has joined.
15:58:28 -!- lereah_ has quit ("Leaving").
16:01:30 -!- Patashu has quit ("Patashu/SteampunkX - MSN = Patashu@hotmail.com , AIM = Patashu0 , YIM = Patashu2 , Googletalk = Patashu0@gmail.com .").
16:43:04 -!- Gracenotes has quit (Success).
16:57:24 -!- BeholdMyGlory has joined.
17:00:50 -!- tombom has joined.
17:06:16 -!- fungebob has joined.
17:06:18 -!- FireFly has joined.
17:40:31 <ehird> cool i still own bf joust
17:42:35 <ehird> 01:38 Patashu: just one glitch
17:42:35 <ehird> 01:38 Patashu: the score it gives is for the LAST time you submitted a program
17:42:37 <ehird> 01:39 Patashu: i.e. one submission delay
17:42:39 <ehird> GregorR: GregorR-L: fix that
17:46:50 <ehird> !bfjoust phantom (>)*10([+[--[+++[----[+++++[------[+++++++[--------[+++++++++[----------]]]]]]]]]].>)*20
17:46:56 <EgoBot> Score for ehird_phantom: 41.5
17:47:06 <ehird> not bad
17:47:08 <ehird> not bad at all
17:47:28 <ehird> !bfjoust phantom (>)*10(-[+[--[+++[----[+++++[------[+++++++[--------[+++++++++[----------]]]]]]]]]]>)*20
17:47:33 <EgoBot> Score for ehird_phantom: 42.6
17:47:48 <ehird> !bfjoust phantom (>)*10(-[+[--[+++[----[+++++[------[+++++++[--------[+++++++++[----------]]]]]]]]]].>)*20
17:47:49 <EgoBot> Score for ehird_phantom: 42.6
17:48:35 <impomatic> Ehird: is that tailored for the decoys left by the programs on the current hill?
17:49:01 <nescience> lol creep officially beats nothing except the defends now
17:49:04 <ehird> impomatic: pretty much, it tries to find out whether it's big or small and efficiently zeroes it based on that
17:49:10 <ehird> !bfjoust phantom (>)*10(+[-[++[---[++++[-----[++++++[-------[++++++++[---------[++++++++++]]]]]]]]]]>)*20
17:49:11 <EgoBot> Score for ehird_phantom: 42.6
17:49:23 <nescience> but amusingly, 'playing the odds' is in 4th
17:49:26 <ehird> hmm flipping them does nothing
17:49:27 <nescience> <3 cached scores
17:49:27 <ehird> interesting
17:49:42 <nescience> refresh page
17:49:47 <nescience> remember it tends to show your last score
17:49:47 <ehird> 3 | - + + - - - - + - | 42.6| -3| ehird_phantom.bfjoust
17:49:50 <ehird> that's what it was before
17:49:50 <nescience> not the score after submission
17:50:03 <nescience> i see
17:50:11 <ehird> !bfjoust phantom (>)*10(-[+[-[+[-[+[-[+[-[+[-]]]]]]]]]]>)*20
17:50:12 <EgoBot> Score for ehird_phantom: 42.6
17:50:16 <nescience> not all that surprising i guess
17:50:17 <impomatic> I was wondering if it's possible to detect certain opponents and use a tailored attack.
17:50:17 <ehird> ouch
17:50:20 <ehird> that put it down to 14.2
17:50:33 <nescience> speed, i guess
17:50:52 <nescience> makes me wonder why so many +s before looping is effective though
17:50:55 <nescience> i guess it sets decoys of its own
17:51:09 <nescience> btw don't you want >*9?
17:51:15 <nescience> if it's 10 units long, it's 9 to the enemy flag
17:51:19 <ehird> oh
17:51:20 <ehird> right
17:52:03 <ehird> !bfjoust phantom (>-)*3(>+)*3(>)*3(+[-[++[---[++++[-----[++++++[-------[++++++++[---------[++++++++++]]]]]]]]]]>)*20
17:52:05 <EgoBot> Score for ehird_phantom: 42.6
17:52:13 <ehird> back to 42.6
17:52:28 <ehird> 5 losses, 3 wins, one draw
17:52:36 <ehird> i think the strategy is essentially good, though
17:52:46 * ehird idea
17:54:40 <ehird> !bfjoust phantom http://pastie.org/491591.txt?key=z90epgclqdxxiifgky728a
17:54:42 <EgoBot> Score for ehird_phantom: 42.6
17:54:48 <ehird> hahaha
17:54:51 <ehird> that makes it worse
17:55:06 <ehird> !bfjoust phantom (>-)*3(>+)*3(>)*3(+++++[-[++[---[++++[-----[++++++[-------[++++++++[---------[++++++++++]]]]]]]]]]>)*20
17:55:08 <EgoBot> Score for ehird_phantom: 27.8
17:56:14 <ehird> !bfjoust phantom (>-)*3(>+)*3(>)*3([-[(+)*2[(-)*3[(+)*4[(-)*5[(+)*6[(-)*7[(+)*8[(-)*9[(+)*10]]]]]]]]]]>)*20
17:56:16 <EgoBot> Score for ehird_phantom: 36.4
17:56:20 <nescience> this game is finicky
17:56:29 <ehird> hmm doing it with repeats actually slowed it down
17:56:49 <nescience> Patashu kept getting very different results by varying constants that didn't seem they should make that much difference
17:56:54 <ehird> shrug
17:57:12 <nescience> eh, the spec said repeats don't take any cycles
17:57:30 <ehird> !bfjoust phantom (>)*9([(-)*32[(+)*32[(-)*32[(+)*32]]]])*20
17:57:32 <EgoBot> Score for ehird_phantom: 36.4
17:57:33 <nescience> just macros.. should be the same
17:57:36 <nescience> unless it's randomness
17:57:39 * ehird crosses fingers
17:57:45 <ehird> nescience: I probably mistyped
17:57:49 <ehird> 3 | - 0 0 - - - - - 0 | 8.0| -6| ehird_phantom.bfjoust
17:57:51 <ehird> :D
17:58:58 <ehird> !bfjoust phantom (>)*9([(-)*16[(+)*32[(-)*48]]][-])*20
17:59:00 <EgoBot> Score for ehird_phantom: 8.0
17:59:14 <ehird> !bfjoust phantom (>-)*3(>+)*3(>)*3(+++++[-[++[---[++++[-----[++++++[-------[++++++++[---------[++++++++++]]]]]]]]]]>)*20
17:59:16 <EgoBot> Score for ehird_phantom: 8.0
17:59:17 <ehird> stick to what works.
17:59:43 <ehird> !bfjoust phantom >->->->+>+>+>>>(+++++[-[++[---[++++[-----[++++++[-------[++++++++[---------[++++++++++]]]]]]]]]]>)*20
17:59:45 <EgoBot> Score for ehird_phantom: 33.5
17:59:51 <ehird> wtf
17:59:59 <nescience> gogo random!
18:00:03 <ehird> nescience: the repeating one for the start got 33.5
18:00:06 <ehird> but this one gets 20.4
18:00:07 <ehird> !bfjoust phantom >->->->+>+>+>>>(+++++[-[++[---[++++[-----[++++++[-------[++++++++[---------[++++++++++]]]]]]]]]]>)*20
18:00:09 <EgoBot> Score for ehird_phantom: 20.4
18:00:12 <ehird> let's see if it's actually random
18:00:17 <ehird> yep, it is
18:00:19 <ehird> oh well
18:00:23 <ehird> impomatic: viper?
18:00:27 <nescience> look at 'playing the odds'
18:00:27 <ehird> are you submitting stuff? do it in channel :-P
18:00:29 <nescience> that's proof
18:00:44 <nescience> i submitted it a couple times till i got a couple decent cached results
18:00:44 <nescience> :P
18:00:53 <ehird> nescience: that's called being a jerk
18:00:54 <ehird> :)
18:00:55 <nescience> this hill is too noisy for such fine tuning
18:01:09 <nescience> if something was done to even out the randomness
18:01:18 <nescience> say, multiple samples *ahem* like i was mentioning yesterday... :P
18:01:20 <impomatic> ehird: I didn't want to flood the channel ;-)
18:01:30 <ehird> impomatic: but I don't notice new programs :-)
18:01:35 <ehird> nescience: yeah I agree now.
18:01:36 <nescience> i bet the max cycles probably doesn't need to be so high either
18:01:40 <ehird> it does
18:01:44 <ehird> defend6 needs it iirc
18:02:00 <nescience> i don't know
18:02:07 <nescience> i wonder how many cycles it'd take to complete at 30 cells
18:02:18 <nescience> i'm sure someone can caluclate but i don't have the required consecutive time atm
18:02:22 <nescience> or draw shortcutting at least
18:02:28 <nescience> detecting two [] loops, for examle :P
18:02:41 <nescience> or a [+] and [-] on the same cell
18:02:47 <ehird> i have 21 programs here. they are provably optimum for their tape length.
18:02:50 <ehird> should I submit them all? :P
18:03:02 <impomatic> Yes :-)
18:03:43 <ehird> okie dokie
18:03:52 <impomatic> !bfjoust viper >--->+++>---(>->+)*3(-[-[-[-[-[-[-[-[-[-[+]]]]]]]]]]>)*20
18:03:54 <EgoBot> Score for impomatic_viper: 42.0
18:04:23 <ehird> !bfjoust bugger1 >>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:04:24 <ehird> !bfjoust bugger2 >>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:04:27 <ehird> !bfjoust bugger3 >>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:04:30 <ehird> !bfjoust bugger4 >>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:04:33 <ehird> !bfjoust bugger5 >>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:04:34 <impomatic> !bfjoust ferret >(-)*9>(+)*9>---(>->+)*3((-)*10[+]>)*20
18:04:35 <EgoBot> Score for impomatic_ferret: 66.0
18:04:36 <ehird> !bfjoust bugger6 >>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:04:37 <nescience> ...lol wut
18:04:39 <ehird> !bfjoust bugger7 >>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:04:42 <ehird> !bfjoust bugger8 >>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:04:45 <ehird> !bfjoust bugger9 >>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:04:48 <ehird> !bfjoust bugger10 >>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:04:48 <nescience> what'd you say about being a dick? :P
18:04:51 <ehird> !bfjoust bugger11 >>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:04:54 <ehird> !bfjoust bugger12 >>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:04:57 <ehird> !bfjoust bugger13 >>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:05:00 <ehird> !bfjoust bugger14 >>>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:05:03 <ehird> !bfjoust bugger15 >>>>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:05:06 <ehird> !bfjoust bugger16 >>>>>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:05:09 <ehird> !bfjoust bugger17 >>>>>>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:05:12 <ehird> !bfjoust bugger18 >>>>>>>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:05:15 <ehird> !bfjoust bugger19 >>>>>>>>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:05:18 <ehird> !bfjoust bugger20 >>>>>>>>>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:05:21 <ehird> !bfjoust bugger21 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>--------------------------------------------------------------------------------------------------------------------------------[-]
18:05:26 <ehird> nescience: impomatic told me to :)
18:05:50 * ehird twiddles thumbs and waits for the report to update
18:06:06 <nescience> poor bot
18:06:36 <ehird> DOO DOO DOO DOO DEE DAA DOO DOO DOOOOOOO
18:06:39 * ehird pokes EgoBot
18:06:58 <ehird> nescience: technically, I have to submit them all infinite times to be sure of their tape lengths being correct
18:07:02 <ehird> since it's random
18:07:09 <ehird> so they'll probably all do awfully
18:07:30 <nescience> indeed
18:07:47 <ehird> BUT DAT'S OKAY
18:07:55 * ehird kicks EgoBot
18:07:57 <EgoBot> Score for ehird_bugger4: 22.4
18:07:57 <EgoBot> Score for ehird_bugger19: 5.7
18:07:57 <EgoBot> Score for ehird_bugger11: 18.3
18:07:57 <EgoBot> Score for ehird_bugger3: 40.9
18:07:57 <EgoBot> Score for ehird_bugger10: 4.8
18:07:58 <EgoBot> Score for ehird_bugger21: 5.3
18:08:00 <EgoBot> Score for ehird_bugger16: 7.4
18:08:02 <EgoBot> Score for ehird_bugger20: 0.0
18:08:04 <EgoBot> Score for ehird_bugger1: 29.4
18:08:04 <ehird> 40.9 for bugger3?
18:08:06 <EgoBot> Score for ehird_bugger13: 8.1
18:08:08 <EgoBot> Score for ehird_bugger17: 12.1
18:08:09 <ehird> That's pretty good, like.
18:08:10 <EgoBot> Score for ehird_bugger14: 6.9
18:08:11 <ehird> Guess I got lucky.
18:08:12 <EgoBot> Score for ehird_bugger8: 12.5
18:08:14 <EgoBot> Score for ehird_bugger12: 8.3
18:08:16 <EgoBot> Score for ehird_bugger15: 3.7
18:08:18 <EgoBot> Score for ehird_bugger9: 12.6
18:08:20 <EgoBot> Score for ehird_bugger18: 4.7
18:08:20 <ehird> nescience: look at the report
18:08:22 <EgoBot> Score for ehird_bugger7: 18.8
18:08:22 <ehird> quick
18:08:24 <EgoBot> Score for ehird_bugger6: 21.1
18:08:24 <ehird> before it trims them
18:08:26 <EgoBot> Score for ehird_bugger2: 42.2
18:08:27 <impomatic> Yeah, lucky score :-)
18:08:27 <ehird> http://codu.org/eso/bfjoust/report.txt
18:08:28 <EgoBot> Score for ehird_bugger5: 25.2
18:08:31 <ehird> hahaha
18:08:32 <ehird> it's huge
18:08:42 <ehird> :D
18:08:43 <ehird> they're all there
18:08:44 <nescience> haha
18:08:45 <nescience> nice
18:08:57 <ehird> 2343.678ehird_defend6_a_parody_or_just_plain_ripoff_question_mark.bfjoust
18:08:57 <ehird> 1342.1710ehird_bugger2.bfjoust
18:09:05 <ehird> i'd say that's pretty good!
18:09:15 <nescience> huh creep only has 4 losses now
18:09:19 <ehird> nescience: haha
18:09:23 <ehird> the power of buggery
18:09:39 <nescience> but ferret is at the top :P
18:09:42 <ehird> impomatic: is your ferret designed to be anti-bugger?
18:10:01 <nescience> i don't think anything can be anti-bugger
18:10:13 <ehird> nescience: it can, though
18:10:18 <ehird> it only decrements 128 times, then [-]s
18:10:22 <ehird> so, if you set your flag to 255
18:10:27 <ehird> it has to loop 128 iterations
18:10:33 <ehird> ofc, it'll still *win*
18:10:35 <ehird> it'll just win slower
18:10:41 <impomatic> Yes, I starting coding when you'd pasted the first two. Didn't take long.
18:10:43 <ehird> but correct, there is no way to actually beat it
18:10:48 <ehird> i dunno how buggers do with themselves
18:10:54 <ehird> ah
18:10:56 <ehird> they win at the same time
18:10:57 <ehird> cute
18:10:59 <ehird> = draw
18:11:05 <ehird> impomatic: how does yours work?
18:11:25 <ehird> nescience: note - this is in the ideal case, when their tape length is the expected one
18:11:39 <ehird> not that many got that
18:11:40 <ehird> if any even did
18:11:57 <ehird> nescience: in every other case, they just either: run right off the tape, or decrement a random cell
18:12:09 <ehird> nescience: I assume ferret sets a bunch of cells
18:12:11 <ehird> and then keeps them up
18:12:14 <ehird> so that it [-]s forever
18:12:19 <ehird> on a non-flag
18:13:10 <impomatic> ehird: just the usual build a decoy the go to the other end of the tape and start zeroing stuff
18:13:14 <ehird> right
18:14:12 <ehird> impomatic: submit ferret once more
18:14:14 <nescience> well it doesn't really matter
18:14:19 <ehird> and it'll trim most of them
18:14:20 <nescience> unless the tape length is correct they lose
18:14:32 <ehird> nescience: not if the other opponent suicides
18:14:52 <ehird> impomatic: it only leaves a lot of >10/11 challengers if they're submitted at once
18:14:52 <nescience> true enough i guess
18:14:55 <ehird> if you add ferret, it'll trim
18:15:53 <impomatic> !bfjoust shadow (>(-)*9)*2(>-)*7(>(+)*10[-])*20
18:15:59 <EgoBot> Score for impomatic_shadow: 58.0
18:16:13 <ehird> tada
18:16:15 <ehird> they're all gone
18:16:24 <ehird> and parody rises once ore
18:20:58 <nescience> laugh
18:21:08 -!- Corun has changed nick to Corun|away.
18:21:22 -!- Corun|away has changed nick to Corun.
18:21:56 -!- impomatic has left (?).
18:23:58 -!- AnMaster has quit (Connection timed out).
18:29:19 <nescience> it's really hard to read which number is which warrior
18:29:39 <nescience> and the numbers change because of the case sorting, too
18:29:57 <nescience> what's the chance of reiterating the numbers immediately to the left of the warrior names or something?
18:30:28 <ehird> would be nice
18:30:50 <ehird> nescience: i think I'm just going to make my own variant instead of waiting for these to change :)
18:31:03 <ehird> do you think I should have + or -? i.e. which?
18:32:27 <nescience> it doesn't really matter
18:32:30 <nescience> if you have to pick one, i mean
18:32:40 <ehird> i was asking purely on aesthetic concerns :)
18:32:46 <nescience> aha
18:32:51 <nescience> i like - better!
18:32:52 <ehird> - seems right
18:32:55 <nescience> it looks like arrows ------>
18:32:57 <nescience> CHARGE!
18:32:59 <ehird> as the main objective is to deplete your opponents flag
18:33:03 <ehird> nescience: haha
18:33:11 <pikhq> »»».
18:33:32 <nescience> arrows or ... jesus, i can't think of the name of the things you joust with!
18:33:40 <ehird> jousting sticks!
18:33:58 * pikhq should create a Brainfuck variant that uses », ›, and > for different things
18:34:07 <ehird> nescience: ok: < move pointer closer to my flag > move pointer closer to their flag - decrease cell at pointer [ jump after matching closer if cell=0 ] jump after matching opener if cell!=0 . nop
18:34:36 <nescience> lol jousting sticks
18:34:37 <ehird> nescience: i think flags should start at 255
18:34:44 <ehird> they only start at 128 in joust to make +/- not have an advantage
18:34:49 <nescience> correct
18:35:01 <nescience> but if you restrict it to only - it becomes about half as interesting
18:35:25 <ehird> nescience: no, I think - vs + is boring. see defend6 vs parody
18:35:32 <ehird> and my flipping of one of impomatics' did it to
18:35:33 <ehird> o
18:35:36 <ehird> it just makes it too trivial
18:35:40 <ehird> as programs become tailored to one
18:35:44 <ehird> and flipping them decimates them
18:36:17 <nescience> rather, it means that nobody has got to the point where they write programs to take account of both polarities for example :P
18:36:22 <nescience> lance!
18:36:24 <nescience> that's the word i wanted
18:36:36 <nescience> if you want to talk about trivial, what exactly are you going to write a program to do that only decrements?
18:36:46 <ehird> nescience: doesn't rushpolarity take into account that?
18:36:54 <ehird> i'm just not convinced it's an interesting aspect
18:37:19 * nescience shrugs
18:37:29 <ehird> nescience: then how about thingy's idea
18:37:35 <ehird> the polarity is flipped or not randomly before execution
18:37:37 <ehird> actually, wait
18:37:40 <ehird> same as with tape lengths
18:37:46 <ehird> we do it for all (tape length,polarity) combinations
18:37:51 <ehird> and take the mean
18:38:03 <ehird> i'm going to write it in C, so it should be fast enough for that
18:38:09 <ehird> nescience: sound good?
18:38:11 <nescience> that's a possibility
18:38:32 <nescience> i'm not sure how i feel about that, but it would at least get rid of the "swap the signs" bit
18:38:50 <nescience> i guess it is true that you'll get the same program if you swap them
18:39:22 <ehird> nescience: it forces you to take in account polarity, still
18:39:25 <ehird> without being able to just swap things
18:40:16 <nescience> i don't think so
18:40:26 <nescience> well, i guess i see what you mean
18:40:33 <nescience> in that you still can benefit from "figuring out" which way to go
18:40:54 <ehird> lifthrasiir: ehm, so north korea just said they're going to nuke the shit out of your country
18:40:58 <ehird> try not to die
18:41:12 <ehird> nescience: yeah
18:41:18 <ehird> nescience: you have to handle both +ers and -ers
18:46:50 -!- jix has joined.
18:47:38 <ehird> nescience: definitely, though, randomness is the bad
18:54:57 -!- AnMaster has joined.
18:57:50 -!- jix_ has quit (Read error: 110 (Connection timed out)).
19:08:46 -!- KingOfKarlsruhe has joined.
19:10:36 -!- sebbu2 has joined.
19:15:46 <ehird> OK, it's implementation time.
19:16:07 <nescience> that's totally out of character for them
19:16:12 <nescience> don't koreans play zerg?!
19:16:26 <ehird> BADUM TISH!
19:18:27 <AnMaster> <ehird> OK, it's implementation time. <-- of what
19:18:44 <AnMaster> (as you can see above I was disconnected)
19:18:44 <ehird> AnMaster: ~20 lines up.
19:18:54 <ehird> http://tunes.org/~nef/logs/esoteric/09.05.27
19:18:56 <ehird> You're welcome.
19:20:07 <AnMaster> ehird, a language based on magnetic tape?
19:20:17 <ehird> ...
19:20:37 <AnMaster> ehird, from reading ~20 lines up in the log :P
19:20:47 <ehird> Mmmmmmmmmmmmmmmmmmmmyeeeeeeeeeeeeeeeeeeeno.
19:22:59 <ehird> nescience: how many cycles do you think I should allow?
19:24:36 -!- sebbu has quit (Success).
19:25:19 <AnMaster> ehird, theory 2: a variant of bfjoust
19:25:27 * ehird clap. clap. clap
19:25:33 <ehird> You found the page up button!
19:25:49 -!- ais523 has joined.
19:25:53 <ehird> hi ais523
19:25:56 <AnMaster> hello ais523
19:26:03 <ehird> I'm plotting revolution by writing a better bf joust ;)
19:26:06 <ais523> hello ehird, AnMaster
19:26:11 <ais523> ehird: as in, better rules, or better interp?
19:26:14 <ehird> ais523: both
19:26:16 <ais523> the interp can definitely be improved
19:26:29 <ehird> it's varying randomly according to tape length [implementation issue], just flipping +/- can change the hill wildly [design issue]
19:26:35 <ais523> but if you want to improve the rules, /please/ do it a different way from zzo38
19:26:36 <ehird> and it's really slow [implementation]
19:26:53 <ehird> for the former, run all tape lengths and take the average (requires fixing #3)
19:27:02 <ehird> for the latter, add another variable: is_plus_and_minus_flipped
19:27:05 <ehird> and do the solution to #1 for it too
19:27:09 <ais523> oh, ok
19:27:13 <ehird> for the latter latter, write it in C and make it superfast
19:27:14 <ais523> so you aren't changing the language rules, but the tournament rules
19:27:19 <ais523> I agree with you on that
19:27:23 <ehird> ais523: well, the flipping +/- thing
19:27:35 <ais523> either you randomly flip one program, or you don't
19:27:36 <ehird> means that you can't just rip off someone else's program, flip +/- and dominate the hill
19:27:41 <ehird> ais523: actually, no
19:27:45 <ehird> well, yes
19:27:48 <ehird> ais523: but not randomly
19:27:53 <ehird> ais523: just like how you try all tape lengths and take the averag
19:27:54 <ehird> e
19:27:54 <ais523> do both
19:27:58 <ehird> exactly
19:28:05 <ehird> try every combination, take the average score
19:28:13 <ehird> that means the same program will always have the same score
19:28:55 <ehird> ais523: how did zzo do it?
19:29:25 <ais523> ehird: having , read from the opponent's . output
19:29:28 <ais523> and a couple of other dubious changes
19:29:38 <ehird> ais523: that change is very zzo
19:29:41 <ehird> link to his variant?
19:29:47 <ais523> ehird: http://esolangs.org/wiki/Talk:BF_Joust
19:29:57 <ehird> grr, wiki seems to be slow
19:30:09 <ehird> ais523: btw, you know how it has to stay 0 for two cycles?
19:30:12 <ais523> yes
19:30:21 <ehird> that means that [-] works if it isn't tampered with. [-]-]-]-(it's zero)](two cycles)
19:30:23 <ehird> is that intentional?
19:30:27 <ehird> i suppose so
19:30:33 <ehird> but it was unintuitive to me at first
19:30:36 <ehird> and I did [-].
19:30:38 <ais523> not quite, but when I noticed I realised it was correct, so didn't change it
19:30:39 <ehird> (with the dot)
19:30:48 <ehird> Safari can’t open the page “http://esolangs.org/wiki/Talk:BF_Joust” because the server unexpectedly dropped the connection. This sometimes occurs when the server is busy. Wait for a few minutes, and then try again.
19:30:52 * pikhq observes that [-]-] is an infinite loop
19:31:00 <ais523> pikhq: not in BF Joust
19:31:11 <ehird> pikhq: i'm counting cycles
19:31:11 <pikhq> ... WTF?
19:31:15 <ais523> there is no way to write a definitively 100% infinite loop in BF Joust
19:31:18 <ehird> [-] runs [-]-]-]-]-]-]-]
19:31:23 <ehird> pikhq: not program
19:31:24 <ehird> cycles
19:31:27 <ais523> because the data on the tape might change due to the opponent messing with it
19:31:32 <ehird> [ ticks, - ticks, ] ticks, - ticks, ] ticks
19:31:33 <ehird> etc
19:31:40 <ehird> also, what ais523 said
19:31:48 <ehird> ais523: [[In case of a draw, figure out who would have lost using the old rule that whoever's flag is zero loses immediately (and determine the winner according to this rule). ]]
19:31:50 <ehird> ok, that's just ridiculous
19:31:55 <ehird> [[If both programs have ended and neither player's flag is zero, then both programs shall restart from the beginning with the tape pointer pointing to their own flag again like it was at the start, but using the current values on the tape instead of resetting them to zero. ]]
19:31:57 <ehird> so's that
19:32:02 <ehird> all of them are ridiculous :)
19:32:06 <ais523> agreed
19:32:15 <ehird> ais523: how could you even use ,/.
19:32:18 <ehird> you couldn't use it to your advantage
19:32:22 <ehird> because your opponent would always lie
19:32:30 <ais523> ehird: I don't think they'd even be lying
19:32:34 <ehird> oh?
19:32:41 <ais523> given that there's no information as to what the random stream of data means anyway
19:32:45 <ehird> true
19:32:55 <ais523> it's like, if I say 6 202 34, am I lying?
19:33:03 <ehird> ais523: Mu
19:33:20 <ehird> [[[ and ] should take the value on the tape *after* the opponent has (potentially) modified it.]
19:33:21 <ehird> ]
19:33:26 <ehird> ais523: does it do it before modification?
19:33:30 <ais523> atm, yes
19:33:30 <ehird> two opcodes running at once is sticky
19:33:34 <ais523> it takes the value at the start of the cycle
19:33:37 <ehird> hmm
19:33:53 <ais523> I experimented with before and after
19:34:00 <ehird> ais523: ah, and before worked better?
19:34:07 <ais523> and decided that although it made a difference, it didn't fundamentally change the nature of things
19:34:12 <ais523> so left it where Kerim had it
19:34:23 <ehird> http://esolangs.org/w/index.php?title=Byte_Syze&curid=2347&diff=14541&oldid=14540
19:34:26 <ehird> lol wat
19:34:31 <pikhq> !bfjoust foo .[+.]
19:34:37 <EgoBot> Score for pikhq_foo: 17.5
19:34:41 <ehird> pikhq: that's just a suicider
19:34:43 <ehird> a slow one at that
19:34:48 <ehird> well, not always
19:34:52 <pikhq> Seems to be effective.
19:34:58 <ehird> but I don't think any program will try and give your flag viagra— what?
19:35:00 <ehird> How is that effective?
19:35:11 <pikhq> It has a positive score. :p
19:35:12 <ehird> if we weren't caching scores, the top program gets ~85pts
19:35:16 <ehird> pikhq: all scores are positive
19:35:17 <ais523> pikhq: we changed the scoring
19:35:19 <ehird> points are negative
19:35:21 <ehird> scores not
19:35:21 <pikhq> Oh.
19:35:25 <ais523> 50% is average, 0% is terrible, 100% is perfect
19:35:49 <ehird> ais523: i submitted (>)*N(-)*128[-] (but manually expanded) for all possible tape lengths today
19:35:54 <pikhq> !bfjoust [>+]
19:35:54 <ehird> one even got ~40-something
19:35:55 <EgoBot> Use: !bfjoust <program name> <program>
19:35:57 <ehird> :-D
19:36:01 <pikhq> Erm.
19:36:03 <pikhq> !bfjoust foo [>+]
19:36:04 <EgoBot> Score for pikhq_foo: 20.5
19:36:04 <ehird> ais523: also, btw
19:36:08 <ehird> if you resubmit a program
19:36:10 <ehird> you get its last score
19:36:15 <ehird> you have to look at the report to get the proper one
19:36:15 <ais523> another bug?
19:36:18 <ehird> yep
19:36:21 <ais523> ah, ok
19:36:23 <ehird> ais523: why do you think i'm writing my own :)
19:36:31 <ehird> ais523: also, well, taking the value at the start requires copying
19:36:33 <ehird> doesn't it?
19:36:35 <ehird> well
19:36:39 <ehird> i guess no
19:36:39 <ehird> since
19:36:42 <ehird> with after-modification
19:36:45 <ehird> you have to wait for your opponent
19:36:48 <ehird> which is just as much fuss
19:36:54 <ais523> it only requires copying for one of the programs
19:36:58 <ais523> and it's as much fuss both ways round
19:37:08 <ehird> yep
19:37:15 <ais523> you could order the execution of the programs inside the interp in the way that avoids copying, but that's even fussier in other ways
19:38:28 <ehird> ais523: do you think I should keep the 20k max cycles?
19:38:46 <ais523> that's about right
19:38:50 <ehird> it may take 3s to execute one combination for 20k cycles in your perl interp, but it'll probably be on the order of milliseconds for mine :)
19:38:51 <ais523> I determined that number via experiment
19:39:04 <ais523> as in, if you make it much lower, valid programs start drawing rather than winning
19:39:11 <ehird> but then we have the reverse polarity
19:39:13 <ehird> which is 3-bits:
19:39:19 <ehird> 0 (no flip), 1 (flip left), 2 (flip right)
19:39:22 <ehird> hmm
19:39:28 <ehird> is that 20**3 for the tape lengths and polarity
19:39:31 <ehird> or 3**20?
19:39:33 <ehird> 20**3, I think
19:39:58 <ehird> ais523: hm, oh dear
19:40:07 <ehird> for all tape length combinations, and the three polarity states,
19:40:16 <ais523> why three polarities?
19:40:16 <ehird> ais523: is 8000 executions per (prog1,prog2)
19:40:18 <ais523> you only need two
19:40:21 <ehird> also
19:40:24 <ehird> ais523: no i don't
19:40:25 <ehird> no flip,
19:40:25 <ais523> because flipping either program has the same effect
19:40:30 <ehird> er, are you sure?
19:40:31 <ais523> and flipping both has the same effect as flipping neither
19:40:31 <ehird> always?
19:40:44 <ais523> ehird: the values at the start are either 128 or 0
19:40:46 <ehird> hmm, i'll take your word for the left-is-right
19:40:53 <ehird> ais523: yeah, you're right
19:40:55 <ehird> ais523: but...
19:40:58 <ehird> which of left/right should I flip?
19:41:00 <ehird> i don't wanna be biased :D
19:41:05 <ais523> it makes no difference to the result
19:41:18 <ehird> 0 = no flip, 1 = flip, the
19:41:18 <ehird> n
19:41:36 <ais523> and you need 20 * 2 (no exponentiation)
19:41:39 <ais523> well, 21 * 2
19:41:44 <ehird> oh, heh
19:41:47 <ais523> each of the 21 possible lengths in each of the 2 flip states
19:41:55 <ehird> i'll finish the message I was typing anyway:
19:42:00 <ehird> ais523: well, that's good; with 3 flip states, I have to run the match 8000 times— so if I take 25ms to run one iteration, that's 200 seconds!
19:42:02 <ehird> ↑ disclaimer: wrong
19:42:45 <ais523> 200 seconds would be a bit slower than it currently is; OTOH, you'd have a fairer tournament
19:42:47 <ehird> ais523: OK, if I take 25ms to run one iteration (reasonable, I think) and do all 21 tape lengths, and have 2 polarity states, a match will take 1.05 seconds
19:42:58 <ehird> a full complete matchup of (prog1,prog2)
19:43:33 <ehird> ais523: err, for 10 programs, you have how many pairs of (prog1,prog2)? my brain is in coding mode atm...
19:44:12 <ais523> (10*9)/2 = 45
19:45:00 <ehird> ais523: so, assuming I do no caching whatsoever, and have a 10-length hill (one less than the current hill; it's 0-10, I guess as a mistake) then it'd take 47.25 seconds to run all matches
19:45:08 <ehird> fairly and deterministically, on every combination of tape length/polarity
19:45:10 <ehird> that's not bad at all
19:45:14 <ehird> and with some caching..
19:45:16 <ehird> *...
19:45:39 <ais523> with some caching, you only need to run the 9 matches involving the current challenger
19:45:42 <ais523> but I don't think that is a mistake
19:45:50 <ais523> the hill atm is 10 returning programs, plus 1 newbie
19:45:54 <ehird> ah
19:45:56 <ehird> that makes sense
19:46:31 <ehird> ais523: so 51.45 seconds then
19:46:33 <ehird> + caching
19:46:47 <ehird> ais523: 9.45 seconds, then, with caching
19:46:51 <ehird> for a challenger
19:46:58 <ehird> ais523: hmm... do you think 25ms for a match is over or underestimating?
19:47:00 <ehird> i'm not sure
19:47:02 <ais523> are you going to pre-expand programs? or expand on the fly to save memory?
19:47:13 <ais523> some of them are likely to get very long with abbreviations removed
19:47:27 <ehird> ais523: i don't care about memory usag
19:47:27 <ehird> e
19:47:33 <ehird> ais523: how long's defend6 expanded?
19:47:39 <ehird> not more than a few kilobytes, I'd wager
19:48:02 <ais523> yep, defend5 is possibly quite long though
19:48:20 <ehird> ais523: megabytes?
19:48:28 <ehird> codu.org runs on a VPS with 1GB of RAM
19:48:30 <ais523> probably not
19:48:37 <ehird> i'm sure a few megabytes is just fine
19:48:50 <ais523> but the reason I didn't expand is that the way I programmed my interp, I'm O(n) below the optimum
19:48:59 <ais523> so it's like I wrote a Mathematica program rather than a C program
19:49:10 <ais523> you can make each cycle run in O(1) time, though, so the length of the program isn't an issue
19:49:26 <ehird> ais523: I'm probably going to have a trivial optimization step
19:49:31 <ehird> ++++++++++++++++++ -> +*foo
19:49:33 <ehird> nothing fancy at all
19:49:40 <ehird> although, wait
19:49:44 <ehird> ais523: you know your (x)*foo thing?
19:49:47 <ehird> it doesn't change cycles, does it?
19:49:47 <ais523> yes
19:49:50 <ais523> and no
19:49:51 <ehird> you said it makes the program "run faster"
19:49:53 <ais523> it's strictly abbreviations
19:49:55 <ehird> i guess that's just interp time
19:49:57 <ais523> it makes the interp run faster
19:49:59 <ehird> ais523: ok, I won't do any optimization at all
19:50:01 <ais523> in realtime
19:50:03 <ehird> it's simplest
19:50:09 <ais523> rather than the program in gametime
19:50:11 <ehird> after all, a cycle will probably take a fraction of a millisecond
19:52:25 <ehird> okay then, time to write the interpreter loop
19:54:33 <ehird> ais523: are you sure, by the way, that 20 is a good variation in tape length?
19:54:37 <ehird> I would go for 10 max
19:54:42 <ehird> otherwise, strategies are too unpredictable
19:55:00 <ehird> IMO tape length variation should just stop the lame strategy of (>)*constant mwahaha i'm at the opponent's flag!
19:55:08 <ais523> ehird: I was wondering about that
19:55:20 <ais523> I definitely want to keep the tape length shorter than 32
19:55:25 <ais523> and I wanted the chance of a very short tape
19:55:34 <ais523> but maybe 10-20, or even 10-15, would be a better variation
19:55:38 <ehird> ais523: also, with the averaging of tape lengths I'm doing, there doesn't need to be enoguh variation
19:55:43 <ehird> ais523: I'd go for 15-25
19:55:53 <ehird> 15 is just long enough to not be stuffy
19:56:01 <ehird> and 25 is just short enough not to be massive
19:56:12 <ais523> the idea is that an aggressive program starting >>>>>>>>>>> should be able to arrive before the opponent completes a complex decoy
19:56:15 <ais523> at least some of the time
19:56:40 <ehird> eh, I'll just keep 10-30
19:56:58 <ehird> ais523: btw, how come it's 21 possibilities?
19:57:04 <ais523> 10-30 inclusive
19:57:17 <ehird> oh, ofc
19:57:23 <ehird> #define MAX_CYCLES 20000
19:57:23 <ehird> #define MIN_TAPE_LENGTH 10
19:57:25 <ehird> #define MAX_TAPE_LENGTH 30
19:57:27 <ehird> configurability!
19:58:20 <ehird> ais523: is \0 a valid char? :P
19:58:36 <ais523> ehird: if it were, it would be a comment
19:58:43 <ais523> I'd say that if you encounter a \0, treat it as a comment
19:58:50 <ais523> but don't expend effort to make sure it doesn't get eaten before then
19:58:51 <ehird> ais523: C byte arrays, yo.
19:59:05 <ehird> I'll just let it be the end of the string like normal, nobody's gonna use it.
19:59:11 <ais523> or you can just strip out the \0s when loading the program, if oy ucare
19:59:13 <ais523> *you care
19:59:23 <ehird> not particularly
19:59:37 <ehird> ais523: how many nested loops do you think there might be?
19:59:48 <ais523> defend5 has several thousand
19:59:55 <ais523> using a ({})% expansion
19:59:56 <ehird> ais523: hmm
20:00:04 <ehird> ais523: is the C stack that big, d'you think? :)
20:00:13 <ais523> probably, it depends on your OS
20:00:22 <ais523> on Windows, the default stack is exactly 1 MiB, I think
20:00:25 * ehird runs a simple test program
20:00:26 <ais523> I'm not sure what it is on Linux
20:03:24 * ehird runs stack-user
20:03:33 <ehird> ais523: on OS X, it's many millions so far
20:04:23 <ehird> hmm
20:04:30 <ehird> maybe gcc removed the tail recursion
20:04:32 * ehird uses the result to make sure
20:04:34 <Deewiant> How about running 'ulimit -s'?
20:04:59 <ehird> 8192, which is surprisingly small. But Deewiant, I want to know how many calls, on average.
20:05:03 <ehird> Not the actual size.
20:05:14 <Deewiant> Just find out the size of your stack frame?
20:05:19 <ehird> How boring
20:05:24 <Deewiant> Also, that's in kilobytes
20:05:28 <Deewiant> So it's 8x the Windows size.
20:05:43 <ehird> yes
20:06:08 <ehird> ais523: does lostkng have more nesting than defend5, do you think?
20:06:16 <ehird> also,
20:06:16 <ais523> probably not
20:06:17 <ehird> 943219
20:06:17 <ehird> zsh: segmentation fault ./lance
20:06:20 <ehird> int stack_size(int i)
20:06:21 <ehird> {
20:06:23 <ehird> int foo = i;
20:06:25 <ehird> printf("%i\n", foo);
20:06:27 <ehird> return foo + stack_size(i+1);
20:06:29 <ehird> }
20:06:31 <ehird> so I should be fine
20:06:45 <ais523> lostkng doesn't seem to nest deeply
20:06:47 <pikhq> 261842 stack calls on my system.
20:07:01 <ehird> ais523: lostkng's bundled interp uses recursion to parse loops, y'see
20:07:04 <ehird> I'm just wondering if that's wise
20:07:09 <ais523> gcc-bf nests a lot more, it's a bit deeper than 256
20:07:15 <ais523> wait, 256*3
20:07:18 <ais523> on a sufficiently long program
20:07:24 <ais523> because it uses nested loops to do switch statements
20:08:02 <pikhq> Millions and counting with -Os.
20:08:28 <ehird> pikhq: it may have optimized it into a loop
20:08:38 * pikhq will laugh if it craps out at INTMAX.
20:08:54 <pikhq> ehird: I bet it did at this rate.
20:09:10 <ehird> i suppose the loop's smaller than the recursion
20:09:22 * pikhq does -S and looks at the generated assembly
20:09:48 <ehird> Hmm.
20:10:08 <ehird> ais523: going through an array's likely to be more efficient than traversing a linked list, isn't it?
20:10:21 <ehird> (I'm thinking about speed upfront because of the large number of combinations I have to run each program through)
20:10:33 <ais523> hmm, let me think
20:10:38 <pikhq> It got optimized into a silly loop.
20:10:40 <ais523> they're both O(1)
20:10:52 <ehird> ais523: not efficiency, speed
20:10:56 <ehird> pikhq: heh, translate the loop to C?
20:10:57 <ais523> so it depends on the individual opcodes
20:10:59 <ehird> *to C
20:11:12 <ehird> ais523: well, I'm thinking about, e.g. the cache
20:11:13 <ais523> taking the next list element involves dereferencing a pointer
20:11:19 <ehird> ais523: a linked list won't be together in memory
20:11:26 <ehird> so jumps will be further away
20:11:27 <ais523> ehird: could be, depending on how it's allocated
20:11:29 <ehird> an array is all clumped together
20:11:32 <ais523> but it's going to take up more memory
20:11:34 <ehird> ais523: could be, but isn't guaranteed to be
20:11:36 <ais523> so less will fit in the cache
20:11:38 <ehird> that also
20:11:40 <ais523> so I suspect the array will be faster
20:11:56 <pikhq> void stack_test(int i){while(1)printf("%i", i++);}
20:12:08 <ais523> also, you can use a posix_foo function to tell the memory manager that you're about to read a load of memory sequentially
20:12:14 <ehird> pikhq: that doesn't include a return value
20:12:21 <ehird> which is what I did to attempt to force some recursion
20:12:21 <ais523> maybe even vectorise it!
20:12:26 <ehird> ais523: hahahahahano.
20:12:27 <pikhq> Ahah.
20:12:33 <ehird> _posix_fadvise
20:12:41 <ehird> yeah without a _
20:12:42 <ehird> whatever :P
20:14:24 <ehird> hmm
20:14:35 * ehird thinks of names for + and - that don't relate to adding and subtracting, due to polarity issues
20:14:40 <ehird> dink and donk‽
20:14:52 <ais523> clockwise and anticlockwise
20:15:06 <ehird> ais523: but... that doesn't even make any sense :D
20:15:11 <ais523> it does
20:15:16 <ais523> because it's using modular arithmetic
20:15:19 <ehird> heh
20:15:22 <ais523> the numbers form a circle, not a numberline
20:15:27 <ehird> [+]--+- "Loop dink end loop donk donk dink donk"
20:15:37 <ehird> ais523: but if they're flipped, it'll be anticlockwise and clockwise
20:15:43 <ehird> I want them to not require flipping when...flipped
20:15:47 <ehird> as it's not flipping, just two different views
20:15:48 <ehird> equal
20:17:21 <ehird> ais523: no?
20:17:51 <ais523> well, clockwise/anticlockwise depends on which end of the tape you're looking from
20:18:00 <ehird> true.
20:18:04 <ais523> but the problem is, with one polarity, one program's dink will be the other program's donk
20:18:11 <ais523> with the other, they'll both dink the same way
20:18:12 <ehird> ais523: nope, wrong
20:18:16 <ehird> dink doesn't mean any particular way
20:18:17 <ehird> it just means dink
20:18:18 <ehird> same with donk
20:18:21 <ais523> ehird: agreed
20:18:24 <ehird> add, however, is presumably adding
20:18:27 <ais523> but are you altering the programs when altering the polarity?
20:18:28 <ehird> which would be false under other polarities
20:18:30 <ehird> ais523: nope
20:18:38 <ehird> ais523: the point is, it's defined as:
20:18:47 <ais523> ehird: well, either one program's dink cancels out the other program's donk, or it doesn't
20:18:52 <ehird> + If polarity is floob, increment. If polarity is boolf, decrement.
20:18:54 <ais523> in one polarity, it does; in the other; it doesn't
20:18:58 <ehird> so it's always dink/donk
20:19:29 <ais523> the point is, changing the polarity has to reverse the meanings of +/- for exactly one program
20:19:45 <ehird> ais523: the meanings don't change
20:19:51 <ehird> the definitions of the operations change
20:20:00 <ais523> well, ok
20:20:01 <ehird> ais523: that's like saying that the meaning of [ is reversed if the cell is zero
20:20:06 <ais523> reverse the definitions for exactly one program
20:20:07 <ehird> it's not; that check is part of the operation and doesn't change
20:20:14 <ehird> no definition, meaning or anything
20:20:21 <ehird> just a conditional in its definition always evaluates one w ay
20:20:22 <ehird> *way
20:21:15 <ais523> ok
20:21:26 <ais523> just bear in mind, that with one polarity, dink in program 1 will do the same thing as dink in program 2
20:21:33 <ehird> yes
20:21:35 <ais523> with the other polarity, dink in program 1 will do the same thing as donk in program 2
20:21:40 <ehird> ais523: i'm really just trying to be nice to the names dink/donk as they sound funny
20:21:43 <ais523> ok
20:21:55 <ehird> you may end up convincing me to use clockwise/counterclockwise instead, though :P
20:22:01 <ehird> bikesheds hooray
20:22:06 <ais523> nah, dink/donk is shorter
20:22:10 <ehird> very true
20:22:24 <ehird> ais523: > is march, < is retreat
20:22:37 <ais523> heh, that sounds about right
20:23:24 <ehird> . is rest
20:23:35 <ehird> hmm
20:23:41 <ehird> ais523: [ = consider, ] = reconsider? :P
20:23:47 <ehird> just trying to go for an intercal vibe :)
20:23:59 <ais523> that's quite a vibe
20:24:18 <ehird> hmm
20:24:45 <ehird> ais523: it doesn't really reflect the jumpyness of it, though, does it?
20:25:21 <ais523> does it need to?
20:25:31 <ehird> not particularly
20:25:35 <ehird> i'm trying to come up with a military analogist
20:25:38 <ehird> *analogy
20:25:48 <ehird> ] = ONE_AND_A_TWO_AND_A is a bit too long.
20:28:51 <ehird> ais523: advantage of linked list— easier to mark end of program
20:28:54 <ehird> wait, no
20:29:07 <ehird> just {a,b,c,NULL}
20:29:12 <ehird> or the like
20:29:25 <ehird> OP_EOF
20:31:26 <ehird> ais523: Polarities: sieve, kettle.
20:33:49 <ais523> fair enough
20:34:15 -!- Gracenotes has joined.
20:34:49 <nescience> ehird, i was just thinking that if you do the swapping thing,
20:34:55 <nescience> that's 4 * 20 fights per pair
20:34:58 <nescience> if you do every combination
20:35:03 <ehird> nescience: nope
20:35:03 <ehird> 2
20:35:04 <nescience> ... but, effectively, you only need to do 2
20:35:08 <nescience> 'cause the others would be equivalent
20:35:13 <ehird> nescience: ais523 told me this ages ago :)
20:35:14 <nescience> ... yeah, so i guess you already did that :>
20:35:16 <ehird> i had none, left, both
20:35:17 <nescience> hehe
20:35:20 <ehird> er
20:35:21 <ehird> none, left, right
20:35:24 <ehird> but ais523 told me left=right
20:35:26 <nescience> i'm not reading, just occurred to me to mention it
20:35:26 <ehird> so, yeah
20:36:36 -!- olsner has joined.
20:37:49 <nescience> (i guess it's actually *21)
20:37:54 -!- MizardX has quit ("Dead pixels in the sky.").
20:37:55 <ehird> yep
20:37:59 <nescience> anyway, this is technically my work computer so i'm sporadic :P
20:38:09 <nescience> you should get super tricky and run all of them in parallel!
20:38:10 <nescience> hehe
20:38:14 <ehird> lawl
20:38:30 <ehird> nescience: iirc, codu only has one virtual cpu
20:38:39 <ehird> so that wouldn't help too much
20:38:43 <ehird> locally, though...
20:40:23 <ehird> "In January 2003, the toothbrush was selected as the number one invention Americans could not live without, beating out the automobile, computer, cell phone, and microwave oven, according to the Lemelson-MIT Invention Index.[4]"
20:41:24 <ehird> ais523: grr, variadic macros are C99 aren't they?
20:41:30 <ehird> and gnuc89
20:42:00 <ais523> yes
20:42:03 <ehird> darn
20:42:08 <ais523> although, you can often have the same effect by using a second pair of parens
20:42:10 <ais523> even in C89
20:42:13 <ehird> yes
20:42:18 <ais523> because (a,b) is one param to a macro
20:42:21 <GregorR-L> ehird: This is the USA, not Britain.
20:42:43 <ehird> GregorR-L: in britain we never use toothbrushes
20:42:50 <ehird> as evidenced by our TERRIBLE BRITISH ORAL HYGIENE
20:42:51 <ehird> HA HA HA
20:43:22 <GregorR-L> I used to believe that was just a stereotype, until I went there on vacation :P
20:43:44 <ehird> i am constantly amazed that people actually go here voluntarily
20:43:49 <ehird> it's... not an exciting country
20:43:53 <nescience> stereotypes are usually based in fact
20:43:59 <nescience> i found the same thing about canadians and "eh"
20:44:25 <ehird> nescience: correct, you blond black homosexual. quick, be blackface, dumb and feminine!
20:44:51 <nescience> if you think about it though, stereotyping is a pretty critical function of the human brain
20:45:09 <ehird> yes
20:45:09 <nescience> imagine if you tried to be politically correct and assume that no ALL bears will maul you if you punch them in the face
20:45:10 <nescience> :P
20:45:10 <GregorR-L> More accurately, categorization is critical, stereotyping is the unfortunate result of categorization.
20:45:21 <ehird> i'm pretty sure political correctness only applies to humans
20:45:27 <GregorR-L> ehird: Not true.
20:45:33 <ehird> o rly
20:45:52 <GregorR-L> Be kind to animal rights activists, they're people too! (And therefore other animals are people by proxy)
20:46:24 <ehird> GregorR-L: It was fine until the parenthical, which is bullshit.
20:46:32 <GregorR-L> :P
20:48:06 <ehird> ais523: nescience: Hokey dokey, interpreter loop time.
20:48:37 <ehird> warrior_id_t run_match(ins_t *a, ins_t *b, polarity_t polarity, int tape_length). Maybe I need 7 more parameters.
20:49:04 <ehird> ais523: (a,b)=(b,a) matchup in your interp, right?
20:49:26 <ais523> ehird: yes
20:49:31 <ehird> right.
20:49:34 <ais523> and a program against itself always draws
20:49:59 <ehird> ais523: draws have no effect on anything, right?
20:50:08 <ehird> apart from draw count...
20:50:13 <ais523> I don't know how that scoring system works
20:50:16 <ehird> ais523: do you special-case that, btw? it seems like it may be quicker just to run it against itself
20:50:17 <ais523> I wrote the interp, not the scorer
20:50:30 <ais523> you'll need to ask GregorR about tournament infrastructure
20:50:58 <ehird>
20:51:43 <ehird> ais523: pingeriffic
20:52:14 <ais523> ehird: as I said, I don't know
20:52:19 -!- tombom_ has joined.
20:52:21 <ehird> 20:50 ehird: ais523: do you special-case that, btw? it seems like it may be quicker just to run it against itself
20:52:26 <ehird> ais523: that's part of your interp is it not?
20:52:28 <ehird> or?
20:52:38 <ais523> I don't check for both programs being identical
20:52:41 <ehird> ah
20:52:42 <ehird> OK
20:52:44 <ais523> I thought you meant, checking for the same filename
20:52:47 -!- MizardX has joined.
20:52:54 <ehird> I don't think GregorR's tournament driver pits programs against themselves, since they get spaces
20:52:58 <ehird> instead of 0s (= draw)
20:53:29 <GregorR-L> Yeah
20:54:16 <GregorR-L> http://codu.org/eso/fyb/SCORES <-- score system
20:58:11 -!- tombom has quit (Read error: 60 (Operation timed out)).
20:58:12 -!- tombom_ has changed nick to tombom.
20:59:08 <nescience> GregorR-L: well, if you categorized but didn't act on it, it'd be afwul useless, wouldn't it? :P
21:01:33 <GregorR-L> nescience: Categorizing is dividing people into groups, stereotyping is taking properties of some part of the group and blindly applying them to the entire group. Saying "All black people have dark skin" is categorization, since that's the definition of the category, saying "All black people steal cars" is stereotyping.
21:04:51 <ehird> Stereotyping is prescribing to a group a property that is not inherent to it.
21:05:03 <ehird> "All black people have dark skin" → having dark skin is inherent in being black
21:05:18 <ehird> "All people who steal cars steal vehicles" → again, inherent
21:05:23 <ehird> "All black people steal cars" → not
21:05:50 <GregorR-L> I believe that's what I just said.
21:06:08 <ehird> GregorR-L: "stereotyping is taking properties of some part of the group and blindly applying them to the entire group"
21:06:11 <ehird> not the same definition
21:06:17 <ehird> mine is more rigorous and precise
21:06:58 <GregorR-L> I guess stereotyping can be based on properties that apply to nobody, like "All black people have antennae" or "All Jewish people came from the Mother Ship"
21:07:12 <ehird> :-D
21:07:30 <ehird> GregorR-L: "All Jewish people control the banks and are part of the New World Order" would be more of a real-world example
21:07:52 <GregorR-L> The first part is an example of my definition :P
21:08:48 <ehird> Yes.
21:08:50 <ehird> So's mine
21:08:57 <ehird> [[Fabian Escalante, who was long tasked with protecting the life of Castro, estimated the number of assassination schemes or attempts by the CIA to be 638. Some such attempts allegedly included an exploding cigar, a fungal-infected scuba-diving suit, and a mafia-style shooting.]]
21:09:45 <nescience> stereotypes that are nonsensical, unless they are a joke i guess, are not going to arise
21:10:20 <nescience> it's more like applying an observed link to the whole
21:10:30 <nescience> but it's considered "rude" if the observed link is negative :P
21:10:41 <ehird> nescience: feel free to observe a Jew new world ordering
21:10:46 <ehird> i'll wait here
21:11:28 <nescience> lol.
21:11:39 <nescience> i have observed no links between jews and conspiracy theories, sadly :P
21:11:53 <nescience> you're not likely to catch hell if you say something like "damn, latinas are sexy!"
21:11:56 <nescience> but it's equally a stereotype
21:11:57 * nescience shrugs
21:12:16 <ehird> ais523: how many nested loops does defend5 have again?
21:12:38 <ais523> I think it's a bit over 2000
21:12:43 <nescience> "as a female member of latin descent, i am offended by your assertion that i must be sexy! take that back right now!" :>
21:14:34 <ais523> sometimes I fly around in a spaceship...
21:14:36 <nescience> anyway uhh, back to brainfuck? :P
21:14:43 <ehird> ais523: :>
21:14:53 <ehird> ROCKET OR SMILEY YOU THE PUBLIC DECIDE
21:17:07 <ehird> aaaaaaaargh
21:17:19 <ehird> my c function needs to return a tuple, now i have to pass a pointer
21:17:20 <ehird> phooey :)
21:19:49 -!- M0ny has quit ("Read error: 182 (Connection reset by beer)").
21:22:07 <ehird> ais523: why are syntactically invalid programs admitted, btw
21:22:07 <ehird> ?
21:22:10 <ehird> I'd just drop them,
21:22:14 <ehird> s/,$//
21:22:31 <ais523> ehird: I exit with an error message, I think
21:22:37 <ais523> but the tournament infrastructure doesn't notice
21:22:43 <ehird> ais523: well, ] treats it all as draws
21:22:49 <ais523> yes
21:22:55 <ais523> it's interpreting the error as a draw
21:22:59 <ehird> ah
21:23:28 <ehird> you know you need to restructure when [[fprintf(stderr, "Unmatched ] in %s.\n", filename);]] ends up at column 91
21:29:39 <nescience> re: the scoring system
21:29:56 <nescience> you use the points for a program in calculating the points for a program
21:30:03 <nescience> how exactly does that work?
21:30:11 <ehird> nescience: points for score, no?
21:30:17 <ehird> or score for score
21:30:27 <nescience> The base score of any given program is the sum of:
21:30:29 <nescience> * The values for the programs which it defeated as defined above.
21:30:32 <nescience> * Half the values for the programs that it tied with as defined above.
21:30:46 <nescience> which means, the first time you submit the program, it gets a better score than afterwards
21:30:59 <ehird> nescience: it removes the program you submitted before running
21:31:00 <ehird> I'm pretty sure
21:31:01 <nescience> since afterwards, whatever programs it defeated are going to have less score
21:31:21 <nescience> but it doesn't recalculate scores for everything on the hill?
21:31:27 <nescience> or rather, i thought that's what the cache thing was about
21:31:33 <GregorR-L> It caches wins, not scores.
21:31:38 <GregorR-L> It always recalculates the scores.
21:31:40 <nescience> i see
21:31:46 <nescience> but then...
21:31:54 <nescience> how do you calculate how many points ANY warrior has
21:31:58 <nescience> even if you remove the new entrant
21:32:13 <nescience> each time you recalculate the score of a given pre-existing warrior, its score is still dependent..?
21:32:28 <GregorR-L> Run it against every program currently on the hill, using the cache instead when available.
21:32:34 <AnMaster> I have an issue
21:32:40 <ais523> AnMaster: what with?
21:32:43 <GregorR-L> The score will change with every run, as it is hill-dependent.
21:32:44 <nescience> sure, that gives you wins/losses
21:32:46 <AnMaster> a good image format
21:32:48 <AnMaster> for something
21:32:50 <AnMaster> to be specific
21:32:51 <ehird> AnMaster: png
21:32:55 <nescience> but points is based on the points of the other programs
21:33:04 <ais523> ehird: you don't know what sort of image it is
21:33:08 <ais523> arguably, iso might be better
21:33:09 <GregorR-L> Score is based on points of the other programs.
21:33:10 <nescience> i don't see how you can have them all in synch without some complicated math ala pagerank :P
21:33:11 <ehird> ais523: heh.
21:33:12 <AnMaster> scanned diagram. Must not be lossy.
21:33:14 <ehird> but seriously.
21:33:18 <AnMaster> In png the file is 70 MB
21:33:19 <ehird> AnMaster: absolutely PNG
21:33:23 <ehird> it's great for geometric shapes
21:33:24 <nescience> ahh
21:33:27 <ais523> there is a non-lossy format for scanned diagrams
21:33:28 <GregorR-L> Points is wins minus losses, score is based on that.
21:33:29 <ehird> AnMaster: 70MB? there's nothing you can do
21:33:29 <AnMaster> which is larger than the xcf at 65 MB
21:33:31 <AnMaster> ...
21:33:32 <ehird> it's gonna be gigantic anyway
21:33:33 <nescience> the text ony said "value"
21:33:36 <ais523> AnMaster: look at Wikimedia Commons for similar files
21:33:37 <ehird> ... 5MB makes a difference to you?
21:33:38 <ais523> and see what it uses
21:33:40 <nescience> i thought it was referring to teh value of those programs' scores
21:33:46 <ehird> AnMaster: just go w/ PNG
21:33:53 <GregorR-L> nescience: Nono, that's their value as in how much they're worth.
21:33:54 <AnMaster> ehird, that isn't as good for scans
21:33:54 <ehird> it's simple and near the best you'll prolly get
21:34:01 <ais523> AnMaster: how large is it after running it through pngcrush?
21:34:02 <AnMaster> ehird, also it is 1200 dpi, full A4
21:34:05 <nescience> based on the number of wins they have
21:34:08 <ehird> AnMaster: 5MB is insignificant at 65-70MB size.
21:34:11 <GregorR-L> nescience: Yeah
21:34:14 <ehird> just use png
21:34:17 <nescience> well at least that can synch up, i see
21:34:21 <GregorR-L> nescience: I didn't want to make a recursive algorithm :P
21:34:26 <AnMaster> ais523, that was *after* pngcrush, optipng and advpng
21:34:28 <nescience> seems like it's partly responsible for some of the noise on the hill too :P
21:34:31 <AnMaster> before it was well over 80 MB
21:34:48 <nescience> if you only beat two programs, but those programs beat everything else... should your score be that high i wonder?
21:34:54 <nescience> oh well, it's there for the exploitation!
21:35:03 <ehird> AnMaster: So, you can store 65MB, but not 20MB more?
21:35:08 <ehird> I seeeee.
21:35:14 <AnMaster> ehird, wrong
21:35:19 <AnMaster> I think 65 is too much too for this
21:35:22 <GregorR-L> nescience: I decree that it should be fairly high, but not as high as the program that beat all the others :P
21:35:31 <ehird> AnMaster: Tough
21:35:36 <ehird> 1200dpi + A4 size = big.
21:35:40 <AnMaster> since I need to upload it.
21:35:44 <AnMaster> ehird, yes I know
21:35:53 <ehird> AnMaster: er, how small is your upstream
21:36:01 <AnMaster> ehird, 1 mbit
21:36:06 <ehird> fast enough
21:36:14 <AnMaster> ehird, on the paper
21:36:17 <AnMaster> in practice?
21:36:24 <AnMaster> ~600 kbps
21:36:30 <ehird> ehm
21:36:34 <ehird> AnMaster: 600 kbps ~= 1mbit
21:36:37 <ehird> KB!=Kbit
21:36:45 <GregorR-L> Kilonibble
21:36:49 <AnMaster> that was kbit
21:36:49 <AnMaster> ...
21:36:51 <ehird> AnMaster: oh.
21:36:54 <AnMaster> 600 kbit/sec
21:36:57 <ehird> AnMaster: so, um
21:36:59 <ehird> http://www.google.com/search?hl=en&safe=off&client=safari&rls=en-us&q=70+megabytes+%2F+600+kilobits+per+second&btnG=Search&aq=f&oq=&aqi=
21:37:02 <ehird> AnMaster: 16 minutes?
21:37:10 <ehird> You're fussing over 16 minutes for uploading a PNG?
21:37:14 <AnMaster> ehird, something like that yeah.
21:37:17 <ehird> Nothing better to do I see.
21:37:19 <AnMaster> ehird, 5 png
21:37:21 <AnMaster> all like this
21:37:30 <AnMaster> so 16 * 5
21:37:39 <ehird> AnMaster: So, you have 80 minutes to spend on finding an obscure format that saves 10-20MB, but you can't spend those 80 minutes uploading.
21:37:43 <ehird> Bit ridiculous, that
21:37:52 <nescience> GregorR-L: i agree. i guess there's enough wins to go around
21:37:55 <AnMaster> ehird, wrong. I was just hoping someone here knew something good
21:37:57 <ais523> ehird: it depends on how many of these images AnMaster needs to upload
21:38:07 <AnMaster> ais523, as I said above. 5. At the moment
21:38:08 <ehird> ais523: he said 5
21:38:10 <GregorR-L> Instead, let's waste 90 minutes arguing about whether obscure formats are worthwhile :P
21:38:11 <AnMaster> might be more in the future
21:38:11 <ehird> = 80 minutes in total
21:38:12 <nescience> but with some tricksiness it might be possible to submit some warriors to act as stepping stones on each other
21:38:15 <AnMaster> but not today
21:38:15 <ehird> using 70MB PNGs
21:38:23 <nescience> seems to me like the hill score should be based on a 0 sum approach somehow
21:38:25 <ehird> @ 16 minutes / file
21:38:27 <ehird> which is just fine
21:38:30 <ais523> nescience: we were talking about doing that while the hill was upside-down
21:38:35 <ehird> nescience: gimme an algorithm and it goes into my impl :)
21:38:38 <ais523> in order to try to get good programs there
21:38:40 <GregorR-L> nescience: Mebbe, feel free to give me a new algo :P
21:40:09 <AnMaster> ehird, ~75 kbyte/sec up would be 600 kbit/sec as far as I can tell.
21:40:22 <ehird> AnMaster: you said you usually got 600 kbit/up
21:40:23 <ehird> per sec
21:40:26 <ehird> i calculated based on that
21:40:29 <ehird> = 16 minutes / file
21:40:34 <ehird> = 80 minutes total for 5 files
21:40:35 <nescience> i can't quite wrap my head around what's going on with the current score
21:40:36 <ehird> which isn't a problem
21:40:54 <nescience> as far as how things affect each other i mean
21:40:57 <nescience> so maybe it already is
21:41:00 <AnMaster> ehird, and it might be more in the future. Just 5 today. Probably 20 more next week
21:41:15 <ehird> AnMaster: 5 hours
21:41:17 <ehird> one off
21:41:20 <ehird> is this seriously a problem?
21:41:22 <AnMaster> 5.3333(...)
21:41:37 <AnMaster> ehird, probably not a one-off!
21:41:50 <ehird> AnMaster: so first it was 5. then 20. now it's 498357348957893457894353495?
21:41:55 <nescience> what's the problem with basing it on most wins, for example?
21:42:12 <nescience> i assume there's some behavior you want from giving more points for defeating "better" warriors
21:42:14 <ehird> nescience: because then you can target bad programs
21:42:19 <ehird> and lose against good ones
21:42:21 <ehird> and rise to the top
21:42:22 <ehird> which sucks
21:42:28 <ehird> but
21:42:31 <ehird> with the 11-length hill...
21:42:32 <ais523> except, there won't be many bad programs on the hill after a while
21:42:35 <nescience> so can everyone else(?)
21:42:40 <ais523> all the ones there are pretty good, I imagine
21:42:48 <ehird> exactly
21:42:49 <ais523> I'll resubmit attack1, and I bet it'll do terribly
21:42:52 <ais523> despite not being all that bad
21:43:02 <ais523> !bfjoust attack1 [>[-]+]
21:43:08 <EgoBot> Score for ais523_attack1: 13.5
21:43:08 <ehird> :-D
21:43:15 <ehird> not bad
21:43:18 <ehird> 531.50-2impomatic_mirage.bfjoust
21:43:19 <ehird> 113.50-8ais523_attack1.bfjoust
21:43:20 <nescience> being the "best" in this setup no longer means having the best record/defeating the most enemies
21:43:24 <ehird> lowest pts apart from it is
21:43:26 <ehird> 948.50-4nescience_creep.bfjoust
21:43:28 <ais523> yep, lost to everything but creep
21:43:34 <nescience> lol :>
21:43:40 <ehird> still, not that terrible
21:43:45 <nescience> and the setup here is such that i don't think it's really much different to target "better" programs than it is to target "worse" programs
21:43:46 <ais523> !bfjoust attack_experimental >>>>>>>>>[>[-]+]
21:43:46 <ehird> we've had 0.0 - 8.0
21:43:55 <nescience> since there's not really much you can do to target any particular program
21:43:57 <EgoBot> Score for ais523_attack_experimental: 15.5
21:43:57 <ehird> Attaxperimental
21:44:00 <nescience> except something like defend6, for example
21:44:02 <ais523> very slightly better...
21:44:11 <ehird> 1 | - 0 0 - - - - - - + | 15.5| -6| ais523_attack_experimental.bfjoust
21:44:17 <ehird> ais523: two draws and one win isn't too bad
21:44:31 <ais523> how did that draw with defend6, I wonder?
21:44:52 <ehird> !bfjoust revelation_fell_short (>)*9[[-]>+]
21:45:01 <nescience> the - loop
21:45:02 <EgoBot> Score for ehird_revelation_fell_short: 6.5
21:45:04 <nescience> wait, nevermind
21:45:08 <ehird> !bfjoust revelation_fell_short (>)*9[[+]>-]
21:45:08 <nescience> it only incs 128 times
21:45:10 <EgoBot> Score for ehird_revelation_fell_short: 6.5
21:45:19 <AnMaster> <ehird> AnMaster: so first it was 5. then 20. now it's 498357348957893457894353495? <-- stop being silly
21:45:20 <ehird> ais523: see, I can do worse!
21:45:36 <nescience> ehird: an idea regarding the polarity flip:
21:45:39 <AnMaster> just it is 5 today. And "the customer might want more next week ;)"
21:45:45 <nescience> what about taking either the best or the worst score for the attacker?
21:46:00 <ehird> nescience: I think averaging all the combinations is petter
21:46:08 <nescience> well, the average of a win and a loss is a tie
21:46:09 <ais523> ah, I see
21:46:16 <ais523> attack_experimental never goes into the [] loop
21:46:20 <ais523> nor does revelation_fell_short
21:46:24 <ais523> unless the tape length is exactly 10
21:46:36 <nescience> but if polarity comes into play, either you will take advantage of it or not take advantage of it
21:46:36 <ais523> !bfjoust attack_experimental >>>>>>>>>+[>[-]+]
21:46:38 <EgoBot> Score for ais523_attack_experimental: 15.5
21:46:42 <nescience> doing both and averaging is kina mediocre i guess
21:46:44 <nescience> i dunno, just a thought
21:46:58 <AnMaster> polarity?
21:47:03 <AnMaster> reverse it!
21:47:59 <ais523> and now it loses to defend6, as it ought to
21:47:59 <nescience> well that's what i'm getting at
21:48:10 <nescience> you can discourage taking advantage of polarity (and thus writing more generalized solutions)
21:48:15 <nescience> by taking the worst score of the two
21:48:15 <ehird> nescience: hmm
21:48:26 <nescience> or you can promote taking advantage of it by doing the opposite
21:51:29 -!- BeholdMyGlory has quit (anthony.freenode.net irc.freenode.net).
21:51:30 -!- tombom has quit (anthony.freenode.net irc.freenode.net).
21:51:30 -!- ais523 has quit (anthony.freenode.net irc.freenode.net).
21:51:30 -!- Sgeo has quit (anthony.freenode.net irc.freenode.net).
21:51:30 -!- kerlo has quit (anthony.freenode.net irc.freenode.net).
21:51:31 -!- ineiros has quit (anthony.freenode.net irc.freenode.net).
21:51:31 -!- Slereah has quit (anthony.freenode.net irc.freenode.net).
21:51:33 -!- Asztal has quit (anthony.freenode.net irc.freenode.net).
21:51:33 -!- ehird has quit (anthony.freenode.net irc.freenode.net).
21:51:33 -!- rodgort has quit (anthony.freenode.net irc.freenode.net).
21:51:33 -!- Gracenotes has quit (anthony.freenode.net irc.freenode.net).
21:51:33 -!- GregorR has quit (anthony.freenode.net irc.freenode.net).
21:51:34 -!- lifthrasiir has quit (anthony.freenode.net irc.freenode.net).
21:51:34 -!- FireFly has quit (anthony.freenode.net irc.freenode.net).
21:51:34 -!- fungebob has quit (anthony.freenode.net irc.freenode.net).
21:51:34 -!- fungot has quit (anthony.freenode.net irc.freenode.net).
21:51:34 -!- MizardX has quit (anthony.freenode.net irc.freenode.net).
21:51:34 -!- Deewiant has quit (anthony.freenode.net irc.freenode.net).
21:51:34 -!- fizzie has quit (anthony.freenode.net irc.freenode.net).
21:51:34 -!- jix has quit (anthony.freenode.net irc.freenode.net).
21:51:35 -!- nescience has quit (anthony.freenode.net irc.freenode.net).
21:51:35 -!- Ilari has quit (anthony.freenode.net irc.freenode.net).
21:51:35 -!- pikhq has quit (anthony.freenode.net irc.freenode.net).
21:51:35 -!- comex has quit (anthony.freenode.net irc.freenode.net).
21:51:35 -!- Leonidas has quit (anthony.freenode.net irc.freenode.net).
21:51:35 -!- sebbu2 has quit (anthony.freenode.net irc.freenode.net).
21:51:35 -!- AnMaster has quit (anthony.freenode.net irc.freenode.net).
21:51:36 -!- Corun has quit (anthony.freenode.net irc.freenode.net).
21:51:36 -!- Dewi has quit (anthony.freenode.net irc.freenode.net).
21:51:37 -!- olsner has quit (anthony.freenode.net irc.freenode.net).
21:51:37 -!- bsmntbombdood has quit (anthony.freenode.net irc.freenode.net).
21:51:38 -!- EgoBot has quit (anthony.freenode.net irc.freenode.net).
21:51:39 -!- inurinternet has quit (anthony.freenode.net irc.freenode.net).
21:51:39 -!- KingOfKarlsruhe has quit (anthony.freenode.net irc.freenode.net).
21:51:39 -!- ski__ has quit (anthony.freenode.net irc.freenode.net).
21:51:39 -!- dbc has quit (anthony.freenode.net irc.freenode.net).
21:51:40 -!- GregorR-L has quit (anthony.freenode.net irc.freenode.net).
21:51:40 -!- mtve has quit (anthony.freenode.net irc.freenode.net).
21:52:14 -!- impomatic has joined.
21:52:14 -!- MizardX has joined.
21:52:14 -!- tombom has joined.
21:52:14 -!- olsner has joined.
21:52:14 -!- Gracenotes has joined.
21:52:14 -!- ais523 has joined.
21:52:14 -!- sebbu2 has joined.
21:52:14 -!- KingOfKarlsruhe has joined.
21:52:14 -!- AnMaster has joined.
21:52:14 -!- jix has joined.
21:52:14 -!- FireFly has joined.
21:52:14 -!- fungebob has joined.
21:52:14 -!- BeholdMyGlory has joined.
21:52:14 -!- inurinternet has joined.
21:52:14 -!- Corun has joined.
21:52:14 -!- Sgeo has joined.
21:52:14 -!- GregorR-L has joined.
21:52:14 -!- GregorR has joined.
21:52:14 -!- nescience has joined.
21:52:14 -!- bsmntbombdood has joined.
21:52:14 -!- Slereah has joined.
21:52:14 -!- pikhq has joined.
21:52:14 -!- ehird has joined.
21:52:14 -!- Dewi has joined.
21:52:14 -!- comex has joined.
21:52:14 -!- lifthrasiir has joined.
21:52:14 -!- kerlo has joined.
21:52:14 -!- Deewiant has joined.
21:52:14 -!- Ilari has joined.
21:52:14 -!- ineiros has joined.
21:52:14 -!- fungot has joined.
21:52:14 -!- fizzie has joined.
21:52:14 -!- Leonidas has joined.
21:52:14 -!- Asztal has joined.
21:52:14 -!- rodgort has joined.
21:52:14 -!- EgoBot has joined.
21:52:14 -!- dbc has joined.
21:52:14 -!- mtve has joined.
21:52:14 -!- ski__ has joined.
21:52:44 <ais523> you can do a[bd]cd
21:52:44 <impomatic> Can I nest () inside {}?
21:52:44 <ehird> AnMaster: If polarity is sieve, + (dink) increments and - (donk) decrements for both warriors. If polarity is kettle, the same applies for one warrior, but the other warrior has the operations reversed - dink (+) decrements and donk (-) increments.
21:52:44 <ais523> impomatic: I think so
21:52:44 <nescience> AnMaster: what we're talking about with "polarity" ..
21:52:44 <ais523> it's meant to work, I'm not sure if it does though
21:52:44 <nescience> er, yeah.
21:52:44 <ais523> because I've never tested
21:52:45 <ehird> AnMaster: This stops people just copying a program and swapping + and - to get an advantage over [-] or [+], etc. but still makes you take into account the other program doing either and both.
21:52:45 <AnMaster> err
21:52:50 <AnMaster> ehird, are these terms from intercal?
21:52:52 <AnMaster> ;P
21:52:55 <ehird> AnMaster: No, I made them up.
21:52:57 <ais523> ehird: defend6 is robust against swapping + and -, by the way
21:52:59 <AnMaster> (dink and donk and so on)
21:52:59 <ehird> ais523: yep
21:53:00 <nescience> ais523: only if d is 0
21:53:16 <ais523> nescience: no, I mean d never finishes
21:53:18 <ehird> ais523: but my parody changes its +s or -s (I forget which) to the other, and beat it for a long time
21:53:19 <ais523> it's the rest of the program
21:53:19 <ehird> by about 10 score
21:53:21 <nescience> and c executes regardless, not just "else"
21:53:26 <nescience> ah
21:53:28 <ehird> 372.005ehird_defend6_a_parody_or_just_plain_ripoff_question_mark.bfjoust
21:53:28 <ehird> 263.004ais523_defend6.bfjoust
21:53:29 <ehird> still does
21:53:31 <AnMaster> aha
21:53:41 <ais523> ehird: interesting, that shouldn't make a difference
21:53:46 <ehird> ais523: with my new system, swapping + and - has no effect
21:53:53 <ais523> unless it interacts differently with one of impomatic's anti-defend6 programs
21:53:55 <ehird> ais523: and possibly it's just luck of the draw; it loses some other times
21:53:57 <nescience> ais523: it does, because it depends on the other programs on the hill
21:53:58 <ehird> also, yes
21:53:59 <ehird> I think
21:54:00 <ehird> right
21:54:15 <nescience> if you just have a simple [+] loop it will behave one way, and a [-] loop differently
21:54:26 <nescience> when i wrote creep it was 2nd for a while
21:54:27 <AnMaster> how does defend6 work?
21:54:29 <nescience> beat defend6 every time
21:54:43 <nescience> but that was because it loope dso as to wait 256 instructions when it hit your tripwire
21:54:45 <ais523> AnMaster: it tries to trap the opponent in a [+] or [-] loop over its flag
21:54:45 <ehird> AnMaster: it traps a [-] or a [+]
21:54:52 <ehird> AnMaster: it waits until it's 0, then increments/decrements it
21:54:55 <ehird> so that the loop runs once again
21:54:55 <nescience> ehird reversed the "polarity" and i couldn't do that both ways
21:54:56 <ehird> iirc
21:55:01 <AnMaster> ehird, interesting
21:55:01 <nescience> so it required other strategies to beat them both
21:55:08 <nescience> which i pulled off, but were less successful against the rest of the hill
21:55:08 <ais523> nescience: heh, that trick; it's what fool1 used, too
21:55:17 <ais523> on the other hand, that's an insanely bad strategy against an attack program
21:55:18 <ehird> AnMaster: so basically, if you try and just [-] or [+] out the opponents' flag, it infinite loops you then goes and rips off your flag
21:55:30 <ehird> ais523: what does fool do?
21:55:33 <ais523> that's why I think BF Joust is stone/paper/scissors in defence/fool/attack strategies
21:55:34 <nescience> thus my comment that the reason your defend is on top currently is because beating it doesn't give much score so nobody's doin it :P
21:55:35 <AnMaster> ehird, hm ok...
21:55:44 <ais523> ehird: walks very slowly along the tape, trying to trick defensive programs into suiciding
21:55:48 <ais523> by changing their flag very slowly
21:55:50 <ehird> ais523: heh
21:55:57 <ehird> ais523: defense1 just puts up fakes, right?
21:56:14 <ais523> ehird: no, defense1 is a specific anti-attack1 program
21:56:17 <ehird> ah
21:56:21 <ehird> so no fakers in the base?
21:56:31 <ais523> it lets its flag go to 0 for one cycle
21:56:34 <ais523> then increases it again
21:56:40 <ais523> and lets the opponent fall off the end
21:56:40 <nescience> it'd be a very distorted rock/paper/scissors
21:56:52 <ais523> defend5 works like that, but for a choice of opposing strategies
21:57:00 <nescience> programs like defend only work in a niche, right now you've got that niche :P
21:57:06 <ehird> Unmatched ] in butt.
21:57:08 <ehird> harumph
21:57:14 <ais523> but impomatic proved with shortsword that a program incapable of falling off the end is not hard to write
21:57:23 <impomatic> :-)
21:57:28 <ais523> so defend6 has to be a little more active in its defensive play
21:58:07 <ais523> it can still win defend1-style, but against shortsword and similar programs to it it locks them in place while grabbing the enemy flag a bit at a time
21:58:16 <AnMaster> ais523, btw... that -*- mode string in gcc-bf output
21:58:21 <AnMaster> how do you highlight bf
21:58:25 <ehird> esolangs.el
21:58:26 <ehird> his thingy
21:58:32 <ais523> yep, I have emacs modes for esolangs
21:58:36 <ais523> which I've pasted in the past
21:58:40 <AnMaster> ais523, I can't think of a useful way to highlight bf
21:58:43 <ehird> hmm I wonder why it thinks I have an unmatched butt
21:58:46 <ais523> AnMaster: you can highlight comments
21:58:51 <ais523> and stray BF chars inside comments
21:58:52 <ais523> also, constants
21:58:57 <ais523> like [-]+++++++
21:59:07 <ais523> and I colour <> differently to +- differently to [] differently to ,.
21:59:11 <ais523> to make the program a bit faster to read
21:59:14 <AnMaster> ais523 what about [-]>++<++++++++ ?
21:59:27 <ais523> AnMaster: [-] is a constant 0
21:59:39 <ais523> the +++++++ at the end is highlighted as addition, though
21:59:46 <ais523> it's a syntax highlighter, not an optimising interpreter
21:59:49 <AnMaster> fair enough
21:59:56 <AnMaster> ais523, where can I find this thing
22:00:02 <AnMaster> and does it highlight b98 too?
22:00:04 <ais523> AnMaster: pastebin in logs
22:00:06 <ais523> and no, it doesn't
22:00:13 <ais523> Befunge is a real pain to syntax-highlight
22:00:17 <AnMaster> ais523, which languages then apart from bf
22:00:30 <ais523> Thutu, and Unlambda
22:00:56 <AnMaster> ais523, you could highlight it mostly based on which character it is. You could handle string mode easily enough for the cardinal directions
22:01:00 <ais523> it also compiles Relambda to Unlambda, a bit buggily
22:01:16 <ais523> AnMaster: can you tell whether an individual Befunge command is part of a string or not?
22:01:18 <ais523> it might be both
22:01:19 <ehird> hmm it's parsing really weird
22:01:26 <AnMaster> ais523, indeed it might
22:01:43 <ehird> ais523: Thue too
22:01:45 <AnMaster> ais523, and you could partially by tracing program and using that info?
22:01:46 <ehird> no?
22:01:54 <ais523> ehird: stub code for that, but IIRC I didn't finish it
22:01:55 <ehird> AnMaster: it can be used as both, always
22:01:56 <ehird> so...
22:02:02 <ehird> ais523: i've used it, I'm sure
22:02:04 <AnMaster> ehird, yes of course
22:02:05 <ais523> AnMaster: I'm beginning to worry that you don't understand the concept of syntax highlighting
22:02:21 <AnMaster> ais523, it wouldn't be CLASSICAL syntax highlighting
22:02:22 <ais523> syntax highlighting != flymake
22:02:33 <AnMaster> ais523, "flymake"?
22:02:35 <ehird> ...
22:02:37 <ehird> how can you use emacs
22:02:39 <ehird> and not know what flymake is?
22:02:49 <ais523> ehird: admittedly, I don't /use/ flymake, but I know what it is
22:03:14 <AnMaster> "flymake not found in emacs info pages"?
22:03:23 <AnMaster> or rather "no flymake in index"
22:03:36 <AnMaster> Info-index: No `flymake' in index <-- there. See it ehird?
22:03:49 <ehird> ..
22:04:03 <ehird> This is an excellent time to brb, as my stupidity-thermometer was about to blow.
22:04:03 <ehird>
22:04:04 <nescience> ehird: defend is a good example of why giving the *better* score might be advantageous
22:04:10 <nescience> (specifically, the difficulty of overcoming the tripwire strategy and still being viable in other contexts)
22:04:32 <nescience> not really too solidly sure on that one though
22:04:45 <AnMaster> I fail to see what ehird meant with that
22:05:01 <AnMaster> Anyway if emacs docs doesn't list it. it probably isn't there in my emacs version...
22:05:11 <AnMaster> maybe it is gnu emacs specific?
22:05:19 * AnMaster is currently using µemacs
22:05:27 <AnMaster> ais523, so tell me what flymake is
22:05:48 <ais523> AnMaster: it repeatedly runs make in the background
22:05:52 <ais523> so you get error messages on the fly
22:06:08 <AnMaster> interesting
22:07:34 <AnMaster> but not very useful. Since it would generate error messages a lot when editing. For example something like typing "if (foo) bar();" (without quotes!) isn't valid at all until completely typed in C at least.
22:07:46 <AnMaster> is that one make for each key-press?
22:07:52 <AnMaster> it would be rather slow if so
22:08:01 <ais523> I think these problems have been thought about
22:08:03 <ais523> but I don't use it
22:08:11 <AnMaster> I wouldn't use it either.
22:10:48 <AnMaster> ais523, the wiki page mentions that "Note that the commands are specified slightly more precisely than in standard Brainfuck; in particular, the timing surrounding [ and ] is relevant in BF Joust." but doesn't actually describe this timing...
22:11:11 <ais523> AnMaster: yes it does
22:11:27 <ais523> they both take one tick, and use the value at the start of the cycle, and jump to the command after the matching pair
22:11:45 <AnMaster> hm...
22:12:16 <AnMaster> why this interest in joust btw...
22:12:26 <AnMaster> also what does the word "joust" mean
22:12:31 <AnMaster> if anything
22:13:08 <ais523> AnMaster: it's a sport that hasn't been seriously played for several thousand years
22:13:23 <ais523> it involves two people on horseback riding at each other with lances
22:13:26 <AnMaster> ah
22:13:29 <nescience> ehird: did you see my comment about timing in the wiki talk page?
22:13:29 <ais523> and trying to hit each other's shields
22:13:30 <AnMaster> turnering in Swedish
22:13:36 <nescience> what do you think about that for your interpreter?
22:14:29 <AnMaster> ais523, several thousands isn't right. More like several hundred.
22:17:05 <ais523> ah, yes
22:17:09 <Deewiant> Hell, jousting only began in the second millennium CE :-P
22:18:32 <ais523> ehird: have you seen the trailer for Enigma, btw?
22:18:36 <ais523> it's so bad it's hilarious
22:18:59 <AnMaster> why does a certain level of jpeg compression make an image look (badly) photoshopped? Hm... I mean photoshopped as in "made by combining two images"
22:19:29 <AnMaster> like this one: http://en.wikipedia.org/wiki/File:Joust1c.jpeg
22:20:11 -!- cowb0y has joined.
22:20:26 <AnMaster> http://retrocode.blogspot.com/2009/05/bf-joust-king-of-hill.html <-- was it someone in here who wrote that?
22:21:07 -!- cowb0y has left (?).
22:21:35 * impomatic owns up
22:21:42 <AnMaster> ah...
22:22:06 <AnMaster> that explains why the blog seems to focused on war programs...
22:22:23 <impomatic> :-)
22:22:33 * AnMaster wonders if you could make a successful pacifist program in joust
22:22:40 <ais523> "pacifist"?
22:22:50 <AnMaster> ais523, misspelled?
22:22:56 <ais523> no
22:23:01 <ais523> I just don't know what it would mean in this context
22:23:07 <AnMaster> ais523, nor do I!
22:23:11 <Deewiant> Makes the other program kill itself?
22:23:13 <AnMaster> but it sounds interesting.
22:23:19 <AnMaster> Deewiant, maybe
22:23:22 <ais523> Deewiant: like defence1?
22:23:37 <Deewiant> Possiblyy what's defence1
22:23:38 <AnMaster> demonstrations against war should be involved
22:23:40 <Deewiant> s/yy/y;/
22:24:12 <AnMaster> Corewars - UN Edition
22:24:14 <AnMaster> :D
22:24:57 -!- sebbu has joined.
22:25:23 -!- BeholdMyGlory has quit (Remote closed the connection).
22:25:39 -!- jix has quit ("leaving").
22:25:52 <ais523> Deewiant: it defends its flag, trying to get the opponent to fall off the end
22:26:20 <Deewiant> Sounds as close to pacifist as you can get
22:27:55 <Deewiant> Is there some kind of time limit?
22:28:40 <ais523> yes
22:28:45 <ais523> and after that, it's a draw
22:29:19 <Deewiant> Okay, so then you could make even more of a pacifist
22:30:47 <Deewiant> !bfjoust farmer1 [>+*128>+*128<[-]>[-]<<]
22:30:49 <EgoBot> Score for Deewiant_farmer1: 0.0
22:30:50 <Deewiant> Or something
22:31:18 <Deewiant> Hmm, did I mess that up, seems like it should tie against the defence-types
22:31:31 <Deewiant> Or do they advance steadily as well
22:32:06 <ais523> Deewiant: defend6 doesn't
22:32:12 <ais523> advance, that is
22:32:16 <ais523> I mean, it starts >+[]
22:32:25 <ais523> ah, your syntax is wrong
22:32:28 <ais523> it's (+)*128
22:32:30 <ais523> not +*128
22:32:40 <Deewiant> What did that do, then
22:32:46 <Deewiant> Just comments?
22:32:50 <ais523> I'm not sure
22:32:53 <ais523> probably it broke the interp
22:32:53 <Deewiant> !bfjoust farmer1 [>(+)*128>(+)*128<[-]>[-]<<]
22:32:55 <EgoBot> Score for Deewiant_farmer1: 0.0
22:32:55 <ais523> which would explain the low score
22:32:55 <Deewiant> Heh
22:33:03 <Deewiant> Well, no difference
22:33:07 <ais523> Deewiant: off the left end
22:33:10 <ais523> after one iteration
22:33:11 <ais523> wait, no
22:33:14 <ais523> I miscounted the > and <
22:33:16 <Deewiant> Shouldn't
22:33:25 <AnMaster> um
22:33:30 <AnMaster> hm
22:33:32 <ais523> Deewiant: let me run it against defend6 locally
22:33:35 <ais523> to see what happens
22:33:40 <Deewiant> By all means
22:33:57 <AnMaster> ais523, you said it broke the interpreter? Huh.
22:34:03 <AnMaster> that doesn't make sense
22:34:24 <Deewiant> Muah, I won http://www.irregularwebcomic.net/cgi-bin/poll.pl
22:34:27 <AnMaster> not that the program seems to make sense either
22:35:01 <AnMaster> I never voted
22:35:03 <ais523> Deewiant: timeout and draw
22:35:05 <ais523> as expected
22:35:14 <ais523> oh, of course
22:35:17 <Deewiant> So the scoring is just such that it gets 0?
22:35:18 <ais523> bug in the channel reporter
22:35:20 <ais523> if you replace a program
22:35:24 <ais523> it reports its old score, not a new one
22:35:31 <Deewiant> !bfjoust farmer1 [>(+)*128>(+)*128<[-]>[-]<<]
22:35:33 <EgoBot> Score for Deewiant_farmer1: 0.0
22:35:38 <Deewiant> Always the original
22:35:38 <Deewiant> Meh
22:35:43 <AnMaster> what about calling it farmer1a then?
22:35:49 <Deewiant> !bfjoust farmer1-fixed [>(+)*128>(+)*128<[-]>[-]<<]
22:35:56 <ais523> and the report has gone suspiciously blank
22:36:01 <Deewiant> ...
22:36:13 <Deewiant> Hyphens not allowed in names? :-P
22:36:20 <Deewiant> !bfjoust farmer1_fixed [>(+)*128>(+)*128<[-]>[-]<<]
22:36:21 <AnMaster> Deewiant, probably not
22:36:28 <AnMaster> !help
22:36:28 <EgoBot> Supported commands: addinterp bf_txtgen bfjoust daemon daemons delinterp fyb help info kill mush userinterps 1l 2l adjust asm axo bch bct befunge befunge98 bf bf16 bf32 bf8 bfbignum boolfuck c chiqrsx9p choo cintercal clcintercal cxx dimensifuck echo echo_sh forth glass glypho google hello kipple lambda lazyk linguine malbolge ook pbrain perl qbf rail rhotor rot13 sadol sceql sh show slashes test trigger udage01 underload unlambda whirl yodawg
22:36:41 <Deewiant> !hello h
22:36:41 <ais523> http://codu.org/eso/bfjoust/report.txt is blank...
22:36:46 <ais523> I wonder what's happening now?
22:36:51 <ais523> !underload (test)S
22:36:52 <nescience> wait a bit and refresh
22:36:58 <ais523> I think EgoBot's mostly dead
22:36:58 <nescience> that's what it's been like when things were going
22:36:58 <Deewiant> !befunge "foo">:#,_@
22:37:03 <ais523> even though it's responding to !help
22:37:10 <nescience> i seem to hae submitted a broken script but i can't see why
22:37:10 <Deewiant> !daemons
22:37:11 <EgoBot> Running daemons: bottles butt
22:37:37 <EgoBot> Score for Deewiant_farmer1-fixed: 0.0
22:37:37 <ais523> !underload (test)S
22:37:38 <EgoBot> Score for Deewiant_farmer1_fixed: 0.0
22:37:38 <EgoBot> test
22:38:04 <ais523> Deewiant: it seems that the scoring method uses doesn't give you points if you don't get any wins
22:38:04 <Deewiant> Still 0, though
22:38:05 <Deewiant> Oh well
22:38:10 <ais523> you got many draws
22:38:15 <ais523> and a few losses
22:38:17 <ais523> but no win
22:38:18 <ais523> *wins
22:38:22 <nescience> it was all draws before
22:38:45 <nescience> wtf creep is on top now
22:38:50 <Deewiant> Hmmnh, that scoring system sucks :-P
22:39:00 <nescience> look at all those ties
22:39:01 <nescience> something broke
22:39:05 <nescience> oh right
22:39:06 <nescience> farmer
22:39:07 <Deewiant> 0 is a tie?
22:39:08 <nescience> too many ties
22:39:25 <nescience> defend has hit its downside
22:39:41 <Deewiant> Can those extraneous farmers be removed?
22:39:42 <ais523> nescience: well, I'll probably make a defend7 at some point
22:39:50 <ais523> Deewiant: they will be
22:39:53 <impomatic> It'd be better to run each pair of warriors at every possible tape length and base the score on that.
22:39:56 <ais523> next time a program is submitted
22:39:58 <Deewiant> ais523: Manually, by someone else? :-P
22:39:59 -!- sebbu2 has quit (Connection timed out).
22:40:04 <ais523> Deewiant: no, automatically
22:40:16 <ais523> !bfjoust attack1 [>[-]+]
22:40:18 <EgoBot> Score for ais523_attack1: 13.5
22:40:30 <ais523> see, gone
22:40:41 <Deewiant> Oh, they're not permanent by default?
22:40:51 <nescience> impomatic: ehird is doing that
22:41:01 <ais523> Deewiant: only the 10 best programs from each run are maintained
22:41:07 <Deewiant> Ah
22:41:10 <ais523> although your three farmers were placed into the same run, it seems
22:41:25 <GregorR-L> If it doesn't finish a run before you add a new one, the new run will have two added instead of one.
22:41:28 <nescience> ok, it is still tying everything
22:41:30 <nescience> what's the deal
22:41:40 <nescience> sorry for the repeated submissions, i kept missing the refresh to see the chart
22:41:47 <nescience> is there some error i am getting?
22:42:37 <ais523> nescience: you have to wait for the report to regenerate
22:42:43 <nescience> i did
22:42:45 <nescience> it wasn't on the report
22:42:47 <nescience> i submitted,
22:42:50 <nescience> now it is, but all ties
22:42:58 <ais523> nescience: all ties normally indicates a bug in the program
22:43:00 <ais523> or a typo
22:43:03 <nescience> strikes me as highly improbable, but i can't see a problem with the program
22:43:07 <ais523> as in, invalid syntax
22:43:09 <nescience> (>(-)*9)*2>(>-)*4(>[(>(+)*10[-])*20])*20
22:43:12 <nescience> do you see one?
22:43:53 <ais523> not an obvious one
22:43:57 <ais523> let me run it through my local interp
22:44:16 -!- tombom has quit ("Peace and Protection 4.22.2").
22:44:44 <ais523> bug in the interp, it doesn't like the syntax (>[(>(+)*10[-])*20])*20
22:44:50 <ais523> I think it doesn't like [] inside ()
22:45:00 <ais523> try using (>[(>(+)*10[-])*20]{})%20 instead
22:45:25 <nescience> what's %20 about
22:45:35 <ais523> nescience: it's the nesting abbreviation
22:45:38 <ais523> like *, but []-aware
22:45:55 <ais523> it means "20 times, replace the {} with the contents of these parens"
22:45:55 <nescience> mmk
22:45:59 <ais523> as in, it's recursive
22:46:01 <nescience> i see
22:46:08 <ais523> so (a{}b)%5 = aaaaabbbbb
22:46:47 <impomatic> Does this work? (a{}b{}c)%5 = aaaaabbbbbccccc
22:47:01 <Deewiant> What would (a{b}c{d}e)%5 be
22:47:17 <nescience> didn't seem to like it any better
22:47:21 <ais523> impomatic: no, that makes no sense
22:47:31 <ais523> you should write it (a{(b)*5}c)%5
22:47:46 <ais523> Deewiant: only one {} block inside each ()%
22:47:58 <Deewiant> ais523: Yeah, it was at impomatic
22:47:58 <nescience> i'll have to mess with it later
22:48:13 <nescience> i don't have the time to concentrate on it >:(
22:48:31 <nescience> or i guess i could just manually expand it
22:50:08 <AnMaster> %20?
22:50:28 <ais523> AnMaster: it's an improved, []-aware, version of runlength compression
22:50:33 <ais523> read the wiki article
22:50:40 <AnMaster> ah
22:50:42 <AnMaster> found it
22:51:05 <AnMaster> ais523, no way I will implement that in in-between btw
22:51:12 <ais523> err, you don't have to
22:51:16 <AnMaster> good
22:51:20 <ais523> optimising BF Joust programs makes no sense as it is
22:51:27 <ais523> because all tape elements are volatile
22:51:36 <ais523> you can't even guarantee memory is at 0 after [-]
22:51:45 <AnMaster> ais523, well I thought you might use it in normal bf
22:51:47 <nescience> ahah
22:51:48 <nescience> it worked
22:51:48 <AnMaster> that compression I mean
22:51:58 <ais523> (and some BF Joust programs specifically check for 0 after [-], as it happens)
22:52:18 <ais523> nescience: wow, that's a good program
22:52:30 <nescience> credit goes to impomatic though
22:52:30 <AnMaster> what program...
22:52:39 <ais523> AnMaster: nescience_shade
22:52:41 <nescience> i just combined his current best code with an idea he put in my head :P
22:52:47 <AnMaster> ais523, the source?
22:53:06 <AnMaster> I mean, this is fairly pointless and boring if I can't see the source.
22:53:06 <ais523> AnMaster: http://codu.org/eso/bfjoust/in_egobot/nescience_shade.bfjoust
22:53:14 <AnMaster> ah
22:53:18 <AnMaster> wow that is large
22:53:31 <nescience> see above
22:53:39 <nescience> i manually expanded it because the interpreter failed on the condensed code
22:53:40 <ais523> nescience: I don't get how that beats defend6
22:53:42 * ais523 runs locally
22:53:55 <nescience> it skips your tripwire
22:54:08 <nescience> and, usefully, inverse defend6's too
22:54:15 -!- nooga has joined.
22:54:22 <nescience> it'll run right off the end for any program that doesn't have decoys though
22:54:44 <nescience> but hey, can't have it all
22:55:32 <ais523> you're right, the tripwire never changes
22:56:05 <ais523> that's brilliant, assuming that the opponent has decoys, and skipping them
22:56:11 <ais523> clearly what defend6 needs is... a decoy decoy!
22:56:27 -!- oerjan has joined.
22:57:01 <AnMaster> hey, some hats are missing on http://choosemyhat.com/index.php
22:57:18 <AnMaster> (compared to a few months ago at least)
22:57:20 <AnMaster> hi oerjan
22:57:32 * oerjan gets spam from the Google Kingdom of Thailand, and thinks google branding may be going a bit overboard
22:57:36 <oerjan> hi AnMaster
22:57:37 <nescience> then i'll skip two!
22:57:37 <nescience> :P
22:57:50 <GregorR-L> People don't actually read choosemyhat.com
22:58:25 <AnMaster> GregorR-L, didn't notice the notice at the top
22:58:33 <ais523> oerjan: Google branded spam?
22:58:46 <ais523> !bfjoust defend7 http://pastebin.ca/raw/1436788
22:58:56 <EgoBot> Score for ais523_defend7: 68.0
22:58:59 <ais523> not bad
22:59:01 <AnMaster> GregorR-L, I was planning to vote for http://codu.org/hats/Tricorn-med.jpg
22:59:49 <oerjan> GregorR-L: the text at the top may be too long, everyone knows AnMaster cannot read more than three lines
23:00:16 <ais523> and straight to the top of the table
23:00:19 <AnMaster> oerjan, I'm trying to do like haskell for everything
23:00:32 <ais523> only program that beats it is impomatic_creep
23:00:50 <oerjan> ais523: the spam text started with the line "Google Kingdom of Thailand"
23:01:17 <AnMaster> so no one is going to ask what I meant with that...
23:01:28 <AnMaster> it seems
23:01:38 <ais523> oerjan: yes, I guessed
23:02:08 <oerjan> AnMaster: BWAHAHAHA
23:02:16 <AnMaster> oerjan, huh?
23:02:31 <oerjan> AnMaster: we wickedly refuse to ask
23:02:35 <AnMaster> :/
23:02:38 <AnMaster> VERY WELL!
23:02:44 <AnMaster> I shall then tell you anyway!
23:02:50 <oerjan> AAAAAAAAAAAAAAAAA
23:02:56 <AnMaster> Lazy evaluation of everything!
23:03:03 <nooga> OMF
23:03:04 <AnMaster> that is the key to getting ehird irritated.
23:03:12 <oerjan> nooga: HUM?
23:03:12 <AnMaster> lazy read scrollback
23:03:14 <AnMaster> and so on
23:03:43 <AnMaster> of course it is, *verbose* lazy evaulation
23:03:51 <oerjan> we notice
23:03:55 <ehird> 22:05 AnMaster: maybe it is gnu emacs specific?
23:03:55 <ehird> 22:05 AnMaster is currently using µemacs
23:03:56 <ehird> you think you're so clever, don't you...
23:04:05 <AnMaster> ehird, what
23:04:26 <AnMaster> ehird, checked in gnu emacs too and couldn't find it
23:05:05 <ehird> 22:13 nescience: ehird: did you see my comment about timing in the wiki talk page?
23:05:06 <ehird> yes
23:07:46 -!- Patashu has joined.
23:09:23 <ehird> 14:53:06 <AnMaster> I mean, this is fairly pointless and boring if I can't see the source.
23:09:26 <ehird> original bf joust worked sourceless
23:09:28 <ehird> which was fine
23:09:47 <AnMaster> ehird, you are basing that comment on false premises.
23:09:52 <AnMaster> You assume I want to "play the game"
23:09:53 <AnMaster> I don't
23:10:02 <ehird> i don't give a fuck what you want to do, AnMaster
23:10:04 <AnMaster> I'm interested in reading the source and seeing how it works though
23:10:06 <ehird> never have, never will
23:10:35 <ehird> but you keep seeming to believe I do...
23:10:39 <AnMaster> ehird, my comment is still true. Since I said was referring to myself.
23:10:49 <ehird> that is not what you said.
23:10:49 <AnMaster> I wasn't saying it was pointless for other people
23:10:51 <AnMaster> only for me
23:11:02 <ais523> !bfjoust defend8 http://pastebin.ca/raw/1436819
23:11:14 <ais523> that one should beat defence programs /and/ most attack programs
23:11:42 <ais523> but it takes ages to run
23:11:47 <AnMaster> ais523, any chance of small and elegant programs ever being best?
23:11:54 <Patashu> haha
23:11:54 <nescience> this is brainfuck
23:11:56 <Patashu> doesn't look like it does it
23:11:58 <nescience> unlikely
23:12:02 <Patashu> rushpolarity...
23:12:05 <AnMaster> nescience, yeah :/
23:12:14 <nescience> ais523: :P
23:12:16 <ais523> AnMaster: programs can be big and still elegant
23:12:21 <ehird> !bfjoust defend8mwahahaha http://pastie.org/492056.txt?key=srkdkdwiqowwbzvvyoow
23:12:24 <Patashu> well actually what we need
23:12:27 <nescience> you can add as many decoys as you want, i can still take you out every time! :>
23:12:29 <nescience> laf
23:12:29 <Patashu> is a preprocessor command that can take a variable
23:12:36 <nescience> ehird: did you just reverse his +s and -s again?
23:12:36 <AnMaster> ais523, sure. But I didn't say that.
23:12:39 <Patashu> and copies it x times, increasing the value y by 1 each time
23:12:40 <ehird> nescience: maybe
23:12:48 <Patashu> (copies a section of code)
23:12:48 <nescience> laf
23:12:53 <nescience> now that there's 4 copies of defend on there
23:12:56 <ais523> ehird: a +/- flipped version?
23:12:59 <nescience> writing a straight up defend-killer is feasible
23:13:00 <ehird> yep
23:13:11 <ehird> ais523: boy this is slow
23:13:12 <ais523> nescience: defend7 and defend8 both beat your decoy-skipper
23:13:26 <ais523> ehird: yes, the program isn't handled well by the interpreter
23:13:56 <nescience> ais523: of course, because i used a cheap trick to beat 6
23:14:05 <nescience> but that's far from the only way to beat it
23:14:05 <ais523> it was a clever trick, though
23:14:10 <ais523> and agreed
23:14:12 <AnMaster> what was that trick
23:14:14 <ais523> defend8 also beats defend6
23:14:15 <nescience> i've already beat it like 5 different ways
23:14:26 <nescience> and now that there's so many.. time to see some other ways
23:14:28 <ais523> AnMaster: deliberately not stepping on the tripwire
23:14:32 <nooga> i wonder how to allow multichar ids in next sadol
23:14:35 <nescience> if the program ever updates
23:14:40 <ais523> $ time perl bfjoust.pl defend8.bj defend6.bj > /dev/null
23:14:41 <AnMaster> ais523, how would it know where that tripwire was
23:14:41 <ais523> real0m40.113s
23:14:43 <ais523> user0m19.613s
23:14:44 <ais523> sys0m13.169s
23:14:54 <ais523> AnMaster: it can't be to the left of the flag
23:14:58 <ais523> so it must be to the right
23:15:10 <AnMaster> hm ok
23:15:14 <ais523> however, defend7 has a decoy decoy
23:15:25 <AnMaster> confusing
23:15:31 <ais523> so that nescience's program skips the decoy decoy, and falls into the real decoy
23:15:56 <AnMaster> ais523, and what about defend8
23:16:14 <AnMaster> and when will that report be generated... :/
23:16:21 <ais523> AnMaster: it's like defend7, but after 2000 cycles it stops waiting and zooms off to attack the opponent instead
23:16:22 <AnMaster> the interpreter seems horribly slow
23:16:25 <ais523> and it is
23:16:31 <ais523> that's why ehird's writing a faster one
23:16:40 <ehird> with polarities!
23:16:52 <ehird> dink donk march retreat consider reconsider rest eof
23:17:02 <AnMaster> ais523, why is the old report zapped before the new one is ready
23:17:02 * ehird twiddles with the parser
23:17:05 <AnMaster> it seems silly
23:17:48 <nescience> !bfjoust simpletest (>[[-]])*29
23:18:16 <Patashu> I think !bfjoust broke
23:18:18 <nescience> that one can only fall through if the instruction it is on is 0 twice in a row
23:18:24 <Patashu> no brainfuck program can take this long to write
23:18:25 <nescience> defend all you want
23:18:25 <nescience> :>
23:18:28 <Patashu> *run
23:18:37 <nescience> max cycles is 384000
23:18:38 <nescience> so ...
23:18:42 <ais523> Patashu: it's running, just slowly
23:18:47 <nescience> i dunno what the interpreter is written in but it could take a while
23:18:51 <ais523> the problem is that it's trying to do regexen on a very long string
23:19:01 <Patashu> is it unpacking all the *s?
23:19:02 <ais523> that interp is O(n) in the length of the program to run one cycle
23:19:03 <ais523> which is bad
23:19:09 <ais523> Patashu: no, the %s
23:19:13 <ais523> it has to unpack them when they run
23:19:17 <Patashu> shouldn't it do it all first
23:19:19 <Patashu> then run the full string?
23:19:41 <ais523> Patashu: to speed it up, it unpacks as it goes
23:19:49 <ais523> the problem is that regex matching on the unpacked strings is very slow
23:19:58 -!- impomatic has left (?).
23:20:26 <ais523> still, it should have finished by now
23:20:45 <nescience> lol
23:20:49 <ais523> even if each game takes 40 seconds, I'd expect it to have finished
23:20:50 <nescience> good job you broke it!
23:20:58 <ais523> it's only playing another programs, that's 400 seconds
23:21:05 <ais523> or a little under 7 minutes
23:21:36 <AnMaster> !befunge98 'A,@
23:21:39 <AnMaster> !help
23:21:39 <EgoBot> Supported commands: addinterp bf_txtgen bfjoust daemon daemons delinterp fyb help info kill mush userinterps 1l 2l adjust asm axo bch bct befunge befunge98 bf bf16 bf32 bf8 bfbignum boolfuck c chiqrsx9p choo cintercal clcintercal cxx dimensifuck echo echo_sh forth glass glypho google hello kipple lambda lazyk linguine malbolge ook pbrain perl qbf rail rhotor rot13 sadol sceql sh show slashes test trigger udage01 underload unlambda whirl yodawg
23:21:39 <Patashu> if it's going to run ten games in a row
23:21:45 <AnMaster> !daemons
23:21:45 <EgoBot> Running daemons: bottles butt
23:21:49 <Patashu> it would be much more efficient to unpack it all at the beginning
23:21:50 <ehird> !butt wut
23:21:55 <ehird> ais523: heh, my interp doesn't even handle the abbreviations
23:21:58 <ehird> that's for a frontend
23:22:00 <ais523> Patashu: much of the program often never needs to unpack
23:22:10 <ais523> ehird: my interp stores the program with the abbreviations in
23:22:10 <pikhq> !c int main(void){printf("HALDO!\n");return 0;}
23:22:11 <AnMaster> it is dead. Borked. Out of order. Not working.
23:22:12 <ais523> and unpacks on the fly
23:22:19 <ais523> AnMaster: the same happened earlier
23:22:19 <Patashu> well
23:22:23 <Patashu> clearly it's not working very well <.<
23:22:23 <ais523> and then all the results came at once
23:22:27 <ehird> ais523: yep
23:22:32 <ehird> when I submitted the 21 buggerers
23:22:32 <AnMaster> ais523, very odd that it throttles then
23:22:36 <AnMaster> I thought it was async
23:22:40 <AnMaster> that was part of the point of it
23:22:48 <nescience> i want some time to examine defend8
23:22:49 <nescience> :
23:22:54 <nescience> it doesn't just sit there like the others :P
23:23:00 <ehird> "the 21 buggerers" sounds like a biblical story
23:23:00 <ais523> not quite
23:23:04 <ais523> it starts with [ 2000 times
23:23:10 <nescience> lol
23:23:19 <ais523> and has a copy of defend6 after each ]
23:23:19 <ehird> ais523: how big is it, expanded?
23:23:23 <ais523> (the defend7 setup is before that)
23:23:24 <ehird> 7 billion megabytes?
23:23:24 <pikhq> !c printf("WTF, Egobot?\n");
23:23:33 <nescience> i see
23:23:36 <nescience> i didn't quite follow that to the end
23:23:40 <ais523> ehird: a bit less than 1 MB
23:23:41 <pikhq> GregorR-L: !c is borken.
23:23:46 <ehird> pikhq: NO.
23:23:47 <ehird> *NO.
23:23:48 <Patashu> lol
23:23:49 <ais523> pikhq: all EgoBot commands seem borken
23:23:49 <ehird> *No.
23:23:52 <ehird> EgoBot is borken
23:23:54 <ais523> whilst bfjoust is running
23:23:56 <AnMaster> !daemon
23:23:56 <ehird> It's hung up doing something
23:23:57 <EgoBot> Invalid invocation.
23:23:58 <ais523> apart from help, daemon, etc
23:23:59 <nescience> i was considering suggesting a "loop max N timse"
23:24:00 <nescience> times*
23:24:03 <AnMaster> !bf_txtgen this too?
23:24:03 <pikhq> GregorR-L: EgoBot is borken.
23:24:05 <nescience> obviously that would be better than this
23:24:07 <EgoBot> 97 +++++++++[>+>+++++++>+++++++++++++>++++<<<<-]>>>-.------------.+.++++++++++.>----.<+.-----..<.<+. [120]
23:24:09 <ais523> !underload (Test)S
23:24:09 <AnMaster> no
23:24:11 <AnMaster> not that one
23:24:16 <ais523> AnMaster: only the interps, it seems
23:24:16 <AnMaster> just the normal commands are
23:24:22 <GregorR-L> I know, I know, when the CPU is being raped by bfjoust nothing else can run.
23:24:25 <AnMaster> ais523, which is the main feature of it
23:24:29 <ehird> GregorR-L: nice foo
23:24:36 <AnMaster> GregorR-L, you need to throttle it then
23:24:36 <ehird> (nice(1))
23:24:39 <nescience> it's not very brainfucky but still
23:24:49 <AnMaster> GregorR-L, I thought this slox already did that...
23:25:36 <AnMaster> GregorR-L, I guess slox is broken
23:25:46 <ehird> I guess slox doesn't do what you thought.
23:25:50 <ehird> UNPOSSIBLE
23:26:23 <nescience> i gues i still don't quite get how {} works
23:26:23 <AnMaster> ehird, um. What would it do instead of throttling programs.
23:26:29 <nescience> it repeats the part between ( and { X times
23:26:33 <nescience> and the part between } and ) X times?
23:26:37 <ehird> AnMaster: Limit memory usage?
23:26:38 <EgoBot> Score for nescience_simpletest: 20.5
23:26:38 <EgoBot> Score for ais523_defend8: 45.1
23:26:38 <EgoBot> Score for ehird_defend8mwahahaha: 58.3
23:26:41 <ehird> YAY
23:26:43 <ehird> ais523: LOL
23:26:45 <ehird> it did badly
23:26:49 <ais523> defend8 only got 45.1?
23:26:52 <AnMaster> ehird, could you please check what on earth you are talking about
23:26:56 <AnMaster> ehird, you are so wrong.
23:26:57 <ehird> ais523: I beat it by reversing polarity!
23:27:14 <ais523> ah, it /lost/ to defend6 and defend7
23:27:17 <ehird> Great Leader AnMaster says slox does one thing. Lo, his superlative opinion is the objective fact!
23:27:19 <ais523> which is strange, as it beat them in my local test
23:27:26 <AnMaster> ehird, I checked duh.
23:27:48 <ehird> AnMaster: Slow down program != throttle program
23:27:50 <ehird> 's CPU usage
23:27:52 <AnMaster> ehird, GO FUCKING READ THE WEBSITE BEFORE BEING STUID.
23:27:57 <AnMaster> STUPID*
23:27:57 <ehird> STUID
23:27:59 <ehird> YOU'RE SO STUID
23:28:00 <AnMaster> http://codu.org/slox.php
23:28:07 <ehird> AAAAAAAAARGH ME AnMaster CRUSH PUNY HUMANLINGS
23:28:10 <AnMaster> ehird, I corrected the typo before you replied.
23:28:23 -!- ais523_ has joined.
23:28:29 -!- ais523 has quit (Nick collision from services.).
23:28:35 -!- ais523_ has changed nick to ais523.
23:28:40 <AnMaster> ehird, please see http://codu.org/slox.php, then come back again.
23:28:41 <ais523> sorry about that, my grandmother turned off the router by mistake
23:29:04 <ehird> AnMaster:
23:29:04 <ehird> 23:27 ehird: AnMaster: Slow down program != throttle program
23:29:05 <ehird> 23:27 ehird: 's CPU usage
23:29:10 <ehird> I did, thank you very much.
23:29:24 <AnMaster> ehird, so how would it fail in this case
23:29:50 <ehird> 23:27 ehird: AnMaster: Slow down program != throttle program
23:29:50 <ehird> 23:27 ehird: 's CPU usage
23:30:15 <AnMaster> as far as I can remember from what GregorR said, it is used for all programs that egobot runs. It gives equal limited CPU time to each such program
23:30:33 <AnMaster> the total cpu time for all programs is limited to a max
23:30:45 <nescience> i musta broke simpletest
23:30:48 <nescience> haha
23:30:48 <ais523> I just tested: defend8 definitely beats defend6
23:30:49 <nescience> creep still wins
23:30:51 <ais523> at my end, at least
23:30:58 <nescience> where's your defend now!
23:31:13 <AnMaster> so non-egobot processes always have a lot
23:31:24 <AnMaster> maybe it fails to use slox for joust
23:31:28 <AnMaster> since it is a special process
23:31:31 <AnMaster> or something like that
23:31:33 <ais523> and creep beats defend7 too...
23:31:36 <ais523> something weird is going on
23:31:42 <ais523> is that the same creep, or an improved version?
23:31:50 <Patashu> check the source code for it
23:31:52 <nescience> same creep
23:31:55 * ehird wonders wtf his parsing is doing
23:31:59 <nescience> been sitting there about since i submitted it yesterday
23:32:24 <ais523> it still has that 132-cycle wait
23:32:30 <ehird> it parses [>[-]+] as >-]+]
23:32:30 <nescience> it's not surprising
23:32:33 <ais523> it would seem rather vulnerable to fast attack programs...
23:32:35 <nescience> creep is a defend killer anyway
23:32:41 <ehird> and gives jump locations to non-jumps
23:32:43 <nescience> oh, it's the slow sucky one
23:32:47 <ais523> and yes, creep is a paper strategy
23:32:48 <nescience> that was made to counteract inverse defend
23:32:51 <ehird> aha
23:33:02 <Patashu> if it's not waiting as long as you need it to sprinkle nops
23:33:03 <ais523> defend programs are doing so well that anti-defence is making a comeback
23:33:03 <ehird> works now
23:33:23 <ais523> !bfjoust attack1 [>[-]+]
23:33:25 <EgoBot> Score for ais523_attack1: 6.5
23:33:52 <nescience> i'm not sure why the test doesn't beat the defends though
23:34:04 <nescience> [[-]] should loop if it's not 0 twice in a row, correct?
23:34:08 <Patashu> aw
23:34:12 <ais523> it beat creep but lost to everything else
23:34:12 <Patashu> rushpolarity finally got pushed off
23:34:15 <Patashu> survival of the fittest etc
23:34:20 <ais523> nescience: not necessarily
23:34:31 <ais523> oh, yes necessarily
23:34:34 <ais523> I was wondering about 0, 1, 0
23:34:38 <ais523> but yes, it needs two 0s in a row
23:34:44 <nescience> so why doesn't it beat defend?
23:34:54 -!- coppro has joined.
23:35:00 <ais523> so why doesn't what beat defend?
23:35:10 <ehird> alrighty, ais523
23:35:18 <ehird> I have all the parsing done for an efficient representation
23:35:23 <ehird> so I'm going to write run_match()
23:35:30 <ehird> ais523: two simple warriors, please?
23:35:38 <AnMaster> ehird, what is this representation
23:35:38 <ehird> [>[-]+] and...
23:35:47 <ehird> AnMaster: the very trivial:
23:35:48 <ehird> struct _ins_t {
23:35:49 <ehird> op_t op;
23:35:51 <ehird> ins_t *jump; /* NULL unless consider or reconsider */
23:35:53 <ehird> };
23:35:53 <ais523> ehird: [>+[]<(.)*258(+)*127]
23:36:00 <ehird> ais523: i said simple
23:36:00 <AnMaster> ehird, in an array?
23:36:01 <ehird> like really simple
23:36:03 <ehird> AnMaster: yes
23:36:17 <ais523> [>[-]-.-.-.-.-.-]
23:36:32 <nescience> why doesn't my test script beat defend
23:36:34 <nescience> i probably did it wrong
23:36:35 <nescience> 1sec
23:36:36 <ais523> !bfjoust fool2 [++[++[>+[(.)*5-]+>]-]-]
23:36:39 <AnMaster> ehird, and "consider or reconsider" are strange names for loops?
23:36:54 <ehird> OP_DINK, /* + */
23:36:54 <ehird> OP_DONK, /* - */
23:36:55 <ehird> OP_MARCH, /* > */
23:36:57 <ehird> OP_RETREAT, /* < */
23:36:58 <EgoBot> Score for ais523_fool2: 24.0
23:36:59 <ehird> OP_CONSIDER, /* [ */
23:37:00 <ais523> ehird: this is #esoteric, get used to it
23:37:01 <ehird> OP_RECONSIDER, /* ] */
23:37:03 <ehird> OP_REST, /* . */
23:37:05 <ehird> OP_EOF, /* (end of program) */
23:37:07 <ehird> AnMaster: you must realise that i _did_ name my two polarities sieve and kettle
23:37:09 <coppro> please don't do that
23:37:09 <ehird> ais523: defense1, then...
23:37:13 <nescience> ... (>[[-]])*29
23:37:14 <ehird> coppro: it was a few lines.
23:37:18 <nescience> why doesn't that beat defend, was the question
23:37:18 <AnMaster> ehird, true. You are going ICK style.
23:37:19 <coppro> 8 is a few?
23:37:23 <AnMaster> ick*
23:37:25 <nescience> it should work as far as i can see
23:37:25 <ehird> AnMaster: no, intercal styl
23:37:26 <ehird> e
23:37:30 <ehird> coppro: Yes.
23:37:49 <AnMaster> ehird, well. ick has some odd names internally too iirc. Not as many though.
23:38:19 <ehird> ais523: ?
23:38:22 <AnMaster> fungot, how are you?
23:38:22 <fungot> AnMaster: ohno ohno
23:38:24 <ais523> !bfjoust fool3 >>>>>>>>>[++[++[>+[(.)*5-]+>]-]-]
23:38:33 <ais523> ehird: ick does have a few, mostly filenames
23:38:38 <AnMaster> fungot, um... Are you Rincewind?
23:38:38 <fungot> AnMaster: youi usuck,boeings better airbus is a writer and writer for snl and crackin' up watchin' this video..when suddenly the local nbc station froze up.
23:38:49 <ehird> ais523: I just asked for defense1
23:38:55 <AnMaster> nop... not discworld
23:38:55 <ais523> ehird: I pasted it above
23:38:56 <ehird> ^style
23:38:57 <fungot> Available: agora alice c64 darwin discworld europarl ff7 fisher ic irc jargon lovecraft nethack pa speeches ss wp youtube*
23:39:00 <ais523> [>+[]<(.)*258(+)*127]
23:39:01 <AnMaster> ahaha
23:39:04 <ehird> ais523: I cannot find it
23:39:07 <ehird> err
23:39:09 <ehird> okay, that's defense1?
23:39:10 <ais523> ehird: see my last comment
23:39:12 <ehird> what about fool1
23:39:12 <ais523> yes, it is
23:39:13 <AnMaster> ^style discworld
23:39:14 <fungot> Selected style: discworld (a subset of Terry Pratchett's Discworld books)
23:39:18 <ehird> i'm looking for something very trivial :)
23:39:19 <AnMaster> fungot, ping
23:39:20 <fungot> AnMaster: ' i think you'll find,' he said. " so i should get something.' now lobsang straightened up and stared straight ahead of him, pushing through the bushes, and he'd sat up all night," said
23:39:21 <ais523> [>[-(.)*64]-]
23:39:22 <ais523> that's fool1
23:39:25 <ais523> and it is very trivial
23:39:34 <AnMaster> fungot, make sense!
23:39:34 <fungot> AnMaster: they did. look," said sergeant colon. " i don't think my calculations were that fnord"
23:39:42 <AnMaster> heh
23:40:02 <ehird> ais523: kay, [>[-................................................................]-]
23:40:11 <EgoBot> Score for ais523_fool3: 19.0
23:40:22 <AnMaster> fungot, .
23:40:24 <AnMaster> hm
23:40:32 <ehird> run_match(a, b, POLARITY_SIEVE, 20);
23:40:35 <AnMaster> mind resetting it's limit?
23:40:42 <ais523> !bfjoust fool4 (>(+)*6)*9[++[++[>+[(.)*5-]+>]-]-]
23:41:11 <EgoBot> Score for ais523_fool4: 41.5
23:42:35 <Patashu> !bfjoust lazy (+-)*150000(>)*9([-]>)*21
23:43:12 <ehird> ais523: is it a pain to synchronize the two programs?
23:43:14 <ehird> in your interp
23:43:29 <ais523> ehird: not really
23:43:40 <KingOfKarlsruhe> !bfjoust simple [>[-]]
23:43:49 <Patashu> hmm
23:43:49 <ehird> ais523: so how does [ work?
23:43:53 <Patashu> must be fighting defend8 ;)
23:43:57 <ehird> do you just indescriminately save the current cell before doing anything?
23:44:04 <ehird> *indiscriminately
23:44:08 <ais523> ehird: that's how I implemented it
23:44:10 <ais523> after all, it's only one int
23:44:16 <ehird> yar
23:44:42 <ehird> __asm__("nop");
23:45:39 <AnMaster> ehird, that seems wasteful. Wouldn't it be better to just directly skip to the other program
23:45:52 <AnMaster> also gcc will optimise away that asm
23:45:59 <AnMaster> you need a volatile asm to actually do it
23:46:33 <ehird> __asm__ about to erupt("nop");
23:46:37 -!- FireFly has quit ("Later").
23:46:42 <AnMaster> ehird, um?
23:46:46 <ehird> Very volatile.
23:46:53 <AnMaster> ...
23:46:54 <Patashu> hehe, bfjoust is stuck again
23:46:56 <Patashu> fight to the death with defend8
23:47:10 <nescience> !bfjoust simpletest (>[[-].])*29
23:47:11 <EgoBot> Score for nescience_simpletest: 20.5
23:47:26 <Patashu> huh?
23:47:26 <Patashu> hang on
23:47:30 <ehird> ais523: what happens if a program ends?
23:47:32 <ehird> that is
23:47:35 <ehird> + vs [>[-]+]
23:47:39 <Patashu> !bfjoust lazy (+-)*180000(>)*9([-]>)*21
23:47:42 <AnMaster> ehird, read on the wiki
23:47:49 <ehird> AnMaster: lazy :)
23:47:51 <AnMaster> I'm pretty sure it said
23:48:00 <nescience> problem with +- is
23:48:04 <AnMaster> ehird, hey I patented lazy evaluation over iIRC
23:48:06 <AnMaster> IRC*
23:48:12 <Patashu> bah
23:48:19 <Patashu> I can't screw around without my instant results
23:48:22 <nescience> eventually they'll get you to 0
23:48:24 <ehird> you'd have more of a hope at being funny with that joke if you knew what lazy evaluation meant
23:48:33 <nescience> and then execute the opposite of your code which is 0 twice
23:48:34 -!- coppro has quit ("The only thing I know is that I know nothing").
23:48:35 * GregorR-L reappears.
23:48:37 <Patashu> aah
23:48:39 <AnMaster> ehird, I know. And I'm making a parody on it
23:48:43 <Patashu> hmm
23:48:45 <GregorR-L> It is throttled, but bfjoust is only nice'd.
23:48:47 <nescience> like if you are 1 and you dec, you become 0, then if they dec and you add, it's 0 again
23:48:48 <ehird> AnMaster: that's like saying grapes are a parody of bread
23:48:49 <Patashu> oh, I remember how I was doing it with matador
23:48:49 <ais523> ehird: if a program ends, it nops forever
23:48:50 <AnMaster> ehird, I'm well aware it isn't exactly the same as this.
23:48:55 <Patashu> it was ++- for a while then --+ for a while
23:48:57 <ehird> ais523: oh.
23:49:03 -!- coppro has joined.
23:49:04 <nescience> same problem, less likely
23:49:12 <nescience> there's nothing wrong with going in only one direction
23:49:18 <nescience> switching direction is what causes a potential loss
23:49:19 <AnMaster> ehird, don't be daft. They are a parody of apples.
23:49:46 <AnMaster> apples are, admittedly, a parody of bred
23:49:48 <AnMaster> bread*
23:49:50 <ehird> argh, I need a type WARRIOR_A or WARRIOR_B.
23:50:08 <AnMaster> ehird, bool
23:50:14 <AnMaster> or something
23:50:14 <ehird> nothx
23:50:15 -!- KingOfKarlsruhe has quit (Remote closed the connection).
23:50:19 <ehird> typedef enum {
23:50:20 <ehird> WARRIOR_A,
23:50:20 <AnMaster> ehird, enum
23:50:21 <ehird> WARRIOR_B,
23:50:23 <AnMaster> yep
23:50:23 <ehird> } warrior_id_t;
23:50:30 <Patashu> !bfjoust lazy ((+)*1024(-))*256(>)*9([-]>)*21
23:50:43 <AnMaster> one has value 0, the other value 1
23:50:46 <AnMaster> iirc
23:50:51 <Patashu> it doesn't like my program :)
23:50:57 <Patashu> it instantly told nescience what HIS program scored
23:50:59 <Patashu> favouritism!
23:51:10 <ais523> Patashu: yours is probably longer than his
23:51:18 <Patashu> I thought it ran them sequentially
23:51:20 <Patashu> it's parallel?
23:51:20 <ais523> either in time to execute, or in physical length
23:51:28 <ais523> and it is sequential
23:51:35 <ais523> but it has to run against all the programs there
23:51:42 <ais523> some of which are slow against various other strategies
23:51:43 <AnMaster> GregorR, there still?
23:51:49 <nescience> i wish you guys would at least wait for the table to update before submitting revisions :\
23:52:00 <Patashu> so you wish I would
23:52:02 <AnMaster> GregorR, can you fix EgoBot so it doesn't stall every other interpreter if bfjoust runs
23:52:12 <AnMaster> GregorR, properly rate limit, like other interpreters
23:52:40 <AnMaster> I guess this is due to it being implemented as a special command
23:52:43 <ais523> "the reward for a job well done is two more jobs..."
23:53:12 <AnMaster> <nescience> i wish you guys would at least wait for the table to update before submitting revisions :\ <-- agreed
23:53:34 <EgoBot> Score for KingOfKarlsruhe_simple: 11.8
23:53:34 <EgoBot> Score for Patashu_lazy: 11.8
23:53:34 <EgoBot> Score for Patashu_lazy: 11.8
23:53:34 <EgoBot> Score for Patashu_lazy: 11.8
23:53:38 <AnMaster> or that someone fixed the bug with the table being cleared before the new results were read
23:53:40 <Patashu> oop here we go
23:53:40 <AnMaster> ready*
23:54:01 <AnMaster> Patashu, silly to resubmit it
23:54:10 <Patashu> lazy gets lots of ties :0
23:54:20 <Patashu> beats...fool4 and shade
23:54:57 <ais523> fool4 is moving up the rankings...
23:55:08 <ais523> and I don't know why 8 is doing so badly, I guess it's tape-length dependent
23:55:15 <ais523> 6 will beat it on a short tape, it'll beat 6 on a long tape
23:55:17 <nescience> it still doesn't beat defend
23:55:19 <nescience> i do not get this
23:55:45 <ais523> nescience: what is simpletest?
23:55:45 <AnMaster> .bfjoust is a very long extension...
23:55:50 <ais523> you haven't pasted the source in-channel
23:55:54 <ais523> AnMaster: ehird told be not to use .bj
23:56:01 <AnMaster> ais523, why
23:56:03 <Patashu> blowjob?
23:56:05 <Patashu> :)
23:56:09 <ehird> what Patashu said
23:56:12 <AnMaster> Patashu, you have a dirty mind
23:56:21 <ais523> ehird: my friends use it as an abbreviation for "bonjour"
23:56:23 <ehird> AnMaster: and LOL means Lots of Love.
23:56:23 <nescience> i did above
23:56:25 <ehird> ais523: hahaha
23:56:28 <ehird> "hi there! bj!"
23:56:29 <nescience> (>[[-]])*29
23:56:34 <AnMaster> ehird, it does?
23:56:42 <ehird> AnMaster: Yep. And BJ means BF Joust.
23:56:55 <nescience> i added a . in case it was some weird parser error
23:56:59 <AnMaster> ehird, "bj" doesn't mean anything specific to me
23:57:25 * ehird thinks of a way to run some code twice in C without a temp var
23:57:50 <AnMaster> ehird, repeat the statement twice? :P
23:57:58 <ehird> AnMaster: more than one
23:58:17 -!- EgoBot has quit (Remote closed the connection).
23:58:20 -!- EgoBot has joined.
23:58:30 <AnMaster> ehird, um. Like foo(); bar(); quux(); foo(); bar(); quux(); ?
23:58:34 <AnMaster> macro
23:58:54 <AnMaster> #define REPEAT_SHIT foo(); bar(); quux(); and then REPEAT_SHIT REPEAT_SHIT
23:58:54 <ehird> AnMaster: like switch(){gigantic}
23:59:00 <AnMaster> ah
23:59:00 <ais523> nescience: it loses to defend6 the same way defend6 beats anything else with [-] in it
23:59:04 <AnMaster> that could be messy in a macro
23:59:22 <AnMaster> ehird, inline function?
23:59:32 <ehird> meh :)
23:59:51 <AnMaster> ehird, not sure if it would affect speed anyway...
←2009-05-26 2009-05-27 2009-05-28→ ↑2009 ↑all