User Tools

Site Tools


kirby64_the_crystal_shards:level_settings_blocks

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
Next revision
Previous revision
kirby64_the_crystal_shards:level_settings_blocks [2020/01/26 21:46]
jesusyoshi54 [Collision]
kirby64_the_crystal_shards:level_settings_blocks [2020/09/15 11:30] (current)
jesusyoshi54 [Collision Header]
Line 1: Line 1:
 ====== Level Settings Block ====== ====== Level Settings Block ======
 Every Area has its own Level Settings Block defined inside the Main Stage Table (see: [[kirby64_the_crystal_shards:​levels|]]). Every Area has its own Level Settings Block defined inside the Main Stage Table (see: [[kirby64_the_crystal_shards:​levels|]]).
-The level settings block defines the camera, collision, and entities spawned inside the stage. The Basic Structure of the Level Settings Block is as follows.+The level settings block defines the camera, pathing, collision, and entities spawned inside the stage. The Basic Structure of the Level Settings Block is as follows. 
 ===== Level Settings Layout ===== ===== Level Settings Layout =====
  
   - Main Header   - Main Header
-  - Vertices ​(s16 triplets) +  - Vertices 
-  - Triangles ​(20 bytes each)+  - Triangles
   - Surface Normals   - Surface Normals
   - Triangle Groups/​Cells   - Triangle Groups/​Cells
   - Surface Normals Groups/​Cells   - Surface Normals Groups/​Cells
-  - Unkown Floats (possibly for star blocks/​breakable geo) +  - Water Data 
-  - Unk halfs (possibly for star blocks/​breakable geo) +  - Water Normals 
-  - Unk halfs 2 (mostly zeroes, ends with 9999) +  - Destructable Geometry Groups 
-  - Unk halfs 3 (Breaking star blocks?) +  - Destructable Geometry Indices 
-  - Collision Header (referred to by Header[0]) +  - Collision Header (referred to by Main Header[0]) 
-  - Camera ​Defines of some sort (referred to by Header[1]) +  - Pathing Nodes 
-  - Entity List (referred to by Header[2])+  - Kirby Node Data & Camera ​Node Data 
 +  - Node Connections 
 +  - Unk Bytes 
 +  - Unk Floats 
 +  - Path Node Headers 
 +  - Node Header ​(referred to by Main Header[1]) 
 +  - Entity List (referred to by Main Header[2])
  
 ==== Main Header ==== ==== Main Header ====
  
-The main header contains references to the three main sections of the level settings block: Collision, ​Camera ​and the Entity List.+The main header contains references to the three main sections of the level settings block: Collision, ​Nodes and the Entity List.
 <code c> <code c>
-struct Main_Header{ +struct Main_Header 
-   ​0x00: u32 Pointer to Collision Header +
-   ​0x04: u32 Pointer to Camera Header +/*0x00*/    struct Collision_Header ​   *Collision_Header;​ 
-   ​0x08: u32 Pointer to Entity IDs +/*0x04*/    struct Node_Header ​        ​*Node_Header;​ 
-   ​}+/*0x08*/    struct Entities ​           (*Entity_IDs)[];​ 
 +/​*0x0C*/ ​   int                        padding; 
 +};
 </​code>​ </​code>​
  
Line 36: Line 45:
  
 Vertices are made up of unsorted s16 tripets of x, y and z position. Vertices are made up of unsorted s16 tripets of x, y and z position.
 +
 +The vertex array starts with a 0x270F triplet and optionally ends with a single 0x9999. This is assumed to be
 +for 4 byte alignment of the following sections.
  
 ==== Triangles ==== ==== Triangles ====
Line 42: Line 54:
 Every Triangle has a struct that has additional parameters telling the game how to handle collision. Every Triangle has a struct that has additional parameters telling the game how to handle collision.
 <code c> <code c>
