An actual playable game!

TL;DR: win conditions, score, better network stuff meaning faster loading

While there is still much to improve here, you can now win (with a
score) and lose! The current level that exists has a goal of “make the
orbit more circular.” Here are all the possible scenarios right now:

• Drifting off into space, never to return!
• Crashing into Earth!

Both of these already existed but now there’s a limited number of burns
(currently 2) and when you run out you will see one of these three
things happen:

• Mission complete! This shows your score between 0 and 1000, with the
  latter meaning you got your orbit to be perfectly circular.
• The orbit became less circular
• The orbit didn’t change

All of these are possible now and the game can detect each one, and so
you can now actually play the game and get scores! In addition to win
detection, I optimized the network transfer of data so it doesn’t resend
all of the position information over the internet every time, just the
new stuff. This makes the game faster.

If you’d like, you can try the game yourself now at https://burn.jmeow.net!

Lots of new things!

Things in this devlog (now with bullet points and more emojis) that I did:

• fixed some bugs and did some refactoring so it’s easier to add stuff!
• loading indicators! (they show progress now!)
• changing burn direction! now you can fly off into space never to return
• explosion on earth impact! this fixes some weird stuff where you could go through the earth and when you hit the center it kind of shot off into space and broke.

As always, check out the live demo at https://burn.jmeow.net and join the Slack channel #burn!

Also: any thoughts on this type of devlog? Do you like it better or worse than my other ones? (this one has more emojis and is a bit more concise) Please comment your opinion or tell me in Slack if you’d like to.

Adding burns in the UI!

I changed several things in this devlog (well really only about two).
The first one is the time system. Now, under the slider, you can see the
time before or after “now.” The time in the future is predicted up to 8
hours ahead for selection of when to put the next burn. You can only
simulate burns in the future.

The other change is that now you can add a burn to the current point
selected in the future using an interface in the top right (early
prototype, the ui will be different later). You type in the number of
seconds the burn should last, move the time with the slider on the
bottom to when you want it to start. Then you press “start burn.” It
takes a second and I haven’t added a loading indicator there yet, but
does do things once you click it!

If you’d like to try these new changes out, go to the live demo on
https://burn.jmeow.net!

Note: I am aware that you can go right through Earth and it looks weird.
In the next devlog I’ll probably add an explosion when you hit Earth so
this doesn’t happen.

TL;DR: You can now add burns in-game and it simulates the trajectory of
the spacecraft 8 hours ahead.

A burn and some particles!

I made some big changes to the backend so that the game can modify the trajectory of the orbit more, and added a burn to slow down the spacecraft! Then I also added a fancy particle effect when a burn is happening that shows the thruster in use. The changes are live on the demo website if you’d like to check it out now!

Also… I’ve officially hit 20 hours of working on this project! (this is my longest hackatime project I’ve ever made lol)

Wheeeeeee

There is now a slider to control the simulation’s time! I also added a play/pause button to watch the animation at 1000x speed. (1x is extremely slow looking) In addition I made some server-side changes to reduce re-calculating things over and over again so my server doesn’t have to work as hard and loading times can be faster.

If you’d like to try the latest version out for yourself, check out the live demo at https://burn.jmeow.net!

3D Orbit Simulation Visualizer!

I integrated the backend I made recently for calculations with the new 3D engine! The orbit calculations run using NASA’s GMAT on my Mac Mini home server, which the website then fetches data from to display on the page. If you’d like to try this out yourself, go to https://burn.jmeow.net and click Play!

Note: if you are in the Hack Club Slack, join #burn for slightly more frequent updates and screenshots!

SPHERE MOVE YAY

I have begun the 3D-ness of the game’s graphics. This is likely what Earth will look like in version 1, although I might change it eventually. Probably won’t modify too much more about the 3D engine for now because I’m about ready to start adding actual simulations! That’s for the next devlog. In the meantime you can play with my movey sphere at https://burn.jmeow.net!

Note: if you are in the Hack Club Slack (which you probably are but I know these devlogs are public) join the channel #burn for slightly more frequent updates and more screenshots!

In-game UI (the beginnings of it anyway)

I made a design in Figma for some UI elements, and now I’m starting to implement it in my actual code. Next I will be starting a custom 3D engine for the simulations.

