https://www.twitch.tv/xpmonsterx

Bring more of your cool games :)

Games played count: 54

Last games: 1. https://ldjam.com/events/ludum-dare/56/exter-meh-nator 2. https://ldjam.com/events/ludum-dare/56/crabs-on-the-island 3. https://ldjam.com/events/ludum-dare/56/particle-wars 4. https://ldjam.com/events/ludum-dare/56/swamp-axe 5. https://ldjam.com/events/ludum-dare/56/window-creatures

Critter Conflict: https://ldjam.com/events/ludum-dare/56/critter-conflict

The Greenies are some kind of Tinies, the creatures of our game.

As their name implies, they are green, but like SUPER green. They are active ecologists and do all the little actions they can for their planet.

Some say they also have green thumbs :eyes:

You can try Tiny World here

* We're waiting for your feedbacks :smile: *

Voting for score chasers has ended and the competitors have voted on the 5 games that will be played in the tournament! Here are the 5 games in order of when they will be played.

#1: Mooovement Game (around 4:15pm UTC)

A speedrunning game where you need to slide down slopes and strafe to build up your momentum (aka yeets/hour). The 100% category which involves collecting all optional collectibles currently has a high score of 2:28.602 by the competitor @nertsal while any% and genocide% (not collecting any collectibles) has a high score of 2:18.588 also by nertsal

• By @markais

| | | | --- | --- | | | |

https://www.youtube.com/watch?v=56E9xwXb4jY

#2: Adelie - When We Were Young (around 4:45pm UTC)

A score based game where you collect fish and drop them into a zone to feed baby penguins. Dropping more fish at the same time (including more than is required) increases the amount of points you get for each subsequent fish. So the first fish in the chain might be worth 10 points while a 6th fish in the chain of what you dropped will be worth 60 points. Hitting obstacles that spawn on the map will make you drop all your fish and also turn them into more obstacles. The record is currently 6640 points held by competitor @kuviman.

• By @meep

| | | --- | |

#3: Boroporo (around 5:15pm UTC)

A score based game where you control arm movements and whether or not to grab. You need to recover and bring back small creatures to your cave while preventing them from getting eaten by larger creatures that spawn in. The current record is 64, held by competitor and dev of the game, @pomo.

• By @pomo

| | | | --- | --- | | |

#4: Da Eg Hatcha (around 6:00pm UTC)

A foddian where you need to boost yourself around and touch eggs on the map to hatch them. There is also optional money collectibles you can find and collect. The current record for no money is around 50 seconds and is held by one of the competitors, @meep while the record for all money is around 1 minute 30 seconds held by @osh-studio.

• By @itsboats

| | | | --- | --- | | | |

#5: Sammich (around 6:30pm UTC)

Score based game where you prevent a sandwich from falling over while collecting as much food onto it as you can. The current record is 7393 held by @jenkinz94.

• By @brainoid, @ruddiculous, @ruddgasm, @coleslaughter

| | | | --- | --- | | |

Interested?

Score chasers is a tournament where people compete to get high scores in games submitted to this Ludum Dare. This includes things such as completing a game in the lowest amount of time, getting the most score in a game, or other ways a game can be competed in. The tournament is taking place on Saturday, October 19th, 2024 4:00 PM UTC at https://twitch.tv/ategondev.

Qualifications for joining is still open until 24 hours before the tournament starts. In order to qualify for the tournament you need to submit an impressive score in any game submitted to the jam. To submit you can join our discord at https://discord.gg/FhP4jaZ7KS and post a screenshot of your score in the entry submissions channel.

Hope to see you there!

Cellspace is a cellular automata based rule system that can be used to create games. I developed it some time ago. My goal for LD56 is to start on a graphical user interface for Cellspace. I tried to "gamify" it by defining some levels you can play around with by defining rules. There are no clear goals, though some levels suggest concrete goals.

I want to develop this into a full fledged graphical IDE in which you can make your own games. This would require at least a level editor and win/lose conditions. Note that it is already possible to control rules using the W,S,A,D keys, using the "playerdir" option.

Cellspace is based on the classical 3x3 cellular automata, but is more complicated, because the output of a cell rule is not just the center cell, but can be any of the cells in the 3x3 grid. This extra complexity makes it possible to specify various games, including a full implementation of Boulderdash. The system handles complex cases meaningfully, such as blocking rules that have output that overlaps with a rule that is already applied, handling competing rules, and randomizing rule execution order to avoid bias. Also, it tries to animate moving sprites smoothly.

