snej55

Today I continued to mess around a bit with the pyinstaller executables. I also edited the bot scripts a little to make them a bit more professional (like not printing out the whole json api request for each bot). I had some issues generating the tar.gz archive for Linux (couldn't extract it on Ubuntu for some reason?) so I generated it with Windows :( . I then made a github release for it, so I think this thing is ready to ship!

Polished the scripts a bit, and made a bash script that uses pyinstaller to generate the binaries for the different scripts. It works, though I had some trouble with the bash syntax (I didn't realize whitespaces are important).

Today I worked on the third version of the pin scanner. I optimized it a little bit, and then mainly worked on the console ui. I used rich to create a live table with the discovered active pins, which is automatically sorted and updated, which also includes a progress percentage. Apart from that I also did some styling to making it look a bit nicer.

Spent two days working on this project. I first added two different scripts (main.py and names.py) that can add bots to kahoot games. The first one, main.py lets you input a text (lyrics or whatever) and spawns a bot for each word, so the text shows up in the lobby. The second one, names.py spawns a set number of bots with auto generated usernames from https://randomuser.me/. I then started working on a pin scanner, so I could join open kahoot games. The first attempt (getpins.py) scans pins synchronously and is very slow. The second attempt (getpinsasync.py) scans them asynchronously so it is much faster. The third attempt (pinscanner.py) has similar fast speeds but uses multiprocessing instead. They scan for games that have started less than ~~10 min ago, and then output the pins. Usually if the game has started less the ~~3/4 min ago then it will still be open and you will be able to join with your bots!

Organised the project a bit and created a shell script to combine seperate markdown files in media/docs into a single readme.

Made a demo video for the project.

Today I continued working on the asset managers (shaders, textures, models), and improved the error messages with some highlights. I'm considering making a generic base class for each 'object' manager, since all the code is fairly similar and repetitive. The next thing to do is to add support for proper PBR materials (with textures instead of hard coded uniforms), but I started off with this for now to get back into it (I took a break for the SoM game jam).

Finished the game! Added a soundtrack, sfx, an itch.io page, made the game easier, made the windows build (pain), and made a demo video, and some more stuff! I still need to upload the linux build to itch.io and do some other stuff (webassembly build), but for today i'm spent (unintentionally got first on the regional hackatime leaderboard 😫).

This afternoon I worked on finishing up the actual gameplay, added some more vfx (shaders + lighting), some more weapons, and a gradually increasing difficulty level. Next I will work on making some music for the game, and find someone to playtest it before I build it for other platforms and release it. I am a bit worried tho that it might be too difficult (I haven't beaten it yet).

I'm FINALLY finished with all the ui stuff, so I was able to finally get started on the juice and vfx. I started by working on the explosions, by adding some more particle fx, cinders, smoke and shockwaves, as well as a bit of slomo.

Nearly finished with the ui! Added a shop to buy new blasters, and fixed some screen scaling bugs. Now I just need to add the final blaster card to the shop and the ui is done!

I continued working on the game ui (should be method of torture) and added a button for the shop (that's next), a coin counter, pausing, rearranged the ui bar, and made some improvements to the health bar, as well as adding a proper death screen (player health is low for testing, or is it?).

Added a menu screen with some settings, and a blank death screen. I also added the sparks and some screen shake to the combat.

Did quite a lot of stuff (had some issues with zed wakatime so devlog time isn't accurate) - added a custom font, a post processing shader, added knockback and recoil to the blaster, squashed some bugs and added a health bar. I'm now working on some more vfx.

Enemies can fight back now!

Mainly worked a bit on the blaster system this weekend. Added some basic lasers that can damage the enemies. Next, I'll make the enemies able to fight back, make a player health bar, some damage feedback (red screen border flash?), fix the blaster fire rate flag (does nothing at the moment), add knockback + recoil to the blaster, start work on the shop and the penguins, and FINALLY add some juice.

Starting working on the gameplay of the game (combat). Brainstormed some ideas, and settled on a basic melee with a selection of different range weapons. Started by working on a basic blaster, which can be used as a base class for upgrades and other weapons.

Made an entity manager, that updates and renders all the entities, and allows easy spawning and removal of enemies.

Start working on some other 'entities' (enemies). I first made a base Entity class that all other entities inherit from and then start working on a 'blobbo' (squid or slime kinda thing).

Made a new player character with some larger pixel art, added camera scroll, WASD support, improved scaling again, and fixed some bugs relating to the deltatime and player's y velocity (can fall through the ground if you go fast enough - not anymore). I'm now working on making an entity management system for some enemies.

Added player movement & collisions, and added some animations for the player. Slight problem though - the player pixel art is way to tiny (only 47, so I have to make some new animations to fit the larger 1212 tiles).

Started work on a basic player sprite, improved screen scaling, and optimized tile detection (plus deltatime, keyboard controls and some other minor stuff). Tile detection now goes via a binary search (std::map), instead of looping through all the tiles in a chunk. The system should therefore be able to handle fairly large waves of enemies as well as plenty of crazy particle vfx.

Today I made some decorations and added support for off grid tiles to my game and level editor, so there are some trees and stuff now.

Added tile and chunk loading from the json map files to the actual game. Tile/chunk based level rendering now works! (the code is very similar to Defblade)

Over the last few days, I set up my game for the SoM game jam. I designed some tile sets, made a level editor with pygame, and set up the basic for the actual game with raylib and c++.

Today I finally got a working PBR shader setup! I can now make some shiny stuff! (though I still need to get IBL and PBR materials and textures setup).

Today I finished the post processor class, so everything is now rendered to a framebuffer instead of directly to the screen, which is then rendered to the screen through a screen shader (where I can put some shiny vfx). I finished it off by adding gamma correction and HDR, ready for PBR.

Today I started working more on the rendering, with some basic diffuse lighting for the models. I also made a convenience python script to make adding shaders easier (it creates the template vertex and fragment shaders and adds them to shaders.json), learnt a bit about blender, and made some general improvements to the engine.

Today I finally finished the model loader (fixed all of the bugs). I largely spent most of the time debugging the Mesh class, where glDrawElements wasn't working - the app ran fine, but nothing was displayed and even RenderDoc failed to capture it. It turned out that the Mesh destructor was being called when it was copied into Model::m_meshes after it was generated, where glDeleteVertexArrays was being called, meaning the vertex array was invalid (long story short, c++ is complicated). But model rendering works now at least!

Today I created the model loading interface for the engine, with a model manager similar to the texture and shader managers. I also tested the actual vertex and indices loading for the model class. Next, I will start work on actually rendering the models, and hopefully be able to start on some PBR lighting equations.

Today I started porting the basic model loader from my opengl wrapper to the new engine. It still uses assimp for reading the 3D model data, and will hopefully be able to support skeletal animations and PBR materials later on. I have already set up the mesh class, for storing the indices/vertices of each 3D model. Next, I am going to implement the assimp model loading, as well as a textures/material system. (and hopefully finally learn blender as well).

This weekend I continued working on getting the basic framework of the engine working. I setup shader and texture loading, with shaders and textures being accessed by their names through a shader and texture manager, instead of as individual objects (though that works as well). I also made the shader loading fully automatic, with checks to ensure all of the required builtin shaders are loaded at runtime. All that you now need to do to add a new shader, is add a new entry to the shaders.json file, pointing to the fragment and vertex shader paths. I also made a basic shape manager, that allows me to draw coloured rects. Next, is some basic default 3D shapes, and model loading.