SZS v2.30a

6 files changed, 229 insertions, 20 deletions

diff --git a/project/dclib/dclib-network.c b/project/dclib/dclib-network.c
index abc5f08..adfa7c9 100644
--- a/project/dclib/dclib-network.c
+++ b/project/dclib/dclib-network.c
@@ -2908,7 +2908,7 @@ void PrintTranferStatistics
 	char duration_buf[10];
 	if (!duration_info)
 	{
-	    PrintTimerUSec6(duration_buf,sizeof(duration_buf),duration,false);
+	    PrintTimerUSec6(duration_buf,sizeof(duration_buf),duration,0);
 	    duration_info = duration_buf;
 	}
 
@@ -3765,21 +3765,21 @@ char * BufInfoTCPStream
     char connect_usec[7];
     if ( ts->connect_usec )
 	PrintTimerUSec6(connect_usec,sizeof(connect_usec),
-			now_usec - ts->connect_usec, true );
+			now_usec - ts->connect_usec, DC_SFORM_ALIGN );
     else
 	connect_usec[0] = '-', connect_usec[1] = 0;
 
     char receive_usec[7];
     if ( ts->receive_usec )
 	PrintTimerUSec6(receive_usec,sizeof(receive_usec),
-			now_usec - ts->receive_usec, true );
+			now_usec - ts->receive_usec, DC_SFORM_ALIGN );
     else
 	receive_usec[0] = '-', receive_usec[1] = 0;
 
     char send_usec[7];
     if ( ts->send_usec )
 	PrintTimerUSec6(send_usec,sizeof(send_usec),
-			now_usec - ts->send_usec, true );
+			now_usec - ts->send_usec, DC_SFORM_ALIGN );
     else
 	send_usec[0] = '-', send_usec[1] = 0;
 
diff --git a/project/dclib/dclib-numeric.c b/project/dclib/dclib-numeric.c
index 500d3bc..e26376b 100644
--- a/project/dclib/dclib-numeric.c
+++ b/project/dclib/dclib-numeric.c
@@ -1442,7 +1442,7 @@ uint EncodeVersion ( ccp arg )
     char *next;
     uint major = str2ul(arg,&next,10);
     if ( major > 4293 )
-	major = major;
+	major = 4293;
 
     uint minor = 0, letter = 0, beta = ~0;
     if ( *next == '.' )
diff --git a/project/dclib/dclib-option.c b/project/dclib/dclib-option.c
index fdcce94..ae7e3a8 100644
--- a/project/dclib/dclib-option.c
+++ b/project/dclib/dclib-option.c
@@ -547,7 +547,7 @@ ccp PrintGParam ( const GParam_t *par )
 
 	case GOPT_IDX_DURATION:
 	    snprintf(buf,sizeof(buf),"[DUR] %12g = %s",
-		par->d, PrintTimerUSec6(0,0,double2usec(par->d),false) );
+		par->d, PrintTimerUSec6(0,0,double2usec(par->d),0) );
 	    break;
 
 	case GOPT_IDX_STRING:
diff --git a/project/dclib/lib-mkw-def.h b/project/dclib/lib-mkw-def.h
index fbda197..df5c85f 100644
--- a/project/dclib/lib-mkw-def.h
+++ b/project/dclib/lib-mkw-def.h
@@ -91,6 +91,35 @@ MkwTrackCategory_t * GetMkwTrackCategory ( int id );
 
 //
 ///////////////////////////////////////////////////////////////////////////////