>>>Play CellSpace here!<<<

Here are some examples of nice looking rule systems.

Example 1: different animated cells

At the bottom left are moving cell colonies (cyan) that propagate and die with random probability. This can be described with two rules:

rule5 indicates propagating the colony to a neighbouring spot with probability 0.33, while rule6 indicates dieoff with probability 0.2 when a colony already has a neighbouring cell. With the rot4 option, the rules are rotated in all directions, creating four competing rules that are randomly selected, resulting in random propagation in all directions.

At the bottom right are "pacman" (red) cells that move around and propagate randomly. This can be described with two rules:

rule_0 indicates that the "@" (pacman) should move right when there is an empty spot there. Again the rot4 option rotates the rule in all directions. Note there is also an outdir "R" defined, which sets the direction of the new "@" to the right. This means the sprite will face right.

rule_1 again indicates that the "@" should propagate with low probability, that is, create a new "@" in an empty spot without removing the old one.

At the top left are moving cells (blue) that leave trails behind (green). They prefer open space over already laid trails, so that they try to explore new areas. This can be described with 3 rules:

rule_2 indicates that an "o" (the blue circle) should move left when there's an empty space ("-"), and should leave a trail behind (":"). With the rot4 option, rule is rotated in all directions, resulting in four competing rules that are randomly selected, resulting in random movement.

rule_3 indicates the "o" moving across an already laid trail, but this rule has lower priority (1 instead of 2).

rule_4 indicates that the "o" should spawn (create a new "o" without removing the old one), when there is an empty spot, again with low (1 in 10) probability.

The self-generating maze (yellow Xes) in the middle can be specified with a single rule, given in the next example.

Example 2: Harvey Wallbangers in a self generating maze

Harvey Wallbanger is a robot that can find the exit of any labyrinth (= maze without loops) by just following the leftmost wall.

The Harveys (cyan) are controlled by the following rules:

Rule_3 generates the maze, the other rules govern the Harvey Wallbanger movements. Note it keeps track of the center cell direction via conddir, which specifies that the center cell should face in that direction.

Example 3: self eating maze

The following rules specify the self-eating walls:

Have you tried our game yet? if not you should consider giving it a try! https://ldjam.com/events/ludum-dare/56/small-problems-to-grapple-with

Hi guys Just 8 days left and I still can't get enough review =( Can you please play my game (or just give me some rating!) I really want to be ranked this time. I really hope I will be in top1000!

https://ldjam.com/events/ludum-dare/56/tiny-aliens

The triangle alien is waiting for your help!

Hey there here is an art breakdown on how we made some of our art in our silly little game it's the last week so we would love your feedback! https://ldjam.com/events/ludum-dare/56/a-fish-based-game

In our last post for the game jam, we broke down how we made each fish have its individual behaviours. However, I said I would do a post for each additional feature that made our fish more unique, which was the blend shapes and gradient mapping. However, I ended up getting quite busy and never posted that so here it is now!

Here are some of the blend shapes responsible for the different fish shapes in the game most of them are based on some kind of fish like guppies, goldfish, eels, and a few variants of just large finned fish.

You can see the different blend shape models, and they're quite exaggerated because the blend shape values end up being fractional when implemented in the engine. The fins are different colours because we used the vertex colour to determine what UV sets the fins and tail would use. We were planning on having more fin varieties, but we ended up not having enough time, partially due to my inexperience in Unreal and in making art.

We wanted to use different pattern textures as well but did not have enough time to make them and test them out I'm also sure that I didn't end up making full use of the gradient mapping technique but it was a solid test!

As you can see I used the unreal nodes to just map the greyscale texture onto different points and that ended up mapping all the grey values with the colours, then we created an unreal material instance and would randomize the colours when the fish spawns in and here are the collapsed nodes I ended up using! you can see a lot more and better applications of this technique here https://www.patreon.com/posts/40192059 and https://joyrok.com/2D-Tech-Art-Chronicles-Gradient-Mapping

here is a picture of the collapsed nodes btw!

and here is what they end up looking like in the game with the randomized colours! without it, they would all be just grey!

