Woah. It's time for the weekly...
🐸 TODEPOND TIMES 🐸
What's new this time?
Time Travel
If you didn't know, I'm making a new engine called Arroost. It's for the next video!
And in the engine, things can time-travel in a few different ways.
For example, something that happens in the future... can affect something in the past. The order of cause-and-effect isn't clear (or is it effect-and-cause?).
This week, I finished coding the engine's time travel! It works!!
To get it to work, I used a lot of lessons that I learned from my previous time travel engine, TimePond (an engine that lets you send frogs forwards and backwards through time).
Since then, a lot of things have improved. Let's look at some of the old engine's issues - and how the new engine fixes them.
🎵 Peak
The core concept is this: We *predict* what would happen at a different point in time. For example, we could imagine what the world looks like... half-a-second into the future.
I call this imagined world a "projection".
In TimePond, we made a projection of the *entire* world. If we wanted to know where one frog would be half-a-second later, we'd also need to figure out where every other frog would be - even if they didn't affect each other at all.
It wasn't just slow pointless work. It was also impossible (sometimes)! There were some situations that were just impossible to project. You'd get stuck in a loop trying to predict what would happen - even when the one frog you were interested in was straightforward to figure out.
The new engine, Arroost, avoids this. Instead of projecting the *entire* world, you can just project the single thing that you're trying to predict.
I call this "peaking".
Instead of seeing the world in its entirety, you just 'peak' at the small part that you're interested in.
🎵 Repeat
In both TimePond and Arroost, you end up calculating the same thing again and again.
Every time you change the world in the present moment... you also change the future of the world.
Sometimes a lot will change, but sometimes not. If you move a frog over on one side of the world, it probably won't affect the frogs on the opposite side! But either way, TimePond has to figure out the future all over again.
Arroost, however, has been designed in a way that makes it easy to spot repeated work. More often than not, we can say, "Hey wait a second. I've done this one before!"
When this happens, we can cheat by looking up our previous answer. This speeds up the engine and lets us make bigger stuff!
It also helps us avoid getting stuck in a time loop. If we try to figure out the same future twice in a row, we can safely assume that it's impossible to figure out - and we can give up. With TimePond, the engine often crashed in those situations.
🎵 Discrete
TimePond was continuous. What I mean by this is... two things.
One: Time flowed forwards continually, measured in milliseconds.
We only display what's going on when the screen refreshes. Usually this happens 60 or 120 times a second. But whatever the case: In between those frames, any number of things can happen.
It's not like chess, where one piece moves at a time. Everything is constantly moving.
And also... Two: When things move, they can move any distance - at any speed. They can move a very very small amount, or they can move very very far.
So when you're trying to predict the future (or the past), how far do you look?
In TimePond, I picked an arbitrary number. It only looks half-a-second forwards. If you time-travel again during that period, it doesn't work. There's no *recursive* time-travel!
However, Arroost is discrete. The rules are as follows: You can only travel 1 beat into the past (or future). And you can only interact with what you're currently touching.
This might sound like it limits you. But really, it does the opposite. It means that you can recursively time-travel as far forwards or as far backwards as you want (unless you run out of memory).
The main point is: The engine knows how far it needs to look. So it won't get stuck looking in the wrong place.
🎵 Symmetry
There's one more thing. TimePond was built for going forwards through time.
Time moves forwards. And things travel forwards with it.
This worked fine for most types of time travel, where you jump to a different point in time. But it didn't work for one specific type of time travel: Tenet-style.
If you haven't seen it, Tenet is a ridiculous film where objects (and people) can be 'inverted'. This means that they start to travel backwards through time, instead of forwards.
I did actually figure out a way of making this in TimePond, but I ran out of time so I didn't finish it. And it involves playing the recorded footage back in reverse to create the desired effect!
With Arroost, I've made sure that the future and the past are exactly the same sort of thing. Traveling to the future is no different from traveling to the past. You can predict each one in the same way. And things can travel in either direction.
I probably won't showcase this in the upcoming video, but I hope to get to it one day! (in the future) (or the past) (or the present)
Thank you so much for your support, and helping me to work on these weird projects! I really can't express how thankful I am. And welcome to all the new patrons this week! Until next time, I hope you have a good one! 🐸
Days since tode fell asleep: 133
Days since bot went missing: 98
Share this post