@Mehmet

Added the second boulder and added masks onto the slime and boulders so that the game now knows when you hit a boulder!

Added a boulder that spawns at different gaps in front of you that you can jump over it. It doesn’t have a hitbox yet, so you won’t be penalized for landing on it, but you can jump over it using the spacebar.

Changed the player to the slime, added jumping with space.

I updated the project. I was notified that it initially crashed on macOS, and the arrow keys were a bit janky on macOS as well. All of that has been completely fixed, and I’ve updated the readme and the latest code on GitHub to encompass those changes.

It’s shaping up. I added the characters, changed the title and the icon at the top left,

I’ve set my eyes on controls next.

Added the Blobbe! It just moves forward and loops though. It cant be controlled, YET

Please format the following text to Markdown in your brain.

Blobbe, written B-L-O-B-B-E, is a platformer game that I’m making fully and entirely in Python, Pygame. I have no clue what Pygame is and how it works right now, but I’m gonna look into the docs, look at examples, and figure it out. I hope to build a very nice and cool platforming game to learn more about game development and Pygame itself.

Right now, I’ve built a color-changing rectangle that changes colors five times every second (so every 200 milliseconds). Here are screenshots of it. (I dont wanna open OBS)

Updated README and added a few more features ;)

A few cleanups on the size of the grid.

Today I changed the title card of the window that pops up.

A few other updates:
• I tweaked the final game feel a bit.
• I made the initial spawning star spawn in a sort of light yellow color, and I also added that light yellow color to the colors list.
• I made sure that the window of the simulation is also in dark mode, so you get more encapsulated in it.

Added a background grid so that you get a sense of spatial bigness and tininess. You get a feel for how big and small your orbitals really are.

I finally got the complex merging done.

Before, when an orbital was going too fast, one frame it was at the back of another orbital, and the next frame, it was in front of it. Since its velocity was so high, the radii didn’t ever collide, so it just went through other ones without merging. That was really not acceptable, so I worked a lot on making sure it works.

How I did it is actually very interesting:

1. Get the starting position of the moving object and its ending position on the next frame.
2. Get the coordinates of the target object you want to check for a potential merge.
3. Draw a line from where the moving object started to where it ended, and check if the target object is intersecting that line (calculating what percentage along that line the checked object sits).
4. If it intersects, you merge them.

Cleaned up the repo a

Added some instructions to make it easier, added more colors, and I’m now working on making more rigorous merge logic.

Today I added zooming that works with scrolling up and scrolling down appropriately: when you scroll down, everything gets smaller, and when you scroll up, everything gets bigger. Mass and gravity, of course, stay the same.

I made sure that the sling function (basically spawning new orbitals) works flawlessly. Our aim function—which draws that mini press-and-drag indicator to make it easier to see where you are spawning orbitals—is also working with both camera differentiation and zoom differentiation.

This way, you can zoom all the way out and still spawn orbitals in the correct way, or zoom all the way in and spawn them super close up. All the physics and rendering works beautifully.

Hey everyone, I’m back with a massive update for Timed.!

After focusing on other projects for a bit, I decided to return and give this project the thorough cleanup, visual redesign, and feature set it deserves. It has been transformed from an extremely basic prototype into a premium, focused, and hyper-minimalist time hub. Here is what is new in the latest version:### 1. Aesthetic Clean-up & Hyper-Minimalism- Clean Slate Background: Removed the distracting background gradient glow for a clean, uniform deep slate environment.- Logo Refinement: Removed the bullet dot next to the logo for a cleaner top-left header.- Hidden Footer: Removed the copyright text and footer entirely, leaving zero visual clutter.- Tabular Digit Spacing: Styled the clock displays to use tabular monospaced digits, preventing annoying layout shifting when the seconds change.

2. Live Clock & Mode Segregation- **

Hidden Minute Ring on Clock**:

The spinning progress ring is now hidden on the Live Clock mode page (to avoid confusion), but it still displays smoothly in Timer and Stopwatch modes.- Interactive Toggles: Tapping the clock display now toggles millisecond view on/off, and there are custom buttons to swap between 12-hour and 24-hour display modes.

3. All-New Stopwatch Mode- Added a full Stopwatch Mode to the web application, featuring millisecond accuracy, controls to pause and resume, and a scrolling lap recording panel.

4. Upgrade Countdown Timer & Presets- Added preset buttons for quick intervals (5m Break, 15m Break, 25m Pomodoro, 50m Focus).- Added an input picker for custom hours, minutes, and seconds.

5. Synthesized Acoustic Bell Chimes- Got rid of the basic, harsh beep sounds.- Coded a custom Web Audio API synthesizer that dynamically triggers a warm, premium E-flat Major arpeggio chime (Eb4 -> Bb4 -> D5 -> F5) using physical acoustic decay curves when the timer completes.

6. Polished Terminal Application (timerr.py)- Upgraded the CLI python app to refresh in-place (\r) so it doesn’t flood the console output.- Added input validation to prevent user typos from crashing the script.- Built a terminal-based stopwatch with lap tracking.- Upgraded the CLI buzzer to play a beautiful arpeggiated chime using Windows system hardware chimes.### 7. Deployment & GitHub- Deployed the entire static application to Vercel at a clean production URL: timed-focused.vercel.app- Staged, committed, and pushed the updated codebase to the remote GitHub repository at SameRainbows/Timed.

I made some more intuitive user changes:

1. Slingshot Dampening:
   Now, the slingshot isn’t like an Angry Bird slingshot that propels your particles to the other side of the universe (though you could do that if you want, just open the code). All the slingshot coordinates and values are now multiplied by 0.2. We’re nerfing it a lot, but it seems more intuitive that way. Since you don’t know it’s nerfed, you won’t notice there is a higher capacity. In our case, a higher capacity actually means friction. Don’t get me wrong: it’s not particle friction, because they go super fast. It’s friction when trying to get orbits to work.

2. Repository Tweaks:
   Calling the script from_scratch.py was killing me, so I found something simpler: orbital.py. It’s much better. I updated the GitHub repository so that the current release is orbital.py (the refactored version). While main.py (the previous version) has a few more features right now, orbital.py is much cleaner. Main.py was more of a learning run, and I feel like I’m bringing my A-game with this new refactor.

3. Look and Feel:
   I really liked the black background and white orbitals of the previous main.py version, so I changed the clinical-seeming style of from_scratch.py. I scrapped that look and made sure the new orbital.py has some taste.

I fixed the “merging from hell”. The first issue was the radius calculation. When two circles merge, simply adding their radii (r1 + r2) is physically wrong because the combined area grows way too fast. In reality, the area of the circles should add up: A_new = A1 + A2. By plugging in the area formula π × r², we get π × r_new² = (π × r1²) + (π × r2²). The π cancels out completely, leaving r_new = math.sqrt(r1² + r2²). I updated the collision code with this, and now the combined masses have physically accurate sizes.To make this look right, I also fixed the visual scaling issue. Previously, every particle rendered at shapesize(1, 1) regardless of its actual mass or radius. I changed the instantiator so that a body’s shapesize dynamically scales with its physics radius: self.turt.shapesize(self.radius / 10, self.radius / 10). Now when objects collide, you can actually see the merged planet grow on the screen.Lastly, I added a quick reset button. Pressing the R key runs a function that loops through the current objects, hides all their turtles to prevent visual ghosts, clears the main objects list, resets the camera back to center coordinates, and spawns a fresh central star