I will say though it's very difficult to actually see the texture which is a shame because I spent a lot of time on it! oh well, a lesson for next time for sure!

raw fish texture if you want to try it out yourself! but it's honestly not a very polished application of gradient mapping definitely needs more tuning!

the next thing I want to break down is the procedural animation which is really really simple and definitely gave some positive results for the time spent!

these are the nodes we used to make the fish move pretty basic the body follows the rotation of the head and using unreals trail bones the body the fins and the rest all trail-making for fairly solid movement animations. Quinton added some wiggle by adding some rotation when the fish moves in the blueprints and it plugs into the rotation variable as you see there!

this is the rig of the fish it ain't pretty and I would have liked to add another joint near the head/neck but didn't do it until it was too late so it's not in the build and so it's not in the post!

Thanks for checking out our post and I really hope you give our game a try!

Our game released with performance issues and we missed our chance to make a patch in the first few days. So now we're coming back with a full-fledged post-jam update instead.



Code Bunny is a top-down wave based slasher about literally slaying the bugs in a program. Here's what the first update brings: - Performance fixes. Game no longer slows down to a crawl after playing for a while. - Various bug fixes and QoL improvements. - Character is now much faster: basic movement, dash and movement from regular attacks all received a buff. - Idle energy drain is much slower. Upgrade perks associated with the mechanic were removed completely. - Overclocking upgrade now affects damage of spin and dash attacks. - Visual improvements: environment and HP bar now change color based on the blade power, menu got a new model.

Play the Post-Jam update here!

# Original LD entry page

Hello everyone!

Hope that you are doing well! Only ~7 days left for rating games and I'm currently working on playing and rating others games. Need a little help? Let's streamline the process by scratching my back and I'll scratch yours!

A little about our game:

We made a creature battling game using a move triangle that works like "rock, paper, scissors". Each move a creature has will have a special effect based on whether they win, lose or tie. You have 6 moves to choose from and only 4 you can have equipped at one time. This adds some depth to the moves and playstyles.

KNOWN BUGS: Unfortunately the multiplayer screen will not pass to the second player and will just loop. So single player is the only available option as of right now.

We are open to constructive criticism as we do want to make this a finished game.

Here is the link: https://ldjam.com/events/ludum-dare/56/tiny-lantern

Here is some art!

playing LD games for apparently another straight up week at https://twitch.tv/funbasealpha

Here is the LD56 version: https://ldjam.com/events/ludum-dare/56/rpigg

Add here is the new post-jam version! https://weirdbitgames.itch.io/rpigg

Link: https://ldjam.com/events/ludum-dare/56/vortex-of-life

We’ve finished the update! This time, we’ve improved the storyboard display, fixed text overlap and speed, and adjusted the bottle values. We’ve also added the option to skip the opening animation. Since many players understood the interactions but were unsure about the meaning of certain elements, we included explanations in both the opening animation and the game, such as audio guides. These will help you quickly understand what the cards and bottles represent!

Part 1 located here: https://ldjam.com/events/ludum-dare/56/mikus-minion-madness/$406164

Misa here again, from Miku's Minion Madness (https://ldjam.com/events/ludum-dare/56/mikus-minion-madness) with another behind the scenes dev blog!

The First 24 Hours

Our engineer @poco0317 would be the one to start the major implementation. His goal was to get the base game up and running by the end of the night.

For @miku, she opted to contribute with the art. When we homed in on the idea that this would be a game that has a big focus on the cards, she felt eager to take on this challenge. Even though she is professional a game designer by trade, she also had just gone off a fresh streak of drawing Hatsune Miku every day for a year. Drawing little creatures like this shouldn’t be hard! Or so she thought…

She honestly had some difficulty with the initial iteration of the cards - we had no idea what size it should be, nor what the creatures should be based off to make them tiny. Should we think of these cards as basic playing cards, or something more elegant like the cards of Magic: the Gathering or Yu-Gi-Oh?

We simply needed to move forward, and as our engineer shared the first draft of the battlefield, Miku shared with us the first draft of our most basic minion.

If you’ve ever been a fan of VOCALOID, this drawing was based off the derivative of Megurine Luka known as Tako Luka. Long story short, the tiny creatures theme made us think of mascots! This would also be our first placeholder card. Miku made sure to keep in mind that this is a card game, so we need a lot of cards, so all the cards must be relatively simple while also being visibly distinct in the UI.

