src/d_main.c

@@ -1365,6 +1365,8 @@ void D_SRB2Main(void)
 	CONS_Printf("Z_Init(): Init zone memory allocation daemon. \n");
 	Z_Init();
 
+	G_InitGametypes();
+
 	clientGamedata = M_NewGameDataStruct();
 	serverGamedata = M_NewGameDataStruct();
 

src/deh_lua.c

@@ -131,6 +131,16 @@ static inline int lib_freeslot(lua_State *L)
 			if (i == NUMCOLORFREESLOTS)
 				CONS_Alert(CONS_WARNING, "Ran out of free skincolor slots!\n");
 		}
+		else if (fastcmp(type, "TEAM"))
+		{
+			UINT8 i = G_AddTeam(word);
+			if (i == MAXTEAMS)
+				CONS_Alert(CONS_WARNING, "Ran out of free team slots!\n");
+			CONS_Printf("Team TEAM_%s allocated.\n",word);
+			lua_pushinteger(L, i);
+			r++;
+			break;
+		}
 		else if (fastcmp(type, "SPR2"))
 		{
 			// Search if we already have an SPR2 by that name...
@@ -308,8 +318,8 @@ static int ScanConstants(lua_State *L, boolean mathlib, const char *word)
 	}
 	else if (fastncmp("GT_", word, 3)) {
 		p = word;
-		for (i = 0; Gametype_ConstantNames[i]; i++)
-			if (fastcmp(p, Gametype_ConstantNames[i])) {
+		for (i = 0; i < gametypecount; i++)
+			if (fastcmp(p, gametypes[i].constant_name)) {
 				CacheAndPushConstant(L, word, i);
 				return 1;
 			}
@@ -561,6 +571,17 @@ static int ScanConstants(lua_State *L, boolean mathlib, const char *word)
 			}
 		return luaL_error(L, "skincolor '%s' could not be found.\n", word);
 	}
+	else if (fastncmp("TEAM_",word,5)) {
+		p = word+5;
+		for (i = 0; i < numteams; i++)
+		{
+			if (fastcmp(p, teamnames[i][0])) {
+				CacheAndPushConstant(L, word, i);
+				return 1;
+			}
+		}
+		return luaL_error(L, "team '%s' could not be found.\n", word);
+	}
 	else if (fastncmp("GRADE_",word,6))
 	{
 		p = word+6;

src/deh_soc.c

@@ -485,6 +485,10 @@ void readfreeslots(MYFILE *f)
 						break;
 					}
 			}
+			else if (fastcmp(type, "TEAM"))
+			{
+				G_AddTeam(word);
+			}
 			else if (fastcmp(type, "SPR2"))
 			{
 				// Search if we already have an SPR2 by that name...
@@ -1145,7 +1149,7 @@ void readsprite2(MYFILE *f, INT32 num)
 	Z_Free(s);
 }
 
-void readgametype(MYFILE *f, char *gtname)
+void readgametype(MYFILE *f, INT32 num)
 {
 	char *s = Z_Malloc(MAXLINELEN, PU_STATIC, NULL);
 	char *word;
@@ -1153,22 +1157,21 @@ void readgametype(MYFILE *f, char *gtname)
 	char *tmp;
 	INT32 i, j;
 
-	INT16 newgtidx = 0;
-	UINT32 newgtrules = 0;
-	UINT32 newgttol = 0;
-	INT32 newgtpointlimit = 0;
-	INT32 newgttimelimit = 0;
-	UINT8 newgtleftcolor = 0;
-	UINT8 newgtrightcolor = 0;
-	INT16 newgtrankingstype = -1;
-	int newgtinttype = 0;
-	char gtdescription[441];
+	char *gtname = gametypes[num].name;
 	char gtconst[MAXLINELEN];
+	char gtdescription[441];
+
+	UINT8 teamcount = gametypes[num].teams.num;
+	UINT8 teamlist[MAXTEAMS];
+	boolean has_teams = false;
+
+	UINT8 newgtleftcolor, newgtrightcolor;
+	boolean has_desc_colors[2] = { false, false };
 
-	// Empty strings.
-	gtdescription[0] = '\0';
 	gtconst[0] = '\0';
 
+	strcpy(gtdescription, "???");
+
 	do
 	{
 		if (myfgets(s, MAXLINELEN, f))
@@ -1226,8 +1229,8 @@ void readgametype(MYFILE *f, char *gtname)
 			if (word2)
 			{
 				if (!word2lwr)
-					word2lwr = Z_Malloc(MAXLINELEN, PU_STATIC, NULL);
-				strcpy(word2lwr, word2);
+					word2lwr = Z_Calloc(MAXLINELEN, PU_STATIC, NULL);
+				strlcpy(word2lwr, word2, MAXLINELEN);
 				strupr(word2);
 			}
 			else
@@ -1235,49 +1238,84 @@ void readgametype(MYFILE *f, char *gtname)
 
 			if (word2[strlen(word2)-1] == '\n')
 				word2[strlen(word2)-1] = '\0';
+			if (word2lwr[strlen(word2lwr)-1] == '\n')
+				word2lwr[strlen(word2lwr)-1] = '\0';
 			i = atoi(word2);
 
+			// Name
+			if (fastcmp(word, "NAME"))
+			{
+				Z_Free(gametypes[num].name);
+				gametypes[num].name = Z_StrDup(word2lwr);
+			}
 			// Game type rules
-			if (fastcmp(word, "RULES"))
+			else if (fastcmp(word, "RULES"))
 			{
 				// GTR_
-				newgtrules = (UINT32)get_number(word2);
+				gametypes[num].rules = (UINT32)get_number(word2);
 			}
 			// Identifier
 			else if (fastcmp(word, "IDENTIFIER"))
 			{
 				// GT_
-				strncpy(gtconst, word2, MAXLINELEN);
+				strlcpy(gtconst, word2, sizeof(gtconst));
 			}
 			// Point and time limits
 			else if (fastcmp(word, "DEFAULTPOINTLIMIT"))
-				newgtpointlimit = (INT32)i;
+				gametypes[num].pointlimit = (INT32)i;
 			else if (fastcmp(word, "DEFAULTTIMELIMIT"))
-				newgttimelimit = (INT32)i;
+				gametypes[num].timelimit = (INT32)i;
 			// Level platter
 			else if (fastcmp(word, "HEADERCOLOR") || fastcmp(word, "HEADERCOLOUR"))
-				newgtleftcolor = newgtrightcolor = (UINT8)get_number(word2);
+			{
+				INT32 color = (INT32)i;
+				if (color >= 0 && color <= 255)
+				{
+					newgtleftcolor = newgtrightcolor = (UINT8)color;
+					has_desc_colors[0] = has_desc_colors[1] = true;
+				}
+				else
+					deh_warning("readgametype %d: Level platter header color %d out of range (0 - 255)", num, i);
+			}
 			else if (fastcmp(word, "HEADERLEFTCOLOR") || fastcmp(word, "HEADERLEFTCOLOUR"))
-				newgtleftcolor = (UINT8)get_number(word2);
+			{
+				INT32 color = (INT32)i;
+				if (color >= 0 && color <= 255)
+				{
+					newgtleftcolor = (UINT8)color;
+					has_desc_colors[0] = true;
+				}
+				else
+					deh_warning("readgametype %d: Level platter header left color %d out of range (0 - 255)", num, i);
+			}
 			else if (fastcmp(word, "HEADERRIGHTCOLOR") || fastcmp(word, "HEADERRIGHTCOLOUR"))
-				newgtrightcolor = (UINT8)get_number(word2);
+			{
+				INT32 color = (INT32)i;
+				if (color >= 0 && color < 255)
+				{
+					newgtrightcolor = (UINT8)color;
+					has_desc_colors[1] = true;
+				}
+				else
+					deh_warning("readgametype %d: Level platter header right color %d out of range (0 - 255)", num, i);
+			}
 			// Rankings type
 			else if (fastcmp(word, "RANKINGTYPE"))
 			{
 				// Case insensitive
-				newgtrankingstype = (int)get_number(word2);
+				gametypes[num].rankings_type = (int)get_number(word2);
 			}
 			// Intermission type
 			else if (fastcmp(word, "INTERMISSIONTYPE"))
 			{
 				// Case sensitive
-				newgtinttype = (int)get_number(word2lwr);
+				gametypes[num].intermission_type = (int)get_number(word2lwr);
 			}
 			// Type of level
 			else if (fastcmp(word, "TYPEOFLEVEL"))
 			{
 				if (i) // it's just a number
-					newgttol = (UINT32)i;
+					gametypes[num].typeoflevel = (UINT32)i;
 				else
 				{
 					UINT32 tol = 0;
@@ -1287,28 +1325,51 @@ void readgametype(MYFILE *f, char *gtname)
 							if (fasticmp(tmp, TYPEOFLEVEL[i].name))
 								break;
 						if (!TYPEOFLEVEL[i].name)
-							deh_warning("readgametype %s: unknown typeoflevel flag %s\n", gtname, tmp);
+							deh_warning("readgametype %d: unknown typeoflevel flag %s\n", num, tmp);
 						tol |= TYPEOFLEVEL[i].flag;
 					} while((tmp = strtok(NULL,",")) != NULL);
-					newgttol = tol;
+					gametypes[num].typeoflevel = tol;
 				}
 			}
-			// The SOC probably provided gametype rules as words,
-			// instead of using the RULES keyword.
-			// Like for example "NOSPECTATORSPAWN = TRUE".
-			// This is completely valid, and looks better anyway.
+			// Teams
+			else if (fastcmp(word, "TEAMLIST"))
+			{
+				tmp = strtok(word2,",");
+				do {
+					if (teamcount == MAXTEAMS)
+					{
+						deh_warning("readgametype %d: too many teams\n", num);
+						break;
+					}
+					char *tmp2 = Z_StrDup(tmp);
+					strupr(tmp2);
+					UINT8 team_id = get_team(tmp2);
+					if (team_id != TEAM_NONE)
+					{
+						teamlist[teamcount++] = team_id;
+						has_teams = true;
+					}
+					else
+						deh_warning("readgametype %d: unknown team %s\n", num, tmp);
+					Z_Free(tmp2);
+				} while((tmp = strtok(NULL,",")) != NULL);
+			}
+			// This SOC probably provided gametype rules as words, instead of using the RULES keyword.
+			// (For example, "NOSPECTATORSPAWN = TRUE")
 			else
 			{
 				UINT32 wordgt = 0;
 				for (j = 0; GAMETYPERULE_LIST[j]; j++)
 					if (fastcmp(word, GAMETYPERULE_LIST[j])) {
 						wordgt |= (1<<j);
-						if (i || word2[0] == 'T' || word2[0] == 'Y')
-							newgtrules |= wordgt;
+						if (word2[0] == 'T' || word2[0] == 'Y')
+							gametypes[num].rules |= wordgt;
+						else if (word2[0] == 'F' || word2[0] == 'N')
+							gametypes[num].rules &= ~wordgt;
 						break;
 					}
 				if (!wordgt)
-					deh_warning("readgametype %s: unknown word '%s'", gtname, word);
+					deh_warning("readgametype %d: unknown word '%s'", num, word);
 			}
 		}
 	} while (!myfeof(f)); // finish when the line is empty
@@ -1318,38 +1379,183 @@ void readgametype(MYFILE *f, char *gtname)
 	if (word2lwr)
 		Z_Free(word2lwr);
 
-	// Ran out of gametype slots
-	if (gametypecount == NUMGAMETYPEFREESLOTS)
+	if (gtdescription[0])
+		G_SetGametypeDescription(num, gtdescription);
+	if (has_desc_colors[0])
+		G_SetGametypeDescriptionLeftColor(num, newgtleftcolor);
+	if (has_desc_colors[1])
+		G_SetGametypeDescriptionRightColor(num, newgtrightcolor);
+
+	// Copy the teams
+	if (has_teams)
 	{
-		CONS_Alert(CONS_WARNING, "Ran out of free gametype slots!\n");
-		return;
+		gametypes[num].teams.num = teamcount;
+		if (teamcount)
+			memcpy(gametypes[num].teams.list, teamlist, sizeof(teamlist[0]) * teamcount);
 	}
 
-	// Add the new gametype
-	newgtidx = G_AddGametype(newgtrules);
-	G_AddGametypeTOL(newgtidx, newgttol);
-	G_SetGametypeDescription(newgtidx, gtdescription, newgtleftcolor, newgtrightcolor);
-
-	// Not covered by G_AddGametype alone.
-	if (newgtrankingstype == -1)
-		newgtrankingstype = newgtidx;
-	gametyperankings[newgtidx] = newgtrankingstype;
-	intermissiontypes[newgtidx] = newgtinttype;
-	pointlimits[newgtidx] = newgtpointlimit;
-	timelimits[newgtidx] = newgttimelimit;
-
-	// Write the new gametype name.
-	Gametype_Names[newgtidx] = Z_StrDup((const char *)gtname);
-
 	// Write the constant name.
-	if (gtconst[0] == '\0')
-		strncpy(gtconst, gtname, MAXLINELEN);
-	G_AddGametypeConstant(newgtidx, (const char *)gtconst);
+	if (gametypes[num].constant_name == NULL)
+	{
+		if (gtconst[0] == '\0')
+			G_AddGametypeConstant(num, gtname);
+		else
+			G_AddGametypeConstant(num, gtconst);
+	}
+	else if (gtconst[0] != '\0')
+		G_AddGametypeConstant(num, gtconst);
 
 	// Update gametype_cons_t accordingly.
 	G_UpdateGametypeSelections();