-struct ​Triangle+struct ​Col_Triangle 
-0x0: u16 Vertex[2+
-0x6: u16 Quads #not sure +/*0x0*/ u16    Vertex[3]; 
-0x8: u16 Collision_Type_1 #(1 forward norm, 2 back norm, 4 no shadow, 8 non solid/warp related?+/*0x6*/ u16    ​Polygon_Number;​ 
-0xA: u16 Destructable Group Index +/*0x8*/ u16    ​Normal_Type; ​         //(1 forward norm, 2 back norm, 4 no shadow, 8 non solid) 
-0xC: u16 Break_Particle ​#(seen in DEDEDE hammer break) +/*0xA*/ u16    ​Collision_Type_Index;​ //based on col type this num references array pos 
-0xE: u16 Halt_Movement ​#warp related? Maybe dest (kirby cant move while on top of this if 1) +/*0xC*/ u16    Break_Particle;       //(seen in DEDEDE hammer break) 
-0x10: s16 Col_Param1 ​#Amount to move kirby while on certain col types or Break Condition +/*0xE*/ u16    Halt_Movement;        //​Stops ​kirby from moving/​triggers automatic behavior. 
-0x12: u16 Collision_Type_2 #see col type list +/*0x10*/ s16    Col_Param1;           //ex.Amount to move kirby while on certain col types or Break Condition 
-}+/*0x12*/ u16    ​Collision_Type; ​      //see col type list 
 +};
 </​code>​ </​code>​
-The following is a list of Collision_Type_2 ​values known.+The following is a list of Collision_Type ​values known. 
 +  * 0x0 - default
   * 0x1 - wall ladder   * 0x1 - wall ladder
   * 0x2 - rope   * 0x2 - rope
Line 65: Line 79:
   * 0x13 - move kirby forwards while on top   * 0x13 - move kirby forwards while on top
   * 0x14 - Platform with custom movement (seems to be in some sort of object list separate from normal level geometry)   * 0x14 - Platform with custom movement (seems to be in some sort of object list separate from normal level geometry)
 +
 +The triangle list begins with a placeholder struct of (0,​1,​2,​3,​4,​5,​6,​7,​8,​9)
  
 ==== Triangle Normals ==== ==== Triangle Normals ====
  