And that's what gave birth to Miku doodling us all as mascots, starting with poco's t-posing Agent Lemon, and then my Mipaka.

We knew we wanted to make the game work on mobile, but did we want to go portrait, or landscape? We opted to go portrait, and @jason-woerner would start to work on some effects in the engine so that we could have an indicator of when units would attack.

Eventually, we were able to get the UI in a state that looked like it made sense. We took major inspiration from games like Clash Royale for how we would place our cards and UI elements. Our base UI used a lot of Godot progress meters, but we knew we wanted more diegetic UI, so those would just be placeholders for the prototype. Although our final implementation of it for the jam was not perfect, we wanted to make it feel more organic when you play the game.

We started to consider how the UI would display information to players, thinking about three specific elements: attack, health, and speed. These elements were used to inspire some of the mascot art, as well. At the same time, poco was working on optimizing the game code so it could support a lot of entities at once. Behold, the Miku Army!

Our game was finally coming together, but we needed more cards. Miku was hard at work, mocking up art for the rest of the cards, based on folks working with us on a Miku RPG and the rest of our dev team.

We were cookin' with gas, but... we were also all exhausted, so it was time to turn in. You'll have to come check back later for the next Behind the Scenes!

Here’s where things get really wild haha: you’ve got 16 unique creatures, each made up of 4 distinct body parts—head, arms, body, and legs. But that’s just the start! For each of those body parts, you can unlock one of 8 possible colors. The result? A staggering 268,435,456 possible creature combinations and this is just the beginning! 🤯

From fierce to funky, every new creation can be a total surprise :D. Whether you’re building the ultimate battle beast or just concocting the weirdest combo you can dream up, the possibilities are endless!

💡 What’s your craziest combo idea? Dive in, start splicing, and show us your monstrous creations! 💥

https://ldjam.com/events/ludum-dare/56/monkepok

https://ldjam.com/events/ludum-dare/56/$402995

Since creating our little prototype for Ludum Dare, we have been obsessed with Stuart.

Over the last few days, we have been imagining more about his world. Where does he live? What does he do when he is not busy out at sea having the time of his life?

@fooorsh has been having the time of his life putting these imaginations down on paper.

Here are some renditions of his Stuart's cosy abode during the day and night. Maybe these will be able to be experienced in game one day?

Play the jam version here and let us know what you think! <3

https://ldjam.com/events/ludum-dare/56/$402995

Join us and we'll rate your game on Stream! https://www.twitch.tv/aaghgames

First of all, I'd like to say a massive thank you to everyone who's played and rated Color Critters so far. I'm running out of time to get to 20 ratings, so if you haven't played it yet, please do! I promise, as ever, to play and rate the games of everyone who leaves a review!

For now, though, it is once again time to take a look back at Color Critters' development - the high points, the low points, and what comes next for it.

What Went Well

• With my last entry having been such a tough act to follow, I went back to focusing on gameplay over storytelling this time round, and it's worked a treat, with most reviewers saying how enjoyable they found the gameplay and nobody seeming to mind the non-existent plot.
• This is my first Ludum Dare since being diagnosed with ADHD. Despite my continuing struggles with the condition, and other medical issues (more on those later), I was able to comfortably finish the game within the compo window, with the exact number of levels I wanted and even adding in mechanics that I hadn't originally planned. Judging from the reviews, I got the difficulty progression spot-on as well. It helped that the game was coded in a way that allowed me to easily shuffle the level order around.
• Fearing that the gameplay might feel slow or arduous, I tried to streamline the gameplay experience as much as possible to avoid slowing it down further, by stripping out things like menus, "level complete/failed" messages, level transitions, and so on. Again, I feel it's worked, as I've received only one or two minor complaints along those lines; for the most part, people seem to be breezing through the game without it feeling like too much of a slog.

What Went Badly