+}
+
+void readteam(MYFILE *f, INT32 num)
+{
+	char *s = Z_Malloc(MAXLINELEN, PU_STATIC, NULL);
+	char *word;
+	char *word2, *word2lwr = NULL;
+	INT32 i;
+
+	team_t *team = &teams[num];
+
+	do
+	{
+		if (myfgets(s, MAXLINELEN, f))
+		{
+			if (s[0] == '\n')
+				break;
+
+			word = strtok(s, " ");
+			if (word)
+				strupr(word);
+			else
+				break;
 
-	CONS_Printf("Added gametype %s\n", Gametype_Names[newgtidx]);
+			word2 = strtok(NULL, " = ");
+			if (word2)
+			{
+				if (!word2lwr)
+					word2lwr = Z_Malloc(MAXLINELEN, PU_STATIC, NULL);
+				strcpy(word2lwr, word2);
+				strupr(word2);
+			}
+			else
+				break;
+
+			if (word2[strlen(word2)-1] == '\n')
+				word2[strlen(word2)-1] = '\0';
+			i = atoi(word2);
+
+			if (fastcmp(word, "NAME"))
+			{
+				Z_Free(team->name);
+				team->name = Z_StrDup(word2lwr);
+			}
+			else if (fastcmp(word, "FLAGNAME"))
+			{
+				Z_Free(team->flag_name);
+				team->flag_name = Z_StrDup(word2lwr);
+			}
+			else if (fastcmp(word, "FLAG"))
+			{
+				team->flag = (UINT16)get_number(word2);
+			}
+			else if (fastcmp(word, "FLAGTYPE"))
+			{
+				if (i == 0 && word2[0] != '0') // If word2 isn't a number
+					i = get_mobjtype(word2); // find a thing by name
+				if (i < NUMMOBJTYPES && i > 0)
+					team->flag_mobj_type = i;
+				else
+				{
+					deh_warning("readteam %d: Thing %d out of range (1 - %d)", num, i, NUMMOBJTYPES-1);
+				}
+			}
+			else if (fastcmp(word, "WEAPON"))
+			{
+				if (i == 0 && word2[0] != '0') // If word2 isn't a number
+					i = get_mobjtype(word2); // find a thing by name
+				if (i < NUMMOBJTYPES && i > 0)
+					team->weapon_mobj_type = i;
+				else
+				{
+					deh_warning("readteam %d: Thing %d out of range (1 - %d)", num, i, NUMMOBJTYPES-1);
+				}
+			}
+			else if (fastcmp(word, "MISSILE"))
+			{
+				if (i == 0 && word2[0] != '0') // If word2 isn't a number
+					i = get_mobjtype(word2); // find a thing by name
+				if (i < NUMMOBJTYPES && i > 0)
+					team->missile_mobj_type = i;
+				else
+				{
+					deh_warning("readteam %d: Thing %d out of range (1 - %d)", num, i, NUMMOBJTYPES-1);
+				}
+			}
+			else if (fastcmp(word, "COLOR"))
+			{
+				if (i == 0 && word2[0] != '0') // If word2 isn't a number
+					i = get_skincolor(word2); // find a skincolor by name
+				if (i && i < numskincolors)
+					team->color = i;
+				else
+				{
+					deh_warning("readteam %d: Color %d out of range (1 - %d)", num, i, numskincolors-1);
+				}
+			}
+			else if (fastcmp(word, "WEAPONCOLOR"))
+			{
+				if (i == 0 && word2[0] != '0') // If word2 isn't a number
+					i = get_skincolor(word2); // find a skincolor by name
+				if (i && i < numskincolors)
+					team->weapon_color = i;
+				else
+				{
+					deh_warning("readteam %d: Weapon color %d out of range (1 - %d)", num, i, numskincolors-1);
+				}
+			}
+			else if (fastcmp(word, "MISSILECOLOR"))
+			{
+				if (i == 0 && word2[0] != '0') // If word2 isn't a number
+					i = get_skincolor(word2); // find a skincolor by name
+				if (i && i < numskincolors)
+					team->missile_color = i;
+				else
+				{
+					deh_warning("readteam %d: Missile color %d out of range (1 - %d)", num, i, numskincolors-1);
+				}
+			}
+			else if (fastcmp(word, "ICON"))
+			{
+				G_SetTeamIcon(num, TEAM_ICON, word2lwr);
+			}
+			else if (fastcmp(word, "FLAGICON"))
+			{
+				G_SetTeamIcon(num, TEAM_ICON_FLAG, word2lwr);
+			}
+			else if (fastcmp(word, "GOTFLAGICON"))
+			{
+				G_SetTeamIcon(num, TEAM_ICON_GOT_FLAG, word2lwr);
+			}
+			else if (fastcmp(word, "MISSINGFLAGICON"))
+			{
+				G_SetTeamIcon(num, TEAM_ICON_MISSING_FLAG, word2lwr);
+			}
+			else
+			{
+				deh_warning("readteam %d: unknown word '%s'", num, word);
+			}
+		}
+	} while (!myfeof(f)); // finish when the line is empty
+
+	// Free strings.
+	Z_Free(s);
+	if (word2lwr)
+		Z_Free(word2lwr);
+
+	ST_LoadTeamIcons();
+	G_UpdateTeamSelection();
 }
 
 void readlevelheader(MYFILE *f, INT32 num)
@@ -3653,19 +3859,19 @@ void readmaincfg(MYFILE *f)
 			}
 			else if (fastcmp(word, "REDTEAM"))
 			{
-				skincolor_redteam = (UINT16)get_number(word2);
+				teams[TEAM_RED].color = (UINT16)get_number(word2);
 			}
 			else if (fastcmp(word, "BLUETEAM"))
 			{
-				skincolor_blueteam = (UINT16)get_number(word2);
+				teams[TEAM_BLUE].color = (UINT16)get_number(word2);
 			}
 			else if (fastcmp(word, "REDRING"))
 			{
-				skincolor_redring = (UINT16)get_number(word2);
+				teams[TEAM_RED].missile_color = (UINT16)get_number(word2);
 			}
 			else if (fastcmp(word, "BLUERING"))
 			{
-				skincolor_bluering = (UINT16)get_number(word2);
+				teams[TEAM_BLUE].missile_color = (UINT16)get_number(word2);
 			}
 			else if (fastcmp(word, "INVULNTICS"))
 			{
@@ -4165,6 +4371,38 @@ skincolornum_t get_skincolor(const char *word)
 	return SKINCOLOR_GREEN;
 }
 
+INT16 get_gametype(const char *word)
+{
+	INT16 i;
+	if (*word >= '0' && *word <= '9')
+		return atoi(word);
+	if (fastncmp("GT_",word,3))
+		word += 3; // take off the GT_
+	for (i = 0; i < gametypecount; i++)
+	{
+		if (fastcmp(word, gametypes[i].constant_name + 3))
+			return i;
+	}
+	deh_warning("Couldn't find gametype named 'GT_%s'",word);
+	return GT_COOP;
+}
+
+UINT8 get_team(const char *word)
+{
+	UINT8 i;
+	if (*word >= '0' && *word <= '9')
+		return atoi(word);
+	if (fastncmp("TEAM_",word,5))
+		word += 5; // take off the TEAM_
+	for (i = 0; i < numteams; i++)
+	{
+		if (fastcmp(word, teamnames[i][0]))
+			return i;
+	}
+	deh_warning("Couldn't find team named 'TEAM_%s'",word);
+	return TEAM_NONE;
+}
+
 spritenum_t get_sprite(const char *word)
 { // Returns the value of SPR_ enumerations
 	spritenum_t i;
@@ -4237,34 +4475,6 @@ menutype_t get_menutype(const char *word)
 	return MN_NONE;
 }
 
-/*static INT16 get_gametype(const char *word)
-{ // Returns the value of GT_ enumerations
-	INT16 i;
-	if (*word >= '0' && *word <= '9')
-		return atoi(word);
-	if (fastncmp("GT_",word,3))
-		word += 3; // take off the GT_
-	for (i = 0; i < NUMGAMETYPES; i++)
-		if (fastcmp(word, Gametype_ConstantNames[i]+3))
-			return i;
-	deh_warning("Couldn't find gametype named 'GT_%s'",word);
-	return GT_COOP;
-}
-
-static powertype_t get_power(const char *word)
-{ // Returns the value of pw_ enumerations
-	powertype_t i;
-	if (*word >= '0' && *word <= '9')
-		return atoi(word);
-	if (fastncmp("PW_",word,3))
-		word += 3; // take off the pw_
-	for (i = 0; i < NUMPOWERS; i++)
-		if (fastcmp(word, POWERS_LIST[i]))
-			return i;
-	deh_warning("Couldn't find power named 'pw_%s'",word);
-	return pw_invulnerability;
-}*/
-
 /// \todo Make ANY of this completely over-the-top math craziness obey the order of operations.
 static fixed_t op_mul(fixed_t a, fixed_t b) { return a*b; }
 static fixed_t op_div(fixed_t a, fixed_t b) { return a/b; }

src/deh_soc.h

@@ -54,9 +54,9 @@ playersprite_t get_sprite2(const char *word);
 sfxenum_t get_sfx(const char *word);
 hudnum_t get_huditem(const char *word);
 menutype_t get_menutype(const char *word);
-//INT16 get_gametype(const char *word);
-//powertype_t get_power(const char *word);
 skincolornum_t get_skincolor(const char *word);
+INT16 get_gametype(const char *word);
+UINT8 get_team(const char *word);
 
 void readwipes(MYFILE *f);
 void readmaincfg(MYFILE *f);
@@ -71,7 +71,8 @@ void readmenu(MYFILE *f, INT32 num);
 void readtextprompt(MYFILE *f, INT32 num);
 void readcutscene(MYFILE *f, INT32 num);
 void readlevelheader(MYFILE *f, INT32 num);
-void readgametype(MYFILE *f, char *gtname);
+void readgametype(MYFILE *f, INT32 num);
+void readteam(MYFILE *f, INT32 num);
 void readsprite2(MYFILE *f, INT32 num);
 void readspriteinfo(MYFILE *f, INT32 num, boolean sprite2);
 #ifdef HWRENDER

src/deh_tables.c

@@ -4416,6 +4416,8 @@ const char *const MOBJEFLAG_LIST[] = {
 	"TRACERANGLE", // Compute and trigger on mobj angle relative to tracer
 	"FORCESUPER", // Forces an object to use super sprites with SPR_PLAY.
 	"FORCENOSUPER", // Forces an object to NOT use super sprites with SPR_PLAY.
+	"TEAMITEM", // Object is a team item
+	"TEAMFLAG", // Object is a team flag
 	NULL
 };
 
@@ -5328,6 +5330,11 @@ struct int_const_s const INT_CONST[] = {
 	{"int_race",int_race},
 	{"int_comp",int_comp},
 
+	// Ranking types
+	{"RANKINGS_DEFAULT",RANKINGS_DEFAULT},
+	{"RANKINGS_COMPETITION",RANKINGS_COMPETITION},
+	{"RANKINGS_RACE",RANKINGS_RACE},
+
 	// Jingles (jingletype_t)
 	{"JT_NONE",JT_NONE},
 	{"JT_OTHER",JT_OTHER},

src/dehacked.c

@@ -186,9 +186,9 @@ void ignorelinesuntilhash(MYFILE *f)
 static void DEH_LoadDehackedFile(MYFILE *f, boolean mainfile)
 {
 	char *s = Z_Malloc(MAXLINELEN, PU_STATIC, NULL);
-	char textline[MAXLINELEN];
 	char *word;
 	char *word2;
+	char word2lwr[MAXLINELEN];
 	INT32 i;
 
 	if (!deh_loaded)
@@ -203,7 +203,6 @@ static void DEH_LoadDehackedFile(MYFILE *f, boolean mainfile)
 	while (!myfeof(f))
 	{
 		myfgets(s, MAXLINELEN, f);
-		memcpy(textline, s, MAXLINELEN);
 		if (s[0] == '\n' || s[0] == '#')
 			continue;
 
@@ -230,10 +229,14 @@ static void DEH_LoadDehackedFile(MYFILE *f, boolean mainfile)
 				continue;
 			}
 			word2 = strtok(NULL, " ");
+			word2lwr[0] = '\0';
 			if (word2) {
+				strcpy(word2lwr, word2);
 				strupr(word2);
 				if (word2[strlen(word2) - 1] == '\n')
 					word2[strlen(word2) - 1] = '\0';
+				if (word2lwr[strlen(word2lwr) - 1] == '\n')
+					word2lwr[strlen(word2lwr) - 1] = '\0';
 				i = atoi(word2);
 			}
 			else
@@ -389,32 +392,60 @@ static void DEH_LoadDehackedFile(MYFILE *f, boolean mainfile)
 				}
 				else if (fastcmp(word, "GAMETYPE"))
 				{
-					// Get the gametype name from textline
-					// instead of word2, so that gametype names
-					// aren't allcaps
-					INT32 c;
-					for (c = 0; c < MAXLINELEN; c++)
+					char *gtname = NULL;
+					if (word2lwr[0])
 					{
-						if (textline[c] == '\0')
-							break;
-						if (textline[c] == ' ')
+						gtname = word2lwr;
+
+						for (size_t j = 0; j < strlen(gtname); j++)
+						{
+							if (gtname[j] == '\0')
+								break;
+							if (gtname[j] < 32 || gtname[j] == '\n')
+							{
+								gtname[j] = '\0';
+								break;
+							}
+						}
+					}
+
+					if (!gtname || !strlen(gtname))
+					{
+						deh_warning("Invalid gametype name");
+						ignorelines(f);
+					}
+					else
+					{
+						INT32 gametype_id = G_GetGametypeByName(gtname);
+						if (gametype_id == -1)
 						{
-							char *gtname = (textline+c+1);
-							if (gtname)
+							if (!strncmp(gtname, "GT_", 3))
+								gametype_id = get_gametype(gtname + 3);
+							else if (gametypecount != NUMGAMETYPEFREESLOTS)
 							{
-								// remove funny characters
-								INT32 j;
-								for (j = 0; j < (MAXLINELEN - c); j++)
-								{
-									if (gtname[j] == '\0')
-										break;
-									if (gtname[j] < 32)
-										gtname[j] = '\0';
-								}
-								readgametype(f, gtname);
+								gametype_id = G_AddGametype();
+								CONS_Printf("Added gametype %s\n", gtname);
 							}
-							break;
+							else
+								deh_warning("Ran out of free gametype slots");
 						}
+
+						if (gametype_id != -1)
+							readgametype(f, gametype_id);
+						else
+							ignorelines(f);
+					}
+				}
+				else if (fastcmp(word, "TEAM"))
+				{
+					if (i == 0 && word2[0] != '0') // If word2 isn't a number
+						i = get_team(word2); // find a team by name
+					if (i >= 0 && i < MAXTEAMS)
+						readteam(f, i);
+					else
+					{
+						deh_warning("Team %d out of range (0 - %d)", i, MAXTEAMS);
+						ignorelines(f);
 					}
 				}
 				else if (fastcmp(word, "CUTSCENE"))

src/doomdata.h

@@ -221,6 +221,15 @@ typedef struct
 	struct mobj_s *mobj;
 } mapthing_t;
 
+#define THING_TYPE_SPAWNPOINT_COOP_START 1
+#define THING_TYPE_SPAWNPOINT_COOP_END 32
+#define THING_TYPE_SPAWNPOINT_MATCH 33
+#define THING_TYPE_SPAWNPOINT_RED_TEAM 34
+#define THING_TYPE_SPAWNPOINT_BLUE_TEAM 35
+#define THING_TYPE_SPAWNPOINT_TEAM 36
+
+#define THING_TYPE_CTF_TEAM_FLAG 324
+
 #define ZSHIFT 4
 
 #define NUMMAPS 1035

src/doomstat.h

@@ -98,7 +98,6 @@ extern boolean multiplayer;
 
 extern INT16 gametype;
 extern UINT32 gametyperules;
-extern INT16 gametypecount;
 
 extern boolean splitscreen;
 extern boolean circuitmap; // Does this level have 'circuit mode'?
@@ -155,9 +154,6 @@ extern INT32 tutorialanalog; // store cv_analog[0] user value
 
 extern boolean looptitle;
 
-// CTF colors.
-extern UINT16 skincolor_redteam, skincolor_blueteam, skincolor_redring, skincolor_bluering;
-
 extern tic_t countdowntimer;
 extern boolean countdowntimeup;
 extern boolean exitfadestarted;
@@ -255,10 +251,11 @@ extern UINT32 ssspheres; //  Total # of spheres in a level
 
 // Fun extra stuff
 extern INT16 lastmap; // Last level you were at (returning from special stages).