-Triangle normals are stored as a F32 array of 4 values. The first three values are the surface normals while the last is the origin offset. Together the normals should solve the plane equation (see:​[[http://​mathworld.wolfram.com/​Plane.html|link]]).+Triangle normals are stored as a F32 array of 4 values. The first three values are the surface normals while the last is the origin offset. 
 +Together the normals should solve the plane equation (see:​[[http://​mathworld.wolfram.com/​Plane.html|link]]).
  
-The list of normals always starts with (-1,​-2,​-3,​-4) ​and this is used to refer to walls. The actual value of the first set of normal is not known to have any significance. Redundant normals are not repeated, but are just referenced multiple times (e.g. two triangles with norm Y==1 and offset==0 share their normal).+The list of normals always starts with (-1,​-2,​-3,​-4). 
 +Redundant normals are not repeated, but are just referenced multiple times (e.g. two triangles with norm Y==1 and offset==0 share their normal). 
 + 
 +<code c> 
 +struct Normal 
 +
 +/​*0x0*/ ​   Vec3f    Surface_Normals;​ 
 +/​*0xC*/ ​   f32      Origin_Offset;​ 
 +}; 
 +</​code>​
  
 ==== Triangle Groups ==== ==== Triangle Groups ====
  
-The triangle groups is a pre-sorted ​list that references each triangle by its index. The triangle group list begins with a flag of 0x8192 and ends with 0x9999. The triangle group starts searching for the right triangle starting at the bottom, and keeps going until it finds the right triangle, or it finds an index with the MSB set.+The triangle groups is a list of triangles used to make collision sorting more efficient.
  
-There should be an equal amount of items in the triangle list and triangle group list.+The triangle ​group list begins with a flag of 0x8192 ​and ends with 0x9999. Each triangle group is a u16 list of indices to the triangle struct array.
  
 +Each triangle group represents one polygon index (0x6 in tri struct). The groups are defined by setting the msb at the last triangle in that group. This means any coplanar, connected N-gon will be a single polygon group.
 +
 +There should be an equal amount of items in the triangle list and triangle group list, but there may be repeats based on how the normal groups are split.
 +Triangles within groups are sorted by Y values.
 ==== Normal Groups ==== ==== Normal Groups ====
  
-The normal groups ​is list that matches each normal ​to triangle. It is formed ​in pairs with the first item being the index of the normal, and the second item being the index of the triangle.+The normal groups ​are binary space partition tree of the level normals and corresponding triangles associated with those normals. Each normal ​group represents ​node in the tree, and has a right and left child based on whether ​the ensemble ​of triangles is in front or behind ​the parent node.
  
-Normal groups are sorted by level H-Position. Only floors & ceilings are referenced by the normal ​groupswalls are given the first index of the normals list (-1,-2,-3,-4).+If a triangle group intersects a normal, ​then the group is split and the normal is repeated in both the left and right children. If that group shares a condition such as being breakablethen the entire group is repeated in the left and right branches.
  
-==== Destructable groups ====+Child indices of zero refer to leaf nodes, the tree start is defined in the collision header.
  
-comes in three u16s +<code c> 
-1- Number of times it loops in list +struct Norm_Group 
-2- Index inside Dustructable indices list (0x30 in col header) +{ 
-3- Unk Index+/​*0x0*/ ​ u16  Normal_Index;​ 
 +/​*0x2*/ ​ u16  Left_Child;​ 
 +/​*0x4*/ ​ u16  Right_Child;​ 
 +/​*0x6*/ ​ u16  Tri_Cell_Index 
 +}; 
 +</​code>​ 
 +==== Destructable Geometry Groups ====
  
-==== Destructable ​indices ​list ====+Destructable ​Geo list is referenced by certain collision types using 0xA inside the col tri struct. 
 +This is so instead of destroying one triangle, all connected geometry is edited as a single rigid body.
  
-Each Index is half that points ​to the triangle ​that is being destroyed.+When triangle is going to be edited, 0xA of the tri struct references the index into this list. 
 +This list will then tell the game the index to the array of destructable geo indices and the number of members in that array.
  
-Basic idea is that 0x2C contains the index inside the tri index list and length/num of triangles ​being deleted. +<code c> 
-Then in 0x30, there is a list of all the triangles that get destroyed.+struct DynGeo_List 
 +
 +/*0x0*/ ​ u16  Num_Dynamic_Geo_Group_Members;​ //​Number ​of connected ​triangles 
 +/​*0x2*/ ​ u16  Index_To_Dynamic_Geo_Group;​ //(0x30 in col header) 
 +/​*0x4*/ ​ u16  Layout_Number;​ //Linked display geometry to also remove 
 +}; 
 +</​code>​
  
-The destructable group to reference is found from 0xA in the Tri Struct+The dynamic geo list usually ends with 0x9999, but it is not necessary. Potentially for alignment. 
 +The dynamic geo list can also be null, in that case the col header will have a null ptr to match. 
 + 
 +==== Destructable Geometry Indices ==== 
 + 
 +Destructable geometry indices are an array of u16 indices that reference ​the tri struct array. 
 + 
 +When a triangle ​is being edited, ​0xA in the tri struct points to the destructable geometry group. 
 +From there an index to this destructable geometry index list is given, and the number of members in that list. 
 + 
 +The dynamic geomtry group only has the references to triangles. 
 +The transformation (only destruction?​) is applied based on col type or specific code. 
 + 
 +The dynamic geo geoup array usually ends with 0x9999, but its not necessary. Possibly for alignment. 
 +This list can also be null, and will have a null ptr in the col header to match. 
 +==== Water Data ==== 
 + 
 +Water data is an array of water structs that will determine how kirby collides with water. 
 +Normals and a bounding box are used instead of polygons to determine collision. First kirby has to be inside the bounding box inside the water data struct. 
 +Then the normals are used. Normals are different than collision triangle geometry in that they define an infinite plane. 
 +The normal planes intersect to create a closed surface which is used as the collision check. 
 + 
 +<code c> 
 +struct Water_Data 
 +
 +/​*0x0*/ ​   u16    Num_Normals;​ 
 +/​*0x2*/ ​   u16    Norm_Array_Index;​ 
 +/​*0x4*/ ​   u8     ​Water_Box_Active;​ 
 +/​*0x5*/ ​   u8     ​Activate_Water_Flow;​ 
 +/​*0x6*/ ​   u8     ​Water_Flow_Direction;​ 
 +/​*0x7*/ ​   u8     ​Water_Flow_Speed;​ 
 +/​*0x8*/ ​   f32    Pos1; 
 +/​*0xC*/ ​   f32    Pos2; 
 +/​*0x10*/ ​  ​f32 ​   Pos3; 
 +/​*0x14*/ ​  ​f32 ​   Pos4; 
 +}; 
 +</​code>​ 
 + 
 +==== Water Floats ==== 
 + 
 +Works exactly like floats for other collision triangles. 
 +Lead by a (1,2,3,4) the followed by (3*norms,​origin offset). See struct Normal. 
 +Follows all the conventions for normals that you'd expect, including n * r = -offset. 
 + 
 +This list is only accessed by being pointed to by the water data struct.
  
 ==== Collision Header ==== ==== Collision Header ====
  
-The collision header is referred to by the first index inside the main header. The collision header has the following format.+The collision header is referred to by the first index inside the main header. 
 +The collision header has the following format. 
 + 
 +<code c> 
 +struct Collision_Header 
 +
 +/​*0x0*/ ​   struct Col_Triangle ​   *Triangles;​ 
 +/​*0x4*/ ​   u32       ​Len_Triangles;​ 
 +/​*0x8*/ ​   s16       ​(*Vertices)[][3];​ 
 +/​*0xC*/ ​   u32       ​Len_Vertices;​ 
 +/​*0x10*/ ​  ​struct Normal ​         (*Triangle_Normals)[];​ 
 +/​*0x14*/ ​  ​u32 ​      ​Len_Tiangle_Normals;​ 
 +/​*0x18*/ ​  ​u16 ​      ​(*Triangle_Cells)[][2];​ 
 +/​*0x1C*/ ​  ​u32 ​      ​Len_Triangle_Cells;​ 
 +/​*0x20*/ ​  ​u16 ​      ​(*Triangle_Norm_Cells)[][2];​ 
 +/​*0x24*/ ​  ​u32 ​      ​Len_Triangle_Norm_Cells;​ 
 +/​*0x28*/ ​  ​u32 ​      ​Norm_Cell_BSP_Root;​ //Always last member 
 +/​*0x2C*/ ​  ​struct DynGeo_List ​    ​(*Destructable_Groups)[];​ 
 +/​*0x30*/ ​  ​u16 ​      ​(*Destructable Indices)[];​ 
 +/​*0x34*/ ​  ​struct Water_Data ​     (*Water_Data)[];​ 
 +/​*0x38*/ ​  ​u32 ​      ​Len_Water_Data;​ 
 +/​*0x3C*/ ​  ​struct Normal ​         (*Water_Normals)[];​ 
 +/​*0x40*/ ​  ​u32 ​      ​Len_Water_Normals;​ 
 +}; 
 +</​code>​ 
 + 
 +After the level loads the pointers are converted from offsets in the Level Settings Block to virtual addresses in a different RAM 
 +location accompanied by other collision data generated. 
 + 
 +===== Node_Header ===== 
 + 
 +The level nodes are referred to by the second index in the main header. 
 +This section tells the game how to move kirby as you progress through the level and how the camera should act. 
 + 
 +<code c> 
 +struct Node_Header 
 +
 +/​*0x0*/ ​   u32    Num_Path_Nodes;​ 
 +/​*0x4*/ ​   struct Path_Node_Header ​  ​(*Path_Node_Header)[];​ 
 +/​*0x8*/ ​   u8     ​(*Unk_Bytes)[];​ 
 +/​*0xC*/ ​   f32    (*Unk_Floats)[];​ 
 +}; 
 +</​code>​ 
 + 
 +==== Path Node Headers ==== 
 + 
 +Pathing nodes are sections of the level that have a defined path and camera movement for kirby as he progresses through the level. 
 + 
 +Each node has several parts which are pointed to by the path node header array. 
 + 
 +<code c> 
 +struct Path_Node_Header 
 +
 +/​*0x0*/ ​   struct Kirby_Node  ​     *Kirby_Node;​ 
 +/​*0x4*/​  ​  ​struct Path_Node_Footer ​   *Path_Node_Footer;​ 
 +/​*0x8*/​  ​  ​struct Node_Connecters ​    ​(*Node_Connections)[];​ 
 +/​*0xC*/​  ​  ​u16 Num_Connections;​ 
 +/​*0xE*/​  ​  ​u16 Self_Connected;​ 
 +}; 
 +</​code>​ 
 + 
 +==== Path Nodes ==== 
 + 
 +Path nodes are made up of 3 mandatory parts, and one optional part. A footer, a position matrix, and the boundary matrix are required. 
 +The optional section has unknown use. 
 + 
 +The path node footer contains pointers to the other sections, as well as important data for those sections. 
 + 
 +The boundary matrix is a N×1 matrix that has percentage completion for the positional matrix. 
 +This matrix tells the game how much each position in the position matrix contributes towards one node. 
 + 
 +The position matrix is a 3×N matrix which tells the game the absolute positioning of kirby as you progress through the level. 
 +This matrix is how kirby moves in both X and Z when you push to the right. 
 + 
 +All together these sections create a path which kirby will walk along when you push right/​left. 
 +Theyre ordered in the rom as: Position matrix, boundary matrix, unknown path matrix, path node footer. 
 + 
 +<code c> 
 +struct Path_Node_Footer 
 +
 +/​*0x00*/ ​   u32    FlagUnk; //0x200 if *Unk should be used 
 +/​*0x04*/ ​   u32    Num_Node_Sections;​ 
 +/​*0x08*/ ​   Vec3f  (*Position_Matrix)[];​ 
 +/​*0x0C*/ ​   f32    Node_Length;​ 
 +/​*0x10*/ ​   f32    (*Boundary_Matrix)[];​ 
 +/​*0x14*/ ​   f32    (*Unk)[][5];​ 
 +}; 
 +</​code>​ 
 + 
 +The unknown section is almost always null. All that is known is that it follows the boundary matrix and is an areay of 5 floats, with length of Num_Node_Sections-1. 
 +The number of Position_Matrices is extended by FlagUnk/​0x100. 
 +Since its always 0x0 or 0x200 depending on the unk section it is only ever extended by 2. 
 + 
 +==== Camera&​Kirby Nodes ==== 
 + 
 +These nodes tell the game how to move the camera with respect to the path nodes. 
 +There are settings for kirby'​s graphics, and warps as he progresses through the level, as well as camera movement. 
 + 
 +Thr flag in 0xE of Kirby_Node determines if 0x10 or 0x4 is read. 
 +A value of 0x10 reads unused3, and a value of 0x1 reads the warp. 
 +This wholly seems useless outside of setting up warps. Very likely to be old code left in. 
 + 
 +Opt_1 and opt_2 are used only in 5-5-1. 
 + 
 +<code c> 
 +struct Kirby_Node 
 +
 +/​*0x00*/​ u8 ​     Node_Number;​ 
 +/​*0x01*/ ​   u8      Padding; 
 +/​*0x02*/ ​   u16     ​unk2;​ 
 +/​*0x04*/​ struct Level    Warps; 
 +/​*0x08*/​ u8 ​ unused; 
 +/​*0x09*/​ u8 ​  ​ Shade_Left;​ 
 +/​*0x0A*/​ u8  ​   Shade_Center;​ 
 +/​*0x0B*/​ u8 ​ Shade_Right;​ 
 +/​*0x0C*/​ u16 ​ unused2; 
 +/​*0x0E*/​ u16  ​   Unkflag; 
 +/​*0x10*/​ s16 ​    ​unused3;​ 
 +/​*0x12*/ ​   s16     ​unused4;​ 
 +/​*0x14*/​ f32 ​    ​opt_1;​ 
 +/​*0x18*/​ f32 ​    ​opt_2;​ 
 +/​*0x1C*/​ u32 ​    ​unused5;​ 
 +/​*0x20*/ ​   struct Camera_Node ​   Camera; 
 +}; 
 +</​code>​ 
 + 
 +For any of the camera values, 9999 can be used to disable reading that value. For a pair, -9999 is used in the first member and 9999 in the second member to disable them. 
 + 
 +Certain values are only used if the bool enables them. For example a focus pos is only used if that axis is locked. 
 + 
 +The bounds variables basically set limits on how far the camera moves before panning to face kirby instead of scrolling. 
 +<code c> 
 +struct Camera_Node 
 +
 +/​*0x00*/ ​  ​u8 ​    ​Profile_View;​ /* Set position to be in line with kirbys side*/ 
 +/​*0x01*/ ​  ​u8 ​    Pad; /​*Unused*/​ 
 +/​*0x02*/ ​  ​u8 ​    ​Lock_X_pos;​ 
 +/​*0x03*/ ​  ​u8 ​    ​Lock_Y_pos;​ 
 +/​*0x04*/ ​  ​u8 ​    ​Lock_Z_pos;​ 
 +/​*0x05*/ ​  ​u8 ​    ​unused;​ 
 +/​*0x06*/ ​  ​u8 ​    ​DisableCamPhi;​ 
 +/​*0x07*/ ​  ​u8 ​    ​DisableCamPhiDown;​ 
 +/​*0x08*/ ​  ​u8 ​    ​EnableCamTheta;​ 
 +/​*0x09*/ ​  ​u8 ​    ​pad2;​ 
 +/​*0x0A*/ ​  ​u16 ​   pad3; 
 +/​*0x0C*/ ​  ​f32 ​   X_Focus_Pos;​ 
 +/​*0x10*/ ​  ​f32 ​   Y_Focus_Pos;​ 
 +/​*0x14*/ ​  ​f32 ​   Z_Focus_Pos;​ 
 +/​*0x18*/ ​  ​f32 ​   Near_Clip_Plane;​ 
 +/​*0x1C*/ ​  ​f32 ​   Far_Clip_Plane;​ 
 +/​*0x20*/ ​  ​f32[2] CamRadiusScale;​ 
 +/​*0x28*/ ​  ​f32[2] CamTheta; 
 +/​*0x30*/ ​  ​f32[2] CamRadius;​ 
 +/​*0x38*/ ​  ​f32[2] FOV_Pair; 
 +/​*0x40*/ ​  ​f32[2] CamPhi; 
 +/​*0x48*/ ​  ​f32[2] Cam_X_LockBounds;​ 
 +/​*0x50*/ ​  ​f32[2] Cam_Y_LockBounds;​ 
 +/​*0x58*/ ​  ​f32[2] Cam_Z_LockBounds;​ 
 +/​*0x60*/ ​  ​f32[2] Cam_Yaw_LockBounds;​ 
 +/​*0x68*/ ​  ​f32[2] Cam_Pitch_LockBounds;​ 
 +}; 
 +</​code>​ 
 + 
 +==== Node Connectors ==== 
 + 
 +Node connectors tell the game which nodes to use as kirby hits the boundaries of a node. 
 +The number of connections for each node is listed in the path node header. 
 <code c> <code c>
