Show HN: Pong Wars

boredhedgehog · 2024-01-28T07:29:45

I'm greatly fascinated by this kind of thing, but I have to call it "this kind of thing" because I don't even know if there are genre terms to categorize and analyze them.

They're inspired by game algorithms, but they aren't games; Conway's "Game of Life" was a misnomer. They're animated, but they aren't scripted like animations. In the real world we have someone like David C. Roy, who calls his art "kinetic sculptures".

Algorithmic motion pictures? Game simulators? Autonomous automatons?

rickdeveloper · 2024-01-28T09:55:07

I have seen the term "zero player game" used for this. There is even a short Wikipedia article: https://en.wikipedia.org/wiki/Zero-player_game.

drclegg · 2024-01-28T11:39:20

I'm a fan of the term "toy", in a similar lens as "executive toy"

lou1306 · 2024-01-28T14:12:16

Chaotic systems? As in, fully deterministic systems that are highly sensitive to initial conditions?

EDIT: browsed the code a bit and there is some randomness in the bounce dynamics, so it's only "fully deterministic" if you count the PNRG seed as part of the initial conditions.

chrisweekly · 2024-01-28T18:38:43

If it's chaotic, is it still fully deterministic?

linkdd · 2024-01-28T18:56:20

Chaotic means "small change in initial conditions lead to big changes in long term behavior". Best examples of this are double pendulums.

It is still fully deterministic.

wavemode · 2024-01-28T15:47:12

"Simulation" probably covers it.

quijoteuniv · 2024-01-28T08:16:55

Algorithm haiku

archon1410 · 2024-01-27T20:58:55

The code links this tweet as the source of the idea: https://twitter.com/nicolasdnl/status/1749715070928433161 [nitter: https://nitter.net/nicolasdnl/status/1749715070928433161]

Quote: "The endless fight for #genuary23 #genuary #genuary2024

It's not an original idea, I've seen this before but couldn't put a hand on it."

It says the battle is endless. I wonder if there's any way to mathematically prove that.

bazzargh · 2024-01-28T00:33:37

I think further back, part of the idea may have been mine.

https://hachyderm.io/deck/@bazzargh/111829275276749971

Originally I saw https://twitter.com/CasualEffects/status/1390290306206216196 which the author says was based on a pico8 original (which I remember seeing, but can't find now). Those earlier ones had the pong bats as well, but when I did the demake in basic, I couldn't fit the code into a tweet to get the bbcmicrobot to run it. So, I removed the bats.

Mine is a bit slow and janky, @rheolism (I think?) posted back a much faster, smoother version using custom characters instead of plotting, and then I saw a remake of the demake in processing? These things take a life of their own.

Anyway, long ago deleted my twitter account, but dug it out of the archive.

geor9e · 2024-01-29T04:09:30

>mathematically prove

I'll give it a rough swing. I probably overcomplicated the endgame I describe below, and maybe make some assumptions that aren't actually how the mechanics work, but hopefully it's understandable.

The balls are about the same size as the blocks. Lets say they are infinitesimally smaller, so they can still fit down a 1 block wide tunnel.

