@Mehmet

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

Hey, I added merging, but it’s “merging out of hell” because I made a very unphysically true and crude (if you’d call it that), but working prototype of merge_collisions and the merge function itself.

It works as I intended, but not physically truly. Right now, it adds the radii of the circles themselves. If you think about it, that’s physically wrong because there’s a big difference between adding the areas of the circles versus their radii. That’s something I want to get right, so the next time I’m working on it, I’ll make sure to fix it so that we are adding the areas of the circles rather than their radii.

I also found a bit of a problem where the merged objects themselves have a shape size of (1, 1). That’s not right because if you merge two objects with shape size 1, you’d expect the new shape size to be 2. Right now, no matter how many objects you merge, it still stays at 1, resulting in a very, very dense circle.

I’m going to change that so we add the areas themselves, and have that new, bigger area update the visual representation of those astronomical objects.

I’ll keep you guys updated. See you next time.

Lots of stuff today:

1. Camera movement: I added camera movement to our new refractor.

2. Better version of the sling: The older one just expected you to press, drag, and release without seeing much of an indicator. While that works if you know the program a bit, I think a direct, laser-esque pointer that shows you actively as you’re pressing, dragging, and releasing is more intuitive and easier to work with. So I added that.

Now we have intuitive camera movement and intuitive spawning.

For this refactor, we won’t have any UI. All the sliders for gravity and mass will be per keyboard or hotkey.

Welcome!

Today, I fully migrated to the object-oriented programming architecture. Earlier, the class wasn’t really full OOP; it was just a hidden list factory that appended the stuff via a class instead of doing it manually. I wanted to change that because this is going to be a refactor in an OOP perspective, and that’s what I did.I made sure that all the formulas used the latest changes:1. Earlier, they would use the index of the objects inside the objs list of lists. It would be something like object1 and the index of whichever element it wants to access, like mass, radius, velocity, or coordinates. It was very sloppy, and you had to keep up with what each index meant.2. With an OOP version, you just write object1.mass, object1.x, or object1.vx. Each and every line is more intuitive.I also worked more on the planet spawning. Remember, this is a new file with a different perspective of trying to remake this in an OOP sense, using classes and the benefits that ensue from them.Additionally, today I implemented the balancing of the canvas differences in Tkinter and Turtle:- In Turtle, the (0, 0) coordinate is directly in the middle of the screen.- In Tkinter, it’s at the absolute top left of the screen.You have to make sure that all the formulas and all the logic get the correct version, which in my project is the Turtle version. I added and worked out the logic that would make sure that balance is kept.