-extern mobj_t *redflag, *blueflag; // Pointers to physical flags
-extern mapthing_t *rflagpoint, *bflagpoint; // Pointers to the flag spawn locations
-#define GF_REDFLAG 1
-#define GF_BLUEFLAG 2
+
+enum {
+	GF_REDFLAG = 1,
+	GF_BLUEFLAG = 2
+};
 
 // A single point in space.
 typedef struct
@@ -390,8 +387,44 @@ typedef struct
 
 extern mapheader_t* mapheaderinfo[NUMMAPS];
 
-// Gametypes
+enum {
+	TEAM_NONE,
+	TEAM_RED,
+	TEAM_BLUE,
+	TEAM_PLAYING = 1,
+	MAXTEAMS = 16
+};
+
+enum {
+	TEAM_ICON,
+	TEAM_ICON_FLAG,
+	TEAM_ICON_GOT_FLAG,
+	TEAM_ICON_MISSING_FLAG,
+	TEAM_ICON_MAX
+};
+
+typedef struct
+{
+	char *name;
+	UINT16 color;
+	UINT32 weapon_mobj_type;
+	UINT32 missile_mobj_type;
+	UINT16 weapon_color;
+	UINT16 missile_color;
+	char *flag_name;
+	UINT16 flag;
+	UINT32 flag_mobj_type;
+	char *icons[TEAM_ICON_MAX];
+} team_t;
+
+extern team_t teams[MAXTEAMS];
+extern UINT8 numteams;
+
+extern char *teamnames[MAXTEAMS][2];
+
 #define NUMGAMETYPEFREESLOTS 128
+
+// Gametypes
 enum GameType
 {
 	GT_COOP = 0, // also used in single player
@@ -410,7 +443,7 @@ enum GameType
 	GT_LASTFREESLOT = GT_FIRSTFREESLOT + NUMGAMETYPEFREESLOTS - 1,
 	NUMGAMETYPES
 };
-// If you alter this list, update deh_tables.c, MISC_ChangeGameTypeMenu in m_menu.c, and Gametype_Names in g_game.c
+// If you alter this list, update deh_tables.c, MISC_ChangeGameTypeMenu in m_menu.c, and gametypes in g_game.c
 
 // Gametype rules
 enum GameTypeRules
@@ -449,13 +482,34 @@ enum GameTypeRules
 	GTR_CUTSCENES        = 1<<31, // Play cutscenes, ending, credits, and evaluation
 };
 
-// String names for gametypes
-extern const char *Gametype_Names[NUMGAMETYPES];
-extern const char *Gametype_ConstantNames[NUMGAMETYPES];
+enum
+{
+	RANKINGS_DEFAULT,
+	RANKINGS_COMPETITION,
+	RANKINGS_RACE
+};
 
-// Point and time limits for every gametype
-extern INT32 pointlimits[NUMGAMETYPES];
-extern INT32 timelimits[NUMGAMETYPES];
+typedef struct
+{
+	UINT8 num;
+	UINT8 list[MAXTEAMS];
+} teamlist_t;
+
+typedef struct
+{
+	char *name;
+	char *constant_name;
+	UINT32 rules;
+	UINT32 typeoflevel;
+	UINT8 intermission_type;
+	INT16 rankings_type;
+	INT32 pointlimit;
+	INT32 timelimit;
+	teamlist_t teams;
+} gametype_t;
+
+extern gametype_t gametypes[NUMGAMETYPES];
+extern INT16 gametypecount;
 
 // TypeOfLevel things
 enum TypeOfLevel
@@ -517,8 +571,10 @@ extern UINT32 tokenlist; ///< List of tokens collected
 extern boolean gottoken; ///< Did you get a token? Used for end of act
 extern INT32 tokenbits; ///< Used for setting token bits
 extern INT32 sstimer; ///< Time allotted in the special stage
-extern UINT32 bluescore; ///< Blue Team Scores
-extern UINT32 redscore;  ///< Red Team Scores
+extern UINT8 teamsingame; ///< Current teams in game
+extern UINT32 teamscores[MAXTEAMS]; ///< Team scores
+extern mobj_t *flagmobjs[MAXTEAMS]; // Pointers to physical flags
+extern mapthing_t *flagpoints[MAXTEAMS]; // Pointers to the flag spawn locations
 
 // Eliminates unnecessary searching.
 extern boolean CheckForBustableBlocks;
@@ -578,15 +634,42 @@ extern tic_t hidetime;
 //  WAD, partly set at startup time.
 
 extern tic_t gametic;
+
 #define localgametic leveltime
 
+typedef struct
+{
+	fixed_t x, y, z;
+	angle_t angle;
+	fixed_t scale;
+	boolean spawn_on_ceiling;
+	boolean spawn_flipped;
+} spawnpoint_t;
+
+enum
+{
+	PLAYER_START_TYPE_COOP,
+	PLAYER_START_TYPE_MATCH,
+	PLAYER_START_TYPE_TEAM
+};
+
+typedef struct
+{
+	size_t count;
+	size_t capacity;
+	mapthing_t **list;
+} playerstarts_t;
+
+#define MAX_DM_STARTS 64
+
 // Player spawn spots.
-extern mapthing_t *playerstarts[MAXPLAYERS]; // Cooperative
-extern mapthing_t *bluectfstarts[MAXPLAYERS]; // CTF
-extern mapthing_t *redctfstarts[MAXPLAYERS]; // CTF
+extern playerstarts_t playerstarts;
+extern playerstarts_t deathmatchstarts;
+extern playerstarts_t teamstarts[MAXTEAMS];
 
 #define WAYPOINTSEQUENCESIZE 256
 #define NUMWAYPOINTSEQUENCES 256
+
 extern mobj_t *waypoints[NUMWAYPOINTSEQUENCES][WAYPOINTSEQUENCESIZE];
 extern UINT16 numwaypoints[NUMWAYPOINTSEQUENCES];
 

src/f_finale.c

@@ -2447,13 +2447,8 @@ void F_StartTitleScreen(void)
 
 		players[displayplayer].playerstate = PST_DEAD; // Don't spawn the player in dummy (I'm still a filthy cheater)
 
