dora explora

ok so i have added a lot :3

1st: moving background
i animated the background to move diagonally using a really stretched out sine function with the time variable in its input

2nd: button highlighting
i added a small circle around the fingerprint scan/open button with a distance function, manual color mixing, and a radius to make sure only the nearby pixels were considered
and i of course added sine(time) to the radius to add some subtle beating

3rd: charging indicator
i used the same distance function from before with a point 30 pixels below the bottom of the screen to make an indicator at the bottom that lights up when the phone is plugged in
i of course added the same sine(time) to the radius and added a bit of noise to the final coloring to make a really nice soft glow.

4th: plug in/out animation
this was definitely the hardest of them all!! i had to use a data pixel in the bottom left of the screen (luckily covered by my screens rounding) and connect the value of a channel to the state and radius of the charging indicator. then, if the phone was charging and the pixel wasnt maxed out, i increased that channel of the data pixel every frame. when not charging and bottomed out, i decreased it.

5th: even smoother plug in/out animation
that approach didnt feel smooth enough to me, so in the checks for the maxing out/bottoming out, i instead checked if the channel was about halfway to 100%. Then, depending on which half it was on, i decreased or increased the speed to make an ease in animation with 2 linear steps. i might even add more steps or an actual function later :3

6th: line direction
the app has a feature where it can detect touches, so i used that and some math to override the code that decides the directions of lines and make them only point to your finger when there is at least one finger touching the screen. unfortunately, the feature doesnt work on the lock screen (which i only found out after i coded it 😭)

okay that is it bye

hi and welcome to the first devlog!!

this project is some shader code that i'm writing to be my android wallpaper! this is only remotely possible because of the app Shader Editor by Markus Fisch (https://github.com/markusfisch/ShaderEditor).

so far, ive implemented the core idea of my wallpaper: a bunch of green moving lines that spawn at the top left and move bottom and right randomly. the randomness was BY FAR the hardest part, because shaders do not work even remotely similarly to other programs. basically, shader code is run on each pixel independently, so the pixel that would be lit if the line turns right would have to agree to the pixel that would be lit if the line turns down on which direction to go in. the way i did that was taking advantage of the fact that my randomness algorithm was deterministic and making sure both pixels used the same seed.

ive also implemented a small piece at the end that reads the number of notifications and uses that to make the lines under the clock a darker blue color. after handling that and making the background a nice shade of purple, i got to where it is now!! okay that is it bye

final devlog time!!!!
ive added a win menu and a loss menu, and after debugging for like an hour (without a working debugger!), its complete! there are just three levels, the tutorial, the original song, and giant steps, but im okay with not adding a fourth one yet. maybe in the future i will, but for now i am much to eager to just ship this :3

the game is out now! just clone the repository, install pygame and pygame-menu with pip, and run main.py!!! see if you can beat my highscore of 99,000 on the last level (hint: you cant)

in this devlog, i took some pretty big strides, made some large leaps, you could say i took some...

BOSS LEVEL: GIANT STEPS - JOHN COLTRANE
yeah so i added a bebop classic because its has really complicated, dense, and hard-to-predict chords, a wildly unpredictable solo, and is at like 250 bpm (sometimes coltrane plays it faster than 300 like wtf 😭)
oh and also its really funny

entering the notes for this part was actually most of the work, i made some tweaks to the notes system to allow for a bass part thats colored blue, but other than that my 2 hours were spent on writing out the notes based of sheet music i found on Musecore (thank you MuseJazz). it also took me like an [untracked] hour and a half to translate that sheet music to an actual song with my own drum pattern.
after all that though, i now have my last level! still havent made the third level, so thats most likely next :3
okay that is it bye

hi and welcome to THE BIGGEST DEVLOG EVER
ok so ive added 4/5 things:

1 - new character
the character is now a little quarter note! i was originally gonna make it an eighth, but it looked a little weird when really small and it was a bit too big for my horrible gaming. speaking of horrible gaming...

2 - game over state (finally 😭)
now, when the character hits any note, the level is set to 0, the menu is brought up, and the music fades out. speaking of the character hitting notes...

3 - collision detection
i spent a not-insignificant amount of time staring at the pygame docs to figure out which functions to use (and it also took me like 15 minutes to debug an error that was just i wrote elif instead of if but whatever blashjkshdavbsd) but i eventually figured out how to use the players position to make a rectangle and check if the note rect and player rect collide. but what if the notes dont collide...

4 - scoring
i used the same rect collide function to check if the notes collide with the players rectangle but f a t t e r . every frame it goes: if its within 20 pixels, 20 points. 40 pixels, 10 points. 60 pixels, 5 points. with this, the game heavily rewards being riskier (which is much more fun!). but players arent the only thing notes collide with...

5 - light-up keys!
now, if the notes collide with any of the piano keys on the bottom, they glow a brighter green until the notes disappear! i used a similar collision function to the game-over and scoring that uses a point instead, and i placed that point at the top-middle of the key. finally, with some rendering order shenanigans, the notes do under the piano texture and the keys light up over both!

with all this done, im getting close to finishing up to submit to SoM and shipwrecked! all thats left is better menus (win, loss, level select) and the other 2 (or however many i decide) levels!
okay that is it bye