Imagine the gameplay somehow gets into the condition that both balls are in tunnels, but white in the worst way (perfectly aligned, so it just bounces off the far ends) and black in the best way (barely zigzagging in a nearly straight line, killing all wall blocks, leaving a 3 block wide tunnel in it's wake).

This would result in whites tunnel rapidly shrinking. Even if white exists in a 2x1 tunnel and is getting kills, black is still killing at almost 2x the rate.

White will be in their 2x1 tunnel, make it into a 3x1 tunnel, but it will become a 2x1 tunnel again by the time it's bounced a little over a block. Now suppose black then reaches the (white) end of their tunnel, scoring 3 kills in almost the same instant. There's nowhere to spawn those three that doesn't clash. The app will either crash with a null value error, or some other result that qualifies as an end condition since it would break the fundamental rules of the game.

conductr · 2024-01-27T21:31:48

Each ball will occupy a minimum area of 1x1, so the opposing ball can never occupy 100%

geraneum · 2024-01-28T09:50:12

The first time I opened the link, I kept watching until both balls ended up in a point where they blocked each other between opposite side’s tiles. The was no way to go and they kept bouncing off each other in a tiny space. I wouldn’t call it an end but there was no progress anymore either.

soneca · 2024-01-28T10:49:58

I got to a similar place, but it only lasted one or two seconds, then they got separated and the game continued

sgtnoodle · 2024-01-27T21:09:26

Well, it seems like there must be a relatively stable equilibrium. As the owned area decreases, the rate of annexation increases.

GolfPopper · 2024-01-28T00:50:15

Mine seems to have reached a meta-stable state after running for a few hours around 320/704, where the ball with less area is bouncing almost vertically, and a nearly flat border between the two.

https://i.ibb.co/7bNTtsK/daynight.png

eps · 2024-01-27T22:47:15

The smaller the area, the more bounces its ball gets per time unit compared to the opponent and more chances to expand the area. So any extreme case of one ball being super-confined will be very short-lived.

realPubkey · 2024-01-28T00:22:46

But it seems that the balls speed increases with a bigger are.

teraflop · 2024-01-28T02:19:58

From what I can see from a quick glance at the code, you have the causality backwards. Each bounce adds a small random variation to each ball's velocity, and if one of them randomly ends up moving faster, then it will tend to gain more territory.

throwup238 · 2024-01-28T02:18:52

I think the changes to speed are random: https://github.com/vnglst/pong-wars/blob/main/index.html#L16...

hombre_fatal · 2024-01-27T22:23:08

You can see what happens when the left ball has one tile and the right ball has the rest of the tiles:

    x1 = y1 = y3 = squareSize, x2 = canvas.width - squareSize
    squares = Array.from({ length: numSquaresX }, (_, i) =>
        Array.from({ length: numSquaresY }, (_, j) => 
            i === 0 && j === 0 ? TEAM1 : TEAM2))

nonfamous · 2024-01-28T16:30:16

I didn’t grab a screenshot, but I did see how the simulation can end. The day and night balls collided with each other at the boundary and got locked in place in a tight infinite loop, and never moved again.

mlhpdx · 2024-01-28T21:00:16

I saw this as well. Shall we call it “entanglement “?

barnabee · 2024-01-27T21:36:31

It would be interesting to know if it can get into a looping state after which it just repeats previous moves forever. I guess that would be an “end” of sorts.

cjg · 2024-01-27T22:46:54

Because there are a finite number of states, it will always loop.

An interesting question might be around how many distinct loops there are and whether there's some pattern to the loop lengths.

schwartzworld · 2024-01-28T00:49:30

> Because there are a finite number of states, it will always loop.

No it wouldn't. The fact that it will pass through every state infinite times doesn't mean it will do it in the same order each time. Each digit of pi has only 10 possible states, but it never loops.

tedsanders · 2024-01-28T01:02:53

If the state evolution:

(a) is deterministic

(b) depends only on the current state, and

(c) can only occupy a finite number of states

then it will loop.

Pi digits do not satisfy this because while the digit space is finite (10), the next digit depends on more than just the prior digit.

Related (but not the same): https://en.wikipedia.org/wiki/Poincaré_recurrence_theorem

bobsmooth · 2024-01-28T02:20:29

The speed of the balls are changed by a small random amount when they hit a tile, so it's not deterministic.

Scarblac · 2024-01-28T08:54:53

If it's a deterministic RNG then it just means the state space is very large.

BriggyDwiggs42 · 2024-01-28T01:30:55

Ooh that’s cool I’ve never seen that before.

Someone · 2024-01-28T18:44:48

I expected a side to win or score a point once it hit the ‘goal line’ of its opponent.

Would make a nice game if there was a way for players to have some control over the ball. Could be as easy as standard pong paddles, with some time delay whenever your ball passes your own goal line.

lou1306 · 2024-01-28T14:17:16

It should suffice to check out what happens (code-wise) if one of the "players" has only one square left. Does the "winning" player have a chance to hit that square and conquer it? Or does the program immediately register a collision for the "losing" player, who goes back to two squares?

onionisafruit · 2024-01-28T15:03:42

That could show that it’s endless, but it wouldn’t necessarily show that an end is possible.

noSyncCloud · 2024-01-28T15:19:14

I don't believe an end is possible. As one player's territory sprinks, it should quite naturally follow that it will have less travel time, hence more collisions.

noSyncCloud · 2024-01-28T15:19:53

s/sprinks/shrinks

baq · 2024-01-27T21:01:59

By definition… if there’s no end condition, it won’t end ;)

geor9e · 2024-01-29T03:35:23

It's ambiguous. The end condition could be a pixel spawning with overlap on a ball because there's nowhere else to go. What will happen when there's no room left to add one more pixel, and it tries to add one more pixel? Will it place it with the collision boundaries on the wrong sides? Will it crash with a null value error because there's no good spot to place it? Can't know without understanding the code. But there are many possible end conditions.

They're asking if one can prove that you never reach any situation where an end condition (intended or not) could ever exist.