-		// Set Default Position
-		if (playerstarts[0])
-			startpos = playerstarts[0];
-		else if (deathmatchstarts[0])
-			startpos = deathmatchstarts[0];
-		else
-			startpos = NULL;
+		// Set initial camera position
+		startpos = G_GetInitialSpawnPoint();
 
 		if (startpos)
 		{

src/g_demo.c

@@ -2553,7 +2553,7 @@ void G_AddGhost(char *defdemoname)
 	ghosts = gh;
 
 	gh->version = ghostversion;
-	mthing = playerstarts[0];
+	mthing = G_GetPlayerStart(0);
 	I_Assert(mthing);
 	{ // A bit more complex than P_SpawnPlayer because ghosts aren't solid and won't just push themselves out of the ceiling.
 		fixed_t z,f,c;

src/g_game.h

@@ -166,11 +166,28 @@ void G_FreeMapSearch(mapsearchfreq_t *freq, INT32 freqc);
 /* Match map name by search + 2 digit map code or map number. */
 INT32 G_FindMapByNameOrCode(const char *query, char **foundmapnamep);
 
-// XMOD spawning
-mapthing_t *G_FindCTFStart(INT32 playernum);
-mapthing_t *G_FindMatchStart(INT32 playernum);
+void G_InitSpawnPointList(playerstarts_t *starts, size_t capacity);
+void G_AddSpawnPointToList(playerstarts_t *starts, mapthing_t *mthing);
+boolean G_IsSpawnPointThingType(UINT16 mthingtype);
+mapthing_t *G_GetInitialSpawnPoint(void);
+
+mapthing_t *G_GetPlayerStart(INT32 i);
+mapthing_t *G_GetMatchPlayerStart(INT32 i);
+mapthing_t *G_GetTeamPlayerStart(UINT8 team, INT32 i);
+
+void G_InitSpawnPoints(void);
+void G_AddPlayerStart(int index, mapthing_t *mthing);
+void G_AddMatchPlayerStart(mapthing_t *mthing);
+void G_AddTeamPlayerStart(UINT8 team, mapthing_t *mthing);
+void G_CountPlayerStarts(void);
+
+mapthing_t *G_FindBestPlayerStart(INT32 playernum);
 mapthing_t *G_FindCoopStart(INT32 playernum);
-mapthing_t *G_FindMapStart(INT32 playernum);
+mapthing_t *G_FindMatchStart(INT32 playernum);
+mapthing_t *G_FindTeamStart(INT32 playernum);
+
+spawnpoint_t *G_FindSpawnPoint(INT32 playernum);
+
 void G_MovePlayerToSpawnOrStarpost(INT32 playernum);
 void G_SpawnPlayer(INT32 playernum);
 
@@ -191,17 +208,17 @@ void G_SaveGame(UINT32 slot, INT16 mapnum);
 
 void G_SaveGameOver(UINT32 slot, boolean modifylives);
 
-extern UINT32 gametypedefaultrules[NUMGAMETYPES];
-extern UINT32 gametypetol[NUMGAMETYPES];
-extern INT16 gametyperankings[NUMGAMETYPES];
-
 void G_SetGametype(INT16 gametype);
-INT16 G_AddGametype(UINT32 rules);
+void G_InitGametypes(void);
+INT16 G_AddGametype(void);
+void G_UpdateTeamSelection(void);
 void G_AddGametypeConstant(INT16 gtype, const char *newgtconst);
 void G_UpdateGametypeSelections(void);
 void G_AddTOL(UINT32 newtol, const char *tolname);
-void G_AddGametypeTOL(INT16 gtype, UINT32 newtol);
-void G_SetGametypeDescription(INT16 gtype, char *descriptiontext, UINT8 leftcolor, UINT8 rightcolor);
+
+void G_SetGametypeDescription(INT16 gtype, const char *descriptiontext);
+void G_SetGametypeDescriptionLeftColor(INT16 gtype, UINT8 color);
+void G_SetGametypeDescriptionRightColor(INT16 gtype, UINT8 color);
 
 INT32 G_GetGametypeByName(const char *gametypestr);
 boolean G_IsSpecialStage(INT32 mapnum);
@@ -224,6 +241,30 @@ void G_UseContinue(void);
 void G_AfterIntermission(void);
 void G_EndGame(void); // moved from y_inter.c/h and renamed
 
+void G_InitTeam(UINT8 team);
+UINT8 G_AddTeam(const char *name);
+UINT8 G_GetGametypeTeam(UINT8 gtype, UINT8 team);
+UINT8 G_GetTeam(UINT8 team);
+UINT8 G_GetTeamFromTeamFlag(UINT32 flag);
+UINT8 G_GetTeamListFromTeamFlags(UINT8 *teamlist, UINT32 flags);
+UINT8 G_GetTeamByName(const char *name);
+const char *G_GetTeamName(UINT8 team);
+const char *G_GetTeamFlagName(UINT8 team);
+UINT32 G_GetTeamWeaponMobjtype(UINT8 team);
+UINT32 G_GetTeamMissileMobjtype(UINT8 team);
+UINT16 G_GetTeamColor(UINT8 team);
+UINT16 G_GetTeamWeaponColor(UINT8 team);
+UINT16 G_GetTeamMissileColor(UINT8 team);
+const char *G_GetTeamIcon(UINT8 team, UINT8 icon_type);
+boolean G_HasTeamIcon(UINT8 team, UINT8 icon_type);
+void G_SetTeamIcon(UINT8 team, UINT8 icon_type, const char *icon);
+void G_FreeTeamData(UINT8 team);
+
+UINT8 G_GetBestPerformingTeam(void);
+UINT8 G_GetWorstPerformingTeam(void);
+UINT8 G_GetMostAdvantagedTeam(void);
+UINT8 G_GetMostDisadvantagedTeam(void);
+
 void G_Ticker(boolean run);
 boolean G_Responder(event_t *ev);
 boolean G_LuaResponder(event_t *ev);

src/hu_stuff.c

@@ -86,10 +86,7 @@ static boolean headsupactive = false;
 boolean hu_showscores; // draw rankings
 static char hu_tick;
 
-patch_t *rflagico;
-patch_t *bflagico;
-patch_t *rmatcico;
-patch_t *bmatcico;
+patch_t *teamicons[MAXTEAMS][TEAM_ICON_MAX];
 patch_t *tagico;
 patch_t *tallminus;
 patch_t *tallinfin;
@@ -626,6 +623,46 @@ static void Command_CSay_f(void)
 static tic_t spam_tokens[MAXPLAYERS] = { 1 }; // fill the buffer with 1 so the motd can be sent.
 static tic_t spam_tics[MAXPLAYERS];
 
+const char *GetChatColorForSkincolor(UINT16 skincolor)
+{
+	UINT16 chatcolor = skincolors[skincolor].chatcolor;
+
+	if (!chatcolor || chatcolor%0x1000 || chatcolor>V_INVERTMAP)
+		return "\x80";
+	else if (chatcolor == V_MAGENTAMAP)
+		return "\x81";
+	else if (chatcolor == V_YELLOWMAP)
+		return "\x82";
+	else if (chatcolor == V_GREENMAP)
+		return "\x83";
+	else if (chatcolor == V_BLUEMAP)
+		return "\x84";
+	else if (chatcolor == V_REDMAP)
+		return "\x85";
+	else if (chatcolor == V_GRAYMAP)
+		return "\x86";
+	else if (chatcolor == V_ORANGEMAP)
+		return "\x87";
+	else if (chatcolor == V_SKYMAP)
+		return "\x88";
+	else if (chatcolor == V_PURPLEMAP)
+		return "\x89";
+	else if (chatcolor == V_AQUAMAP)
+		return "\x8a";
+	else if (chatcolor == V_PERIDOTMAP)
+		return "\x8b";
+	else if (chatcolor == V_AZUREMAP)
+		return "\x8c";
+	else if (chatcolor == V_BROWNMAP)
+		return "\x8d";
+	else if (chatcolor == V_ROSYMAP)
+		return "\x8e";
+	else if (chatcolor == V_INVERTMAP)
+		return "\x8f";
+
+	return "\x80";
+}
+
 /** Receives a message, processing an ::XD_SAY command.
   * \sa DoSayCommand
   * \author Graue <graue@oceanbase.org>
@@ -736,6 +773,7 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 	{
 		const char *prefix = "", *cstart = "", *cend = "", *adminchar = "\x82~\x83", *remotechar = "\x82@\x83", *fmt2, *textcolor = "\x80";
 		char *tempchar = NULL;
+		char *tempteam = NULL;
 
 		// player is a spectator?
         if (players[playernum].spectator)
@@ -745,54 +783,13 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 		}
 		else if (target == -1) // say team
 		{
-			if (players[playernum].ctfteam == 1) // red
-			{
-				cstart = "\x85";
-				textcolor = "\x85";
-			}
-			else // blue
-			{
-				cstart = "\x84";
-				textcolor = "\x84";
-			}
+			cstart = GetChatColorForSkincolor(G_GetTeamColor(players[playernum].ctfteam));
+			textcolor = cstart;
 		}
 		else
-        {
-			UINT16 chatcolor = skincolors[players[playernum].skincolor].chatcolor;
-
-			if (!chatcolor || chatcolor%0x1000 || chatcolor>V_INVERTMAP)
-				cstart = "\x80";
-			else if (chatcolor == V_MAGENTAMAP)
-				cstart = "\x81";
-			else if (chatcolor == V_YELLOWMAP)
-				cstart = "\x82";
-			else if (chatcolor == V_GREENMAP)
-				cstart = "\x83";
-			else if (chatcolor == V_BLUEMAP)
-				cstart = "\x84";
-			else if (chatcolor == V_REDMAP)
-				cstart = "\x85";
-			else if (chatcolor == V_GRAYMAP)
-				cstart = "\x86";
-			else if (chatcolor == V_ORANGEMAP)
-				cstart = "\x87";
-			else if (chatcolor == V_SKYMAP)
-				cstart = "\x88";
-			else if (chatcolor == V_PURPLEMAP)
-				cstart = "\x89";
-			else if (chatcolor == V_AQUAMAP)
-				cstart = "\x8a";
-			else if (chatcolor == V_PERIDOTMAP)
-				cstart = "\x8b";
-			else if (chatcolor == V_AZUREMAP)
-				cstart = "\x8c";
-			else if (chatcolor == V_BROWNMAP)
-				cstart = "\x8d";
-			else if (chatcolor == V_ROSYMAP)
-				cstart = "\x8e";
-			else if (chatcolor == V_INVERTMAP)
-				cstart = "\x8f";
-        }
+		{
+			cstart = GetChatColorForSkincolor(players[playernum].skincolor);
+		}
 		prefix = cstart;
 
 		// Give admins and remote admins their symbols.
@@ -836,10 +833,11 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 			fmt2 = "%s<%s%s%s>\x80 %s%s";
 		else // To your team
 		{
-			if (players[playernum].ctfteam == 1) // red
-				prefix = "\x85[TEAM]";
-			else if (players[playernum].ctfteam == 2) // blue
-				prefix = "\x84[TEAM]";
+			if (players[playernum].ctfteam > TEAM_NONE && players[playernum].ctfteam < numteams)
+			{
+				tempteam = Z_StrDup(va("%s[TEAM]", GetChatColorForSkincolor(G_GetTeamColor(players[playernum].ctfteam))));
+				prefix = tempteam;
+			}
 			else
 				prefix = "\x83"; // makes sure this doesn't implode if you sayteam on non-team gamemodes
 
@@ -850,6 +848,8 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 
 		if (tempchar)
 			Z_Free(tempchar);
+		if (tempteam)
+			Z_Free(tempteam);
 	}
 #ifdef _DEBUG
 	// I just want to point out while I'm here that because the data is still
@@ -1589,12 +1589,6 @@ static void HU_DrawChat(void)
 	if (teamtalk)
 	{
 		talk = ttalk;
-#if 0
-		if (players[consoleplayer].ctfteam == 1)
-			t = 0x500;  // Red
-		else if (players[consoleplayer].ctfteam == 2)
-			t = 0x400; // Blue
-#endif
 	}
 
 	if (CHAT_MUTE)
@@ -1757,12 +1751,6 @@ static void HU_DrawChat_Old(void)
 	if (teamtalk)
 	{
 		talk = ttalk;
-#if 0
-		if (players[consoleplayer].ctfteam == 1)
-			t = 0x500;  // Red
-		else if (players[consoleplayer].ctfteam == 2)
-			t = 0x400; // Blue
-#endif
 	}
 
 	while (talk[i])
@@ -1908,7 +1896,7 @@ static void HU_drawGametype(void)
 	if (gametype < 0 || gametype >= gametypecount)
 		return; // not a valid gametype???
 
-	strvalue = Gametype_Names[gametype];
+	strvalue = gametypes[gametype].name;
 
 	if (splitscreen)
 		V_DrawString(4, 184, 0, strvalue);
@@ -2119,7 +2107,7 @@ void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, I
 
 	for (i = 0; i < scorelines; i++)
 	{
-		if (players[tab[i].num].spectator && gametyperankings[gametype] != GT_COOP)
+		if (players[tab[i].num].spectator && !G_GametypeUsesCoopLives())
 			continue; //ignore them.
 
 		greycheck = greycheckdef;
@@ -2196,7 +2184,7 @@ void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, I
 		if (players[tab[i].num].exiting || (players[tab[i].num].pflags & PF_FINISHED))
 			V_DrawSmallScaledPatch(x - exiticon->width/2 - 1, y-3, 0, exiticon);
 
-		if (gametyperankings[gametype] == GT_RACE)
+		if (gametypes[gametype].rankings_type == RANKINGS_RACE)
 		{
 			if (circuitmap)
 			{
@@ -2266,13 +2254,13 @@ static void HU_Draw32TeamTabRankings(playersort_t *tab, INT32 whiteplayer)
 		greycheck = greycheckdef;
 		supercheck = supercheckdef;
 
-		if (tab[i].color == skincolor_redteam) //red
+		if (tab[i].team == G_GetTeam(1)) //red
 		{
 			redplayers++;
 			x = 14 + (BASEVIDWIDTH/2);
 			y = (redplayers * 9) + 20;
 		}
-		else if (tab[i].color == skincolor_blueteam) //blue
+		else if (tab[i].team == G_GetTeam(2)) //blue
 		{
 			blueplayers++;
 			x = 14;
@@ -2293,23 +2281,21 @@ static void HU_Draw32TeamTabRankings(playersort_t *tab, INT32 whiteplayer)
 
 		if (gametyperules & GTR_TEAMFLAGS)
 		{
-			if (players[tab[i].num].gotflag & GF_REDFLAG) // Red
-				V_DrawFixedPatch((x-10)*FRACUNIT, (y)*FRACUNIT, FRACUNIT/4, 0, rflagico, 0);
-			else if (players[tab[i].num].gotflag & GF_BLUEFLAG) // Blue
-				V_DrawFixedPatch((x-10)*FRACUNIT, (y)*FRACUNIT, FRACUNIT/4, 0, bflagico, 0);
+			UINT8 teamlist[MAXTEAMS];
+			UINT8 teamcount = G_GetTeamListFromTeamFlags(teamlist, players[tab[i].num].gotflag);
+			if (teamcount > 0)
+				V_DrawFixedPatch((x-10)*FRACUNIT, (y)*FRACUNIT, FRACUNIT/4, 0, ST_GetTeamIconImage(teamlist[0], TEAM_ICON_FLAG), 0);
 		}
 
 		// Draw emeralds
 		if (players[tab[i].num].powers[pw_invulnerability] && (players[tab[i].num].powers[pw_invulnerability] == players[tab[i].num].powers[pw_sneakers]) && ((leveltime/7) & 1))
 		{
 			HU_Draw32Emeralds(x+60, y+2, 255);
-			//HU_DrawEmeralds(x-12,y+2,255);
 		}
 		else if (!players[tab[i].num].powers[pw_super]
 			|| ((leveltime/7) & 1))
 		{
 			HU_Draw32Emeralds(x+60, y+2, tab[i].emeralds);
-			//HU_DrawEmeralds(x-12,y+2,tab[i].emeralds);
 		}
 
 		if (supercheck)
@@ -2354,7 +2340,7 @@ void HU_DrawTeamTabRankings(playersort_t *tab, INT32 whiteplayer)
 		if (players[tab[i].num].spectator)
 			continue; //ignore them.
 
-		if (tab[i].color == skincolor_redteam) //red
+		if (tab[i].team == G_GetTeam(1)) //red
 		{
 			if (redplayers++ > 8)
 			{
@@ -2362,7 +2348,7 @@ void HU_DrawTeamTabRankings(playersort_t *tab, INT32 whiteplayer)
 				break; // don't make more loops than we need to.
 			}
 		}
-		else if (tab[i].color == skincolor_blueteam) //blue
+		else if (tab[i].team == G_GetTeam(2)) //blue
 		{
 			if (blueplayers++ > 8)
 			{
@@ -2393,14 +2379,14 @@ void HU_DrawTeamTabRankings(playersort_t *tab, INT32 whiteplayer)
 		if (players[tab[i].num].spectator)
 			continue; //ignore them.
 
-		if (tab[i].color == skincolor_redteam) //red
+		if (tab[i].team == G_GetTeam(1)) //red
 		{
 			if (redplayers++ > 8)
 				continue;
 			x = 32 + (BASEVIDWIDTH/2);
 			y = (redplayers * 16) + 16;
 		}
-		else if (tab[i].color == skincolor_blueteam) //blue
+		else if (tab[i].team == G_GetTeam(2)) //blue
 		{
 			if (blueplayers++ > 8)
 				continue;
@@ -2422,10 +2408,10 @@ void HU_DrawTeamTabRankings(playersort_t *tab, INT32 whiteplayer)
 
 		if (gametyperules & GTR_TEAMFLAGS)
 		{
-			if (players[tab[i].num].gotflag & GF_REDFLAG) // Red
-				V_DrawSmallScaledPatch(x-28, y-4, 0, rflagico);
-			else if (players[tab[i].num].gotflag & GF_BLUEFLAG) // Blue
-				V_DrawSmallScaledPatch(x-28, y-4, 0, bflagico);
+			UINT8 teamlist[MAXTEAMS];
+			UINT8 teamcount = G_GetTeamListFromTeamFlags(teamlist, players[tab[i].num].gotflag);
+			if (teamcount > 0)
+				V_DrawSmallScaledPatch(x-28, y-4, 0, ST_GetTeamIconImage(teamlist[0], TEAM_ICON_FLAG));
 		}
 
 		// Draw emeralds
@@ -2455,8 +2441,6 @@ void HU_DrawTeamTabRankings(playersort_t *tab, INT32 whiteplayer)
 		{
 			if (tab[i].num != serverplayer)
 				HU_drawPing(x+ 113, y, players[tab[i].num].quittime ? UINT32_MAX : playerpingtable[tab[i].num], false, 0);
-			//else
-			//	V_DrawSmallString(x+ 94, y+4, V_YELLOWMAP, "SERVER");
 		}
 	}
 }
@@ -2477,7 +2461,7 @@ void HU_DrawDualTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scoreline
 
 	for (i = 0; i < scorelines; i++)
 	{
-		if (players[tab[i].num].spectator && gametyperankings[gametype] != GT_COOP)
+		if (players[tab[i].num].spectator && !G_GametypeUsesCoopLives())
 			continue; //ignore them.
 
 		greycheck = greycheckdef;
@@ -2544,7 +2528,7 @@ void HU_DrawDualTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scoreline
 		}
 
 		// All data drawn with thin string for space.
-		if (gametyperankings[gametype] == GT_RACE)
+		if (gametypes[gametype].rankings_type == RANKINGS_RACE)
 		{
 			if (circuitmap)
 			{
@@ -2584,7 +2568,7 @@ static void HU_Draw32TabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scor
 
 	for (i = 0; i < scorelines; i++)
 	{
-		if (players[tab[i].num].spectator && gametyperankings[gametype] != GT_COOP)
+		if (players[tab[i].num].spectator && !G_GametypeUsesCoopLives())
 			continue; //ignore them.
 
 		greycheck = greycheckdef;
@@ -2655,7 +2639,7 @@ static void HU_Draw32TabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scor
 		}
 
 		// All data drawn with thin string for space.
-		if (gametyperankings[gametype] == GT_RACE)
+		if (gametypes[gametype].rankings_type == RANKINGS_RACE)
 		{
 			if (circuitmap)
 			{
@@ -2815,7 +2799,7 @@ static void HU_DrawRankings(void)
 		tab[i].num = -1;
 		tab[i].name = 0;
 
-		if (gametyperankings[gametype] == GT_RACE && !circuitmap)
+		if (gametypes[gametype].rankings_type == RANKINGS_RACE && !circuitmap)
 			tab[i].count = INT32_MAX;
 	}
 
@@ -2835,7 +2819,7 @@ static void HU_DrawRankings(void)
 			if (!G_PlatformGametype() && players[i].spectator)
 				continue;
 
-			if (gametyperankings[gametype] == GT_RACE)
+			if (gametypes[gametype].rankings_type == RANKINGS_RACE)
 			{
 				if (circuitmap)
 				{
@@ -2844,6 +2828,7 @@ static void HU_DrawRankings(void)
 						tab[scorelines].count = players[i].laps+1;
 						tab[scorelines].num = i;
 						tab[scorelines].color = players[i].skincolor;
+						tab[scorelines].team = players[i].ctfteam;
 						tab[scorelines].name = player_names[i];
 					}
 				}
@@ -2854,11 +2839,12 @@ static void HU_DrawRankings(void)
 						tab[scorelines].count = players[i].realtime;
 						tab[scorelines].num = i;
 						tab[scorelines].color = players[i].skincolor;
+						tab[scorelines].team = players[i].ctfteam;
 						tab[scorelines].name = player_names[i];
 					}
 				}
 			}
-			else if (gametyperankings[gametype] == GT_COMPETITION)
+			else if (gametypes[gametype].rankings_type == RANKINGS_COMPETITION)
 			{
 				// todo put something more fitting for the gametype here, such as current
 				// number of categories led
@@ -2868,6 +2854,7 @@ static void HU_DrawRankings(void)
 					tab[scorelines].num = i;
 					tab[scorelines].color = players[i].skincolor;
 					tab[scorelines].name = player_names[i];
+					tab[scorelines].team = players[i].ctfteam;
 					tab[scorelines].emeralds = players[i].powers[pw_emeralds];
 				}
 			}
@@ -2879,6 +2866,7 @@ static void HU_DrawRankings(void)
 					tab[scorelines].num = i;
 					tab[scorelines].color = players[i].skincolor;
 					tab[scorelines].name = player_names[i];
+					tab[scorelines].team = players[i].ctfteam;
 					tab[scorelines].emeralds = players[i].powers[pw_emeralds];
 				}
 			}

src/hu_stuff.h

@@ -14,6 +14,7 @@
 #ifndef __HU_STUFF_H__
 #define __HU_STUFF_H__
 
+#include "doomstat.h"
 #include "d_event.h"
 #include "w_wad.h"
 #include "r_defs.h"
@@ -56,6 +57,7 @@ typedef struct
 	INT32 num;
 	INT32 color;
 	INT32 emeralds;
+	UINT8 team;
 	const char *name;
 } playersort_t;
 
@@ -87,10 +89,7 @@ extern patch_t *ntb_font[NT_FONTSIZE];
 extern patch_t *nto_font[NT_FONTSIZE];
 extern patch_t *ttlnum[10];
 extern patch_t *emeraldpics[3][8];
-extern patch_t *rflagico;
-extern patch_t *bflagico;
-extern patch_t *rmatcico;
-extern patch_t *bmatcico;
+extern patch_t *teamicons[MAXTEAMS][TEAM_ICON_MAX];
 extern patch_t *tagico;
 extern patch_t *tallminus;
 extern patch_t *tallinfin;
@@ -120,6 +119,8 @@ void HU_DrawEmeralds(INT32 x, INT32 y, INT32 pemeralds);
 
 INT32 HU_CreateTeamScoresTbl(playersort_t *tab, UINT32 dmtotals[]);
 
+const char *GetChatColorForSkincolor(UINT16 skincolor);
+
 // CECHO interface.
 void HU_ClearCEcho(void);
 void HU_SetCEchoDuration(INT32 seconds);

src/info.c

@@ -7123,7 +7123,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
 		24*FRACUNIT,    // radius
 		64*FRACUNIT,    // height
 		0,              // display offset
-		16,             // mass
+		TEAM_RED,       // mass
 		0,              // damage
 		sfx_None,       // activesound
 		MF_SPECIAL,     // flags
@@ -7150,7 +7150,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
 		24*FRACUNIT,    // radius
 		64*FRACUNIT,    // height
 		0,              // display offset
-		16,             // mass
+		TEAM_BLUE,      // mass
 		0,              // damage
 		sfx_None,       // activesound
 		MF_SPECIAL,     // flags

src/lua_baselib.c

@@ -155,6 +155,11 @@ static const struct {
 	{META_SFXINFO,      "sfxinfo_t"},
 	{META_SKINCOLOR,    "skincolor_t"},
 	{META_COLORRAMP,    "skincolor_t.ramp"},
+	{META_GAMETYPE,     "gametype_t"},
+	{META_TEAM,         "team_t"},
+	{META_TEAMLIST,     "teamlist_t"},
+	{META_TEAMSCORES,   "teamscores"},
+	{META_PLAYERSTARTS, "playerstarts"},
 	{META_SPRITEINFO,   "spriteinfo_t"},
 	{META_PIVOTLIST,    "spriteframepivot_t[]"},
 	{META_FRAMEPIVOT,   "spriteframepivot_t"},
@@ -843,13 +848,32 @@ static int lib_pGetMobjGravity(lua_State *L)
 static int lib_pWeaponOrPanel(lua_State *L)
 {
 	mobjtype_t type = luaL_checkinteger(L, 1);
-	//HUDSAFE
 	if (type >= NUMMOBJTYPES)
 		return luaL_error(L, "mobj type %d out of range (0 - %d)", type, NUMMOBJTYPES-1);
 	lua_pushboolean(L, P_WeaponOrPanel(type));
 	return 1;
 }
 
+static int lib_pGetTeamFlag(lua_State *L)
+{
+	int team = luaL_checkinteger(L, 1);
+	if (team <= 0 || team >= numteams)
+		return luaL_error(L, "team index %d out of range (1 - %d)", team, numteams - 1);
+	INLEVEL
+	LUA_PushUserdata(L, P_GetTeamFlag(team), META_MOBJ);
+	return 1;
+}
+
+static int lib_pGetTeamFlagMapthing(lua_State *L)
+{
+	int team = luaL_checkinteger(L, 1);
+	if (team <= 0 || team >= numteams)
+		return luaL_error(L, "team index %d out of range (1 - %d)", team, numteams - 1);
+	INLEVEL
+	LUA_PushUserdata(L, P_GetTeamFlagMapthing(team), META_MAPTHING);
+	return 1;
+}
+
 static int lib_pFlashPal(lua_State *L)
 {
 	player_t *pl = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
@@ -1857,6 +1881,19 @@ static int lib_pPlayerShouldUseSpinHeight(lua_State *L)
 	return 1;
 }
 
+static int lib_pPlayerHasTeamFlag(lua_State *L)
+{
+	player_t *player = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
+	INT32 team = (INT32)luaL_checkinteger(L, 2);
+	INLEVEL
+	if (!player)
+		return LUA_ErrInvalid(L, "player_t");
+	if (team <= 0 || team >= numteams)
+		luaL_error(L, "team index %d out of range (1 - %d)", team, numteams-1);
+	lua_pushboolean(L, P_PlayerHasTeamFlag(player, team));
+	return 1;
+}
+
 // P_MAP
 ///////////
 
@@ -2571,6 +2608,19 @@ static int lib_pPlayerTouchingSectorSpecialFlag(lua_State *L)
 	return 1;
 }
 
+static int lib_pMobjTouchingTeamBase(lua_State *L)
+{
+	mobj_t *mo = *((mobj_t**)luaL_checkudata(L, 1, META_MOBJ));
+	INT32 team = (INT32)luaL_checkinteger(L, 2);
+	INLEVEL
+	if (!mo)
+		return LUA_ErrInvalid(L, "mobj_t");
+	if (team <= 0 || team >= numteams)
+		luaL_error(L, "team index %d out of range (1 - %d)", team, numteams-1);
+	LUA_PushUserdata(L, P_MobjTouchingTeamBase(mo, team), META_SECTOR);
+	return 1;
+}
+
 static int lib_pFindLowestFloorSurrounding(lua_State *L)
 {
 	sector_t *sector = *((sector_t **)luaL_checkudata(L, 1, META_SECTOR));
@@ -2712,11 +2762,29 @@ static int lib_pFadeLight(lua_State *L)
 static int lib_pIsFlagAtBase(lua_State *L)
 {
 	mobjtype_t flag = luaL_checkinteger(L, 1);
-	//HUDSAFE
 	INLEVEL
 	if (flag >= NUMMOBJTYPES)
 		return luaL_error(L, "mobj type %d out of range (0 - %d)", flag, NUMMOBJTYPES-1);
-	lua_pushboolean(L, P_IsFlagAtBase(flag));
+	for (UINT8 i = 1; i < teamsingame; i++)
+	{
+		UINT8 team = G_GetTeam(i);
+		if (teams[team].flag_mobj_type == flag)
+		{
+			lua_pushboolean(L, P_TeamHasFlagAtBase(team));
+			return 1;
+		}
+	}
+	lua_pushboolean(L, false);
+	return 1;
+}
+
+static int lib_pTeamHasFlagAtBase(lua_State *L)
+{
+	INT32 team = luaL_checkinteger(L, 1);
+	INLEVEL
+	if (team <= 0 || team >= numteams)
+		luaL_error(L, "team index %d out of range (1 - %d)", team, numteams-1);
+	lua_pushboolean(L, P_TeamHasFlagAtBase(team));
 	return 1;
 }
 
@@ -3657,24 +3725,24 @@ static int lib_sResumeMusic(lua_State *L)
 // G_GAME
 ////////////
 
-// Copypasted from lib_cvRegisterVar :]
 static int lib_gAddGametype(lua_State *L)
 {
 	const char *k;
 	lua_Integer i;
 
-	const char *gtname = NULL;
-	const char *gtconst = NULL;
-	const char *gtdescription = NULL;
-	INT16 newgtidx = 0;
+	char *gtname = NULL;
+	char *gtconst = NULL;
+	char *gtdescription = NULL;
 	UINT32 newgtrules = 0;
 	UINT32 newgttol = 0;
 	INT32 newgtpointlimit = 0;
 	INT32 newgttimelimit = 0;
-	UINT8 newgtleftcolor = 0;
-	UINT8 newgtrightcolor = 0;
-	INT16 newgtrankingstype = -1;
+	UINT8 newgtleftcolor = 54;
+	UINT8 newgtrightcolor = 54;
+	INT16 newgtrankingstype = RANKINGS_DEFAULT;
 	int newgtinttype = 0;
+	UINT8 teamcount = 0;
+	UINT8 teamlist[MAXTEAMS];
 
 	luaL_checktype(L, 1, LUA_TTABLE);
 	lua_settop(L, 1); // Clear out all other possible arguments, leaving only the first one.
@@ -3700,7 +3768,6 @@ static int lib_gAddGametype(lua_State *L)
 		else if (lua_isstring(L, 2))
 			k = lua_tostring(L, 2);
 
-		// Sorry, no gametype rules as key names.
 		if (i == 1 || (k && fasticmp(k, "name"))) {
 			if (!lua_isstring(L, 3))
 				TYPEERROR("name", LUA_TSTRING)
@@ -3745,6 +3812,36 @@ static int lib_gAddGametype(lua_State *L)
 			if (!lua_isnumber(L, 3))
 				TYPEERROR("headerrightcolor", LUA_TNUMBER)
 			newgtrightcolor = (UINT8)lua_tointeger(L, 3);
+		} else if (i == 12 || (k && fasticmp(k, "teams"))) {
+			if (lua_istable(L, 3))
+			{
+				lua_pushnil(L);
+
+				while (lua_next(L, 3)) {
+					lua_Integer idx = luaL_checkinteger(L, -2) - 1;
+					if (idx >= 0 && idx < MAXTEAMS)
+					{
+						int team_index = luaL_checkinteger(L, -1);
+						if (team_index <= 0 || team_index >= numteams)
+							luaL_error(L, "team index %d out of range (1 - %d)", team_index, numteams-1);
+
+						teamlist[idx] = (UINT8)team_index;
+
+						if ((lua_Integer)teamcount < idx + 1)
+							teamcount = (UINT8)idx + 1;
+					}
+
+					lua_pop(L, 1);
+				}
+			}
+			else if (lua_isuserdata(L, 3))
+			{
+				teamlist_t *tl = *((teamlist_t **)luaL_checkudata(L, 3, META_TEAMLIST));
+				teamcount = tl->num;
+				memcpy(teamlist, tl->list, sizeof(teamlist[0]) * teamcount);
+			}
+			else
+				TYPEERROR("teams", LUA_TTABLE)
 		// Key name specified
 		} else if ((!i) && (k && fasticmp(k, "headercolor"))) {
 			if (!lua_isnumber(L, 3))
@@ -3763,36 +3860,52 @@ static int lib_gAddGametype(lua_State *L)
 	// Set defaults
 	if (gtname == NULL)
 		gtname = Z_StrDup("Unnamed gametype");
-	if (gtdescription == NULL)
-		gtdescription = Z_StrDup("???");
+
+	if (G_GetGametypeByName(gtname) != -1)
+	{
+		luaL_error(L, "gametype %s already exists", gtname);
+		Z_Free(gtname);
+		Z_Free(gtconst);
+		Z_Free(gtdescription);
+		return 0;
+	}
 
 	// Add the new gametype
-	newgtidx = G_AddGametype(newgtrules);
-	G_AddGametypeTOL(newgtidx, newgttol);
-	G_SetGametypeDescription(newgtidx, NULL, newgtleftcolor, newgtrightcolor);
-	strncpy(gametypedesc[newgtidx].notes, gtdescription, 441);
-
-	// Not covered by G_AddGametype alone.
-	if (newgtrankingstype == -1)
-		newgtrankingstype = newgtidx;
-	gametyperankings[newgtidx] = newgtrankingstype;
-	intermissiontypes[newgtidx] = newgtinttype;
-	pointlimits[newgtidx] = newgtpointlimit;
-	timelimits[newgtidx] = newgttimelimit;
-
-	// Write the new gametype name.
-	Gametype_Names[newgtidx] = gtname;
-
-	// Write the constant name.
-	if (gtconst == NULL)
-		gtconst = gtname;
-	G_AddGametypeConstant(newgtidx, gtconst);
-
-	// Update gametype_cons_t accordingly.
+	INT16 gtype = G_AddGametype();
+
+	gametype_t *gt = &gametypes[gtype];
+
+	gt->name = gtname;
+
+	// Copy the teams
+	gt->teams.num = teamcount;
+	if (teamcount)
+		memcpy(gt->teams.list, teamlist, sizeof(teamlist[0]) * teamcount);
+
+	if (gtconst)
+		G_AddGametypeConstant(gtype, gtconst);
+	else
+		G_AddGametypeConstant(gtype, gtname);
+
+	if (gtdescription)
+		G_SetGametypeDescription(gtype, gtdescription);
+	G_SetGametypeDescriptionLeftColor(gtype, newgtleftcolor);
+	G_SetGametypeDescriptionRightColor(gtype, newgtrightcolor);
+
+	gt->rules = newgtrules;
+	gt->typeoflevel = newgttol;
+	gt->rankings_type = newgtrankingstype;
+	gt->intermission_type = newgtinttype;
+	gt->pointlimit = newgtpointlimit;
+	gt->timelimit = newgttimelimit;
+
 	G_UpdateGametypeSelections();
 
-	// done
-	CONS_Printf("Added gametype %s\n", Gametype_Names[newgtidx]);
+	CONS_Printf("Added gametype %s\n", gt->name);
+
+	Z_Free(gtconst);
+	Z_Free(gtdescription);
+
 	return 0;
 }
 
@@ -4217,6 +4330,74 @@ static int lib_gCompetitionGametype(lua_State *L)
 	return 1;
 }
 
+static int lib_gGetBestPerformingTeam(lua_State *L)
+{
+	lua_pushinteger(L, G_GetBestPerformingTeam());
+	return 1;
+}
+
+static int lib_gGetWorstPerformingTeam(lua_State *L)
+{
+	lua_pushinteger(L, G_GetWorstPerformingTeam());
+	return 1;
+}
+
+static int lib_gGetMostAdvantagedTeam(lua_State *L)
+{
+	lua_pushinteger(L, G_GetMostAdvantagedTeam());
+	return 1;
+}
+
+static int lib_gGetMostDisadvantagedTeam(lua_State *L)
+{
+	lua_pushinteger(L, G_GetMostDisadvantagedTeam());
+	return 1;
+}
+
+static int lib_gFindPlayerStart(lua_State *L)
+{
+	player_t *plr = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
+	INLEVEL
+	if (!plr)
+		return LUA_ErrInvalid(L, "player_t");
+	mapthing_t *mapthing = G_FindBestPlayerStart(plr - players);
+	if (mapthing)
+		LUA_PushUserdata(L, mapthing, META_MAPTHING);
+	else
+		lua_pushnil(L);
+	return 1;
+}
+
+static int lib_gFindMatchStart(lua_State *L)
+{
+	player_t *plr = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
+	INLEVEL
+	if (!plr)
+		return LUA_ErrInvalid(L, "player_t");
+	mapthing_t *mapthing = G_FindMatchStart(plr - players);
+	if (mapthing)
+		LUA_PushUserdata(L, mapthing, META_MAPTHING);
+	else
+		lua_pushnil(L);
+	return 1;
+}
+
+static int lib_gFindTeamStart(lua_State *L)
+{
+	player_t *plr = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
+	INLEVEL
+	if (!plr)
+		return LUA_ErrInvalid(L, "player_t");
+	mapthing_t *mapthing = NULL;
+	if (plr->ctfteam > TEAM_NONE && plr->ctfteam < numteams)
+		mapthing = G_FindTeamStart(plr - players);
+	if (mapthing)
+		LUA_PushUserdata(L, mapthing, META_MAPTHING);
+	else
+		lua_pushnil(L);
+	return 1;
+}
+
 static int lib_gTicsToHours(lua_State *L)
 {
 	tic_t rtic = luaL_checkinteger(L, 1);
@@ -4322,6 +4503,8 @@ static luaL_Reg lib[] = {
 	{"P_MobjFlip",lib_pMobjFlip},
 	{"P_GetMobjGravity",lib_pGetMobjGravity},
 	{"P_WeaponOrPanel",lib_pWeaponOrPanel},
+	{"P_GetTeamFlag",lib_pGetTeamFlag},
+	{"P_GetTeamFlagMapthing",lib_pGetTeamFlagMapthing},
 	{"P_FlashPal",lib_pFlashPal},
 	{"P_GetClosestAxis",lib_pGetClosestAxis},
 	{"P_SpawnParaloop",lib_pSpawnParaloop},
@@ -4403,6 +4586,7 @@ static luaL_Reg lib[] = {
 	{"P_DoFollowMobj",lib_pDoFollowMobj},
 	{"P_PlayerCanEnterSpinGaps",lib_pPlayerCanEnterSpinGaps},
 	{"P_PlayerShouldUseSpinHeight",lib_pPlayerShouldUseSpinHeight},
+	{"P_PlayerHasTeamFlag",lib_pPlayerHasTeamFlag},
 
 	// p_map
 	{"P_CheckPosition",lib_pCheckPosition},
@@ -4456,6 +4640,7 @@ static luaL_Reg lib[] = {
 	{"P_MobjTouchingSectorSpecialFlag",lib_pMobjTouchingSectorSpecialFlag},
 	{"P_PlayerTouchingSectorSpecial",lib_pPlayerTouchingSectorSpecial},
 	{"P_PlayerTouchingSectorSpecialFlag",lib_pPlayerTouchingSectorSpecialFlag},
+	{"P_MobjTouchingTeamBase",lib_pMobjTouchingTeamBase},
 	{"P_FindLowestFloorSurrounding",lib_pFindLowestFloorSurrounding},
 	{"P_FindHighestFloorSurrounding",lib_pFindHighestFloorSurrounding},
 	{"P_FindNextHighestFloor",lib_pFindNextHighestFloor},
@@ -4468,6 +4653,7 @@ static luaL_Reg lib[] = {
 	{"P_SpawnLightningFlash",lib_pSpawnLightningFlash},
 	{"P_FadeLight",lib_pFadeLight},
 	{"P_IsFlagAtBase",lib_pIsFlagAtBase},
+	{"P_TeamHasFlagAtBase",lib_pTeamHasFlagAtBase},
 	{"P_SetupLevelSky",lib_pSetupLevelSky},
 	{"P_SetSkyboxMobj",lib_pSetSkyboxMobj},
 	{"P_StartQuake",lib_pStartQuake},
@@ -4556,6 +4742,13 @@ static luaL_Reg lib[] = {
 	{"G_CoopGametype",lib_gCoopGametype},
 	{"G_TagGametype",lib_gTagGametype},
 	{"G_CompetitionGametype",lib_gCompetitionGametype},
+	{"G_GetBestPerformingTeam",lib_gGetBestPerformingTeam},
+	{"G_GetWorstPerformingTeam",lib_gGetWorstPerformingTeam},
+	{"G_GetMostAdvantagedTeam",lib_gGetMostAdvantagedTeam},
+	{"G_GetMostDisadvantagedTeam",lib_gGetMostDisadvantagedTeam},
+	{"G_FindPlayerStart",lib_gFindPlayerStart},
+	{"G_FindMatchStart",lib_gFindMatchStart},
+	{"G_FindTeamStart",lib_gFindTeamStart},
 	{"G_TicsToHours",lib_gTicsToHours},
 	{"G_TicsToMinutes",lib_gTicsToMinutes},
 	{"G_TicsToSeconds",lib_gTicsToSeconds},

src/lua_hook.h

@@ -72,6 +72,7 @@ automatically.
 	X (MusicChange),\
 	X (PlayerHeight),/* override player height */\
 	X (PlayerCanEnterSpinGaps),\
+	X (PlayerSpawnPoint),\
 	X (KeyDown),\
 	X (KeyUp),\
 
@@ -150,4 +151,5 @@ int  LUA_HookShouldJingleContinue(player_t *, const char *musname);
 int  LUA_HookPlayerCmd(player_t *, ticcmd_t *);
 int  LUA_HookMusicChange(const char *oldname, struct MusicChange *);
 fixed_t LUA_HookPlayerHeight(player_t *player);
+spawnpoint_t *LUA_HookPlayerSpawnPoint(player_t *player);
 int  LUA_HookPlayerCanEnterSpinGaps(player_t *player);

src/lua_hooklib.c

@@ -264,7 +264,12 @@ typedef struct Hook_State Hook_State;
 typedef void (*Hook_Callback)(Hook_State *);
 
 struct Hook_State {
-	INT32        status;/* return status to calling function */
+	union {
+		int      type_int;
+		fixed_t  type_fixed;
+		boolean  type_bool;
+		void   * type_void_pointer;
+	} status;/* return status to calling function */
 	void       * userdata;
 	int          hook_type;
 	mobjtype_t   mobj_type;/* >0 if mobj hook */
@@ -313,7 +318,9 @@ static boolean init_hook_type
 		const char * string,
 		int          nonzero
 ){
-	hook->status = status;
+	memset(&hook->status, 0, sizeof(hook->status));
+
+	hook->status.type_int = status;
 
 	if (nonzero)
 	{
@@ -531,13 +538,13 @@ static int call_hooks
 static void res_true(Hook_State *hook)
 {
 	if (lua_toboolean(gL, -1))
-		hook->status = true;
+		hook->status.type_bool = true;
 }
 
 static void res_false(Hook_State *hook)
 {
 	if (!lua_isnil(gL, -1) && !lua_toboolean(gL, -1))
-		hook->status = false;
+		hook->status.type_bool = false;
 }
 
 static void res_force(Hook_State *hook)
@@ -545,9 +552,9 @@ static void res_force(Hook_State *hook)
 	if (!lua_isnil(gL, -1))
 	{
 		if (lua_toboolean(gL, -1))
-			hook->status = 1; // Force yes
+			hook->status.type_int = 1; // Force yes
 		else
-			hook->status = 2; // Force no
+			hook->status.type_int = 2; // Force no
 	}
 }
 
@@ -563,7 +570,7 @@ int LUA_HookMobj(mobj_t *mobj, int hook_type)
 		LUA_PushUserdata(gL, mobj, META_MOBJ);
 		call_hooks(&hook, 1, res_true);
 	}
-	return hook.status;
+	return hook.status.type_int;
 }
 
 int LUA_Hook2Mobj(mobj_t *t1, mobj_t *t2, int hook_type)
@@ -575,7 +582,7 @@ int LUA_Hook2Mobj(mobj_t *t1, mobj_t *t2, int hook_type)
 		LUA_PushUserdata(gL, t2, META_MOBJ);
 		call_hooks(&hook, 1, res_force);
 	}