level 2 is done!! it took an excruciating amount of time (like 2 and a half hours) but it looks really good and is pretty fun!
other than that, it might actually be time to start working on collision (which i somehow haven't done yet 😭)
then after, ill change up the character, probably to a quarter note, and add effects when the notes hit the piano
okay that is it bye

ive added in level 2's music! the level itself isn't done, however, because im having some very weird timing problems (which using bluetooth headphones probably doesnt help with 😭)

its also wayyyyy too difficult, so i may need to make the character thinner so that it can fit in between black note-white note thirds (like G and Bb)
ive added the song to this post so that you can take a peek! its not final though (especially since im not very happy with that lead)

okay that is it bye

ive added the first level and a small menu!
it took a lottttttttttt of shenanigans to do it (especially since the debugger doesnt work for some reason) (and because i needed like 17 different packages to get pygame working properly on linux) but its much closer to working now!

first and foremost, i need to add collision and an actual way to game-over, i need to add the rest of the levels, and id also like to make the notes look better and maybe draw a background :3
okay that is it bye

hello and welcome to this very simple concept ive had for a rhythm game!
the entire game is gonna be chords falling from the sky according to the music, and you just have to dodge them for the length of the song!

all ive done so far is make a window and a tiny character with pygame, and ive drawn the character and the piano at the bottom that the chords will fall into eventually
okay that is it bye

RUDIMENTARY STEPPING IS WORKING!!

i can now step DAT and MOV* instructions!
(MOV has some modifier and address mode shenanigans, but MOV 0, 1 works so who cares (future me cares))
i also added a Simulation Manager window that for now only has buttons for a partial step and a full step, but thatll be expanded much more later
okay that is it bye

okay so these changes have very little visual effect but a lot has happened internally! notably, ive made a processes variable and Process class that is made to handle all the various process dispatched by warriors, and can support much more than two warriors at a time! i also redid the Instruction class to make accessing field values significantly easier
all of this is in preparation for the step() function and finally getting simulation going!
oh and i also changed the core view's colors a bit and added a stroke to show where warriors' instruction pointers are... yknow... pointing
okay that is it bye

ive made the Chord class and started on the tree of chords and tension mechanics!
the Chord class has 6 fields: name, numeral, notes, tension, followups, and followupkeys. the first three are just the name, numeral, and midi note offsets of the chord. ex: ii minor 7, 2, and [2, 5, 9, 12]
tension is the amount of tension this chord adds to the overall music, and it currently ranges from ~~25 to ~~0. For the iim7, it's -2.
followups is chords that would be good after this chord. this is the main part of the algorithm!!! for now, its only IV6_u3. in the future, this list will be sorted from low tension to high tension for guided tension oscillation and stuff
followupkeys contains how each chord in followups will change the key, which IV6_u3 is a good example of. for now, its only [3].

ive attached a demo of the I9 -> ii7 -> IV6_u3 -> I9 loop going a few times to show off the algorithm and the synth!!
(please ignore the bad audio quality, OBS and Linux were not happy with each other 😭)
okay that is it bye

welcome to the first devlog!
all ive done so far is:
make a function for adding chords and playing them off a root note and chord type (so E and Maj9 for example)
set up the midi connection with Mido and get those chords to play in Vital
set up midi messages that move the pressure parameter up and down parabolically over the course of the chord
made a Vital synth pad that uses the pressure parameter to affect the level of the oscillators and the reverb

since i can now play chords, ill make the actual procedure that generates the music! and ill also make the synth pad better
okay that is it bye

nevermind im not done with the core view
i added a text label at the top that shows the currently highlighted instruction in full and i added a small yellow stroke around the square that you've highlighted
i also moved the gui to gui.rs to make things a little easier
okay that is it bye

I PROMISE IM DONE WITH THE CORE VIEW but i added just a little bit of label highlighting like in ares3 BUT I PROMISE IM DONE I SWEAR

the core view now has three sizes and side labels that adjust to resizing. with that, i think the core view is done! (unless i plan on adding opcode and/or instruction modes, or highlighting for the warriors' current squares like ARES3 does, but thats for later)
now, its time for more windows to manage warriors or get a closer core view
okay that is it bye

the core view is pretty much done! it's draggable, resizable, minimizable, and it of course displays the core! ive set it up so that the core will update in real time and in the future the colors will be customizable
all thats left for the core view is labels and potentially grid highlighting, itll be completely finished!
okay that is it bye

I GOT A SEGFAULT :noo:

ive started on implementing a coreview through macroquad and egui, but something isnt working...
for whatever reason, only when it needs to render more than 1092 squares, it crashes, but otherwise it works perfectly fine

i attached a screenshot of it with those 1092 squares as a kinda proof-of-concept before i actually figure out what the hell is happening
okay that is it bye

ive implemented placing the second warrior somewhere between the end of the first warrior and the end of the core, making sure to account for the instructions taken up by the first warrior and a calculated minimum distance
with that, loading the warriors into the core is finished!! all thats left is the entirety of the simulator and gui...
okay that is it bye

hi welcome to the first devlog!!!! i may or may not have already spent 6 and a half hours on the project, so i already have a few things down:

command line arguments (for if you wanna run it from there)
its just the filepaths to warrior a and b, and also the coresize if its not 8000

compiling warriors, which is just a yoinked piece of code that works with the main library i am using, corewa.rs (I LOVE YOU COREWA.RS THANK YOU SO MUCH)

loading warriors into the core is almost done, but it is rather hard to handle the offsets when dealing with modular arithmetic apparently

okay that is it bye