Bug Tracking for Basketball Games

Basketball games juggle a lot at once: ten players animating and colliding, a ball with its own physics, shot mechanics graded on timing, and an AI running offensive plays and defensive assignments. The bugs come from the seams between these systems. A clean shot that misses, a dribble that warps the ball, two players that clip into one possession, a defender that ignores its assignment. Players describe these as the game cheated me. This post covers what shot, animation, and AI state to capture so a busted possession becomes a reproducible moment you can step through instead of arguing about feel.

Shot mechanics and ball physics

The shot is the payoff of every possession, and its mechanics are a timing-and-physics bug magnet. A shot is graded on release timing, contested or open, and the shooter's rating, then the ball follows an arc to the rim. Bugs include a perfectly timed open shot that bricks, an arc that ignores the shot power, or a ball that passes through the backboard. Capture the release timing grade, the open-or-contested state, the computed shot percentage, and the ball's launch arc. A green-timing open miss is a percentage-calculation bug, and these fields show whether the math or the physics failed.

The rim and backboard collision is the most scrutinized physics in the game. A ball that should rattle in but bounces out, one that swishes through a contested hand, or one that clips the rim wrong all stem from collision response at the basket. Log the ball velocity approaching the rim, the contact points with the rim and backboard, and the restitution applied. When players report shots that should have gone in keep rimming out, the contact and restitution data reveal whether the rim collider is too bouncy or positioned slightly off from where it renders.

Animation blending and player state

Basketball is animation-heavy, and the blending between dribble, drive, shot, and defense states is where many bugs live. A crossover that snaps instead of blending, a shot animation that teleports the ball to the hand, or a player stuck in a dribble pose after a steal are all blend or state-sync bugs. Capture the active animation, the blend weights, and the gameplay state the animation should mirror. A ball that warps to the hand is a blend that skipped, and the blend weights at that frame expose the gap.

Player-to-player interactions add collision bugs on top of animation. Two players going for the same ball, a screen that clips defenders through the screener, or a post player that phases into a defender are collision and capsule bugs. Log the positions and capsule states of the players involved and the contact resolution the physics applied. When a player reports defenders walk through screens, the capsule and contact data show whether the screen collider failed to engage, which separates an animation issue from a genuine collision bug in the pick-and-roll.

AI plays, defense, and assignments

The AI runs the game when the player is not controlling a man, and its bugs are about basketball intelligence. An offense that ignores an open play, a defender that abandons its assignment, a help defense that never rotates, or a teammate that stands still on a fast break all read as the AI is broken. Capture the play the AI is running, each defender's assignment, the decision each AI made this possession, and the difficulty parameters. A defender that left an open shooter is an assignment or rotation bug, and the decision data shows which rule fired or failed to.

Defensive rotations are the subtlest AI behavior and the most reported. When the ball moves, defenders should rotate to cover the open man, and a bug where the rotation triggers late, double-teams the wrong player, or never fires leaves shooters wide open. Log the rotation triggers, which defender was assigned to rotate, and the timing of that decision relative to the pass. When players report the AI leaves shooters open, the rotation timing field tells you whether the trigger fired late or the assignment logic picked the wrong defender to rotate.

Fouls, scoring, and game state

Fouls and scoring are logic systems layered on the physics, and their bugs are maddening because they decide outcomes. A foul not called on clear contact, a phantom foul on clean defense, a basket that does not count, or a shot clock that resets wrong all break the game's rules. Capture the contact event that should or should not have drawn a foul, the foul decision the engine made, and the relevant game-state values. A phantom foul is a contact-detection threshold bug, and the contact event plus the decision show whether the threshold tripped on incidental contact.

Scoring and clock state add timing-sensitive bugs. A buzzer-beater that counts when it left the hand late, a three that scores as a two, or a shot clock violation that is not called are all transitions in the scoring and clock systems. Log the timestamp of the release relative to the clock, the points awarded, and the rule applied. When a player disputes a buzzer-beater, the release timestamp versus the clock settles it objectively and, if wrong, points at the timing comparison in the scoring code.

Setting it up with Bugnet

Bugnet adds an in-game report button so a player who just watched a wide-open green-timing shot brick can report it on the spot, and the SDK captures the possession state automatically. You wire that capture to include the shot timing grade and arc, the rim collision contacts, the active animation and blend weights, the AI play and assignments, and the relevant game state. The player says it cheated me; the snapshot shows whether the shot math, the rim physics, or the AI rotation was at fault. Crashes during a busy possession arrive with a full stack trace and device and platform context.

Because the same shot, animation, or AI complaint comes from many players, Bugnet folds duplicate reports into one issue with an occurrence count that becomes your priority signal. A defensive-rotation bug with hundreds of reports outranks a rare animation snap. Custom fields store the game mode and team IDs, player attributes track platform and controller, and one dashboard lets you filter to a mode or play type to find exactly where the shot physics, blending, or AI breaks instead of reading every possession report individually.

Testing the full possession

Basketball bugs emerge from full possessions, so test possessions, not isolated mechanics. Build automated scenarios that run every offensive play against every defensive set, take open and contested shots from every spot, and trigger screens and rotations repeatedly. Most AI and animation bugs surface when you brute-force these combinations rather than scripting one clean play, and a nightly run catches regressions in shot percentage, blending, and rotation logic before a build ships to players.

Pair that synthetic coverage with real field reports, because players find play and timing combinations your scenarios missed. When a new wide-open-shooter bug arrives with the full possession state attached, fold that exact setup into your test suite so it cannot silently regress. Over time your basketball game becomes one where the systems cooperate and the only misses are the ones the shot percentage intended, and your reports shift from it cheated me to genuinely rare edge cases worth investigating.

Basketball bugs live in the seams between physics, animation, and AI. Capture the whole possession and a shot that cheated you becomes a moment you can step through.