-	return hook.status;
+	return hook.status.type_int;
 }
 
 void LUA_HookVoid(int type)
@@ -613,7 +620,7 @@ int LUA_HookPlayer(player_t *player, int hook_type)
 		LUA_PushUserdata(gL, player, META_PLAYER);
 		call_hooks(&hook, 1, res_true);
 	}
-	return hook.status;
+	return hook.status.type_int;
 }
 
 int LUA_HookTiccmd(player_t *player, ticcmd_t *cmd, int hook_type)
@@ -632,7 +639,7 @@ int LUA_HookTiccmd(player_t *player, ticcmd_t *cmd, int hook_type)
 		if (hook_type == HOOK(PlayerCmd))
 			hook_cmd_running = false;
 	}
-	return hook.status;
+	return hook.status.type_int;
 }
 
 int LUA_HookKey(event_t *event, int hook_type)
@@ -643,7 +650,7 @@ int LUA_HookKey(event_t *event, int hook_type)
 		LUA_PushUserdata(gL, event, META_KEYEVENT);
 		call_hooks(&hook, 1, res_true);
 	}
-	return hook.status;
+	return hook.status.type_int;
 }
 
 void LUA_HookHUD(int hook_type, huddrawlist_h list)
@@ -742,7 +749,7 @@ int LUA_HookMobjLineCollide(mobj_t *mobj, line_t *line)
 		LUA_PushUserdata(gL, line, META_LINE);
 		call_hooks(&hook, 1, res_force);
 	}
