next »

[increpare]

another grid...

*[[[e*[sw*[e*]]]s*]n*]

shortest whitescreen code?

*[[e*]*s*]*

shortest grid code?

*[[ee*]*es*]*

I quite like this one:

*[[[[e*]ssw*]n*]*n]

(also this one

*[[[e*]*[s*]*n[e*]*w[n*]*[sw*]*[*n][*se*]e]*]

)

[Hideous]

Now make it generate TIG-Pixel-pictures.

[increpare]

One thing, if you introduced coloured syntax (something that doesn't interest me too much in and of itself) would be to have a correspondence between syntax elements and language symbols, so that you'd be able to feed a program back into itself.

[Farbs]

mjau's Whee is awesome!

I tried to copy data between rows last night, but couldn't figure it out without destroying the original or losing the pointer. Hrm.

If you wanted to make it pretty without destroying the simplicity you could show pixel colour based on age. Set and unset pixels could blend across different colour gradients based on how long since they were last touched or modified. I'm not sure how well flash would deal with the drawing load though.

[Alevice]

Self-deleting and redrawing boxed cross
*[[e*]*w[s*]*n[w*]*e[n*]*

[se*]*e[ne*]*e[*se]*nw*e[*ne]*sw*e
[*e]w*[*s]n*[*w]e*[*n]*]

[increpare]

more atomic statements:

Code:

black square

[*]

white square

[*]*

if statements sort of look like this I think (wait no, it's wrong...I think maybe impossibly just using one cell?):

Code:

*[* IFBLACK *]*[ IFWHITE *]*

(provided the ifblack statement doesn't modify the square being checked, and that you end on that square)

an unconditional loop of sorts(ergo also wrong)?

Code:

*[* *[* LOOPCODE ]  *]*[ [ LOOPCODE ] *]

[increpare]

Just thinking now, one thing that would be nice would be a trace tool, showing which part of the code is currently getting executed.

[Farbs]

Code:

*[* IFBLACK *]*[ IFWHITE *]*

I'm pretty sure the first part of that condition will loop indefinitely if black.
Also the second part will leave the test pixel as white regardless of the input state.
This is why I couldn't duplicate data last night, since my tests always destroyed the source.

Good work on the atomics though.
And yes, trace and step functionality would be awesome.

[increpare]

I'm pretty sure the first part of that condition will loop indefinitely if black.

Yeah, it doesn't work.

(just tried to implement this, but...yeah...it's not quite working just yet )

One thing that would make coding a lot easier would be to have an 'if' bracket, that would run it's contents if the current square was white (as opposed to looping).

Also: having the text-entry area be resizeable would be coolbeans.

[Farbs]

Heh, that's exactly what I was trying to do 

[increpare]

Heh, that's exactly what I was trying to do 

:D

[Farbs]

Read and write access to a single one bit register would be extremely handy, but then it's not really in the spirit of the language. Hrm.

[increpare]

Read and write access to a single one bit register would be extremely handy, but then it's not really in the spirit of the language. Hrm.

in principle, we have everything we need to hand already, languagewise ... :/

[increpare]

I tried to copy data between rows last night, but couldn't figure it out without destroying the original or losing the pointer. Hrm.

This copies a point one row down, but it destroys stuff up to two rows above, I think

Code:

n [*] n [*] ss

[ n [*]* n [*]* ss *]

n

 s [*] s [*] n n

[ s [*]* s [*]* nn *]

s

That what you were talking about, or?

(for instance, this seems to work ok:

Code:

*[ee*]

s [*]*
[
n

n [*] n [*] ss

[ n [*]* n [*]* ss *]

n

 s [*] s [*] n n

[ s [*]* s [*]* nn *]

s

s e [*]*
]

)

For the automata, these should be easily-enough modifiable to turn into 'save/restore' functions (given that you're only going to need to read one row of output to produce the next one).

[Loren Schmidt]

*[[w*ee*]*nnn*]

s*[e*n*w*s]

[Farbs]

Oh that's clever increpare!
Although you can't inspect a bit without destroying it, on inspecting it you can copy it to multiple locations. I've simplified this below to use only one helper bit:

Code:

*
n [*] s
[ n * s *]
s [*]
nn [ s * s * nn *]
s

By step it:
Sets source data (remove to copy 0 rather than 1)
Clears tile above
Moves test tile to upper tile (leaving test clear)
Clears lower tile
Moves upper tile to test and lower tile, clearing upper tile
Returns pointer to test tile

[increpare]

I think I have that universal automata done...it runs very slowly though, from what I can see it's producing the right sort of output, but it's five to five, and I have tutorials early in the morning to give, so forgive me if I have any mistakes in it   

*big fingers crossed*

( source )

----

and yip farbs, your modifications is close to what I did in the end (only storing information above instead of below, because the automata moves down...)

*[[w*ee*]*nnn*]

s*[e*n*w*s]

The delux version:

Code:

*[
[[w*ee*]*nnn*]

s*[e*n*w*sn]
*
]

[Decipher]

So there goes my maze-solver, I coded this during a very boring ToK (Theory of Knowledge) lesson while listening to a TED talk on something I don't (want to) know.

And because of that guy my maze solver isn't perfect :/, it leaves trace... I can solve it when I get to home.

I call this Westwood Maze Solver, because it solves the maze west-ward.

Anyways, have fun.

Code:

*[e*]*
ssss
eee*eeeee*[e*]*
ssss
wwwwww*wwwww*[w*]*
ssss
ww*wwwww*[w*]*
ssss
eeeeeee*eeeee*[e*]*
ssss
ww*eeeee*[e*]*

nnnn
nnnn
nnnn
nnnn
nn

*[*w*ss[nn*]*]

[increpare]

So there goes my maze-solver, I coded this during a very boring ToK (Theory of Knowledge) lesson while listening to a TED talk on something I don't (want to) know.

And because of that guy my maze solver isn't perfect :/, it leaves trace... I can solve it when I get to home.

I call this Westwood Maze Solver, because it solves the maze west-ward.

very cute

[jeb]

The world's slowest rain animation:

Code:

*s*s*eeeee*s*s*eee*s*s*eee*s*s*eenee*s*s*eee*s*s*eeee*s*s*eee*s*s*eee*s*s*eee*s*s*eee*s*s*eee*s*eee*s*s*eee*s*s*
eee*s*s*eeee*s*s*ee*s*s*eee*s*s*eeee*s*s*ee*s*s*eene*s*s*eee*s*s*eee*s*eee*s*s*eee*s*s*eee*s*s*eee*s*s*
eene*s*s*eeee*s*s*eee*s*s*eee*s*s*eee*s*s*ee*s*s*eee*s*s*eee*s*s*eeeee*s*s*eee*s*s*eee*s*s*eee*s*
eee*s*s*eeee*s*s*eee*s*s*eee*s*s*eee*s*s*ee*s*s*eee*s*s*eee*s*s*eeeee*s*s*eee*s*s*eee*s*s*eee*s*
eee*s*s*eeee*s*s*eee*s*s*eee*s*s*eee*s*s*ee*s*s*eee*s*s*eee*s*s*eeeee*s*s*eee*s*s*eee*s*s*eee*s*
[e*[*e*]*[n]s*s[s]*]