+////////////////////////////   LE-CODE track flags   //////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+// [[LecodeFlags_t]]
+typedef enum LecodeFlags_t
+{
+	G_LEFL_NEW                 = 0x0001,	// N2: new track
+	G_LEFL_RND_HEAD            = 0x0002,	// HX: first track of random group
+	G_LEFL_RND_GROUP           = 0x0004,	// GX: member of random group, but not first
+	G_LEFL_ALIAS               = 0x0008,	// A-: use TrackByAliasLE(prop,music)
+	G_LEFL_TEXTURE             = 0x0010,	// T2: track is declared as texture hack of same property slot
+	G_LEFL_HIDDEN              = 0x0020,	// i-: exclude a track from cups.
+	G_LEFL__RND                = 0x0006,	// both random flags
+	G_LEFL__ALL                = 0x003f,	// all bits of above
+	G_LEFL_BATTLE              = 0x0100,	// B-: track is a battle arena
+	G_LEFL_VERSUS              = 0x0200,	// V-: track is a versus track
+	G_LEFL_CUP                 = 0x0400,	// --: track is referenced by a cup
+	G_LEFL_ORIG_CUP            = 0x0800,	// ob: track is referenced by a original cup
+	G_LEFL_CUSTOM_CUP          = 0x1000,	// cb: track is referenced by a custom cup
+	G_LEFL_RANDOM              = 0x2000,	// r-: slot id LE-CODE random
+	G_LEFL__USED               = 0x3c3f,	// if any of these bits is set, the track is used
+	G_LEFL__XALL               = 0x3f3f,	// all bits of above
+}
+LecodeFlags_t;
+
+#define DB_LECODE_FLAGS_TYPE      "smallint unsigned"
+
+//
+///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////   misc   //////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
diff --git a/project/dclib/lib-mkw.c b/project/dclib/lib-mkw.c
index a97b8e2..bdbf80b 100644
--- a/project/dclib/lib-mkw.c
+++ b/project/dclib/lib-mkw.c
@@ -1171,33 +1171,33 @@ const mkw_driver_t mkw_driver_attrib[MKW_N_DRIVER+1] =
 	{ 1, 0, "Peac",	"Peac",	"Peach",	"Peach" },		// M2 #16
 	{ 1, 0, "Bird",	"Bird",	"Birdo",	"Birdo" },		// M5
 	{ 1, 0, "DidK",	"DidK",	"Diddy Kong",	"Diddy Kong" },		// M6
-	{ 2, 0, "KBoo",	"BuHu",	"King Boo",	"König Buu Huu" },	// L4
+	{ 2, 0, "KBoo",	"BuHu",	"King Boo",	"König Buu Huu" },	// L4
 
 	{ 1, 0, "B.Jr",	"B.Jr",	"Bowser Jr.",	"Bowser Jr." },		// M7 #20
 	{ 2, 0, "DBow",	"KnBo",	"Dry Bowser",	"Knochen-Bowser" },	// L7
 	{ 2, 0, "Funk",	"Funk",	"Funky Kong",	"Funky Kong" },		// L6
 	{ 2, 0, "Rosa",	"Rosa",	"Rosalina",	"Rosalina" },		// L5
 
-	{ 0, 1, "MAsm",	"MAkm",	"Mii A (small,male)",	"Mii A (klein,männ)" },	// S8 #24
+	{ 0, 1, "MAsm",	"MAkm",	"Mii A (small,male)",	"Mii A (klein,männ)" },	// S8 #24
 	{ 0, 1, "MAsf",	"MAkw",	"Mii A (small,female)",	"Mii A (klein,weib)" },	// S9
-	{ 0, 2, "MBsm",	"MBkm",	"Mii B (small,male)",	"Mii B (klein,männ)" },	// S10
+	{ 0, 2, "MBsm",	"MBkm",	"Mii B (small,male)",	"Mii B (klein,männ)" },	// S10
 	{ 0, 2, "MBsf",	"MBkw",	"Mii B (small,female)",	"Mii B (klein,weib)" },	// S11
-	{ 0, 3, "MCsm",	"MCkm",	"Mii C (small,male)",	"Mii C (klein,männ)" },	// 0x11c
+	{ 0, 3, "MCsm",	"MCkm",	"Mii C (small,male)",	"Mii C (klein,männ)" },	// 0x11c
 	{ 0, 3, "MCsf",	"MCkw",	"Mii C (small,female)",	"Mii C (klein,weib)" },	// 0x11d
 
-	{ 1, 1, "MAmm",	"MAmm",	"Mii A (medium,male)",	"Mii A (mittel,männ)" },// M8 #30
+	{ 1, 1, "MAmm",	"MAmm",	"Mii A (medium,male)",	"Mii A (mittel,männ)" },// M8 #30
 	{ 1, 1, "MAmf",	"MAmw",	"Mii A (medium,female)","Mii A (mittel,weib)" },// M9
