I've found some solutions which cheat but the Malevolence engine doesn't notice.

The following solution for robochildren works unless there are 18more red or blue, where it fails. It seems this isn't tested for though.

1. You can cram more branches in than that, for example

Code:

?lvl=18&code=p12:3f3;p11:3f3;p10:3f3;p9:3f3;p13:3f3;p14:3f3;p15:3f3;c7:3f3;p8:5f2;i8:3f2;c8:2f2;c9:2f3;p8:6f2;i16:3f3;c17:3f3;c16:2f0;c15:2f3;p8:4f2;c7:4f2;p16:4f0;c17:4f0;c7:11f1;p8:8f2;p8:9f2;i8:11f6;c8:12f2;p9:11f1;c9:12f1;c12:8f3;c12:9f3;p8:7f2;p8:10f2;c7:10f2;p10:10f0;i10:11f7;c11:11f1;c11:10f0;c10:12f0;p10:9f0;p10:8f0;p10:7f0;c13:10f2;c13:11f1;p14:7f2;p14:8f2;p14:9f2;p14:10f2;i14:11f6;c14:12f2;p15:11f1;c15:12f1;p16:6f0;p16:7f0;p16:8f0;p16:9f0;p16:10f0;i16:11f7;c16:12f0;c17:10f0;c17:11f1;p16:5f0;c12:10f3;c12:11f3;i12:6f5;c12:7f3;c12:4f3;i12:5f1;c10:6f2;i11:6f7;c13:6f3;c13:7f2;c14:6f1;c14:5f0;c13:5f0;c11:5f3;c11:7f0;

2. If you ever feel insane enough to read all the long back discussion, there's numerous independent discoveries of this little loophole. Including some that use some clever chicanery with yellows/greens to extend the idea without limit, so no theoretical test case would fail. Pretty sure I posted one myself (without the clever chicanery) at some point. The level's just broken that way, no way to remedy it.

Unless the grid were to be shrunk down to the point where only a respectably compact "real" solution would fit. But then it'd be pretty difficult; there wouldn't be enough space for less efficient solutions that are still in the spirit of things.

Also, here's my solution dump, should it offer insight to anyone.

I'm considering finishing the bonus puzzles, but really, I should get back to my reading.

I started looking through the first couple, and you could really improve the efficiency of those. Largely by making use of the fact that you don't have to feed robots into a branch from the "top".

For example,

Code:

?lvl=3&code=p12:6f4;c12:5f3;c11:7f3;p11:8f4;c11:9f2;p12:7f3;c13:7f0;c12:9f3;
?lvl=6&code=c12:8f3;c12:9f3;c12:10f3;c11:5f2;c11:6f1;c11:7f1;p12:5f2;p12:6f2;p12:7f7;c13:7f0;c12:4f3;

Might just be the early ones though... I haven't looked at the later levels, and I know my initial run of solutions got gradually better as I learned more tricks.

Oh, another one would be how you can reverse the direction of branches

Example,

Code:

?lvl=16&code=c12:4f3;p12:5f2;p12:6f3;c12:7f3;c12:8f3;c12:9f3;c12:10f3;p13:6f7;