The screenshot is the current state of the UI (the square is a placeholder)

Custom satellite trajectory!

Turns out SPICE does not do everything I need it to after all, so I am going back to GMAT. Instead of compiling it to WebAssembly, I’m going to run calculations on my server (Maybe WASM in v2? We’ll see).

The image below is my custom 3d renderer made in my last devlog adapted to work with GMAT’s output. It’s showing the path of a simulated satellite in orbit around Earth as it starts a long burn pushing it off into space. The white circle is Earth.

Moon orbit… in a browser!

TL;DR: Spent a long time researching, also decided to use the SPICE library instead of GMAT for calculations, and run SPICE on a remote server instead of the browser. Images are the path of the moon’s orbit around Earth, drawn inside a web browser(!!!)

⋆⋆⋆⋆⋆⋆⋆⋆

So it’s been kind of a while since my last devlog. The main reason for this is that I’ve been working on things that can’t be tracked with Hackatime or measured very well, such as attempting to compile things (In the terminal, not an editor) or researching on various websites. (Speaking of which, here’s a really good NASA resource I found for explaining the basics of spaceflight)

I’ve decided to make some changes to how I’m going to simulate the game. Instead of using GMAT (Mentioned in previous devlogs), I’m going to use a different NASA program called SPICE. GMAT uses this internally, and SPICE is a library instead of a GUI application. Sadly, I have not yet managed to get SPICE running in a browser with WebAssembly, so I’ll be running all the calculations on a python web server. To summarize, I’m now using SPICE for calculations instead of GMAT, and running the calculations on a remote server instead of in the browser.

To demonstrate that this works, I made a webpage and simple python web server that calculates and displays the orbit of the moon around Earth for 90 days. It visualizes the orbit with a custom 3D engine I’m creating for this project. Screenshots of this are attached, where the rainbow line is the path of the orbit and the white dot is Earth. (Note: my 3D engine seems to stretch things out so it doesn’t look perfectly circular. I’ll probably fix this if I include it in the real game.)

⋆⋆⋆⋆⋆⋆⋆⋆

Edit: seems like Stardance isn’t showing all the images, if you can only see the first one, please look in the comments of this devlog for links to the other two!

Title screen!

In this update I added a title screen, as well as a small notice saying that the game is in development. This is so that when it’s deployed, people won’t get confused about why none of the buttons work on the title screen (they don’t yet). Speaking of deploying this, I put the current version on my site at https://burn.jmeow.net! Feel free to check it out, but be aware that the buttons don’t do anything just yet.

Next, I’ll probably be starting to experiment with WebAssembly and Emscripten, and try to compile NASA’s GMAT so it can run in the browser. (Don’t know what GMAT is? Read my first devlog for more about that!)

(Note: the screenshot attached is not of the entire page, the text isn’t this big in the real game. I cropped out the parts that aren’t interesting.)

I spent all day today configuring NeoVim (my code editor) and did not get much done so far. I did set up a web app with fun things like SCSS and hot reloading, and I made a cool splash screen (attached below)! Also made a simplified to-do list, which I’ll probably add more to at some point.

Fancy space visualization things!

I installed an open source piece of simulation software by NASA called GMAT (general mission analysis tool) which has a GUI and a scripting interface. (GMAT is really cool, though I sadly don’t understand much of it yet) It can output computer-readable files of where things go (among other things) and I made a demo program for reading these files (if GMAT is configured correctly) and visualizing the position of a satellite.

I’m planning to compile GMAT (written in C++) to WebAssembly so I can use its capabilities inside the game, for realistic physics. For now, I’m just pre-generating output files and showing them.

The image below is the path of a satellite being launched into orbit around the moon. Currently, neither the position of the earth nor the moon are shown, only the path of the satellite. The Z axis is also not shown yet, because I haven’t done much 3D graphics coding. The color represents time.

Disclaimer: This is my first time doing much with outer space and physics simulations, meaning I don’t know that much about it right now. I hope to learn more about these topics as this project continues in development!

TL;DR: GMAT = fancy NASA software for simulating/planning missions. I’m using GMAT for realistic simulations (currently manually, programmatically in the future). Image is of a satellite being launched into lunar orbit.

Welcome to Stardance!