-	return hook.status;
+	return hook.status.type_int;
 }
 
 int LUA_HookTouchSpecial(mobj_t *special, mobj_t *toucher)
@@ -754,7 +761,7 @@ int LUA_HookTouchSpecial(mobj_t *special, mobj_t *toucher)
 		LUA_PushUserdata(gL, toucher, META_MOBJ);
 		call_hooks(&hook, 1, res_true);
 	}
-	return hook.status;
+	return hook.status.type_int;
 }
 
 static int damage_hook
@@ -778,7 +785,7 @@ static int damage_hook
 		lua_pushinteger(gL, damagetype);
 		call_hooks(&hook, 1, results_handler);
 	}
-	return hook.status;
+	return hook.status.type_int;
 }
 
 int LUA_HookShouldDamage(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 damage, UINT8 damagetype)
@@ -809,7 +816,7 @@ int LUA_HookMobjMoveBlocked(mobj_t *t1, mobj_t *t2, line_t *line)
 		LUA_PushUserdata(gL, line, META_LINE);
 		call_hooks(&hook, 1, res_true);
 	}
-	return hook.status;
+	return hook.status.type_int;
 }
 
 typedef struct {
@@ -862,7 +869,7 @@ static void res_botai(Hook_State *hook)
 	B_KeysToTiccmd(botai->tails, botai->cmd,
 			k[0],k[1],k[2],k[3],k[4],k[5],k[6],k[7]);
 
-	hook->status = true;
+	hook->status.type_bool = true;
 }
 
 int LUA_HookBotAI(mobj_t *sonic, mobj_t *tails, ticcmd_t *cmd)
@@ -885,7 +892,7 @@ int LUA_HookBotAI(mobj_t *sonic, mobj_t *tails, ticcmd_t *cmd)
 		call_hooks(&hook, 8, res_botai);
 	}
 
-	return hook.status;
+	return hook.status.type_int;
 }
 
 void LUA_HookLinedefExecute(line_t *line, mobj_t *mo, sector_t *sector)
@@ -923,7 +930,7 @@ int LUA_HookPlayerMsg(int source, int target, int flags, char *msg)
 		lua_pushstring(gL, msg); // msg
 		call_hooks(&hook, 1, res_true);
 	}
-	return hook.status;
+	return hook.status.type_int;
 }
 
 int LUA_HookHurtMsg(player_t *player, mobj_t *inflictor, mobj_t *source, UINT8 damagetype)
@@ -937,7 +944,7 @@ int LUA_HookHurtMsg(player_t *player, mobj_t *inflictor, mobj_t *source, UINT8 d
 		lua_pushinteger(gL, damagetype);
 		call_hooks(&hook, 1, res_true);
 	}
-	return hook.status;
+	return hook.status.type_int;
 }
 
 void LUA_HookNetArchive(lua_CFunction archFunc)
@@ -979,7 +986,7 @@ int LUA_HookMapThingSpawn(mobj_t *mobj, mapthing_t *mthing)
 		LUA_PushUserdata(gL, mthing, META_MAPTHING);
 		call_hooks(&hook, 1, res_true);
 	}
-	return hook.status;
+	return hook.status.type_int;
 }
 
 int LUA_HookFollowMobj(player_t *player, mobj_t *mobj)
@@ -991,7 +998,7 @@ int LUA_HookFollowMobj(player_t *player, mobj_t *mobj)
 		LUA_PushUserdata(gL, mobj, META_MOBJ);
 		call_hooks(&hook, 1, res_true);
 	}
-	return hook.status;
+	return hook.status.type_int;
 }
 
 int LUA_HookPlayerCanDamage(player_t *player, mobj_t *mobj)
@@ -1003,7 +1010,7 @@ int LUA_HookPlayerCanDamage(player_t *player, mobj_t *mobj)
 		LUA_PushUserdata(gL, mobj, META_MOBJ);
 		call_hooks(&hook, 1, res_force);
 	}
-	return hook.status;
+	return hook.status.type_int;
 }
 
 void LUA_HookPlayerQuit(player_t *plr, kickreason_t reason)
@@ -1029,7 +1036,7 @@ int LUA_HookTeamSwitch(player_t *player, int newteam, boolean fromspectators, bo
 		lua_pushboolean(gL, tryingscramble);
 		call_hooks(&hook, 1, res_false);
 	}
-	return hook.status;
+	return hook.status.type_int;
 }
 
 int LUA_HookViewpointSwitch(player_t *player, player_t *newdisplayplayer, boolean forced)
@@ -1045,7 +1052,7 @@ int LUA_HookViewpointSwitch(player_t *player, player_t *newdisplayplayer, boolea
 		call_hooks(&hook, 1, res_force);
 		hud_running = false;
 	}
-	return hook.status;
+	return hook.status.type_int;
 }
 
 int LUA_HookSeenPlayer(player_t *player, player_t *seenfriend)
@@ -1060,7 +1067,7 @@ int LUA_HookSeenPlayer(player_t *player, player_t *seenfriend)
 		call_hooks(&hook, 1, res_false);
 		hud_running = false;
 	}
-	return hook.status;
+	return hook.status.type_int;
 }
 
 int LUA_HookShouldJingleContinue(player_t *player, const char *musname)
@@ -1076,7 +1083,7 @@ int LUA_HookShouldJingleContinue(player_t *player, const char *musname)
 		call_hooks(&hook, 1, res_true);
 		hud_running = false;
 	}
-	return hook.status;
+	return hook.status.type_int;
 }
 
 boolean hook_cmd_running = false;
@@ -1109,7 +1116,7 @@ static void res_musicchange(Hook_State *hook)
 	if (lua_isstring(gL, -6))
 		update_music_name(musicchange);
 	else if (lua_isboolean(gL, -6) && lua_toboolean(gL, -6))
-		hook->status = true;
+		hook->status.type_bool = true;
 
 	// output 2: mflags override
 	if (lua_isnumber(gL, -5))
@@ -1164,7 +1171,7 @@ int LUA_HookMusicChange(const char *oldname, struct MusicChange *param)
 		lua_settop(gL, 0);
 	}
 
-	return hook.status;
+	return hook.status.type_int;
 }
 
 static void res_playerheight(Hook_State *hook)
@@ -1176,7 +1183,7 @@ static void res_playerheight(Hook_State *hook)
 		// when an object's height is set to a negative number directly with lua, it's forced to 0 instead.
 		// here, I think it's better to ignore negatives so that they don't replace any results of previous hooks!
 		if (returnedheight >= 0)
-			hook->status = returnedheight;
+			hook->status.type_fixed = returnedheight;
 	}
 }
 
@@ -1188,7 +1195,160 @@ fixed_t LUA_HookPlayerHeight(player_t *player)
 		LUA_PushUserdata(gL, player, META_PLAYER);
 		call_hooks(&hook, 1, res_playerheight);
 	}
