room topic changed to Labyrinth: Discussion about the 2D esolang Labyrinth: github.com/mbuettner/labyrinth (no tags)

Toot toot here comes books

?

Don't worry about it

@Sp3000 so, simple questions first: any objections to " as NOP?

Aside from the fact that my IDE currently automatically inserts another one, not particularly :P

yeah, that's bugging me too, but oh well...

You've kinda used all the no-op-like commands, so it's hard to pick anything good

I'm just pretending " looks like footprints

XD okay

cool, so I'll change that

so... the depth command you proposed

I was considering backtick as well, but I'm not sure if that's too unnoticeable

@Sp3000 yeah that's an issue too... even with NOPs the path should still be visible without too much trouble

so depth. might be useful, but it's not really well defined on an infinite stack

I can't decide whether one should be able to push 0s at the bottom and whether they should count

What do you mean?

well there are lots of ways to push 0s, right? if I do that on an "empty" stack, will those just be swallowed up by the infinite amount of 0s at the bottom? or will there be "custom" 0s now, which are included the stack depth

(I have Prelude-style stacks)

I'd say custom, right? As in the zeroes at the bottom don't count unless you do something that requires them

e.g. a straight + will make the stack look like [0], i.e. length 1

okay

now that # is free again, I could make that the depth operator

$ is weird for that

I noticed that I overlooked one relevant junction: a straight corridor where you're looking at the wall. that is, there's a neighbour to the left, one to the right, but neither straight ahead or at your back

this can only happen with very specific grid rotation setups

I've decided to keep the normal left/right with negative/positive switch. but if the value is 0, the direction is chosen uniformly at random. that gives a weird, cumbersome, but usable built-in PRNG.

I've already used it to build a random byte generator.

I still don't get grid rots :/

the commands shift one column or row by a single cell (cyclically)

the row or column is indexed relative to your own current position (with a popped value from the main stack)

so if 0 is on the stack, your own row/column is rotated

(and the indexing is modular in case it exceeds the grid)

Er... okay

also, if you shift your own column/row you move with the shift (potentially through the grid edges) before your normal move

okay, so I've got the following potential operators left: $&'[]`|

I could assign & and | to bitwise operators, but I don't have obvious choices for xor and bitwise not left

btw, I thought about adding several "floors" of the labyrinth which you could move between... these would essentially be usable like subroutines... but then I figured I'd rather leave that for some future (potentially successor) language

Yeah I was thinking that too (like Rail/Marbelous) but I'm not sure if that'd make coding harder to keep track of :P

I'll probably keep it in mind for Super Mario Lang (which will totally get pipes)

XD

I've got big plans for that one :D

added bitand and bitor now

how about $ for xor and ` for not?

I guess? There's not exactly much choice left :P

lol yeah

any idea for '[] then?

Not really. You can keep them open for now I guess and when you try coding you might come up with something you need

yeah, probably

[] might be something about the two stacks

well then it's writing docs, I guess

:P