One last Useful Trick™, given that there are often setups where a branch has a writer pointing back into it (when you're scanning through the tape waiting for something to come up), instead of putting a writer on the return journey to that branch point, connect the returning conveyor to the writer that was part of the scanning section.

E.g. (compare to your solution to Robomecha)

Code:

?lvl=28&code=g12:3f3;c12:9f3;c12:8f3;p12:5f3;q11:5f1;q13:5f5;b11:4f2;r13:4f0;c12:4f3;g10:5f3;g14:5f3;b11:6f2;p12:6f3;q12:7f0;r13:6f0;c10:6f2;c14:6f0;c12:10f3;c12:11f3;

Not sure if that's the best example... but the principle stands; re-use your writers.

I keep coming back to this with another useful thing to add to the list... hopefully this is the last. Looking at your solution to Level 29, and generally speaking on the ones where you need to do something a bit clever with greens/yellows, it can save you some trouble if you can re-use the same machinery and just keep track of which of several greens you're expecting to be reading towards at that point, rather than using a yellow for the other one.
This is hard to articulate so I'm just going to post a level code rather than trying to explain it all.

Code:

?lvl=29&code=g12:4f3;p12:5f3;q13:5f2;q11:5f4;p10:5f2;p14:5f4;r10:4f3;r14:4f3;b10:6f1;b14:6f1;c12:3f3;c12:6f3;c12:7f3;c12:8f3;c12:9f3;c12:10f3;c12:11f3;p11:3f1;p13:3f1;c11:4f1;c13:4f1;

Copy-pasting this solution to robo-children from an older version:

Code:

http://pleasingfungus.com/#?lvl=18&code=c12:4f3;c12:5f3;c12:6f3;g12:3f3;c12:7f3;c12:8f3;i11:8f4;i13:8f0;c14:8f0;c10:8f2;p11:9f1;p12:9f7;p13:9f1;r10:9f1;b14:9f1;q12:10f6;p12:11f7;g11:10f1;g13:10f1;c11:11f1;c13:11f1;

The malevolence engine finds no flaw, but then prints this on the Success screen:

THE MALEVOLENCE ENGINE IS EXTREMELY DISAPPOINTED IN YOU.

CHEATER.

What's his beef with my solution, exactly? I tried clearing it and recreating it from scratch except to shift some writers and it still says the same thing.

At a guess I'd say it's picking up on having R/B branches stacked next to each other, and mistakenly reaches the conclusion that you're using the "endless row of R/B branches" method of solving that level.

Edit: Except I just tried that and it didn't call me a cheater.

I was just thinking have a little animation of a loading bar that takes x seconds to "load" from end to end, where x is a time greater than the calculation generally takes.

But an honest loading bar is cool too I guess 

My (woefully inefficient) solution to judiciary made the engine give up; it said it was brooding for a couple of seconds, then said it was "out of patience".

Probably a good idea to have a timeout if it's taking too long to look for flaws, but the threshold could be higher. Even on this craptacular laptop it was only 'thinking' for a short time.

Hell, I was thinking of suggesting an artificial delay of a second or so, just so there's time to read the odd screen that flashes by in an eyeblink (on most levels) when you click play. Maybe drop in a fake progress bar or a spinner while it calculates. I didn't even realise it was saying that it found no flaws until I tried it on a more complex level to slow the thing down.

Testing would be appreciated - your saves won’t work, but if you press �

Gave it a very brief run-through, and it did what it was supposed to do.
Running it from a crappy laptop (slow enough that it occasionally makes twitch-based flash games easier by playing them at a reduced rate) and it still calculated its malevolence in just a moment's wait, at least on the few levels I tried.

Although... ?lvl=2&code=p12:6f7;c13:6f3;c13:7f3;c13:8f3;c13:9f0;p11:6f4;p11:7f7;p10:7f4;p10:8f7;p11:9f7;c11:8f3;

Slip in a circuitous route by which a case that should be rejected might be accepted, and it didn't catch it.

Edit: Or, on the same level, a not so circuitous route to accept a bad case. ?lvl=2&code=p12:6f7;c13:6f3;c13:7f3;c13:8f3;c13:9f0;p11:6f6;c11:7f3;c11:8f3;c11:9f2;

Yeah, um, Batmanifestdestiy, I know that passes the tests... but it isn't a solution to the question.  Try feeding it BRBR which should fail but passes yours.  I think it is just accepting any even length input that starts with a B.

Oh, well, I passed the level, so...I'm too lazy to fix it.

Failed in random testing for me. "Any even length input that starts with a B" would be accurate - the only way for input to be rejected is if it runs out of dots on the 1st, 3rd, 5th etc symbol.

?lvl=17&code=c12:9f3;c12:10f3;p12:6f3;g12:4f3;r10:5f2;q11:4f5;p11:5f1;p11:6f4;b11:7f1;q12:7f6;p12:8f7;i12:5f5;

12 piece solution.

As for the interface, I found the way to rotate or flip copied regions 100% unintuitive. It took me AGES to figure it out, and it's basically a ui gesture you don't see anywhere else (hover something somewhere to change it?). But somehow, it kind of adds to the charm.

Ooooh, so that's how that works. Thanks 

Smallest solution to Police I've seen came from Wyrm - link

It can be done faster but with more pieces if you place an initial green, read one and place a yellow, read on one more and place a green, then with each pass through a loop move the yellow forward one and the last green forward two, until the greens meet.
As seen in my design - link
and the inevitable "I made that smaller for you" version, also by Wyrm - link

But size ends up being more important than time when you're trying to use it as a subcomponent of something else.

What's the best people have done with Robo-Tanks? It's not a difficult one, but I feel like I have more conveyor belts than ought to be necessary.

Any advance on 0:38 with 30 parts?

If the tests are, in part, randomised, do we lose the element of comparing test-run times? Surely that's only a consistent point of comparison if the tests are the same... unless I'm misunderstanding how the random tests happens.

Ah... I see 

I was assuming that the old one being highlighted, it would replace rather than append.

This may sound unrelated, but - does the mute button work for you?

You're right... that does sound unrelated 

Mute works fine - not muted = music plays, click mute and it stops. Exactly as a mute button should be.

...kidding. Fixed. Thanks for the video! (I wonder if this'll fix man-man's problem?)

Nope, just re-tested and it was doing the same thing. Flash player 10.0.45.2 here too.

Also, pasting links into the address bar isn't working for me; it's loading the game but not the level, unless I open up said level and paste into the save/load box. Even then, I have to clear the previous solution to prevent it writing the new stuff on top of the old machine, creating a weird and jumbled mess of components from both of them.

That is really really weird. Also, I can't replicate it.

Any more information you can give me...? A specific string that causes this behavior

I will go one better and record the behaviour as I see it, so that you don't have to rely on my descriptive ability to see what I mean.





If relevant, this is running on Firefox 3.5.9 on Windows XP. Hmm... I should probably update Firefox. It's probably not relevant, but even so, updating is good.

had another look at my solution, managed to get it down to 1:20 in 25 parts:
http://pleasingfungus.com/?lvl=23&code=c12:12f3;y12:2f3;c12:10f3;c12:11f3;b10:3f3;p10:4f6;r10:5f1;c11:3f2;q11:4f4;y11:5f0;r11:6f2;p12:4f7;q12:5f2;p12:6f7;c13:3f0;q13:4f2;y13:5f2;b13:6f0;r14:3f3;p14:4f4;b14:5f1;g12:3f3;q12:7f6;c12:8f3;c12:9f3;

Holy balls that's compact...

My solution to the "add one to the binary" problem is now being rejected for returning BB in response to BR - the test summary screen says it wanted an output of B  

Also, pasting links into the address bar isn't working for me; it's loading the game but not the level, unless I open up said level and paste into the save/load box. Even then, I have to clear the previous solution to prevent it writing the new stuff on top of the old machine, creating a weird and jumbled mess of components from both of them.

I optimized that one and went down to 3:11, 17 parts

Code:

?lvl=27&code=g12:4f3;c12:10f3;c12:9f3;c12:6f3;b13:5f0;g14:5f0;p12:5f7;r11:5f3;p11:6f2;c11:7f2;q12:8f6;i12:7f7;b13:6f3;p13:7f6;r13:8f1;q14:7f2;c14:6f1;

I... but... damn it, there's always another couple of seconds to shave off isn't there.

Anyway, wanted to share my solution for Academics which I find rather elegant (and visually appealing, but that's a matter of taste), I don't think it's possible to do anything shorter :

Code:

?lvl=23&code=c12:12f3;b10:5f2;c10:6f1;g10:7f1;q10:8f4;b11:4f3;p11:5f6;r11:6f1;b11:7f3;p11:8f0;r11:9f1;b11:10f2;g12:4f3;c12:7f3;p12:8f3;q12:9f6;p12:10f3;q12:11f2;b13:4f3;p13:5f0;r13:6f1;b13:7f3;p13:8f6;r13:9f1;r13:10f0;r14:5f0;c14:6f1;g14:7f1;q14:8f2;y12:2f3;p12:3f7;r11:3f2;b13:3f0;q12:5f2;y12:6f3;

If anyone's got something faster or w/ less parts, I'd really like to see it.

Mine ran the test cases in very slightly less time (1:28 instead of 1:30) but uses more parts and looks less pretty.

Code:

http://pleasingfungus.com/#?lvl=23&code=c12:4f3;c13:10f0;c14:10f0;c16:6f1;y12:3f3;g12:2f3;c11:10f2;c12:10f3;q12:8f0;q14:9f7;b13:8f2;p14:8f3;r15:8f0;b11:6f2;q11:7f1;c12:6f3;p12:7f3;r13:6f0;q13:7f5;g14:7f3;c12:5f3;c16:7f1;c13:5f0;c14:5f0;c15:5f0;c16:5f0;c10:10f2;g10:7f3;p10:8f3;r11:8f0;b9:8f2;q10:9f3;c8:7f1;c8:6f1;c8:5f2;c9:5f2;c10:5f2;c11:5f2;q9:9f0;b9:10f2;b8:9f1;y8:8f1;q15:9f6;r16:9f1;y16:8f1;r15:10f0;c12:11f3;c12:12f3;q12:9f4;

Crix
Time: 10:35
Parts: 28

Zapados
Time: 7:07
Parts: 39

4:09 and 27 parts

http://pleasingfungus.com/?lvl=27&code=g12:4f3;c12:10f3;c12:5f3;c12:9f3;b11:7f2;p12:7f3;q12:8f0;c12:6f3;c15:5f0;c14:5f0;c13:5f0;r14:6f3;p14:7f2;i14:8f6;c15:7f3;c15:8f0;c16:6f1;c16:7f1;b16:8f1;g16:9f1;c16:5f0;r13:7f2;c13:8f0;p14:9f3;b13:9f2;r15:9f0;q14:10f3;c15:10f2;c16:10f1;

Scratch that... went back over it to make use of the flippability of branches

3:17, 17 parts:
http://pleasingfungus.com/?lvl=27&code=g12:4f3;c12:10f3;c12:5f3;c12:9f3;b11:7f2;p12:7f3;q12:8f0;c12:6f3;b13:5f0;r13:7f2;c13:8f0;g14:5f0;b14:6f2;p14:7f7;c14:8f0;q15:5f1;p15:6f5;r16:6f0;c15:7f1;

and because I'm bored I made an annotated guide to the above  

As best I can tell, the difference of approach is
Yours: move the first red you find to the end, then check whether it's valid, and if not loop around for another go.
Mine: check whether it's valid, if not then move the first out of place blue to the front, loop.

Yours can be made more efficient than it is with a simple alteration to the "loop around for another go" part, that makes it move the last blue it finds to the front, as well as the first red to the end... I'm wondering if there's an even more efficient hybrid version on those lines - mine would take a lot longer than necessary to complete if you gave it one red followed by many blues.

Running with that idea... this one will move the first red to the end and the last blue to the front with each pass, runs the tests in 3:22 with 19 parts. Can't quite find a way to shave off the few seconds and one piece difference from the other one, but I suspect it'd be faster in the general case (i.e. not just the test runs as given)

http://pleasingfungus.com/?lvl=27&code=c12:4f3;p12:8f7;q12:9f0;p12:10f2;b13:8f0;c10:10f2;c11:10f2;q9:8f0;r9:9f3;p10:8f0;r10:9f1;c9:10f2;c11:8f0;b9:7f2;q10:6f5;p10:7f5;r11:6f2;r11:7f0;g12:6f3;b12:7f3;c12:5f3;

Unrelated: A timer (counting game-time rather than wall-time) in the testing mode would be nice; get a handle on how long a machine takes when given a custom string.

Wait... look back at the "17 part" solution up top, and actually count the pieces; there are 19 of them. The count by piece type on the summary screen adds up to 19, but it still says "total: 17" underneath. Same goes for the 19 part solution - counting parts yields 21. Seems to be doing the same on every other puzzle too (reporting 2 less than the actual value for the number of parts). Either I can't count, or I'm not reckoning some reason for discounting 2 parts, or there's something wrong here.

Without knowing the exact number of color inputs a robot can have, there is no logic to this. It's merely trial and error until you have found all the combinations.

This guy fails at logic forever.

Meanwhile my optimisation attentions have turned to Police (Output with a yellow in the middle). I've gotten it down a fair way from what it was, but it feels like there's more trimming could be done if I could just get the little fiddly sticky-outy bits to tuck away neatly. What's the best people have done with that one?

*optimises*
I optimised it down to 35!
*optimises*
Back up to 40 :@
*optimises*
33!
*backs away from the keyboard*

I've done it faster, but with more pieces. Method there is to place GxYxG around the first two bits, then each iteration moves the yellow down by 1, and the tailing green down by two, until the greens meet.

There's probably more can be done to reduce the piece count of that, but as it stands it takes 79 pieces but only needs 3:11 time.