-	return hook.status;
+	return hook.status.type_fixed;
+}
+
+static void res_playerspawnpoint(Hook_State *hook)
+{
+	hook->status.type_void_pointer = NULL;
+
+	int a = hook->results;
+
+	if (lua_isnil(gL, -a))
+		return;
+
+	boolean height_is_relative = false;
+	fixed_t height_offset = 0;
+	boolean has_z = false;
+
+	spawnpoint_t spawnpoint = {
+		.x = 0, .y = 0, .z = 0,
+		.angle = 0, .scale = FRACUNIT,
+		.spawn_on_ceiling = false, .spawn_flipped = false
+	};
+
+	if (lua_istable(gL, -a))
+	{
+		lua_pushvalue(gL, -a);
+		lua_pushnil(gL);
+		while (lua_next(gL, -2))
+		{
+			lua_pushvalue(gL, -2);
+
+			const char *key = NULL;
+			if (lua_isstring(gL, -1))
+				key = lua_tostring(gL, -1);
+
+#define TYPEERROR(f,t) \
+	CONS_Alert(CONS_WARNING, \
+		"bad value for \"%s\" in table returned by \"PlayerSpawnPoint\" hook (%s expected, got %s)\n", \
+		f, lua_typename(gL, t), luaL_typename(gL, -2))
+#define GETNUMBER(r,f) \
+	if (!strcmp(key, f)) { \
+		if (!lua_isnumber(gL, -2)) \
+			TYPEERROR(f, LUA_TNUMBER); \
+		else \
+			r = lua_tonumber(gL, -2); \
+	}
+#define GETNUMBEROPT(r,f,opt) \
+	if (!strcmp(key, f)) { \
+		if (!lua_isnumber(gL, -2)) \
+			TYPEERROR(f, LUA_TNUMBER); \
+		else \
+			r = lua_tonumber(gL, -2); \
+		opt = true; \
+	}
+#define GETBOOLEAN(r,f) \
+	if (!strcmp(key, f)) { \
+		if (!lua_isboolean(gL, -2)) \
+			TYPEERROR(f, LUA_TBOOLEAN); \
+		else \
+			r = lua_toboolean(gL, -2); \
+	}
+
+			if (key)
+			{
+				GETNUMBER(spawnpoint.x, "x");
+				GETNUMBER(spawnpoint.y, "y");
+				GETNUMBEROPT(spawnpoint.z, "z", has_z);
+				GETNUMBER(height_offset, "height");
+				GETNUMBER(spawnpoint.angle, "angle");
+				GETBOOLEAN(spawnpoint.spawn_flipped, "spawn_flipped");
+				GETBOOLEAN(spawnpoint.spawn_on_ceiling, "spawn_on_ceiling");
+				GETNUMBER(spawnpoint.scale, "scale");
+			}
+
+#undef GETNUMBER
+#undef GETNUMBEROPT
+#undef GETBOOLEAN
+#undef TYPEERROR
+
+			lua_pop(gL, 2);
+		}
+
+		lua_pop(gL, 1);
+
+		if (!has_z)
+			height_is_relative = true;
+		else
+			spawnpoint.z += height_offset;
+	}
+	else
+	{
+#define TYPEERROR(f,t,i) \
+	CONS_Alert(CONS_WARNING, \
+		"bad value for \"%s\" returned by \"PlayerSpawnPoint\" hook (%s expected, got %s)\n", \
+		f, lua_typename(gL, t), luaL_typename(gL, i))
+#define GETNUMBER(r,f,i) \
+	if (!lua_isnil(gL, i)) { \
+		if (!lua_isnumber(gL, i)) \
+			TYPEERROR(f, LUA_TNUMBER, i); \
+		else \
+			r = lua_tonumber(gL, i); \
+	}
+#define GETNUMBEROPT(r,f,opt,i) \
+	if (!lua_isnil(gL, i)) { \
+		if (!lua_isnumber(gL, i)) \
+			TYPEERROR(f, LUA_TNUMBER, i); \
+		else \
+			r = lua_tonumber(gL, i); \
+		opt = true; \
+	}
+#define GETBOOLEAN(r,f,i) \
+	if (!lua_isnil(gL, i)) { \
+		if (!lua_isboolean(gL, i)) \
+			TYPEERROR(f, LUA_TBOOLEAN, i); \
+		else \
+			r = lua_toboolean(gL, i); \
+	}
+
+		GETNUMBER(spawnpoint.x, "x", -a + 0);
+		GETNUMBER(spawnpoint.y, "y", -a + 1);
+		GETNUMBEROPT(height_offset, "z", has_z, -a + 2);
+		if (!has_z)
+			height_is_relative = true;
+		GETNUMBER(spawnpoint.angle, "angle", -a + 3);
+		GETBOOLEAN(spawnpoint.spawn_flipped, "spawn_flipped", -a + 4);
+		GETBOOLEAN(spawnpoint.spawn_on_ceiling, "spawn_on_ceiling", -a + 5);
+		GETBOOLEAN(height_is_relative, "height_is_relative", -a + 6);
+		GETNUMBER(spawnpoint.scale, "scale", -a + 7);
+
+		if (!height_is_relative)
+			spawnpoint.z = height_offset;
+
+#undef GETNUMBER
+#undef GETNUMBEROPT
+#undef GETBOOLEAN
+#undef TYPEERROR
+	}
+
+	if (height_is_relative)
+		P_SetAbsoluteSpawnPointHeight(&spawnpoint, height_offset);
+
+	spawnpoint_t *result = Z_Calloc(sizeof(spawnpoint_t), PU_STATIC, NULL);
+	memcpy(result, &spawnpoint, sizeof(spawnpoint_t));
+	hook->status.type_void_pointer = result;
+}
+
+spawnpoint_t *LUA_HookPlayerSpawnPoint(player_t *player)
+{
+	Hook_State hook;
+	if (prepare_hook(&hook, 0, HOOK(PlayerSpawnPoint)))
+	{
+		LUA_PushUserdata(gL, player, META_PLAYER);
+		call_hooks(&hook, 8, res_playerspawnpoint);
+	}
+	return (spawnpoint_t *)hook.status.type_void_pointer;
 }
 
 int LUA_HookPlayerCanEnterSpinGaps(player_t *player)
@@ -1199,5 +1359,5 @@ int LUA_HookPlayerCanEnterSpinGaps(player_t *player)
 		LUA_PushUserdata(gL, player, META_PLAYER);
 		call_hooks(&hook, 1, res_force);
 	}
-	return hook.status;
+	return hook.status.type_int;
 }

src/lua_infolib.c

@@ -1900,6 +1900,614 @@ static int colorramp_len(lua_State *L)
 	return 1;
 }
 
