The other hardware change that needs to be done is a proper display... we can make everything use the new smaller metacells, then have a small display of the old metapixels and memory-map..

I don't think _x16 will be a sufficient resolution for Pong, unlike Tetris

@DaveGreene you around?

we'll see if that shows up in the inbox

I can always go onto the forums but

@KZhang so, I'm no GoL expert, but what I was thinking could work for busses is if they worked by transmitting columns of LWSSs

There's always one on the top, to trigger whatever mechanism is on the other side for receiving, and then one present/absent for each bit

They travel from one bus to the other

Making them duplex could be more complicated

@PhiNotPi Is there a way to fetch multiple local variables from one call in Cogol? (I find that mechanism really interesting)

@quartata It's been a while since I've looked at it.

But I don't think so.

That isn't to say that a mechanism can't be added if necessary.

It's not, just an interesting thought

I agree that call is a pretty wacky feature.

I mean, you can just use the returned pointer to fetch multiple local variables, actually.

Be kinda tricky -- easy to clobber the frame...

It's super-duper important that you retrieve any data that you want before performing another call, which totally screws everything up.

So, I've asked this before but it's worth bringing up again

Do you want to post Pong as a challenge and then work on it and answer it

Or should we just make it and make like a small blog post

And not bring PPCG into it

The trouble is that a spec for Pong, especially networked Pong, would be very particular...

For instance we'll probably need some form of lag compensation -- rewind the ball to when the "packet" was sent

I'm down for making a challenge, but I think it'll only work out if we have significant improvements at every level of our design, and have a broad enough spec that others can theoretically compete.

The latter point is the trouble

We have a lot of improvements in store

(particularly in just flat out golfing, if we get 8x8 and the new metacell working)

Of course, for these challenges it's not like anyone's gonna outgolf you

@quartata I'm not entirely sure about how to convert a metacell signal to a stream of gliders/LWSSes, considering that metacells take thousands of generations to pass their signal from one metapixel to another.

Yeah, I don't know what the exact machinery would be, I just meant the concept of emitting spaceships would be ideal. Rather than chaining metacells

There are LWSS guns obviously

How to toggle them, I don't know

Do the instructions as I've implemented them in the interpreter seem feasible?

Hardware wise, the buffer for the receiving end of a bus does not have to be particularly big -- 2048 bytes would be ideal but

(I linked the PR above)

(this one)

It sounds doable, I'll take a look into it.

For recieving data, should do 16 bits instead of just a byte?

Most protocols we'd be implementing on top of it are octet oriented

Would it be easier to work in full machine words?

I'd imagine that both would be fine, but only utilizing 8 of the 16 bits seems a bit inefficient.

I guess I'll do a byte first, and go from there.

Hmm

Well, the emulator does actually work with 16-bit words, since JS does UTF-16

It's just that stuff like Ethernet all are 8-bit

I guess I don't have to use the high bits for that

OK, sure, word

I intend to implement at minimum Ethernet + ARP on top of this, for reference

What exactly is the current plan with ports and networking?

We only need one duplex bus for Pong, but it would be cool to see how many could fit on the computer (one on each side?)

@PhiNotPi For Pong, it would be simple peer-to-peer

They connect to each other, and start a game timer

When one moves their paddle, it's sent to the other along with the time

So the other can see what the position of the ball was then

No attempt to actually verify anything

When working in the emulator, the Websocket bus could be used to play over the Internet

I'd write a simple Ethernet "bridge" over websockets in C that would run on El'endia's server

both connect, put in the "IP," ...

That'll be cool.

Main trouble is we'd probably want DHCP actually

so that you don't have to risk picking an IP for yourself only to have someone else have it

What's the plan hardware-wise for the computer?

Aside from the busses, we have 8x8 tiles and the new metacell to reduce size, as well as proper video memory using the old metapixels (since the new metacells aren't really visible)

This will give us a chance to increase resolution

I don't think there are any other hardware plans aside from that

We don't need floating point

We don't need a proper clock

The rest is all about the toolchain: GCC, assembler, linker, metafier

For some reason I can't help but visualize minecraft minecart stations/networks when thinking about networking.

hahaha

Networking is actually a lot more slip-shod than you might think

In naive Ethernet setups packets are just passed along until someone decides to act on it (hopefully someone with the matching MAC address)

Under ARP, resolving an IP to a MAC address means broadcasting to everyone, then someone can broadcast a reply with the MAC address

It's all hideously insecure, honestly

But it works, as long as there is a path...

@KZhang ^ figured this was appropriate

lmao

@PhiNotPi This is beautiful.

Oh woops, don't merge that PR yet, I did the WS receiving a bit too hastily

Well, you guys started this all, I just joined in and added on to the original hardware with a bunch of trial and error. I did none of the interpreter work, compiler work, hardware architecture decisions like RSIC and harvard layout, the tetris programming, or metacell design. Give yourselves some credit, too!

all right that should be better

@El'endiaStarman I haven't a clue about how permalinks work, but preserving bus configuration in them would be good

Should do that next

I am actually pretty happy about the job we did with hardware design... measure twice, cut once. We made our instruction set before building logic circuits, wrote the first compiler draft before having an interpreter, and basically simulated tetris before completing any significant portions of the actual hardware.

OK so I forgot that Mego actually found this Pong challenge:

The trouble is if we implemented, say, a better AI, we'd be non-competing

Of course, now I wonder if we'd run the risk of getting closed as a duplicate if we made our own