-struct ​Collision_Header+struct ​Node_Connectors 
- 0x0: Triangles Offset +
- 0x4: Number of Triangles +/​*0x00*/ ​   u16     ​Go_Backwards;​ 
- 0x8: Vertices offset +/​*0x02*/ ​   u16     ​Current_Node;​ 
- 0xC: Number of Vertices +/​*0x04*/ ​   u16     ​Connected_Node;​ //Not sure 
- 0x10: Triangle Normals $3 Norms, then a NegDot/offset from origin. +/*0x06*/ ​   u16     ​Go_Foward;​ 
- 0x14: Number of Norms #processed by 0x80101400 +};
- 0x18: Triangle Groups (cells) Offset #processed by 0x80102570?​ +
- 0x1C: Number of Triangle Groups +
- 0x20: Triangle Norms Cells #processed by 0x80101400. Sorted by H position. +
- 0x24: Number Tri Norm Cells #Sorted by H position. +
- 0x28: Size of Unk +
- 0x2C: Destructable_Groups +
- 0x30: Destructable Indices +
- 0x34: Optional Param +
- 0x38: Optional Param +
- 0x3C: Optional Param +
- 0x40: Optional Param +
-}+
 </​code>​ </​code>​
  
-===== Camera =====+Basically if a node is connected on both ends to the same node, there is only one 
 +node connector. In this case Go_Forward is used to determine if kirby should be allowed to pass 
 +or not. On the other hand Go_Backwards only allows movement through when 0. 
 +If there are two connections than backand front connect to different nodes. In that case the first 
 +determines backwards connection while the second determines forwards. Go_Backwards now determines all movement, 
 +with the same effect as the single node.
  
-The camera ​is referred to by the second index in the main header.+===== Entity List ===== 
 +The entity list is an array of structs which spawn objects as kirby gets in range. It is terminated ​by an 0x99999999 marker. 
 +See [[kirby64_the_crystal_shards:​entity_ids|]] for more info. 
 +This section is optional and if a not pointed to in the main header ​will not be used.
kirby64_the_crystal_shards/level_settings_blocks.1580075215.txt.gz · Last modified: 2020/01/26 21:46 by jesusyoshi54