Imagine black has a long horizontal 1 pixel tunnel, but it's zigzagging down hitting every side pixel rapidly, while white has a long white tunnel and it's bouncing perfectly horizontally, taking a long time to hit each end. As the ends close in on white, is there some perfectly aligned timespan where black can hit a pixel while white doesn't have a full pixel of open space on either side? It would be interesting if someone can articulate logically why or why not that would ever happen.

praptak · 2024-01-27T21:10:33

On top of this there's a negative feedback loop. The ball whose territory gets smaller has less distance to travel between hits.

This means that even if there was anything resembling a "win" condition it would be hard to achieve.

mrec · 2024-01-27T21:38:36

You'd think, but I'm currently looking at a 161/863 split which has been pretty stable for a while now. I thought at first that ball speed is being scaled by territory size to cancel out the negative feedback, and the "winning" ball is moving noticeably faster than the losing one, but I can't see that being deliberate in the code. (There is some randomization of speed on a bounce, but it ought to be pure noise.)

EDIT: 120/904 now.

geor9e · 2024-01-29T03:38:02

That just explains why it tends towards balance. It's just like all the air molocules in a room reliably bouncing around where you can inhale them. There's no hard law of nature saying all the air wont move to one side, suffocating you. It's just statically extremely improbable.

But they asked for proof for or against a possibility at all, not whats probable.

yellowapple · 2024-01-27T22:34:53

One possible win condition would be a ball reaching the opponent's side. That happened in my case, with "night" eventually breaking through to the left-most edge.

keyle · 2024-01-27T23:20:27

Which makes the name War even better. There is no winner in war and the cycle repeats itself.

dorus42 · 2024-01-28T11:59:52

My 12 year old son just made it in Scratch:

https://scratch.mit.edu/projects/957461584/

jprd · 2024-01-28T13:47:28

You are rightfully proud!

sega_sai · 2024-01-27T22:08:30

It is really cool. It would be interesting to make the speed proportional to the either the number of squares owned or the square root of that. Because right now as the area the ball owns gets smaller, the number of hits will increase at the same speed.

JKCalhoun · 2024-01-27T22:10:53

Like the card game, "War", it seems to self-regulate that way. I assume neither side will ever win.

yellowapple · 2024-01-27T22:36:57

With "War" it's indeed possible to win, though.

stevekemp · 2024-01-28T14:58:01

The only winning move is not to play?

sodality2 · 2024-01-27T23:19:11

War is also entirely deterministic and contains no choices, so some don't consider it a game

Waterluvian · 2024-01-28T00:28:41

Hmm! Because once the cards are shuffled everything is a fixed series of events?

Would Snakes and Ladders be the same then if we replaced a die with a randomized deck of cards of the numbers 1-6? And in that sense: any “game” that’s purely random is also not a game then?

jaredsohn · 2024-01-28T07:30:14

Agree but I think these things can be considered games in the sense that it gives younger kids practice in following rules and interacting within a group. Also is an activity for them to spend time and there is a concept of 'winning' even if the participants cannot impact that.

ramijames · 2024-01-28T13:26:12

This is genuinely beautiful on a few levels. Esthetically it is pleasing to just sit and watch. Philosophically it is interesting in that it is a digital metaphor for an ongoing struggle.

Lastly, and most interestingly, it remixes two really simple old ideas into something new. This is an exceedingly rare thing to do well.

Kudos. Many kudos.

busfahrer · 2024-01-28T17:13:08

Also, it sort of models yin-yang both in what the game is simulating as well as what is presented visually

senkora · 2024-01-27T20:49:17

See also OP’s post on Mastodon: https://hachyderm.io/@vnglst/111828811496422610

geor9e · 2024-01-27T20:52:17

3 colors would get interesting, because as the other two bully one into a corner, the small space causes rapid block zapping, quickly bringing it back from the brink of defeat.

brown · 2024-01-27T22:38:19

4 players: https://codyebberson.github.io/pong-wars/

almostnormal · 2024-01-28T00:27:56

In that one balls seem to be able to punch through (and flip) squares (when going almost vertical) instead of bouncing on every square they hit.

bitcurious · 2024-01-28T15:07:25

It's a bug/choice that is present in the original as well.

macintux · 2024-01-28T15:56:54

Spent a fair bit of time watching that one last night, thanks. I can definitely see why computer scientists were entranced by Conway's Game of Life.

DylanSp · 2024-01-27T23:04:56

That's definitely cool to watch, the patterns of territories get a lot more complex.

breaker-kind · 2024-01-28T03:26:53

https://contranoid.com/

