Box2D Circle Collision Issue

Sounds like you’re having a tough time getting your circles to cooperate with Box2D. It can definitely be a bit confusing when you’re just starting out!

Here are a few things you might want to check:

• Circle Shape Definition: Make sure you’re defining the circle correctly. When you create a circle shape, you typically do something like this:

  b2CircleShape circleShape;
  circleShape.m_radius = yourRadius; // Set the radius
              

• Body Type: Ensure that the body for your circle is set to dynamic so that it can respond to collisions and gravity:

  b2BodyDef circleBodyDef;
  circleBodyDef.type = b2_dynamicBody;
              

• Positioning: Check the position where you’re placing the circle. If it’s way below the ground or overlapping with the ground, it might fall straight through. Coordinates can be tricky!
• Density and Friction: Just like you did with the rectangle, make sure you’re setting the density and friction for the circle correctly:

  b2FixtureDef circleFixtureDef;
  circleFixtureDef.density = yourDensity; // Set density
  circleFixtureDef.friction = yourFriction; // Set friction
              

• Debugging: Sometimes it’s helpful to visualize the shapes and bodies using Raylib’s debugging tools. This can give you insight into whether they’re being created properly.

If everything else looks good and it’s still not working, you might want to share a snippet of your code for the circle. Other folks here might be able to spot something you’ve missed!

Keep at it, and you’ll get it sorted out!

Cool idea! I’ve never really made something like this, but I’ll give it a shot:

First off, I think I’d keep it simple at the start. Maybe something like a bunch of lists or arrays to store the cup colors. Like maybe each player has their own set of colors stored like this:

    playerOneColors = ["red", "orange", "yellow"];
    playerTwoColors = ["blue", "green", "purple"];
  

Then for each individual stack, I might make an array too, just to track the current cups being stacked. So whenever you add a cup, I’d just push it onto the array, checking real quick that you haven’t used the same color yet. Something like:

    currentStack = [];

    function addCupToStack(color) {
      if (currentStack.includes(color)) {
        alert("Oops! You already used " + color + ". Try another color!");
      } else if (currentStack.length < 3) {
        currentStack.push(color);
      } else {
        alert("Stack is full already!");
      }
    }
  

For handling players' moves, you could probably just use buttons or simple input prompts to keep things easy. Like, ask the player which color they want to stack, or if they want to knock someone's stack down or trade cups. Maybe you'd organize it into small little functions that handle each kind of move and just call those when needed.

About random events—I guess I could use JavaScript's random number generator (Math.random() I think?) to choose when these special events happen. Maybe something like:

    function randomEvent() {
      let chance = Math.random();
      if (chance < 0.2) {
        alert("Wind event! Oh no, some cups might topple over!");
      } else if (chance < 0.3) {
        alert("Power Cup! Relax, stacking rules ignored this turn.");
      } else {
        alert("It's all calm. No event this round.");
      }
    }
  

To handle the flow of the game, I could use a simple while loop or for loop that counts rounds, calls randomEvent each round, and asks players to make moves.

I know for big games, people usually talk about objects or something fancier, but at this stage, arrays and simple functions make sense to me. Maybe later down the road, I'd learn how to make objects or classes to handle players and stacks better, but for now, simple arrays and functions seem fine. You think that's a good way to start?

It sounds like you’re doing some cool work with the Anya algorithm! I totally get where you’re coming from with the whole start and target position issue. It’s tricky when you’re dealing with non-discrete positions, especially since Anya was originally designed for discrete cells.

Your approach to truncate the decimal parts makes sense for keeping the algorithm in line with the grid system. But I wonder if instead of just truncating, you might try to utilize interpolation or snapping. Maybe you could look into snapping the positions to the nearest walkable vertex rather than just the grid cell. This way, even if your start and target are decimal, you’d still be able to work with them more precisely.

Another idea could be using the concept of local minima. If you’re finding that certain paths are suboptimal, consider running a simple local optimization after Anya has generated a path. Basically, check specific segments of the path to see if they could be straightened out based on line-of-sight checks. There are also some smoothing techniques where you iteratively adjust the path to minimize distance while checking if the new segment can still be traversed.

On a different note, you might want to implement a secondary pathfinding run after you get the initial result from Anya. Like, after you get the path, take the start and target points and run a different algorithm (maybe A* or Dijkstra’s) specifically around those non-discrete points, which might give you a smoother path.

And hey, don’t feel too frustrated! Many people face similar challenges with grid-based algorithms, especially when trying to adapt them for more complex scenarios. Just keep experimenting and iterating on your ideas; that’s the best part of programming!