-	{ 1, 2, "MBmm",	"MBmm",	"Mii B (medium,male)",	"Mii B (mittel,männ)" },// M10
+	{ 1, 2, "MBmm",	"MBmm",	"Mii B (medium,male)",	"Mii B (mittel,männ)" },// M10
 	{ 1, 2, "MBmf",	"MBmw",	"Mii B (medium,female)","Mii B (mittel,weib)" },// M11
-	{ 1, 3, "MCmm",	"MCmm",	"Mii C (medium,male)",	"Mii C (mittel,männ)" },// 0x122
+	{ 1, 3, "MCmm",	"MCmm",	"Mii C (medium,male)",	"Mii C (mittel,männ)" },// 0x122
 	{ 1, 3, "MCmf",	"MCmw",	"Mii C (medium,female)","Mii C (mittel,weib)" },// 0x123
 
-	{ 2, 1, "MAlm",	"MAgm",	"Mii A (large,male)",	"Mii A (groß,männ)" },	// L8 #36
-	{ 2, 1, "MAlf",	"MAgw",	"Mii A (large,female)",	"Mii A (groß,weib)" },	// L9
-	{ 2, 2, "MBlm",	"MBgm",	"Mii B (large,male)",	"Mii B (groß,männ)" },	// L10
-	{ 2, 2, "MBlf",	"MBgw",	"Mii B (large,female)",	"Mii B (groß,weib)" },	// L11
-	{ 2, 3, "MClm",	"MCgm",	"Mii C (large,male)",	"Mii C (groß,männ)" },	// 0x128
-	{ 2, 3, "MClf",	"MCgw",	"Mii C (large,female)",	"Mii C (groß,weib)" },	// 0x129
+	{ 2, 1, "MAlm",	"MAgm",	"Mii A (large,male)",	"Mii A (groß,männ)" },	// L8 #36
+	{ 2, 1, "MAlf",	"MAgw",	"Mii A (large,female)",	"Mii A (groß,weib)" },	// L9
+	{ 2, 2, "MBlm",	"MBgm",	"Mii B (large,male)",	"Mii B (groß,männ)" },	// L10
+	{ 2, 2, "MBlf",	"MBgw",	"Mii B (large,female)",	"Mii B (groß,weib)" },	// L11
+	{ 2, 3, "MClm",	"MCgm",	"Mii C (large,male)",	"Mii C (groß,männ)" },	// 0x128
+	{ 2, 3, "MClf",	"MCgw",	"Mii C (large,female)",	"Mii C (groß,weib)" },	// 0x129
 
 	{0,0,"","",0,0} // TERM #42
 };
@@ -1319,6 +1319,134 @@ ccp GetVehicleName4 ( u8 vehicle )
 
 //
 ///////////////////////////////////////////////////////////////////////////////
