Mercurial > repo

comparison interps/fukyorbrane/README @ 996:859f9b4339e6

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
<Gregor> tar xf egobot.tar.xz
author HackBot
date Sun, 09 Dec 2012 19:30:08 +0000
parents
children
comparison
equal deleted inserted replaced
995:6883f5911eb7 996:859f9b4339e6
1 FukYorBrane is a cross between Brainfuck and Corewar. Basically, you have two FYB programs
2 running simultaneusly. The data buffer for each of them is the opponent's program buffer. The
3 objective is to cause the opponent's program to quit with a "bomb." The changes you make to the
4 opponent's program buffer must be committed (see !) before they will have an effect.
5 Comments can be put into the program either the same way as BF (anything that isn't a command is a
6 comment) and/or by surrounding comments in (). The advantage of () is that the comments can
7 contain '.', ',', ':', ';', etc.
8 The program buffers will always be of the same length - if one is shorter, it will be padded at the
9 end with nops (see %). When a program pointer reaches the end of a program, it simply goes back to
10 the beginning.
11 There are 17 commands in FukYorBrane:
12
13 COMMAND | VALUE | EFFECT
14 --------+-------+--------
15 % | 0 | nop, does nothing
16 | |
17 + | 1 | increments the current value in the opponent's program buffer, looping if
18 | | necessary
19 | |
20 < | 2 | moves the data pointer to the left (NOT looping, if it goes below 0, it stays at
21 | | 0)
22 | |
23 > | 3 | moves the data pointer to the right (looping if necessary)
24 | |
25 , | 4 | reserved but has no effect
26 | |
27 . | 5 | reserved but has no effect
28 | |
29 ! | 6 | commit the current value to the opponent's active program buffer
30 | |
31 ? | 7 | uncommit the current value (replace the current value with the value in the
32 | | original program)
33 | |
34 [ | 8 | start a brainfuck-style loop (loop while the value at the current location in the
35 | | opponent's program buffer is not nop)
36 | |
37 ] | 9 | end of a [ loop
38 | |
39 { | 10 | loop while the opponent does not have a program pointer at the current location
40 | |
41 } | 11 | end of a } loop
42 | |
43 : | 12 | start a thread. The parent thread will skip over the matching ;, the child will
44 | | loop between this and the matching ;
45 | | NOTE: any given : will only fork once, then it's spent
46 | |
47 ; | 13 | end of a ; loop
48 | |
49 N/A | 14 | BOMB! This is an important one. If ANY program pointer (even if you have
50 | | several from threading) hits this, you lose!
51 | | NOTE: You cannot write a bomb in your own program, so it doesn't have a character.
52 | |
53 * | 15 | exit - end the current thread. If you're not in the topmost thread, you can only
54 | | exit at the very end of a thread: :......*;
55 | | NOTE: If the current thread is the only thread, you lose!
56 | |
57 @ | 16 | defect: instead of editing the opponent's program buffer, this thread will edit
58 | | your own. You can later defect back.
59 | | NOTE: If you commit a defect, YOU DEFECT
60 | | (this is to try to prevent pure manglers from being effective)
61
62
63 ---------------
64 SIMPLE STRATEGY
65 ---------------
66 One of the most simple FukYorBrane programs is:
67 {>}[+]+++++++++++++!
68 This very simply:
69 {>} | tries to find the opponent's program pointer
70 [+] | blanks the value where you found it (as in BrainFuck, but looping values)
71 +++++++++++++! | sets the value there to 14 (bomb)
72
73 This simple program isn't very effective, as it has tight loops. Tight loops are generally best
74 avoided, because of how bombs are usually placed. If the enemy finds you and places a bomb, and
75 you're in a tight loop, you'll hit the bomb long before you can do something about the enemy.
76
77
78 A slightly more complex FukYorBrane program:
79 :{>}[+[+[+[+[+[+[+[+[+[+[+[+[+[+[+]]]]]]]]]]]]]]]+++++++++++++!>%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
80 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%;
81 :@[>+++]!;*
82
83 Let's break this down:
84 >} | This is the same as before (and still a tight
85 | loop, which is bad).
86 [+[+[+[+[+[+[+[+[+[+[+[+[+[+[+]]]]]]]]]]]]]]] | This is one way to zero a value without a tight
87 | loop
88 +++++++++++++! | set the bomb
89 > | since we already have a bomb here, go on
90 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%... | by setting a lot of nops, we make the :; loop
91 | less tight
92 :@[>+++]!; | this is a simple bomb finding algorithm:
93 | it defects,
94 | then loops,
95 | nop'ing any bombs
96 | and committing if they were a bomb
97
98 Because you can defect, you can have a self-replicating program. But that's up to future hackers
99 to produce ;)
100
101 --------------
102 PROGRAM STYLES
103 --------------
104 Gregor has only written two major styles of programs:
105 Manglers
106 and
107 Seekers.
108
109 Of Manglers, there are several subtypes:
110 Pure mangler: All this does is destroy code with no attempt at any logic. Very quick. It's also
111 the shortest code: +!>
112 Logic mangler: Usually look for loops, disable loop beginnings or ends. That way, program
113 pointers fly through the entire program, so you can bomb anywhere.
114
115 Seekers basically seek out program pointers ({>}), then try to bomb where the program pointer was,
116 since the pointer is likely to come back to the same point. Easily catchable with a false
117 thread.
118
119 -------
120 LOOPING
121 -------
122 It is worth mentioning how many ticks different loop styles take.
123
124 If you have a loop of the style [A]B
125 (where A and B are sections of code)
126 It will run like so (where every character that isn't A or B is a tick):
127 [A][A][A][B...
128
129 If you have a loop of the style {A}B
130 It will run like so
131 {A}{A}{A}{B...
132
133 However, if you have a loop of the style A:B;C
134 It will run like so
135 A:B;B;B;B;B;B...
136 C...
137
138 Important to note is that while [ and { will take a tick every loop, : will take a tick only on the
139 first loop.
140
141 Where loops are unmatched, any applicable jump will be skipped. That is, in a situation like:
142 [A[B]
143 , where the [ before A doesn't have a match, if it hit that [ and decided to jump, it would not.
144 It would run like this:
145 [A[B][B][B].....
146 in either situation.
147 The situation is similar for ending brackets. This:
148 [A]B]C
149 would run like this:
150 [A][A][A]...B]C
151
152 If you produce a : somewhere where one has already existed, it's "spent" status will be maintained.
153 That is, if one program did this:
154 :A;B
155 , and later, the second program turned that into this:
156 %A;B
157 , then yet later, the second program turned it back into:
158 :A;B
159 , the : before the A would still be spent, and would not fork again. If a : is produced somewhere
160 where there was not one before, it defaults to unspent.