Notes

Maybe change game to 'bullet hell' idea. So when generating the map, we pre-generate chests and other interactive objects and then in each level, enemies are constantly generated outside of the player's fov depending on their level. Now they can equip different guns and spells which get better the higher the level. So it's sorta like a bullet hell like dunegon crawler. Maybe have prefabs generated after rooms and a* can connect then (no idea how to store the room structure tho). Maybe pass a ExtraLevelConstants namedtuple in map.py that has the total amount of enemies (will need more thought considering enemy gen needs level to get different leveled enemies)

Start developing ideas for further improving generation, improving attacking, improving movement and adding more features. Base it of the binding of Isaac. Could get ideas from cogmind too

Go through https://bfnightly.bracketproductions.com/chapter_27.html#picking-a-starting-point for ideas

Jump point search references: https://zerowidth.com/2013/a-visual-explanation-of-jump-point-search.html https://www.gamedev.net/tutorials/programming/artificial-intelligence/jump-point-search-fast-a-pathfinding-for-uniform-cost-grids-r4220/ https://lucho1.github.io/JumpPointSearch/ https://github.com/qiao/PathFinding.js/blob/master/src/finders/JPFNeverMoveDiagonally.js https://kairaedsch.github.io/GridSearchVisualiser/ https://github.com/kevinsheehan/jps

New idea for map gen: place just floors then use cellular automata to smooth it out then can place walls afterwards (can't use prefabs with this I don't think) + for item gen, maybe start at distance of 10 (no neighbours items within 10 tiles) and if 5 tries or so, then count down and repeat

Try and improve dummy imports

Maybe try and unify entitydata and consumabledata since it may be a liskov violation

Try and convert vector field to pure functions (only problem is the initialisation which needs to run). Could further be optimised by limiting vectors to a range around the player (max enemy view distance (on each enemy level increase, could add max limit for each attribute so it doesn't get too big (so max level and max attribute)))

Maybe look at changing all folder and files names to plural

If Consumable.item_use() isn't clean after attribute branch, refactor it. Build the instant effects into EntityAttribute (should make it more flexible)

Plan out all of entity attributes and what sections they belong in

When changing to poetry groups, change build.yaml to use nuitka group when installing dependencies + maybe look at removing poetry altogether from this action (look at test.yaml)

Enemy and consumable level spawns should be normally distributed

Maybe try and change generation constants into enum

Redo attack range for constructors since AttackData.attack_range is only used for limiting the enemy's reach when attacking the player

Maybe look at turning tiletype into normal enum

Maybe have melee shader scripts in python file

Look at adding ABCmeta to base classes

Maybe add jump point branch. In this branch, look at adding compass direction feature (add direction for each move to simplify placing (benchmark original vs this to see which is faster)) and maybe allow diagonals (if use compass direction idea, then maybe place box for diagonals)

Add @ hide symbol to makefile https://git.blueplanet.com/blueplanet/tools/private-tools/bpo-tools/bp-microservice/bp-microservice-paster/-/blob/master/Makefile

Investigate if we can support multiple status effects for a single attribute (or if we should (poison and health boost could be a big thing)

Optimisation for vector field: maybe only calculate it within a specific max distance (the max distance that the enemy can be from the player for them to move towards the player). should try and get enemy movement ai improvement done first

After cellular automata generation done, maybe test if converting whole of generation to c++ is worth it

Look at redoing regen and damage system (also the entity in combat stuff could do with improvements)

Maybe update to poetry 1.2 so I can get tool.poetry.group dependencies

Add more stuff to readme

Fix melee shader bug

Improve inventory gui and system. Or probably just rewrite it

Look at adding more logging statements

Would like to improve entity generation (maybe add checks to make sure each entity/item is a certain distance from each other). Could change to generating them outside fov based on player experience and dungeon level (would need an exit for level). Could use a flow field too for exit

Maybe eventually wall gen could be changed to allow for different orientations

Maybe redo which rooms get connected. Would like to use properties of bsp but don't have too. Maybe use a mst. Or could look at adding extra connections. Maybe balance the binary tree before hand to get closest neighbours (idk if it works that way). Maybe use a nearest neighbour algorithm. Would like to use cellular automata to smooth walls out. Look at: https://github.com/seanemery1/Procedural-Roguelike

Balance game values more (including all limits, all constants, all lambda functions, basically all of constants folder)

Improve animations and sprites

Add collectibles such as rings/keys and other stuff

Add different enemy types to tiletype enum

Add multiple player characters using same method for enemies

Flip the player and entity once they face different horizontal directions. Use entity.facing and entity.direction for this. Do this when all animations are done. Maybe part of branch

Create lots of potion types. One could be a tank potion which slows down player but gives lots of defence and health. Would need to plan them all out (including the already implemented one). Maybe create collectible/item constants file which has namedtuples detailing what each collectible/item does. Will need more thinking about the structure. Could be part of a collectible-rewrite branch. Would need a collectible.py file in constants and can put everything in dataclasses or namedtuples

Add prefabs to map generation

Maybe add different subclasses of enemies with different abilities such as a mage, scout, etc

Change info box so it replaces nearest text. So it can display stats about a potion, etc (acts as a error or debug box). For stuff in upgrade screen, will use separate default box which gets changed then enabled when an item is selected. Maybe only do this if I create a 'learnt knowledge' or 'collectible' hall

Maybe look at creating passive entities

Maybe look at using flake8-docstrings further on

Use raycasts (or similar) to hide parts of the dungeon around the corners. Maybe have it so line of sight and specific distance. This could integrate with the enemy line of sight check to only update those that are visible

Have shop be accessed through the lobby with an upgrade that allows a key to be pressed to open the shop

New attributes which can be upgraded: inventory size, potion duration, ammo count. Extra upgrades like shop in-game or respawn ticket can be added to list/dict after theyre bought. Need to think about how to upgrade attacks. Plan for upgrades: Player can complete story mode and get coins to upgrade any character they choose, the player can also redo each mission and get a percentage of the total coins earned (to discourage infinite coins). For freeplay, they can go on for however long they like gaining coins on each level and being able to upgrade any character but can't replay easier levels (stop infinite money) and can't transfer progress to story mode (story mode can't transfer either) and once they die, freeplay is set back to level 1, More details: Shop is in central lobby, if they win a game in story mode, get them all coins (except for previous levels), but if they lose, give them a percentage of total coins

Look at maybe having interaction distance in the melee shader

Add localisation https://api.arcade.academy/en/latest/examples/text_loc_example.html

Have minimap display the game map (maybe including the items too, but not enemies) + include player. Or maybe just the map and player (no items or enemies). This may not be needed

Maybe add more attack algorithms

With light shadow around player, maybe have torch upgrade which increases the view distance (and maybe bullet max range, idk tho)

Add bonus health and bonus armour bars which extend normal bars and are gold coloured (then are removed when effect is gone). Also add bars for player ui

Add save system. Store different attribute upgrades here too

Have option in freeplay to select random seed. For freeplay, the size increases by 5% each time (idk about split count or enemy count)

Have option in main menu to select difficulty (via multiplier which mutlipies the constants) and to select seed for random generation

Maybe add lobby. Would need to think about how to transfer entity data for player to game view tho, maybe have entities initalised without game view then have entity.set_game_view()

Improve title screen with settings, textured buttons, credits and story + freeplay

Improve sprites

Make name + story

Add skins to enemy and player