+///////////////			LE-CODE track flags		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+le_flags_t ScanLEFL ( ccp text )
+{
+    // automatic flags are not scannend!
+
+    le_flags_t res = 0;
+    if (text)
+    {
+	if ( strchr(text,'N') || strchr(text,'n') ) res |= G_LEFL_NEW;
+	if ( strchr(text,'H') || strchr(text,'h') ) res |= G_LEFL_RND_HEAD;
+	if ( strchr(text,'G') || strchr(text,'g') ) res |= G_LEFL_RND_GROUP;
+	if ( strchr(text,'X') || strchr(text,'x') ) res |= G_LEFL_RND_HEAD | G_LEFL_RND_GROUP;
+	if ( strchr(text,'A') || strchr(text,'a') ) res |= G_LEFL_ALIAS;
+	if ( strchr(text,'T') || strchr(text,'t') ) res |= G_LEFL_TEXTURE;
+	if ( strchr(text,'2')                     ) res |= G_LEFL_ALIAS | G_LEFL_TEXTURE;
+	if ( strchr(text,'I') || strchr(text,'i') ) res |= G_LEFL_HIDDEN;
+    }
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintLEFL8 ( le_flags_t flags, bool aligned )
+{
+    char *buf = GetCircBuf(7);
+    flags &= 0xff;
+
+    if ( flags & ~G_LEFL__ALL )
+	snprintf(buf,7,"?0x%02x ",flags);
+    else if (aligned)
+    {
+	buf[0] = flags & G_LEFL_NEW		? 'N' : '-';
+	buf[1] = flags & G_LEFL_RND_HEAD	? 'H' : '-';
+	buf[2] = flags & G_LEFL_RND_GROUP	? 'G' : '-';
+	buf[3] = flags & G_LEFL_ALIAS		? 'A' : '-';
+	buf[4] = flags & G_LEFL_TEXTURE		? 'T' : '-';
+	buf[5] = flags & G_LEFL_HIDDEN		? 'i' : '-';
+	buf[6] = 0;
+    }
+    else
+    {
+	char *d = buf;
+	if ( flags & G_LEFL_NEW		) *d++ = 'N';
+	if ( flags & G_LEFL_RND_HEAD	) *d++ = 'H';
+	if ( flags & G_LEFL_RND_GROUP	) *d++ = 'G';
+	if ( flags & G_LEFL_ALIAS	) *d++ = 'A';
+	if ( flags & G_LEFL_TEXTURE	) *d++ = 'T';
+	if ( flags & G_LEFL_HIDDEN	) *d++ = 'i';
+	if ( d == buf )
+	    *d++ = '-';
+	*d = 0;
+    }
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintLEFL16 ( le_flags_t flags, bool aligned )
+{
+    char *buf = GetCircBuf(7);
+
+    if ( flags & ~G_LEFL__XALL )
+    {
+	snprintf(buf,7,"?0x%03x ",flags);
+	return buf;
+    }
+
+    char *d = buf;
+    switch ( flags & (G_LEFL_BATTLE|G_LEFL_VERSUS|G_LEFL_RANDOM) )
+    {
+	case G_LEFL_BATTLE: *d++ = 'B'; break;
+	case G_LEFL_VERSUS: *d++ = 'V'; break;
+	case G_LEFL_RANDOM: *d++ = 'r'; break;
+	default:
+	    if ( aligned )
+		*d++ = '-';
+    }
+
+    switch ( flags & (G_LEFL_ORIG_CUP|G_LEFL_CUSTOM_CUP) )
+    {
+	case G_LEFL_ORIG_CUP:				*d++ = 'o'; break;
+	case G_LEFL_CUSTOM_CUP:				*d++ = 'c'; break;
+	case G_LEFL_ORIG_CUP | G_LEFL_CUSTOM_CUP:	*d++ = 'b'; break;
+	default:
+	    if ( aligned )
+		*d++ = '-';
+    }
+
+    switch ( flags & (G_LEFL_RND_HEAD|G_LEFL_RND_GROUP) )
+    {
+	case G_LEFL_RND_HEAD:				*d++ = 'H'; break;
+	case G_LEFL_RND_GROUP:				*d++ = 'G'; break;
+	case G_LEFL_RND_HEAD | G_LEFL_RND_GROUP:	*d++ = 'X'; break;
+	default:
+	    if ( aligned )
+		*d++ = '-';
+    }
+
+    switch ( flags & (G_LEFL_NEW|G_LEFL_TEXTURE) )
+    {
+	case G_LEFL_NEW:				*d++ = 'N'; break;
+	case G_LEFL_TEXTURE:				*d++ = 'T'; break;
+	case G_LEFL_NEW | G_LEFL_TEXTURE:		*d++ = '2'; break;
+	default:
+	    if ( aligned )
+		*d++ = '-';
+    }
+
+    if (aligned)
+    {
+	*d++ = flags & G_LEFL_ALIAS	? 'A' : '-';
+	*d++ = flags & G_LEFL_HIDDEN	? 'i' : '-';
+    }
+    else
+    {
+	if ( flags & G_LEFL_ALIAS	) *d++ = 'A';
+	if ( flags & G_LEFL_HIDDEN	) *d++ = 'i';
+	if ( d == buf )
+	    *d++ = '-';
+    }
+    *d = 0;
+    return buf;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
 ///////////////			random slots			///////////////
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1350,6 +1478,7 @@ ccp GetLecodeRandomInfo ( uint slot, ccp return_on_err )
 		: return_on_err;
 }
 
+
 //
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////			sizeof_info_t: mkw		///////////////
diff --git a/project/dclib/lib-mkw.h b/project/dclib/lib-mkw.h
index 5233506..8141e46 100644
--- a/project/dclib/lib-mkw.h
+++ b/project/dclib/lib-mkw.h
@@ -89,6 +89,7 @@ enum mkw_consts_t // some constants
 	MKW_ORIGINAL_BEG	= MKW_TRACK_BEG,
 	MKW_ORIGINAL_END	= MKW_ARENA_END,
 
+
 	//--- LE-CODE random tracks
 
 	MKW_LE_RANDOM_BEG	= 0x3d,
@@ -106,6 +107,13 @@ enum mkw_consts_t // some constants
 	MKW_LE_SLOT_END		= 0x1000,
 	MKW_N_LE_SLOT		= MKW_LE_SLOT_END - MKW_LE_SLOT_BEG,
 
+
+	//--- special slots (LE-CODE randon included)
+
+	MKW_SPECIAL_BEG		= MKW_ORIGINAL_END,
+	MKW_SPECIAL_END		= MKW_LE_SLOT_BEG,
+
+
 	//--- music ids
 
 	MKW_MUSIC_MIN_ID	= 0x75,
@@ -148,7 +156,11 @@ static inline bool IsValidLecodeSlot ( uint tid )
 		|| tid >= MKW_LE_RANDOM_BEG && tid < MKW_LE_RANDOM_END; }
 
 static inline bool IsMkwSpecial ( uint tid )
-	{ return tid >= MKW_ARENA_END && tid < MKW_LE_SLOT_BEG; }
+	{ return tid >= MKW_SPECIAL_BEG && tid < MKW_SPECIAL_END; }
+
+static inline bool IsLecodeSpecial ( uint tid )
+	{ return tid >= MKW_SPECIAL_BEG && tid < MKW_LE_RANDOM_BEG
+	      || tid >= MKW_LE_RANDOM_END && tid < MKW_SPECIAL_END; }
 
 //
 ///////////////////////////////////////////////////////////////////////////////
@@ -430,6 +442,45 @@ ccp GetVehicleName4 ( u8 vehicle );
 
 //
 ///////////////////////////////////////////////////////////////////////////////
+///////////////			LE-CODE track flags		///////////////
+///////////////////////////////////////////////////////////////////////////////
+// bits for [[le_flags8_t]] [[le_flags_t]]
+
+typedef u8  le_flags8_t;	// type of LE-CODE track flags (classic 8 bits)
+typedef u16 le_flags_t;		// type of LE-CODE track flags since build 35
+
+// see 'LecodeFlags_t' in dclib/lib-mkw-def.h for G_LEFL_*
+
+static inline bool IsTitleLEFL ( le_flags_t flags )
+	{ return (flags&(G_LEFL_RND_HEAD|G_LEFL_RND_GROUP)) == G_LEFL_RND_HEAD; }
+
+static inline bool IsHiddenLEFL ( le_flags_t flags )
+	{ return (flags&G_LEFL_HIDDEN)
+		||  (flags&(G_LEFL_RND_HEAD|G_LEFL_RND_GROUP)) == G_LEFL_RND_GROUP; }
+
+static inline bool IsRandomLEFL ( le_flags_t flags )
+	{ return (flags&(G_LEFL_RND_HEAD|G_LEFL_RND_GROUP)) != 0; }
+
+//-----------------------------------------------------------------------------
+// scan lecode flags
+
+le_flags_t ScanLEFL ( ccp text );
+
+//-----------------------------------------------------------------------------
+// print lecode flags
+
+ccp PrintLEFL8  ( le_flags_t flags, bool aligned );
+ccp PrintLEFL16 ( le_flags_t flags, bool aligned );
+
+static inline ccp PrintLEFL ( le_flags_t flags_bits, le_flags_t flags, bool aligned )
+	{ return ( flags_bits == 16 ? PrintLEFL16 : PrintLEFL8 )(flags,aligned); }
+
+typedef ccp (*PrintLEFL_func) ( le_flags_t flags, bool aligned );
+static inline PrintLEFL_func GetPrintLEFL ( uint flags_bits )
+	{ return flags_bits == 16 ? PrintLEFL16 : PrintLEFL8; }
+
+//
+///////////////////////////////////////////////////////////////////////////////
 ///////////////			    END				///////////////
 ///////////////////////////////////////////////////////////////////////////////