cypherpunk666 · 2024-01-28T04:21:34

€0.02 another pong variant, desktop only tho... https://www.obfusco.com/pn0gjs/index.html

ognarb · 2024-01-28T01:19:10

Just did an implementation of this in C++ with Qt Scene Graph as a learning experience in case someone is interested https://invent.kde.org/carlschwan/warpong/-/blob/master/src/...

TacticalCoder · 2024-01-27T21:08:18

There's beauty in knowing that one could be ported and run perfectly fine on any old 8 bit computer! So simple yet mesmerizing...

wkjagt · 2024-01-28T12:14:05

Now I want to try this on my Commodore 64. I should already have some code I could reuse as I was already working on a breakout type of game. So the “clearing a block and bounce the ball back in the right direction” should be somewhat reusable.

jmmv · 2024-01-28T21:40:40

So cool I had to spend an hour replicating it in EndBASIC: https://repl.endbasic.dev/?run=jmmv/pongwars.bas -- Super-hacky and buggy, but it works for a quick demo! Make sure to press any key while this runs to drop into the interpreter and play around :)

totetsu · 2024-01-28T03:47:38

It’s like staring into a mirror for the soul. It’s just dots and square why should it feel so dramatic

billylo · 2024-01-27T21:39:32

What if it has real paddles? left-hand (using A,Z) vs. right-hand mode (K,M)? :-)

NKosmatos · 2024-01-27T22:55:39

Hey, I can see an addictive mini game being developed pretty soon… I’m sure one of the bright minds of HN will offer us this game so we can alter/control/influence this never ending battle of the two pongs :-)

netsharc · 2024-01-28T00:01:49

Seeing "day" and "night", I thought the site was taking the local time reported by browsers of all the visitors, and rendering a "pie graph" of the proportion of visitors currently with daylight and visitors without daylight...

Although I suppose with the planet's unequal distribution of population (and then the distribution of HN visitors), such a graph would have a correspondence with the time of day.

Now I'm wondering if there is a visualization of time of day at Z vs number of world population in daylight (assuming good weather and no smog...)

notfed · 2024-01-28T03:59:23

Hold my beer.

notfed · 2024-01-28T04:00:08

Done, I opened a pull request for this.

https://github.com/vnglst/pong-wars/pull/5

notfed · 2024-01-28T07:44:26

Hosted it here: https://identity.pub/pong-wars-web/

Control the paddles with:

- Q (Player 1, Up)

- A (Player 1, Down)

- P (Player 2, Up)

- L (Player 2, Down)

dbrueck · 2024-01-27T23:22:32

Darn, I wish they had named it breakout wars instead.

layer8 · 2024-01-27T22:57:34

There’s a universe in which it will reach a yin-yang configuration.

joshuahutt · 2024-01-28T02:49:58

Mine did.

https://imgur.com/a/DC8iqY1

jareklupinski · 2024-01-28T17:03:15

sometimes you gotta make the universe

https://imgur.com/a/dtY960z

https://github.com/vnglst/pong-wars/pull/8

orenlindsey · 2024-01-27T20:37:33

Only a single HTML file. All you need.

geor9e · 2024-01-27T20:57:19

I thought this comment was saying they only used html like this other HN post was talking about https://www.htmhell.dev/adventcalendar/2023/2/ . But no, the comments just saying they put all the .js and .css inside the .html file.

quercusa · 2024-01-28T18:32:29

Setting the with to 1200 in

give flatter bounces off the long walls. This makes for some interesting 'drill' patterns

busfahrer · 2024-01-28T22:29:12

This reminds me of a blog post a while advocating less state, as a demo they implement the infamous DVD screensaver completely stateless.

throwaway2046 · 2024-01-27T20:36:35

So hypnotizing... I was waiting for something magical to happen when the two balls touch.

zeeZ · 2024-01-27T21:20:55

The dividing line slowly shifted to diagonal and then horizontal.

JKCalhoun · 2024-01-27T22:11:29

Saw them get kind of intertwined briefly.

Wowfunhappy · 2024-01-28T02:55:22

I wish the speed of the balls didn't change. I would prefer that randomness come from slight changes to the bounce angle.

charlieyu1 · 2024-01-28T10:11:04

Interesting, but is it possible to speed up, or change the color scheme?

Duanemclemore · 2024-01-28T15:36:07

Tooo cool. I sat and watched it play for a length of time that's longer than I'm comfortable admitting last night.

ericskiff · 2024-01-27T22:12:29

Oh man - I love this, but I thought it was going to be a loving write up of the freeware “mortal kombat but it’s pong” game from 1994 https://archive.org/details/msdos_Pong_Kombat_1994

