▄▄▄▄▄▄ ▄▄ ▄▄ ▄▄▄▄▄▄▄ ▄▄▄ ▄▄ ┌──────────────────────────────────────────────────────────┐
██╔═══██╗██║ ██║██╔════╝████╗ ██║ │ >_ Qwen Code (v0.13.0-nightly.20260320.b8dda154d) │
██║ ██║██║ █╗ ██║█████╗ ██╔██╗ ██║ │ │
██║▄▄ ██║██║███╗██║██╔══╝ ██║╚██╗██║ │ Qwen OAuth | coder-model (/model to change) │
╚██████╔╝╚███╔███╔╝███████╗██║ ╚████║ │ ~/Albi/Archive/restunts/src/restunts │
╚══▀▀═╝ ╚══╝╚══╝ ╚══════╝╚═╝ ╚═══╝ └──────────────────────────────────────────────────────────┘
Tips: You can resume a previous conversation by running qwen --continue or qwen --resume.
✕ Automatic update failed. Please try updating manually
> Analyze this codebase, and find out the part where the car's steering affects the attitude of some polygons in the car's 3D model
✦ I need to explore this codebase to understand its structure and find where steering affects 3D model polygons. Let me start by reading key files and searching for relevant
terms.
✦ I'll analyze this codebase to find where car steering affects 3D model polygons. Let me start by exploring the structure and searching for relevant code.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ ReadFile makefile │
│ │
│ ✓ ListFiles c │
│ │
│ Listed 23 item(s) │
│ │
│ ✓ ListFiles asm │
│ │
│ Listed 91 item(s) │
│ │
│ ✓ Grep 'steer|steering' in path '/home/albi/Albi/Archive/restunts/src/restunts' │
│ │
│ Found 118 matches (truncated) │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ Found steering references in frame.c calling sub_204AE with car_steeringAngle - need to read that function and search for polygon/shape transformation code.
✦ Good! I found references to steering. Let me look at the key file frame.c where the steering angle is used with 3D shapes, and also search for polygon-related code.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ ReadFile c/frame.c (lines 921-1020) │
│ │
│ Read lines 921-1020 of 1205 from c/frame.c │
│ │
│ ✓ Grep 'sub_204AE' in path '/home/albi/Albi/Archive/restunts/src/restunts' │
│ │
│ Found 44 matches (truncated) │
│ │
│ ✓ Grep 'polygon|verts|shape3d' in path '/home/albi/Albi/Archive/restunts/src/restunts/c' │
│ │
│ Found 185 matches (truncated) │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I found that sub_204AE is the key function that applies steering to car vertices - let me read its implementation in shape3d.c and check the SHAPE3D structure definition.
✦ Perfect! I found it. The function sub_204AE is called with car_steeringAngle and modifies the car's 3D shape vertices. Let me read the implementation of this function in
shape3d.c:
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ ReadFile c/shape3d.c (lines 4921-5120) │
│ │
│ Read lines 4921-5068 of 5068 from c/shape3d.c │
│ │
│ ✓ ReadFile c/shape3d.h │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ Now I have a complete understanding of how steering affects the car's 3D model - let me summarize the findings for the user.
✦ Excellent! I found the exact code. Let me also check the assembly version to understand the full picture:
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ ReadFile asmorig/seg004.asm (lines 3831-4110) │
│ │
│ Read lines 3831-4110 of 6278 from asmorig/seg004.asm │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ Now I have all the information needed to provide a comprehensive analysis of how steering affects the car's 3D model polygons, including the function implementation, call
chain, and specific vertex indices involved.
✦ Perfect! Now I have a complete picture. Let me create a summary of my findings:
Analysis Complete
I found the exact code where car steering affects the 3D model polygons. Here's the breakdown:
Key Function: sub_204AE
Location: /home/albi/Albi/Archive/restunts/src/restunts/c/shape3d.c (lines 5012-5060)
How Steering Affects the Car Model:
1. Input Parameters:
- arg_verts - Pointer to the car's 3D vertices (starting at vertex 8)
- arg_4 - The steering angle (car_steeringAngle)
- arg_6 - Array tracking suspension compression values
- arg_vecarray - Precomputed offset vectors for wheel vertices
- arg_vecptr - Reference points for wheel rotation centers
2. Steering Rotation Logic (lines 5022-5044):
1 if (arg_8[4] != 0) { // If steering angle changed
2 var_C = sin_fast(arg_4 / 2); // sin(steeringAngle/2)
3 var_2 = cos_fast(arg_4 / 2); // cos(steeringAngle/2)
4
5 // Rotate first 6 vertices (front wheels - vertices 8-13)
6 for (i = 0; i < 6; i++) {
7 var_14 = multiply_and_scale(arg_vecarray[i].x, var_2);
8 arg_verts[i].x = multiply_and_scale(arg_vecarray[i].z, var_C) + arg_vecptr[0].x + var_14;
9 var_14 = multiply_and_scale(arg_vecarray[i].z, var_2);
10 arg_verts[i].z = multiply_and_scale(arg_vecarray[i].x, var_C) + arg_vecptr[0].z + var_14;
11 }
12 // Rotate next 6 vertices (vertices 14-19)
13 for (i = 6; i < 0xC; i++) {
14 // Similar rotation around second pivot point
15 }
16 arg_8[4] = arg_4; // Store new steering angle
17 }
3. Suspension Movement (lines 5046-5058):
The second part adjusts Y-coordinates based on suspension compression for 4 groups of 6 vertices each.
Call Sites in frame.c:
- Line 932: Player car steering
1 sub_204AE(&game3dshapes[0x0AD4 / sizeof(struct SHAPE3D)].shape3d_verts[8],
2 state.playerstate.car_steeringAngle, ...);
- Line 986: Opponent car steering
1 sub_204AE(&game3dshapes[0x0AEA / sizeof(struct SHAPE3D)].shape3d_verts[8],
2 state.opponentstate.car_steeringAngle, ...);
What Polygons Are Affected:
The function modifies vertices 8-19 of the car's 3D model (car1 shape), which correspond to the front wheel assemblies. The steering angle rotates these vertices around pivot
points to simulate the wheels turning left/right.
● A new version of Qwen Code is available! 0.13.0-nightly.20260320.b8dda154d → 0.13.0-nightly.20260321.38caa0b21
Installed with npm. Attempting to automatically update now...
> cool. can you tellme something more about how the pivot points are found?
✦ The user wants to know more about how the pivot points are calculated. I need to look at where carshapevec and oppcarshapevec are initialized in the shape3d_load_car_shapes
function, as these are the pivot points passed to sub_204AE.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ ReadFile c/shape3d.c (lines 4924-5023) │
│ │
│ Read lines 4924-5023 of 5068 from c/shape3d.c │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ Let me also check the data structure definitions to better understand the global variables used for pivot points.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ Grep 'carshapevec|oppcarshapevec|word_443E8' in path '/home/albi/Albi/Archive/restunts/src/restunts/c' │
│ │
│ Found 47 matches (truncated) │
│ │
│ ✓ ReadFile c/externs.h (lines 201-250) │
│ │
│ Read lines 201-250 of 507 from c/externs.h │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ Let me search for the actual definitions of these pivot point variables to understand their data types and initial values better.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ Grep '^struct VECTOR carshapevec' in path '/home/albi/Albi/Archive/restunts/src/restunts/c' │
│ │
│ No matches found │
│ │
│ ✓ Grep 'carshapevec|oppcarshapevec' in path '/home/albi/Albi/Archive/restunts/src/restunts/asm' │
│ │
│ Found 76 matches (truncated) │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ Let me read the assembly code around lines 3356-3380 to see exactly how the pivot points are calculated from the vertex data.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ ReadFile asm/seg004.asm (lines 3341-3420) │
│ │
│ Read lines 3341-3420 of 6278 from asm/seg004.asm │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ Now I have enough information to explain how the pivot points are calculated from the car model's vertex data - they're computed as center points between specific wheel
vertices.
✦ Perfect! Now I have the full picture. Let me explain how the pivot points are calculated:
---
Pivot Point Calculation for Steering
The pivot points are computed from the car's 3D model vertices when the car shape is loaded. Here's the detailed breakdown:
Vertex Layout (starting at vertex 8)
The car model's vertices 8-27 are organized as:
- Vertices 8-13 (indices 0-5): Front wheel assembly (left side)
- Vertices 14-19 (indices 6-11): Front wheel assembly (right side)
- Vertices 20-25 (indices 12-17): Suspension components 1
- Vertices 26-31 (indices 18-23): Suspension components 2
Pivot Point Calculation (lines 4936-4939 in shape3d.c)
1 var_E = &(game3dshapes[126].shape3d_verts[8]); // Start at vertex 8
2
3 // First pivot point (for left front wheel)
4 carshapevec.z = var_E[0].z; // Z from vertex 8
5 carshapevec.x = (var_E[3].x + var_E[0].x)/2; // Average X of vertices 8 and 11
6
7 // Second pivot point (for right front wheel)
8 carshapevec2.z = var_E[6].z; // Z from vertex 14
9 carshapevec2.x = (var_E[6].x + var_E[9].x) /2; // Average X of vertices 14 and 17
Visual Representation
1 Front of car (looking from top)
2 Z
3 ↑
4 |
5 v8 | v14
6 (L) | (R)
7 ●────┼────●
8 | | |
9 | | |
10 ●────┼────●
11 v11 | v17
12 |
13 └────────→ X
14
15 Pivot 1 (left): X = (v8.x + v11.x)/2, Z = v8.z
16 Pivot 2 (right): X = (v14.x + v17.x)/2, Z = v14.z
Offset Vector Calculation (lines 4941-4949)
After finding the pivots, the code precomputes offset vectors from each pivot to its associated vertices:
1 for (i = 0; i < 6; i++) {
2 // Offsets from first pivot to vertices 8-13
3 carshapevecs[i].x = carshapevec.x - var_E[i + 0].x;
4 carshapevecs[i].z = carshapevec.z - var_E[i + 0].z;
5 carshapevecs[i].y = var_E[i + 0].y;
6
7 // Offsets from second pivot to vertices 14-19
8 carshapevecs2[i].x = carshapevec2.x - var_E[i + 6].x;
9 carshapevecs2[i].z = carshapevec2.z - var_E[i + 6].z;
10 carshapevecs2[i].y = var_E[i + 6].y;
11 }
Key Insight
The pivot points represent the steering axis centers - essentially where the steering column would connect to the wheel assembly. The game:
1. Averages the X coordinates of opposite corners of each wheel assembly to find the center
2. Uses the Z coordinate from the front vertex directly
3. Stores the Y coordinate separately for suspension movement
This allows the wheels to rotate around a realistic pivot point rather than their geometric center, giving more authentic steering animation.
> I see the game assumes that the first 24 vertices are organized in groups of 6. this is true if the firs four primitives are wheels. But what, I wonder, would happen with
different primitives having a different number/meaning for the vertexes? I'd like you to find out. First, look up how what the arg_verts content is for the various primitives
(the function transformedshape_op might help).
✦ The user wants me to investigate how vertices are organized for different primitives/shapes, not just the car wheels. They mentioned transformedshape_op might help. Let me
search for this function and understand how different shapes use vertices.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ Grep 'transformed_shape_op|transformedshape_op' in path '/home/albi/Albi/Archive/restunts/src/restunts/c' │
│ │
│ Found 14 matches │
│ │
│ ✓ ReadFile c/shape3d.c (lines 101-250) │
│ │
│ Read lines 101-250 of 5068 from c/shape3d.c │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I need to understand how different shapes use vertices. Let me search for where sub_204AE is called and what shapes are passed to it, and also look at the shape3d structure to
understand vertex organization better.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ Grep 'sub_204AE.*game3dshapes' in path '/home/albi/Albi/Archive/restunts/src/restunts/c' │
│ │
│ Found 4 matches │
│ │
│ ✓ ReadFile c/shape3d.c (lines 81-130) │
│ │
│ Read lines 81-130 of 5068 from c/shape3d.c │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I need to find out what shapes are loaded and how many vertices they have. Let me search for shape loading code and look at the car shape names to understand the vertex
organization.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ Grep 'shape3d_init_shape.*game3dshapes\[' in path '/home/albi/Albi/Archive/restunts/src/restunts/c' │
│ │
│ Found 15 matches │
│ │
│ ✓ Grep 'locate_shape_fatal' in path '/home/albi/Albi/Archive/restunts/src/restunts' │
│ │
│ Found 117 matches (truncated) │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I need to understand what shapes are loaded for the track/scene objects and how many vertices they have. Let me search for where track objects are loaded and what shapes they
use.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ Grep 'trkObjectList|sceneshapes3' in path '/home/albi/Albi/Archive/restunts/src/restunts/c' │
│ │
│ Found 15 matches │
│ │
│ ✓ ReadFile c/frame.c (lines 1-50) │
│ │
│ Read lines 1-50 of 1205 from c/frame.c │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ Let me search for where track objects and scene shapes are loaded to understand what shapes they reference and how many vertices they have.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ Grep 'ss_shapePtr|ss_loShapePtr' in path '/home/albi/Albi/Archive/restunts/src/restunts/c' │
│ │
│ Found 18 matches │
│ │
│ ✓ Grep 'struct TRACKOBJECT' in path '/home/albi/Albi/Archive/restunts/src/restunts/c' │
│ │
│ Found 8 matches │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ Let me look at the TRACKOBJECT structure definition and search for where track objects are loaded to understand what shapes they reference.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ ReadFile c/externs.h (lines 186-215) │
│ │
│ Read lines 186-215 of 507 from c/externs.h │
│ │
│ ✓ Grep 'shape3d_load_all|game2ptr|shapename' in path '/home/albi/Albi/Archive/restunts/src/restunts/c' │
│ │
│ Found 30 matches │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I need to look at shape3d_load_all to see what shapes are loaded from game2 and how many vertices they have, and also look at where track objects get their shapes assigned.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ ReadFile c/shape3d.c (lines 41-90) │
│ │
│ Read lines 41-90 of 5068 from c/shape3d.c │
│ │
│ ✓ Grep 'aBarn|game3dshapes\[' in path '/home/albi/Albi/Archive/restunts/src/restunts/asm' │
│ │
│ Found 5 matches │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I found aBarn is defined in dseg.asm. Let me read that section to see all the shape names that are loaded into game3dshapes array.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ ReadFile asm/dseg.asm (lines 3991-4090) │
│ │
│ Read lines 3991-4090 of 41828 from asm/dseg.asm │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I need to find all the shape names in aBarn array and understand which shapes have how many vertices. Let me search for a way to see all shape names and also look for any
debugging or logging that shows vertex counts.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ ReadFile asm/dseg.asm (lines 3998-4397) │
│ │
│ Read lines 3998-4397 of 41828 from asm/dseg.asm │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I need to find where the actual vertex counts for these shapes are determined. Let me look at the status.html file which seems to track porting status and might have
information about shapes, or search for where shapes are analyzed for their vertex counts.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ Grep 'shape3d_numverts|numverts|header_numverts' in path '/home/albi/Albi/Archive/restunts/src/restunts' │
│ │
│ Found 675 matches (truncated) │
│ │
│ ✓ Glob '**/*.3ds' in path '/home/albi/Albi/Archive/restunts/src/restunts' │
│ │
│ No files found │
│ │
│ ✓ Glob '**/game1.*' in path '/home/albi/Albi/Archive/restunts/src/restunts' │
│ │
│ No files found │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I need to find where the track objects get their shape pointers assigned, and also look at the assembly code for sub_204AE to understand the vertex indexing better. Let me also
search for where sceneshapes3 is populated.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ Grep 'sceneshapes3' in path '/home/albi/Albi/Archive/restunts/src/restunts/asm' │
│ │
│ Found 6 matches │
│ │
│ ✓ Grep 'ss_shapePtr|ss_loShapePtr' in path '/home/albi/Albi/Archive/restunts/src/restunts/asm' │
│ │
│ Found 17 matches │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I need to look at where sceneshapes3 is populated with shape data to understand what shapes it references and how many vertices they have. Let me look at seg003.asm where
sceneshapes3 is being set up.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ ReadFile asm/seg003.asm (lines 2381-2480) │
│ │
│ Read lines 2381-2480 of 7185 from asm/seg003.asm │
│ │
│ ✓ ReadFile asm/structs.inc (lines 171-200) │
│ │
│ Read lines 171-200 of 330 from asm/structs.inc │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I need to find where sceneshapes3 gets its shape pointers assigned - this will tell me what shapes are used for track objects. Let me search for where the shape pointers are
set for sceneshapes3.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ ReadFile asm/seg003.asm (lines 2281-2430) │
│ │
│ Read lines 2281-2430 of 7185 from asm/seg003.asm │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I need to find where sceneshapes3 is initialized with actual shape data. Let me search for where the shape pointers are assigned to sceneshapes3 entries.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ Grep 'mov.*sceneshapes3.*ss_shapePtr|mov.*sceneshapes3\+' in path '/home/albi/Albi/Archive/restunts/src/restunts/asm' │
│ │
│ No matches found │
│ │
│ ✓ ReadFile asm/dseg.asm (lines 12971-13020) │
│ │
│ Read lines 12971-13020 of 41828 from asm/dseg.asm │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I need to find where sceneshapes3 gets its shape pointers assigned. Let me search for where track objects are built or initialized with shapes from game3dshapes.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ Grep 'build_track_object|ss_physicalModel' in path '/home/albi/Albi/Archive/restunts/src/restunts/asm' │
│ │
│ Found 12 matches │
│ │
│ ✓ Grep 'build_track_object' in path '/home/albi/Albi/Archive/restunts/src/restunts/c' │
│ │
│ Found 9 matches │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I found that build_track_object is the function that sets up track objects. Let me read this function to understand how shapes are assigned to track objects.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ ReadFile asm/seg004.asm (lines 50-249) │
│ │
│ Read lines 50-249 of 6278 from asm/seg004.asm │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I need to continue reading build_track_object to find where it assigns shape pointers to track objects. Let me search for where the shape pointer is actually set.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ ReadFile asm/seg004.asm (lines 421-620) │
│ │
│ Read lines 421-620 of 6278 from asm/seg004.asm │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I need to find where the shape pointers are actually assigned to track objects. Let me search for where game3dshapes indices are used to set ss_shapePtr.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ Grep 'game3dshapes.*ss_shapePtr|ss_shapePtr.*game3dshapes|off_3BE44' in path '/home/albi/Albi/Archive/restunts/src/restunts/asm' │
│ │
│ Found 4 matches │
│ │
│ ✓ ReadFile asm/seg004.asm (lines 2601-2700) │
│ │
│ Read lines 2601-2700 of 6278 from asm/seg004.asm │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I found that off_3BE44 is a table of pointers to game3dshapes. Let me look at how this table is used and also read the dseg.asm to understand the full structure.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ ReadFile asm/dseg.asm (lines 3126-3155) │
│ │
│ Read lines 3126-3155 of 41828 from asm/dseg.asm │
│ │
│ ✓ ReadFile asm/seg003.asm (lines 876-955) │
│ │
│ Read lines 876-955 of 7185 from asm/seg003.asm │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ I found that off_3BE44 is a lookup table that maps indices to game3dshapes entries. Let me calculate what shapes these offsets correspond to and also look for where track
objects get their shape pointers assigned from game3dshapes.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓ ReadFile asm/seg003.asm (lines 1651-1750) │
│ │
│ Read lines 1651-1750 of 7185 from asm/seg003.asm │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