• I have been, to put it mildly, suffering from various chronic aches and pains ever since the second day of the jam, which forced me to wrap things up early (more on that later). It wasn't as bad as LD45, where I was throwing up at my desk, but unlike LD45 where I was fine the next day, that chronic pain has persisted ever since, and for the past week it's been compounded by a nasty cold. All this has meant I haven't been able to put as much time and effort as I would have liked into advertising my game or playing other people's, and my chances of hitting the 20-rating mark are in jeopardy. There's not much I could have done about this, I suppose, but it's still not ideal.
• Each critter was intended to have an active ability, activated by pressing Z. In the end I couldn't come up with any before the compo ended, and they were left with just their passive immunities. As well as messing up the control scheme, since Z was reserved then never actually used, this meant the critters didn't feel as "unique" as they should have done and significantly reduced the game's intended complexity, leaving me struggling to scrape together enough puzzles to hit my target number of 15.
• I had plenty of time left to compose some music for the game, but again, I couldn't come up with anything and just left it. There's at least a rich selection of sound effects to make up for it, but this is still my first entry in quite a while that feels musically lacking.

What Comes Next

The general consensus regarding Color Critters seems to be "this is great, but it has the potential to be so much more". I agree. Therefore, my intention at this time - although it's not set in stone - is to expand Color Critters into a full-sized game. I'm undecided as to whether it will be a free release on Newgrounds, or a paid release on Steam and itch.io, but the following is definitely planned for inclusion:

• Many more levels (I'm thinking 60 is a good number), grouped into sections
• Active abilities. Yowler will be able to attract and repel metal crates, which are too heavy to be pushed; I envisage Roart and Blute being able to respectively melt and freeze certain objects but I'm not 100% certain how that's going to work yet
• More level mechanics/gimmicks (and a complete overhaul of the game's code to let me add them more easily, as the compo version's code is a clusterf*ck).
• A save system
• Music
• Some sort of color-blind mode - while nobody has requested one, I expect the number of color-coded elements in the game will make it difficult to play for anyone with color blindness

I will try to post dev updates to my social media profiles, which you can find linked in my LD profile. Again, though, I don't know when (or even if) this full-size version will be released, and I have various other projects in the pipeline at present, so please bear with me!

That's all for now. My focus for now will be on getting to the magic 20-rating mark, and once that's done I can start working on the full-size Color Critters. It'd be good if I could get it finished and out of the way as soon as possible so I can get back to working on Prism Warriors, which is lagging well behind where it should be.

Well done to everyone who managed to get their entries done on time, and I wish you all the best of luck for when the ratings come out!

There were few complaints in the feedback; one of them was that the game could feel a bit slow. To address this, I’ve added new, more practical controls, and more control improvements are on the way. I’ve also made some tweaks to difficulty and balance, though I’m unsure if that’s a good thing, it might affect the game's lighthearted feel, which is one of its charms. I might change it in the future. I also made a variety of small adjustments.

1.25 - The sound when enemy bullets hit the monster was changed

1.25 - You can now hold the left mouse button to pick multiple pixels at once

1.25 - You can now use the scroll wheel to reposition black pixels

1.25 - There is now a pixel counter on the screen showing how many pixels your monster currently has

1.25 - You now receive one black pixel for every four colorful pixels placed

1.25 - Black pixels are destroyed when they hit and destroy enemies

1.25 - You can now hold the left mouse button to place multiple pixels at once on your monster

1.25 - Changed cursor appearance

1.25 - Your monster loses pixels when they come into contact with enemies

This is a windows only game:

Version 1.25: NOW LESS BORING!! ~

Compo Version ~ Itch.io ~ Game Page ~

We have good news for you!

Recently in Blob, to The Top! we added a subtle circular indicator that shows max power while charging a shoot. We mentioned it in our latest update post (check it out here; yes it has gifs :D)

This indicator was made using shaders and here is a quick step by step guide how we made it.

To start.. create a new Godot Sprite2D, put there a default icon.svg texture and create a new shader material with a code (not a shader graph!). And now it's time for code!

1. First we need a function to draw a simple circle:

c float circle(float radius, vec2 uv) { float len = length(uv); return len < radius ? 1.0 : 0.0; } We can replace ternary operator with built-in step function to simplify it, like that: c float circle(float radius, vec2 uv) { float len = length(uv); return step(len, radius); }

2. Now let's make a ring function to draw a ring.

The plan is simple.. we will draw 2 circles and remove inner circle from outer circle. To simplify some math later, instead of just subtraction operation we will use multiplication instead. c float ring(float radius, float width, vec2 uv) { float outer_circle = circle(radius, uv); float inner_circle = 1.0 - circle(radius - width, uv); return outer_circle * inner_circle; } We can optimize it a little bit by using code from the circle function directly. We can also invert result of step function just by swapping arguments inside.

c float ring(float radius, float width, vec2 uv) { float len = length(uv); float outer_circle = step(len, radius); float inner_circle = step(radius - width, len); return outer_circle * inner_circle; }

Time to test this ring function!

Well.. it works! But you can see it's not very practical. We have to use normalized values and ring isn't even centered. Let's fix that by modifying UV in the vertex function.

Also for the future use, we will copy value of COLOR variable from the vertex function. It's a Godot specific feature which allows for using value of modulate property (the one from the node) directly inside a shader code within the fragment function. To "transport" value from the vertex function to fragment function we will define a special varying variable.

So in the end our vertex function will look like this: ```c varying vec4 modulate;

void vertex() { // Copy value of modulate property to new variable modulate = COLOR;

// Read a node scale from built-in matrix
vec2 node_scale = vec2(MODEL_MATRIX[0][0], MODEL_MATRIX[1][1]);

// Read texture size used in the Sprite2D node (in this case we used default 128x128 Godot icon)
vec2 tex_size = 1.0 / TEXTURE_PIXEL_SIZE; // = 128x128

// Let's change UV from range 0..1 to -64..64.
UV = (UV * 2.0 - 1.0) * tex_size * node_scale * 0.5; //0..1 -> -1..1 -> -64..64

} ```

And now we can finally use pixels as units! And also shader reacts to modulate property and circle is finally centered.

3. Now it's time to make dashed ring instead of solid one.

First, to make a rotating dashed ring we will need few utility functions:

• A. get_angle to get angle of the vector in range -PI to PI.
• B. rotate which will return 2d transformation matrix to rotate any vector by specific angle.

3A. Let's start with get_angle function.

The proper formula would be like this: c float get_angle(vec2 vec) { vec2 base = vec2(1.0, 0.0); // Base vector from which we will calculate angle to `vec` float a = dot(vec, base); float b = determinant(mat2(vec, base)); return atan(a, b); } This might look like a dark magic but let's simplify some things. We can replace dot and determinant built-in functions with just plane formulas:

c float get_angle(vec2 vec) { vec2 base = vec2(1.0, 0.0); float a = vec.x * base.x + vec.y * base.y; float b = vec.x * base.y - vec.y * base.x; return atan(a, b); }

Isn't it more clear now? But that's not the end. We can replace base.x and base.y with numbers and in the end we will get this simple function:

c float get_angle(vec2 vec) { return atan(vec.x, -vec.y); }

Now when it's finally done..

3B. Let's write a rotate function!

This will return a basic rotation matrix. The theory works like this: if we will multiply any vector by such matrix it will be rotated by a specific angle.. simple enough, right? :D

The final rotate function will look like this: c mat2 rotate(float angle) { float s = sin(angle); float c = cos(angle); return mat2(vec2(c,-s),vec2(s,c)); } Now it's the hardest part.

4. Time to make holes in the ring to create a dashed ring.

The idea is simple: 1. Split space into N*2 squared pizza fragments. 2. Make only each odd fragment visible. 3. Let's combine our ring with pizza.

```c float pizza(float radius, int n, vec2 uv) { float deltaangle = TAU / (float(n) * 2.0); float angle = getangle(uv); float i = floor(angle / delta_angle); return float(int(i) % 2); }

float dashedring(float radius, float width, int n, vec2 uv) { float pizzashape = pizza(radius, n, uv); float ringshape = ring(radius, width, uv); return ringshape * pizzashape; } And now to add rotation we can just rotate `UV` by a specific angle using `rotate` function we already prepared. c float dashedring(float radius, float width, int n, float rotation, vec2 uv) { uv *= rotate(rotation); float pizzashape = pizza(radius, n, uv); float ringshape = ring(radius, width, uv); return ringshape * pizzashape; } ```

Let's test this thing!

We are almost there. The only thing left is to add fading. We did it by combining two fades like so:

Aaand that's it!

I hope someone will find this helpful :D

Now you can check out the final result in our game here!

If you are interested more in our game, we have good news for you.

After such an amazing and positive feedback (again, thank you sooo much for that :heart:), we have decided to expand the game and release it as a full-fledged title! If there is something you would like to see in the final game, share your thoughts/ideas in the feedback section or under this post. We will see what we can do :grin: