Sounds like you’re really diving into the world of slot game development! Hitting that 99% RTP target can definitely be tricky, especially with those wild results you’re getting. Let’s break down a few things that might help you out.

First, regarding your RTP calculations, it’s super important to make sure you’re accounting for all wins correctly. Since you have 20 win lines, you need to ensure that your win calculations are comprehensive—that means checking every possible combination! If you’ve not set up your scatter wins and they might have big impacts, be sure to include them in future tests.

About your testing volume—yeah, running over 300,000 spins is a smart move. The random function you’re using is important too; while the default random function works for many applications, you might want to consider switching to something more robust like the Mersenne Twister for better randomness in your tests. The quality of randomness can influence your RTP skew, but it’s also tied to the number of spins you run.

Don’t forget about the significance of volatility! Your game’s design can affect the RTP, so try varying your paytable and see if it makes a difference. Testing with different setups might give you a clearer picture of what’s happening with your numbers.

Finally, don’t be afraid to reach out to other developers or even check online communities focused on game development for more advice. There’s a lot to learn, and getting insight from others can help bridge gaps you might be unsure about. Good luck, and keep at it!

Hey! So, I totally get where you’re coming from with the palette cycling issue in your shader. It sounds like that alpha comparison loop could definitely be slowing things down, especially if you have a lot of objects using this shader.

One approach I can think of is to avoid that loop entirely. Instead of checking alpha values one by one, you might consider using a texture that maps the grayscale values directly to their corresponding palette indices. This way, you can just sample the texture to get the palette index directly instead of having to loop through all the colors.

Here’s a rough idea of how you might implement this:

float4 paletteCycle(float4 inCol, sampler2D paletteCycle, sampler2D indexMap, float paletteCount)
{
    float4 outCol = inCol;

    // Use a texture to get the palette index based on the grayscale value
    float index = tex2D(indexMap, float2(inCol.r, 0)).r; // Assuming input color is in grayscale
    int paletteOffset = int(index * paletteCount + _Time.y * 12) % paletteCount;
    
    outCol = tex2D(paletteCycle, float2(paletteOffset / paletteCount, 0));
    return outCol;
}
    

This way, you avoid the loop entirely, and each frame, you’re just doing texture lookups which are generally faster. You’ll need to create that indexMap texture, but it should be worth it for the performance boost!

Also, keep an eye on your palette size. If you can limit the number of colors in your palette or perhaps compress them down even further while still maintaining visual fidelity, that might help too.

Hope that helps! Good luck with your shader work – you got this!

Oh wow, this sounds like a really fun but tricky problem! I’ve definitely gotten stuck trying to count overlapping shapes before, and at first glance, it’s way harder than you’d think. 🤔

If I were tackling this, I’d probably first just sketch it on paper to get a visual sense of it, honestly. For the seven polygons you described—like triangles, squares, and that sneaky hexagon—I think I’d draw them roughly, not even worrying about neatness for now, and see visually how many overlaps there really are.

To actually count how many overlaps there are, I’d probably start with pairs first, like seeing clearly if “Triangle A overlaps Square B” or “Square C overlaps Hexagon D.” I’d make a quick list of these pairwise overlaps first. After that, for overlapping groups of three or more (like the three triangles sharing a corner), I’d note those groups separately, trying to carefully look for points where multiple shapes intersect at once. Maybe marking these “special” intersection points with colored dots might help visualize better.

Now, you’re adding color conditions too… 🧐 That definitely ramps things up! I’d probably create simple labels or abbreviations, like “RT” for “red triangle” or “BS” for “blue square,” and only examine overlaps between those with different color combinations. Honestly, I think trying to remember all combinations would be impossible without some kind of systematic labeling or notes. Maybe write out each possible color combination overlap separately, and then go through each one at a time?

If the sketches got too messy and confusing (which I’m pretty sure would happen pretty fast!), I’d probably turn to software. Maybe some basic drawing tools first, or if I were feeling ambitious, I’d google some simple geometry visualization apps or online tools. I’ve also heard a bit about libraries or graphical tools that might help identify intersection points automatically, although I’d honestly need to research that cause I haven’t really played around much with geometry in code yet.

I don’t have a specific trick up my sleeve yet—sorry about that! But I think organizing, sketching clearly, and labeling things systematically would be my go-to approach. Hope this helps a bit! Curious to know how you’d tackle it too, honestly. 😄