+///////////////
+// GAMETYPES //
+///////////////
+
+static int lib_getGametypes(lua_State *L)
+{
+	INT16 i;
+	lua_remove(L, 1);
+
+	i = luaL_checkinteger(L, 1);
+	if (i < 0 || i >= gametypecount)
+		return luaL_error(L, "gametypes[] index %d out of range (0 - %d)", i, gametypecount - 1);
+	LUA_PushUserdata(L, &gametypes[i], META_GAMETYPE);
+	return 1;
+}
+
+// #gametypes -> gametypecount
+static int lib_gametypeslen(lua_State *L)
+{
+	lua_pushinteger(L, gametypecount);
+	return 1;
+}
+
+enum gametype_e
+{
+	gametype_name,
+	gametype_rules,
+	gametype_typeoflevel,
+	gametype_intermission_type,
+	gametype_rankings_type,
+	gametype_pointlimit,
+	gametype_timelimit,
+	gametype_teams
+};
+
+const char *const gametype_opt[] = {
+	"name",
+	"rules",
+	"type_of_level",
+	"intermission_type",
+	"rankings_type",
+	"point_limit",
+	"time_limit",
+	"teams",
+	NULL,
+};
+
+static int gametype_fields_ref = LUA_NOREF;
+
+static int gametype_get(lua_State *L)
+{
+	gametype_t *gt = *((gametype_t **)luaL_checkudata(L, 1, META_GAMETYPE));
+	enum gametype_e field = Lua_optoption(L, 2, gametype_name, gametype_fields_ref);
+
+	I_Assert(gt != NULL);
+	I_Assert(gt >= gametypes);
+
+	switch (field)
+	{
+	case gametype_name:
+		lua_pushstring(L, gt->name);
+		break;
+	case gametype_rules:
+		lua_pushinteger(L, gt->rules);
+		break;
+	case gametype_typeoflevel:
+		lua_pushinteger(L, gt->typeoflevel);
+		break;
+	case gametype_intermission_type:
+		lua_pushinteger(L, gt->intermission_type);
+		break;
+	case gametype_rankings_type:
+		lua_pushinteger(L, gt->rankings_type);
+		break;
+	case gametype_pointlimit:
+		lua_pushinteger(L, gt->pointlimit);
+		break;
+	case gametype_timelimit:
+		lua_pushinteger(L, gt->timelimit);
+		break;
+	case gametype_teams:
+		LUA_PushUserdata(L, &gt->teams, META_TEAMLIST);
+		break;
+	default:
+		return luaL_error(L, LUA_QL("gametype_t") " has no field named " LUA_QS, gametype_opt[field]);
+	}
+	return 1;
+}
+
+static int gametype_set(lua_State *L)
+{
+	gametype_t *gt = *((gametype_t **)luaL_checkudata(L, 1, META_GAMETYPE));
+	enum gametype_e field = Lua_optoption(L, 2, -1, gametype_fields_ref);
+
+	if (!lua_lumploading)
+		return luaL_error(L, "Do not alter gametype data from within a hook or coroutine!");
+	if (hud_running)
+		return luaL_error(L, "Do not alter gametype data in HUD rendering code!");
+	if (hook_cmd_running)
+		return luaL_error(L, "Do not alter gametype data in CMD building code!");
+
+	I_Assert(gt != NULL);
+	I_Assert(gt >= gametypes);
+
+	INT16 gametype_id = gt - gametypes;
+
+	switch (field)
+	{
+	case gametype_name:
+		Z_Free(gt->name);
+		gt->name = Z_StrDup(luaL_checkstring(L, 3));
+		G_UpdateGametypeSelections();
+		break;
+	case gametype_rules:
+		gt->rules = luaL_checkinteger(L, 3);
+		break;
+	case gametype_typeoflevel:
+		gt->typeoflevel = luaL_checkinteger(L, 3);
+		break;
+	case gametype_intermission_type:
+		gt->intermission_type = luaL_checkinteger(L, 3);
+		break;
+	case gametype_rankings_type:
+		gt->rankings_type = luaL_checkinteger(L, 3);
+		break;
+	case gametype_pointlimit:
+		gt->pointlimit = luaL_checkinteger(L, 3);
+		break;
+	case gametype_timelimit:
+		gt->timelimit = luaL_checkinteger(L, 3);
+		break;
+	case gametype_teams:
+		if (lua_istable(L, 3))
+		{
+			gt->teams.num = 0;
+			memset(gt->teams.list, TEAM_NONE, sizeof(gt->teams.list));
+
+			lua_pushnil(L);
+
+			while (lua_next(L, 3)) {
+				lua_Integer i = luaL_checkinteger(L, -2) - 1;
+				if (i >= 0 && i < MAXTEAMS)
+				{
+					int team_index = luaL_checkinteger(L, -1);
+					if (team_index <= 0 || team_index >= numteams)
+						luaL_error(L, "team index %d out of range (1 - %d)", team_index, numteams-1);
+
+					gt->teams.list[i] = (UINT8)team_index;
+
+					if ((lua_Integer)gt->teams.num < i + 1)
+						gt->teams.num = (UINT8)i + 1;
+				}
+
+				lua_pop(L, 1);
+			}
+
+			if (gametype == gametype_id)
+			{
+				teamsingame = gt->teams.num;
+				G_UpdateTeamSelection();
+			}
+		}
+		else
+		{
+			teamlist_t *teamlist = *((teamlist_t **)luaL_checkudata(L, 3, META_TEAMLIST));
+
+			memcpy(&gt->teams, teamlist, sizeof(teamlist_t));
+
+			if (gametype == gametype_id)
+			{
+				teamsingame = gt->teams.num;
+				G_UpdateTeamSelection();
+			}
+		}
+		break;
+	default:
+		return luaL_error(L, LUA_QL("gametype_t") " has no field named " LUA_QS, gametype_opt[field]);
+	}
+	return 0;
+}
+
+static int gametype_num(lua_State *L)
+{
+	gametype_t *gt = *((gametype_t **)luaL_checkudata(L, 1, META_GAMETYPE));
+
+	I_Assert(gt != NULL);
+	I_Assert(gt >= gametypes);
+
+	lua_pushinteger(L, gt-gametypes);
+	return 1;
+}
+
+///////////
+// TEAMS //
+///////////
+
+enum team_e
+{
+	team_name,
+	team_flag_name,
+	team_flag,
+	team_flag_mobj_type,
+	team_weapon_mobj_type,
+	team_missile_mobj_type,
+	team_color,
+	team_weapon_color,
+	team_missile_color,
+	team_icon,
+	team_icon_flag,
+	team_icon_got_flag,
+	team_icon_missing_flag
+};
+
+const char *const team_opt[] = {
+	"name",
+	"flag_name",
+	"flag",
+	"flag_mobj_type",
+	"weapon_mobj_type",
+	"missile_mobj_type",
+	"color",
+	"weapon_color",
+	"missile_color",
+	"icon",
+	"flag_icon",
+	"captured_flag_icon",
+	"missing_flag_icon",
+	NULL,
+};
+
+static int team_fields_ref = LUA_NOREF;
+
+static int lib_getTeams(lua_State *L)
+{
+	INT16 i;
+	lua_remove(L, 1);
+
+	i = luaL_checkinteger(L, 1);
+	if (i < 0 || i >= numteams)
+		return luaL_error(L, "teams[] index %d out of range (0 - %d)", i, max(0, (int)numteams - 1));
+	LUA_PushUserdata(L, &teams[i], META_GAMETYPE);
+	return 1;
+}
+
+static int set_team_field(lua_State *L, team_t *team, enum team_e field)
+{
+	switch (field)
+	{
+	case team_name:
+		Z_Free(team->name);
+		team->name = Z_StrDup(luaL_checkstring(L, 3));
+		G_UpdateTeamSelection();
+		break;
+	case team_flag_name:
+		Z_Free(team->flag_name);
+		team->flag_name = Z_StrDup(luaL_checkstring(L, 3));
+		break;
+	case team_flag:
+		team->flag = (UINT16)luaL_checkinteger(L, 3);
+		break;
+	case team_flag_mobj_type:
+	{
+		mobjtype_t type = luaL_checkinteger(L, 3);
+		if (type >= NUMMOBJTYPES)
+		{
+			luaL_error(L, "mobj type %d out of range (0 - %d)", type, NUMMOBJTYPES-1);
+			return 0;
+		}
+		team->flag_mobj_type = type;
+		break;
+	}
+	case team_weapon_mobj_type:
+	{
+		mobjtype_t type = luaL_checkinteger(L, 3);
+		if (type >= NUMMOBJTYPES)
+		{
+			luaL_error(L, "mobj type %d out of range (0 - %d)", type, NUMMOBJTYPES-1);
+			return 0;
+		}
+		team->weapon_mobj_type = type;
+		break;
+	}
+	case team_missile_mobj_type:
+	{
+		mobjtype_t type = luaL_checkinteger(L, 3);
+		if (type >= NUMMOBJTYPES)
+		{
+			luaL_error(L, "mobj type %d out of range (0 - %d)", type, NUMMOBJTYPES-1);
+			return 0;
+		}
+		team->missile_mobj_type = type;
+		break;
+	}
+	case team_color:
+	{
+		UINT16 newcolor = (UINT16)luaL_checkinteger(L, 3);
+		if (newcolor >= numskincolors)
+		{
+			luaL_error(L, "skincolor %d out of range (0 - %d).", newcolor, numskincolors-1);
+			return 0;
+		}
+		team->color = newcolor;
+		break;
+	}
+	case team_weapon_color:
+	{
+		UINT16 newcolor = (UINT16)luaL_checkinteger(L, 3);
+		if (newcolor >= numskincolors)
+		{
+			luaL_error(L, "skincolor %d out of range (0 - %d).", newcolor, numskincolors-1);
+			return 0;
+		}
+		team->weapon_color = newcolor;
+		break;
+	}
+	case team_missile_color:
+	{
+		UINT16 newcolor = (UINT16)luaL_checkinteger(L, 3);
+		if (newcolor >= numskincolors)
+		{
+			luaL_error(L, "skincolor %d out of range (0 - %d).", newcolor, numskincolors-1);
+			return 0;
+		}
+		team->missile_color = newcolor;
+		break;
+	}
+	case team_icon:
+		G_SetTeamIcon(team - teams, TEAM_ICON, luaL_checkstring(L, 3));
+		ST_LoadTeamIcons();
+		break;
+	case team_icon_flag:
+		G_SetTeamIcon(team - teams, TEAM_ICON_FLAG, luaL_checkstring(L, 3));
+		ST_LoadTeamIcons();
+		break;
+	case team_icon_got_flag:
+		G_SetTeamIcon(team - teams, TEAM_ICON_GOT_FLAG, luaL_checkstring(L, 3));
+		ST_LoadTeamIcons();
+		break;
+	case team_icon_missing_flag:
+		G_SetTeamIcon(team - teams, TEAM_ICON_MISSING_FLAG, luaL_checkstring(L, 3));
+		ST_LoadTeamIcons();
+		break;
+	default:
+		return -1;
+	}
+	return 1;
+}
+
+static int lib_setTeams(lua_State *L)
+{
+	UINT32 teamnum;
+	team_t *team;
+	lua_remove(L, 1);
+	{
+		teamnum = luaL_checkinteger(L, 1);
+		if (teamnum >= numteams)
+			return luaL_error(L, "teams[] index %d out of range (0 - %d)", teamnum, max(0, (int)numteams - 1));
+		team = &teams[teamnum];
+	}
+	luaL_checktype(L, 2, LUA_TTABLE);
+	lua_remove(L, 1);
+	lua_settop(L, 1);
+
+	if (hud_running)
+		return luaL_error(L, "Do not alter team data in HUD rendering code!");
+	if (hook_cmd_running)
+		return luaL_error(L, "Do not alter team data in CMD building code!");
+
+	G_InitTeam(teamnum);
+
+	lua_pushnil(L);
+	while (lua_next(L, 1)) {
+		const char *str = luaL_checkstring(L, 2);
+		int field = -1;
+
+		for (int i = 0; team_opt[i]; i++) {
+			if (fastcmp(str, team_opt[i]))
+			{
+				field = i;
+				break;
+			}
+		}
+
+		if (field != -1)
+			set_team_field(L, team, field);
+		else
+			luaL_error(L, LUA_QL("team_t") " has no field named " LUA_QS, str);
+
+		lua_pop(L, 1);
+	}
+	return 0;
+}
+
+// #teams -> numteams
+static int lib_teamslen(lua_State *L)
+{
+	lua_pushinteger(L, numteams);
+	return 1;
+}
+
+static int team_get(lua_State *L)
+{
+	team_t *team = *((team_t **)luaL_checkudata(L, 1, META_GAMETYPE));
+	enum team_e field = Lua_optoption(L, 2, team_name, team_fields_ref);
+
+	I_Assert(team != NULL);
+	I_Assert(team >= teams);
+
+	switch (field)
+	{
+	case team_name:
+		lua_pushstring(L, team->name);
+		break;
+	case team_flag_name:
+		lua_pushstring(L, team->flag_name);
+		break;
+	case team_flag:
+		lua_pushinteger(L, team->flag);
+		break;
+	case team_flag_mobj_type:
+		lua_pushinteger(L, team->flag_mobj_type);
+		break;
+	case team_weapon_mobj_type:
+		lua_pushinteger(L, team->weapon_mobj_type);
+		break;
+	case team_missile_mobj_type:
+		lua_pushinteger(L, team->missile_mobj_type);
+		break;
+	case team_color:
+		lua_pushinteger(L, team->color);
+		break;
+	case team_weapon_color:
+		lua_pushinteger(L, team->weapon_color);
+		break;
+	case team_missile_color:
+		lua_pushinteger(L, team->missile_color);
+		break;
+	case team_icon:
+		if (G_HasTeamIcon(team - teams, TEAM_ICON))
+			lua_pushstring(L, G_GetTeamIcon(team - teams, TEAM_ICON));
+		else
+			lua_pushnil(L);
+		break;
+	case team_icon_flag:
+		if (G_HasTeamIcon(team - teams, TEAM_ICON_FLAG))
+			lua_pushstring(L, G_GetTeamIcon(team - teams, TEAM_ICON_FLAG));
+		else
+			lua_pushnil(L);
+		break;
+	case team_icon_got_flag:
+		if (G_HasTeamIcon(team - teams, TEAM_ICON_GOT_FLAG))
+			lua_pushstring(L, G_GetTeamIcon(team - teams, TEAM_ICON_GOT_FLAG));
+		else
+			lua_pushnil(L);
+		break;
+	case team_icon_missing_flag:
+		if (G_HasTeamIcon(team - teams, TEAM_ICON_MISSING_FLAG))
+			lua_pushstring(L, G_GetTeamIcon(team - teams, TEAM_ICON_MISSING_FLAG));
+		else
+			lua_pushnil(L);
+		break;
+	default:
+		return luaL_error(L, LUA_QL("team_t") " has no field named " LUA_QS, lua_tostring(L, 2));
+	}
+	return 1;
+}
+
+static int team_set(lua_State *L)
+{
+	team_t *team = *((team_t **)luaL_checkudata(L, 1, META_GAMETYPE));
+	enum team_e field = Lua_optoption(L, 2, -1, team_fields_ref);
+
+	if (!lua_lumploading)
+		return luaL_error(L, "Do not alter team data from within a hook or coroutine!");
+	if (hud_running)
+		return luaL_error(L, "Do not alter team data in HUD rendering code!");
+	if (hook_cmd_running)
+		return luaL_error(L, "Do not alter team data in CMD building code!");
+
+	I_Assert(team != NULL);
+	I_Assert(team >= teams);
+
+	if (set_team_field(L, team, field) < 0)
+		return luaL_error(L, LUA_QL("team_t") " has no field named " LUA_QS, lua_tostring(L, 2));
+
+	return 0;
+}
+
+static int team_num(lua_State *L)
+{
+	team_t *team = *((team_t **)luaL_checkudata(L, 1, META_GAMETYPE));
+
+	I_Assert(team != NULL);
+	I_Assert(team >= teams);
+
+	lua_pushinteger(L, team-teams);
+	return 1;
+}
+
+static int teamlist_get(lua_State *L)
+{
+	teamlist_t *teamlist = *((teamlist_t **)luaL_checkudata(L, 1, META_TEAMLIST));
+	int i = luaL_checkinteger(L, 2);
+	if (i <= 0 || i > teamlist->num)
+		return luaL_error(L, "array index %d out of range (1 - %d)", i, teamlist->num);
+	lua_pushinteger(L, teamlist->list[i - 1]);
+	return 1;
+}
+
+static int teamlist_set(lua_State *L)
+{
+	teamlist_t *teamlist = *((teamlist_t **)luaL_checkudata(L, 1, META_TEAMLIST));
+	int i = luaL_checkinteger(L, 2);
+	int team = luaL_checkinteger(L, 3);
+	if (i <= 0 || i > teamlist->num)
+		return luaL_error(L, "array index %d out of range (1 - %d)", i, teamlist->num);
+	if (team <= 0 || team >= numteams)
+		return luaL_error(L, "team index %d out of range (1 - %d)", team, numteams - 1);
+	teamlist->list[i - 1] = (UINT8)team;
+	return 0;
+}
+
+static int teamlist_len(lua_State *L)
+{
+	teamlist_t *teamlist = *((teamlist_t **)luaL_checkudata(L, 1, META_TEAMLIST));
+	lua_pushinteger(L, teamlist->num);
+	return 1;
+}
+
+static int teamscores_get(lua_State *L)
+{
+	UINT32 *scoreslist = *((UINT32 **)luaL_checkudata(L, 1, META_TEAMSCORES));
+	int team = luaL_checkinteger(L, 2);
+	if (team <= 0 || team >= numteams)
+		return luaL_error(L, "team index %d out of range (1 - %d)", team, max(0, (int)numteams - 1));
+	lua_pushinteger(L, scoreslist[team]);
+	return 1;
+}
+
+static int teamscores_set(lua_State *L)
+{
+	UINT32 *scoreslist = *((UINT32 **)luaL_checkudata(L, 1, META_TEAMSCORES));
+	int team = luaL_checkinteger(L, 2);
+	UINT32 score = (UINT32)luaL_checkinteger(L, 3);
+	if (team <= 0 || team >= numteams)
+		return luaL_error(L, "array index %d out of range (1 - %d)", team, max(0, (int)numteams - 1));
+	scoreslist[team] = score;
+	return 0;
+}
+
+static int teamscores_len(lua_State *L)
+{
+	lua_pushinteger(L, max(0, numteams - 1));
+	return 1;
+}
+
+///////////////////
+// PLAYER STARTS //
+///////////////////
+
+static int playerstarts_get(lua_State *L)
+{
+	playerstarts_t *starts = *((playerstarts_t **)luaL_checkudata(L, 1, META_PLAYERSTARTS));
+	int index = luaL_checkinteger(L, 2);
+	if (index < 0 || index >= (signed)starts->count)
+		return luaL_error(L, "player start index %d out of range (0 - %d)", index, max(0, (int)starts->count - 1));
+	LUA_PushUserdata(L, starts->list[index], META_MAPTHING);
+	return 1;
+}
+
+static int playerstarts_set(lua_State *L)
+{
+	playerstarts_t *starts = *((playerstarts_t **)luaL_checkudata(L, 1, META_PLAYERSTARTS));
+	int index = luaL_checkinteger(L, 2);
+	mapthing_t *mthing = *((mapthing_t **)luaL_checkudata(L, 3, META_MAPTHING));
+	if (index < 0 || index >= (signed)starts->count)
+		return luaL_error(L, "player start index %d out of range (0 - %d)", index, max(0, (int)starts->count - 1));
+	if (!mthing)
+		return LUA_ErrInvalid(L, "mapthing_t");
+	starts->list[index] = mthing;
+	return 0;
+}
+
+static int playerstarts_len(lua_State *L)
+{
+	playerstarts_t *starts = *((playerstarts_t **)luaL_checkudata(L, 1, META_PLAYERSTARTS));
+	lua_pushinteger(L, starts->count);
+	return 1;
+}
+
+static int lib_getTeamstarts(lua_State *L)
+{
+	lua_remove(L, 1);
+
+	int i = luaL_checkinteger(L, 1);
+	if (i <= 0 || i >= numteams)
+		return luaL_error(L, "team index %d out of range (1 - %d)", i, numteams - 1);
+
+	LUA_PushUserdata(L, &teamstarts[i], META_PLAYERSTARTS);
+	return 1;
+}
+
+static int lib_teamstartslen(lua_State *L)
+{
+	lua_pushinteger(L, max(0, numteams - 1));
+	return 1;
+}
+
 //////////////////////////////
 //
 // Now push all these functions into the Lua state!
@@ -1917,6 +2525,11 @@ int LUA_InfoLib(lua_State *L)
 
 	LUA_RegisterUserdataMetatable(L, META_STATE, state_get, state_set, state_num);
 	LUA_RegisterUserdataMetatable(L, META_MOBJINFO, mobjinfo_get, mobjinfo_set, mobjinfo_num);
+	LUA_RegisterUserdataMetatable(L, META_GAMETYPE, gametype_get, gametype_set, gametype_num);
+	LUA_RegisterUserdataMetatable(L, META_TEAM, team_get, team_set, team_num);
+	LUA_RegisterUserdataMetatable(L, META_TEAMLIST, teamlist_get, teamlist_set, teamlist_len);
+	LUA_RegisterUserdataMetatable(L, META_TEAMSCORES, teamscores_get, teamscores_set, teamscores_len);
+	LUA_RegisterUserdataMetatable(L, META_PLAYERSTARTS, playerstarts_get, playerstarts_set, playerstarts_len);
 	LUA_RegisterUserdataMetatable(L, META_SKINCOLOR, skincolor_get, skincolor_set, skincolor_num);
 	LUA_RegisterUserdataMetatable(L, META_COLORRAMP, colorramp_get, colorramp_set, colorramp_len);
 	LUA_RegisterUserdataMetatable(L, META_SFXINFO, sfxinfo_get, sfxinfo_set, sfxinfo_num);
@@ -1926,12 +2539,16 @@ int LUA_InfoLib(lua_State *L)
 	LUA_RegisterUserdataMetatable(L, META_LUABANKS, lib_getluabanks, lib_setluabanks, lib_luabankslen);
 
 	mobjinfo_fields_ref = Lua_CreateFieldTable(L, mobjinfo_opt);
+	team_fields_ref = Lua_CreateFieldTable(L, team_opt);
 
 	LUA_RegisterGlobalUserdata(L, "sprnames", lib_getSprname, NULL, lib_sprnamelen);
 	LUA_RegisterGlobalUserdata(L, "spr2names", lib_getSpr2name, NULL, lib_spr2namelen);
 	LUA_RegisterGlobalUserdata(L, "spr2defaults", lib_getSpr2default, lib_setSpr2default, lib_spr2namelen);
 	LUA_RegisterGlobalUserdata(L, "states", lib_getState, lib_setState, lib_statelen);
 	LUA_RegisterGlobalUserdata(L, "mobjinfo", lib_getMobjInfo, lib_setMobjInfo, lib_mobjinfolen);
+	LUA_RegisterGlobalUserdata(L, "gametypes", lib_getGametypes, NULL, lib_gametypeslen);
+	LUA_RegisterGlobalUserdata(L, "teams", lib_getTeams, lib_setTeams, lib_teamslen);
+	LUA_RegisterGlobalUserdata(L, "teamstarts", lib_getTeamstarts, NULL, lib_teamstartslen);
 	LUA_RegisterGlobalUserdata(L, "skincolors", lib_getSkinColor, lib_setSkinColor, lib_skincolorslen);
 	LUA_RegisterGlobalUserdata(L, "spriteinfo", lib_getSpriteInfo, lib_setSpriteInfo, lib_spriteinfolen);
 	LUA_RegisterGlobalUserdata(L, "sfxinfo", lib_getSfxInfo, lib_setSfxInfo, lib_sfxlen);

src/lua_libs.h

@@ -29,6 +29,11 @@ extern boolean ignoregameinputs;
 #define META_SKINCOLOR "SKINCOLOR_T*"
 #define META_COLORRAMP "SKINCOLOR_T*RAMP"
 #define META_SPRITEINFO "SPRITEINFO_T*"
+#define META_GAMETYPE "GAMETYPE_T*"
+#define META_TEAM "TEAM_T*"
+#define META_TEAMLIST "TEAMLIST_T*"
+#define META_TEAMSCORES "TEAMSCORES"
+#define META_PLAYERSTARTS "PLAYERSTARTS"
 #define META_PIVOTLIST "SPRITEFRAMEPIVOT_T[]"
 #define META_FRAMEPIVOT "SPRITEFRAMEPIVOT_T*"