BugsJustFindMe · 2024-01-28T00:30:53

Or the better named Mortal Pongbat https://www.macintoshrepository.org/5394-mortal-pongbat

prakashn27 · 2024-01-28T08:52:29

Can someone explain what is use of this ? Is there something I am missing?

More confined the area ball bounces more Other ball always occupies 1 spot at time

These two conditions make this game never ending

reqo · 2024-01-28T09:00:02

It does not have to have a use or a point, it is up to you to decided what it represents. I see at as an interactive yin and yang!

fifilura · 2024-01-28T09:03:39

It represents a statistical distribution.

Probably not a a bell curve but something related.

The use of it? Humanity has yet to find out, but there are lots of uses for other statistical distributions.

Maybe it finds it use in a machine that calculates the optimal route for autonomous robot drones to take in a warehouse? (Just making it up)

Meanwhile it is there for you to enjoy. A toy.

widea · 2024-01-28T11:01:42

Interesting, I wonder if randomness and jitter as its source play a part here. Than, is this the visualisation of a True Random Number Generator?

Tepix · 2024-01-28T01:30:22

Neat. Isn't it a bug that sometimes the ball drills deeper?

wkjagt · 2024-01-28T12:18:13

I don’t thinks so. It’s a bit like in a breakout game where the ball gets “stuck” behind some blocks and clears a ton of them by bouncing back and forth between them.

pests · 2024-01-29T03:11:18

I think there is.

The ball can wedge itself between cells that are touching and then it penetrates 5-6 cells in clearing the whole path instantly (probably as it's bouncing between the 0 pixel gap between cells).

I had just started the sim and the left ball on its first or second bounce suddenly took a major section of the right side.

MegaDeKay · 2024-01-28T16:41:10

This would look great running on a HUB75 LED panel driven by an ESP32!

qwertyforce · 2024-01-27T20:42:26

dx1*=2; dy1*=2; dx2*=2; dy2*=2;

qwertox · 2024-01-28T12:10:30

Great idea, but watching it makes me feel terribly anxious.

pbiggar · 2024-01-27T21:02:57

Would love to be able to speed this up!

sbarre · 2024-01-27T21:28:51

I had the same thought... If you drop this in the console you can speed things up:

    dx1*=2;dx2*=2;dy1*=2;dy2*=2;

edit: someone else in the thread figured out a better way, I updated mine, but credit to them.

Although it has accuracy issues when you get too fast...

jb1991 · 2024-01-28T10:13:51

This is unexpectedly hypnotizing.

robblbobbl · 2024-01-28T10:23:11

haha cool, reminds me of kid cudi day 'n' night

tamimio · 2024-01-27T21:22:03

It look like the white ball is faster..

sbarre · 2024-01-27T21:36:26

The code introduces some speed variation on each bounce, either positive or negative so it's possible that over time one ball ends up a lot faster?

Waterluvian · 2024-01-28T00:26:44

I love how the “losing” side has a shorter distance to go to “fight back” so it is a somewhat endless battle.

eigenvalue · 2024-01-28T02:18:30

Not trying to steal anyone's thunder here, but I was so taken with this little program when I saw it earlier today on Twitter that I thought it might be fun to make it somewhat interactive, so that the players could actually influence the path of the balls using the keyboard, and also activate a "speedup" (mode but at the expense of their ability to influence the path). I also added some charts to track the state over time. You can "play" it here:

https://dicklesworthstone.github.io/ball_fighters/

And code is here:

https://github.com/Dicklesworthstone/ball_fighters

I give full credit to the original author of this post FWIW.

notfed · 2024-01-28T04:10:46

I just did my own mod, hosted here:

https://identity.pub/pong-wars-web/

Control the paddles with:

- Q (Player 1, Up)

- A (Player 1, Down)

- P (Player 2, Up)

- L (Player 2, Down)

Pull request opened:

https://github.com/vnglst/pong-wars/pull/5

> I give full credit to the original author of this post FWIW.

Ditto :)

starshadowx2 · 2024-01-28T05:01:48

Sometimes a ball gets stuck behind the paddle in your version.

voisin · 2024-01-28T04:07:53

Something seems off in the behaviour, at least on mobile. The bouncing doesn’t seem to be the same.

eigenvalue · 2024-01-28T04:20:10

The original collision behavior glitched (the ball would skip through blocks of the opposite color)when the velocity was higher, so I tweaked it a bit so that wouldn’t happen. That probably explains the difference.

（评论） (comments)

（评论）
(comments)