Alex's Taxes by ExMachina

This is our first game jam, made by 3 people in a rush and still managing to do 100% of the assets ourself (Except the audio). It has a few known bug due to the fact that we all had work and school in-between so feel free to point them out and also if any challenges feel too hard or too sketchy notify us(We did that part in a rush)
Art: @thaDev / Greg
Programming: @ExMachina / Greg
If you have any problems with the WebGL build in here It should work on Itch.io >>> https://adrian641.itch.io/alexs-taxes
Also :: Move - WASD
Jump - Spacebar
Dash - L \ Mouse Right Click
Directional Dash - add any of the WASD to the dash
Wall Climb - M \ Mouse Left Click
| Link | https://github.com/Adrian641/LD-58 |
| Original URL | https://ldjam.com/events/ludum-dare/58/alexs-taxes |
Ratings
| Overall | 397th | 3.5⭐ | 27🧑⚖️ |
| Fun | 336th | 3.44⭐ | 27🧑⚖️ |
| Innovation | 628th | 2.8⭐ | 27🧑⚖️ |
| Theme | 613th | 3.24⭐ | 27🧑⚖️ |
| Graphics | 256th | 3.98⭐ | 27🧑⚖️ |
| Audio | 312th | 3.386⭐ | 24🧑⚖️ |
| Humor | 257th | 3.354⭐ | 26🧑⚖️ |
| Mood | 369th | 3.583⭐ | 26🧑⚖️ |
| Given | 33🗳️ | 29🗨️ |
L/Right click for dash
M/Left click for wall climb
As for all the other physics interactions it's a bit more complicated but it should resemble (As close as my sanity allowed me) Celeste's mouveset
I'd also prioritize having the tutorial be a little more fleshed out to make sure that players don't have to leave the game to check the description or post-submission comments; you might lose a lot of players immediately because they might not have the patience to go hunting for control schemes.
I just wish I could have seen all you guys had to offer, this seems like such a fun little game!
To go over what is playable, the move set is very fluid! It really does the Celeste style very well. I like how even the feather on the cap indicates the dash has been used. The two conversations I can have are funny, and the visuals are very well done. I do hope you can fix the scene transitions so I can play some more of this game.
But it still very well done!
One bug I think is that for me using Left and Right mouse button does nothing so i had to use m/l for dashing and climbing
Some suggestions:
* Make the dash along the current movement, sometimes I died because of a miss click and instead of going in the same direction as the character if I have not direction pressed the character goes to the right.
* If you miss, click dash while you are climbing, you lose the dash without doing it. I will be more permissive here and avoid losing it.
* Inform the user about the hat mechanic, which shows if you have a dash available or not. I realized because I played Celeste, but other players could not be aware.
* I think the difficulty curve is too steep at the beginning, I would present some forgiving levels to get used to the controls first.
I would have liked a little more checkpoints, I ended up having too much trouble near the end of a level (a level in the stone area where you have to jump left out of a platform and dash up without hitting the spikes on the ceiling nor the ones just bellow at the arrival). I also felt the mouse controls where weird, I sort of got used to it (but I kept clicking outside the screen and it paused the game)
The levels were pretty well designs, you sort of got the hang of it through-out the levels, but I think for someone that hasn't played Celeste the learning curve was a little steep, but it was alright for me. Maybe a little "twist" over the gameplay of celeste would have been nice (or maybe there was one, but I just didn't reach it?)
I really liked the controls, it didn't feel like the character was floating nor that it had no inertia. The graphics were also nice, especially the background.
Overall well done, hope you will keep making games

First of all, this is *awesome* - It's especially incredible that this is your first Ludum Dare! You should be extremely proud of what you built. I've got a lot of feedback, but that's because the game is already extremely high quality, and the little details are what would really bring it over the top
In addition to being awesome, this was also *brutally* hard lol - It took me about an hour and a half to beat, and I love tough-as-nails platformers
Other folks have already discussed the controls, so I'll just echo that I unfortunately never got used to them - I'm not sure if it's because I'm using a US QWERTY keyboard, but trying to use the arrow keys, L, M, and Space was extremely awkward, as was WASD, L, M and Space. I ended up using WASD, Space, and the right mouse button, while *always* holding down the left mouse button, and this was the only way that I get past the more difficult challenges.
In terms of visuals, I loved the parallax effect in the intro area, and the sprites all individually look very good! My only feedback is that it would feel more cohesive if sprites were drawn with a uniform pixel scale. It was strange seeing background elements with huge pixels alongside foreground elements with tiny pixels, and it was especially noticeable when one element would have differently sized pixels inside of it - One example is this small tuft of background grass - If pixels were all the same scale, everything should be lined up on a 1x1 grid, but somehow things get offset by quarter pixels throughout the grass tuft:

Were you drawing your art in such a way that one pixel in your program of choice didn't represent one pixel of the finished sprite? Generally, the easiest way to create pixel art is to draw at a 1:1 scale, and then upscale it with nearest-neighbor interpolation by 1x, 2x, 3x, etc to fit your target resolution. That will easily give you consistently sized pixels, and sticking to whole number scales will avoid any artifacts from upscaling :)
In terms of level design, there were some challenges that felt great to clear, and others that felt very frustrating - The best challenges were the ones where death was an opportunity for learning, and where nailing the challenge rewarded me with some really fluid platforming to enjoy. The most frustrating challenges were the ones where I had to thread an incredibly tiny needle, and had to very slowly and precisely set up each attempt.

The above area is an example of that second type of challenge. I was banging my head against the ceiling again and again trying to hit the finicky wall jump to get through this gap, and it was really unclear *why* the game was asking me to do this. It wasn't particularly fun movement, and there wasn't an interesting puzzle to solve; it just felt like precision for the sake of making things harder on the player. Whenever you create a challenge, it's best to think about the experience you want the player to have, and build the challenge to provide that feeling. :)
Finally, I did run into one physics bug that unfortunately *really* negatively impacted the game feel: Physics seem to be nondeterministic, and the same inputs can produce drastically different results. This was particularly frustrating to discover at one of the last sections of the game, where I could only make the last dash *sometimes*. I suspect that the issue is that you're updating the player's velocity (or a timer for dash length) during update, but you need to be doing physics calculations like that during fixedUpdate or they will be unstable. The below gif shows what I mean:

Overall though, this is a *very* impressive game - Please don't take this as me disliking the game in any way! It was awesome, and you're already crushing it. I wanted to provide so much feedback because I spent so long with the game! Great job, and very well done!
We had planned 3 levels with a much smaller learning curve (and the tutorial ended up staying as only the placeholder) but with the constraint of time, we ended up designing this singular level with all the difficulties included and without being able to include the necessary custom controls settings T-T
For the visuals, it was my first time working with pixel art, even less for a game. So in the end, yes, all my sprites were drawn at the same pixel size 1:1, but once i got in the game engine i didn't know how to actually proceed so i just worked with loose assets and scaling/placing everything at random until i got a good enough result. That must be where the inconsistencies appeared so thank you for mentioning it, i'll remember it for next time!
Thanks for such a detailed review! and for playing it until the end ;)
As for the game design I’m glad you were able to find them interesting even with their unpolished nature and again very pertinent comments and suggestions. Btw that little crook jump was a way for me to force the player to go up whilst not using the dash, I know it’s a frustrating one and I will try to make another version that preserves the idea, but (call me cynical) I still find it very funny ;)
To explain what I mean when I say to use `FixedUpdate` for physics calculations, `Update` runs every time the game *renders* a frame, while `FixedUpdate` always runs at a consistent 50 FPS by default (you can change this in your Unity Project settings). A player who has a fast computer with the game running at 60 FPS will have `Update` called twice as often as a player on a slower computer running at 30 FPS. This is totally fine for non-physics related purposes, but when you're dealing with physics, a change in frame timing could drastically change what happens in the simulation.
For example, say you're trying to keep the player dashing for 0.5 seconds. If they start lagging when your timer hits 0.49 seconds, and the next frame takes 0.25 seconds to render, that means that they're going to keep moving at their current velocity for those remaining 0.25 seconds until the next frame renders, and dash *much* further than intended. If you were to update your dash timer during `FixedUpdate`, lag would no longer impact how long a dash takes - It would always finish in the same number of `FixedUpdates`, and always give the exact same results.
If you turn the `PlayerMouvement` `Update` function into a `FixedUpdate` function, and swap all references from `Time.deltaTime` to `Time.fixedDeltaTime`, that should get you 90% of the way towards deterministic physics\*, but inputs will randomly get dropped. This is because `Input.GetKeyDown` reads inputs every time a frame is *rendered*, and because `FixedUpdate` happens at a fixed rate, you might have multiple rendered frames between `FixedUpdates`. When that happens, the second update would clear out the `keyDown` before you read it in the next `FixedUpdate`! To fix that, instead of polling `Input.GetKeyDown` directly during `FixedUpdate`, you'll need to poll for inputs during `Update`, and set them into a local variable for `FixedUpdate` to read, which you can reset at the end of every `FixedUpdate`. (You might also want to re-tune your constants to the new framerate-independent physics to make sure that things feel how you intended the game to feel!)
If you're curious to learn more how this works at a lower level, [Gaffer on Games has a great article about fixed timesteps, and describes how one might go about implementing a fixed timestep in a custom engine](https://www.gafferongames.com/post/fix_your_timestep/). But as long as you're using Unity, all you need to know is that using `FixedUpdate` when dealing with physics calculations/timers will give you deterministic results :)
\*Ideally, you wouldn't want to just move everything into `FixedUpdate` - You'd want to split these functions up so that code which doesn't impact physics is running during `Update`, and the code which impacts physics runs during `FixedUpdate`. In this case as a quick fix, just moving everything to `FixedUpdate` *should* be fine (although I may have overlooked something), but I wanted to point out that this is a quick fix, and not a best practice! You generally want to be doing as little as possible during `FixedUpdate`, because you can get stuck in a death spiral of lag if one `FixedUpdate` takes longer to run than the length of time between `FixedUpdate`s. It also gets weird to have certain things locked to the physics fixed update that should be updating during frame renders (eg: animation timing, camera movements, etc), leading to unexpected jittery looking gameplay. This is all a broad-strokes oversimplification, but hopefully gives you a good place to start investigating further!