Show HN: Tetris Implemented in ClojureScript | Hacker News Reader

Show HN: Tetris Implemented in ClojureScript

djblue.github.io

135 pointsdjblue25 comments

This is super condensed but still very readable if you know Reagent and Hiccup.

It's interesting to compare this to a lot of tetris clones written in TypeScript. There are a few that take enormous pleasure in defining a type hierarchy and what not.

Contrasting that to the very compact representation of tetrominos

    {:I {:color "#1197dd"
       :dim [4 1]
       :zero [1 0]
       0 [[-1 +0] [+0 +0] [+1 +0] [+2 +0]]
       1 [[+1 -1] [+1 +0] [+1 +1] [+1 +2]]
       2 [[-1 +1] [+0 +1] [+1 +1] [+2 +1]]
       3 [[+0 +1] [+0 +0] [+0 -1] [+0 +2]]}

and the very cute rotate function:

   (defn rotate [r] (-> r inc (mod 4)))

gives you a good idea what a Lisp is about.

Thanks! I really enjoyed the data modeling aspect of this project. I also ended up modeling the board as a mapping of [row, column] -> color which might be different from the traditional 2D array representation.

Why pick Typescript instead of Javascript as a comparison? there's really not that much difference in your example if plain javascript objects/arrays/functions was used.

Clojure has better and more map handling functions in the std lib for sure, but I find that with the help of some libs you can write lots of Javascript in a Clojury way without too much hassle.

Typescript is becoming a popular alternative to JS and is often being chosen to correct the perceived shortcomings of JS. Just like ClojureScript, which is often chosen to correct the perceived shortcomings of JS ;)

You picked on static typing, which Clojurescript doesn't have.

Yes, and Clojure exists in opposition to static types. There is always core/typed, but Rich Hickey does not like static types and Clojure was not intended to be written in that way. These days, with languages like TypeScript on the rise, static types are more fashionable than ever whereas Clojure appears to not be having the same momentum. While I like my static types very much, it never hurts to try to understand both perspectives and what they offer. To sell Clojure these days, you first have to sell dynamic types.

I picked on needless complexity due to top-down design not on static typing per se.

Here's a good video highlighting the difference of approach. Well worth watching. Applies to how many Java architects would design a solution. I see the same kind of top-down approach happening in the Typescript area as well.

https://www.youtube.com/watch?v=Tb823aqgX_0&list=PL0ydHZ1qvY...

Its statically typed, object oriented style is a good contrast to cljs.

I don't really see it. A similar approach in any imperative or functional language would read pretty much exactly the same.

Except that with static types, you'd gain a lot of clarity, efficiency, and future maintenance, one of the downfalls of Lisp.

to create obfuscated and undocumented code? That's known already.

The goal actually is this: being able to write descriptive and understandable code for others and oneself.

Come back to the code a year later and is it still understandable? Lot's of cute character-level operators and fancy control flow is maybe not the way to go.

Nice work! :)

A few years ago some friends and I wrote a tetris clone to celebrate the 30th anniversary of tetris and learn ClojureScript in the process. Really fun group project.

Playable here: http://t3tr0s.com/

Repo: https://github.com/imalooney/t3tr0s

Your project is substantially superior to mine. It looks so goooooood!

Here's my tetris copy: http://wolandbros.com/tetris/

Both the game and the source are much more minimal, it's very easy to customise the rules. You can see the source here: https://github.com/gunn/tetris/blob/master/src/store.js

Sweet! Thanks for sharing. I see you're using pure-store to manage your game state. My implementation also uses a redux pattern for state management :)

Thank you too! It's fun seeing the different ways we implemented the same things, even pieces and rotation.

pure-store is a library I made for very simple but efficient state management. The entire source is this file: https://github.com/gunn/pure-store/blob/master/src/index.ts

Here's a shorter cljs version [1], as a bonus it cross-compiles to the JVM and Js reusing the core logic.

[1] https://github.com/yogthos/clj-tetris/blob/master/src/tetris...

This is sick! Link to source: https://github.com/djblue/tetris

Thanks!

If interested in more ClojureScript games, I made Breakout: http://city41.github.io/reagent-breakout/

https://jstris.jezevec10.com/

The HTML page, which includes the JS scripts embedded, is only 75KB... not bad for a language so different from JS.

Up being rotate rather than hard drop is tripping me up. I guess I could fork it, though. :)

I was following https://tetris.com/play-tetris, but I would be down to change it. It messes me up when I use the HJKL mapping.

I really appreciated that it followed that convention because I was used to it. Also remembering 2 buttons (rotate and hold) makes it harder IMO. Being able to use up for rotate means I can just keep my finger hovered over the hold button. Then again I'm not much of a keyboard gamer.

https://github.com/djblue/tetris/blob/master/src/tetris/core... to update the mapping :)

Reply on news.ycombinator.com