Merge remote-tracking branch 'origin/v1' into v1

src/config.h.in

@@ -52,7 +52,7 @@
 #define ASSET_HASH_CHARS_KART    "e2c428347dde52858a3dacd29fc5b964"
 #define ASSET_HASH_MAPS_KART     "1335cd064656aedca359cfbb5233ac4a"
 #ifdef USE_PATCH_KART
-#define ASSET_HASH_PATCH_KART    "6461b30bb20754a16a1b582120f55842"
+#define ASSET_HASH_PATCH_KART    "7093231f2c3c1cca1a909a708be85d9a"
 #endif
 
 #endif

src/k_kart.c

@@ -8189,6 +8189,11 @@ static void K_drawBattleFullscreen(void)
 	INT32 y = -64+(stplyr->kartstuff[k_cardanimation]); // card animation goes from 0 to 164, 164 is the middle of the screen
 	INT32 splitflags = V_SNAPTOTOP; // I don't feel like properly supporting non-green resolutions, so you can have a misuse of SNAPTO instead
 	fixed_t scale = FRACUNIT;
+	boolean drawcomebacktimer = true;	// lazy hack because it's cleaner in the long run.
+#ifdef HAVE_BLUA
+	if (!LUA_HudEnabled(hud_battlecomebacktimer))
+		drawcomebacktimer = false;
+#endif
 
 	if (splitscreen)
 	{
@@ -8240,7 +8245,7 @@ static void K_drawBattleFullscreen(void)
 		else
 			K_drawKartFinish();
 	}
-	else if (stplyr->kartstuff[k_bumper] <= 0 && stplyr->kartstuff[k_comebacktimer] && comeback && !stplyr->spectator)
+	else if (stplyr->kartstuff[k_bumper] <= 0 && stplyr->kartstuff[k_comebacktimer] && comeback && !stplyr->spectator && drawcomebacktimer)
 	{
 		UINT16 t = stplyr->kartstuff[k_comebacktimer]/(10*TICRATE);
 		INT32 txoff, adjust = (splitscreen > 1) ? 4 : 6; // normal string is 8, kart string is 12, half of that for ease
@@ -8798,7 +8803,10 @@ void K_drawKartHUD(void)
 
 	if (battlefullscreen)
 	{
-		K_drawBattleFullscreen();
+#ifdef HAVE_BLUA
+		if (LUA_HudEnabled(hud_battlefullscreen))
+#endif
+			K_drawBattleFullscreen();
 		return;
 	}
 

src/lua_hud.h

@@ -21,6 +21,8 @@ enum hud {
 	hud_position,
 	hud_minirankings,	// Rankings to the left
 	hud_battlebumpers,	// mini rankings battle bumpers.
+	hud_battlefullscreen,	// battle huge text (WAIT, WIN, LOSE ...) + karma comeback time
+	hud_battlecomebacktimer,	// comeback timer in battlefullscreen. separated for ease of use.
 	hud_wanted,
 	hud_speedometer,
 	hud_freeplay,

src/lua_hudlib.c

@@ -48,6 +48,8 @@ static const char *const hud_disable_options[] = {
 	"position",
 	"minirankings",	// Gametype rankings to the left
 	"battlerankingsbumpers",	// bumper drawer for battle. Useful if you want to make a custom battle gamemode without bumpers being involved.
+	"battlefullscreen",			// battlefullscreen func (WAIT, ATTACK OR PROTECT ...)
+	"battlecomebacktimer",		// come back timer in battlefullscreen
 	"wanted",
 	"speedometer",
 	"freeplay",
@@ -381,6 +383,179 @@ static int libd_drawScaled(lua_State *L)
 	return 0;
 }
 
+// KART: draw patch on minimap from x, y coordinates on the map
+static int libd_drawOnMinimap(lua_State *L)
+{
+	fixed_t x, y, scale;	// coordinates of the object
+	patch_t *patch;	// patch we want to draw
+	const UINT8 *colormap = NULL;	// do we want to colormap this patch?
+	boolean centered;	// the patch is centered and doesn't need readjusting on x/y coordinates.
+
+	// variables used to replicate k_kart's mmap drawer:
+	INT32 lumpnum;
+	patch_t *AutomapPic;
+	INT32 mx, my;
+	INT32 splitflags, minimaptrans;
+
+	// base position of the minimap which also takes splits into account:
+	INT32 MM_X, MM_Y;
+
+	// variables used for actually drawing the icon:
+	fixed_t amnumxpos, amnumypos;
+	INT32 amxpos, amypos;
+
+	node_t *bsp = &nodes[numnodes-1];
+	fixed_t maxx, minx, maxy, miny;
+
+	fixed_t mapwidth, mapheight;
+	fixed_t xoffset, yoffset;
+	fixed_t xscale, yscale, zoom;
+	fixed_t patchw, patchh;
+
+	HUDONLY	// only run this function in hud hooks
+	x = luaL_checkinteger(L, 1);
+	y = luaL_checkinteger(L, 2);
+	scale = luaL_checkinteger(L, 3);
+	patch = *((patch_t **)luaL_checkudata(L, 4, META_PATCH));
+	if (!lua_isnoneornil(L, 5))
+		colormap = *((UINT8 **)luaL_checkudata(L, 5, META_COLORMAP));
+	centered = lua_optboolean(L, 6);
+
+	// replicate exactly what source does for its minimap drawer; AKA hardcoded garbo.
+
+	// first, check what position the mmap is supposed to be in (pasted from k_kart.c):
+	MM_X = BASEVIDWIDTH - 50;		// 270
+	MM_Y = (BASEVIDHEIGHT/2)-16; //  84
+	if (splitscreen)
+	{
+		MM_Y = (BASEVIDHEIGHT/2);
+		if (splitscreen > 1)	// 3P : bottom right
+		{
+			MM_X = (3*BASEVIDWIDTH/4);
+			MM_Y = (3*BASEVIDHEIGHT/4);
+
+			if (splitscreen > 2) // 4P: centered
+			{
+				MM_X = (BASEVIDWIDTH/2);
+				MM_Y = (BASEVIDHEIGHT/2);
+			}
+		}
+	}
+
+	// splitscreen flags
+	splitflags = (splitscreen == 3 ? 0 : V_SNAPTORIGHT);	// flags should only be 0 when it's centered (4p split)
+
+	// translucency:
+	if (timeinmap > 105)
+	{
+		minimaptrans = cv_kartminimap.value;
+		if (timeinmap <= 113)
+			minimaptrans = ((((INT32)timeinmap) - 105)*minimaptrans)/(113-105);
+		if (!minimaptrans)
+			return 0;
+	}
+	else
+		return 0;
+
+
+	minimaptrans = ((10-minimaptrans)<<FF_TRANSSHIFT);
+	splitflags |= minimaptrans;
+
+	if (!(splitscreen == 2))
+	{
+		splitflags &= ~minimaptrans;
+		splitflags |= V_HUDTRANSHALF;
+	}
+
+	splitflags &= ~V_HUDTRANSHALF;
+	splitflags |= V_HUDTRANS;
+
+	// Draw the HUD only when playing in a level.
+	// hu_stuff needs this, unlike st_stuff.
+	if (gamestate != GS_LEVEL)
+		return 0;
+
+	if (stplyr != &players[displayplayers[0]])
+		return 0;
+
+	lumpnum = W_CheckNumForName(va("%sR", G_BuildMapName(gamemap)));
+
+	if (lumpnum != -1)
+		AutomapPic = W_CachePatchName(va("%sR", G_BuildMapName(gamemap)), PU_HUDGFX);
+	else
+		return 0; // no pic, just get outta here
+
+	mx = MM_X - (AutomapPic->width/2);
+	my = MM_Y - (AutomapPic->height/2);
+
+	// let offsets transfer to the heads, too!
+	if (encoremode)
+		mx += SHORT(AutomapPic->leftoffset);
+	else
+		mx -= SHORT(AutomapPic->leftoffset);
+	my -= SHORT(AutomapPic->topoffset);
+
+	// now that we have replicated this behavior, we can draw an icon from our supplied x, y coordinates by replicating k_kart.c's totally understandable uncommented code!!!
+
+	// get map boundaries using nodes
+	maxx = maxy = INT32_MAX;
+	minx = miny = INT32_MIN;
+	minx = bsp->bbox[0][BOXLEFT];
+	maxx = bsp->bbox[0][BOXRIGHT];
+	miny = bsp->bbox[0][BOXBOTTOM];
+	maxy = bsp->bbox[0][BOXTOP];
+
+	if (bsp->bbox[1][BOXLEFT] < minx)
+		minx = bsp->bbox[1][BOXLEFT];
+	if (bsp->bbox[1][BOXRIGHT] > maxx)
+		maxx = bsp->bbox[1][BOXRIGHT];
+	if (bsp->bbox[1][BOXBOTTOM] < miny)
+		miny = bsp->bbox[1][BOXBOTTOM];
+	if (bsp->bbox[1][BOXTOP] > maxy)
+		maxy = bsp->bbox[1][BOXTOP];
+
+	// You might be wondering why these are being bitshift here
+	// it's because mapwidth and height would otherwise overflow for maps larger than half the size possible...
+	// map boundaries and sizes will ALWAYS be whole numbers thankfully
+	// later calculations take into consideration that these are actually not in terms of FRACUNIT though
+	minx >>= FRACBITS;
+	maxx >>= FRACBITS;
+	miny >>= FRACBITS;
+	maxy >>= FRACBITS;
+
+	// these are our final map boundaries:
+	mapwidth = maxx - minx;
+	mapheight = maxy - miny;
+
+	// These should always be small enough to be bitshift back right now
+	xoffset = (minx + mapwidth/2)<<FRACBITS;
+	yoffset = (miny + mapheight/2)<<FRACBITS;
+
+	xscale = FixedDiv(AutomapPic->width, mapwidth);
+	yscale = FixedDiv(AutomapPic->height, mapheight);
+	zoom = FixedMul(min(xscale, yscale), FRACUNIT-FRACUNIT/20);
+
+	amnumxpos = (FixedMul(x, zoom) - FixedMul(xoffset, zoom));
+	amnumypos = -(FixedMul(y, zoom) - FixedMul(yoffset, zoom));
+
+	if (encoremode)
+		amnumxpos = -amnumxpos;
+
+	// scale patch coords
+	patchw = patch->width*scale /2;
+	patchh = patch->height*scale /2;
+
+	if (centered)
+		patchw = patchh = 0;	// patch is supposedly already centered, don't butt in.
+
+	amxpos = amnumxpos + ((mx + AutomapPic->width/2)<<FRACBITS) - patchw;
+	amypos = amnumypos + ((my + AutomapPic->height/2)<<FRACBITS) - patchh;
+
+	// and NOW we can FINALLY DRAW OUR GOD DAMN PATCH :V
+	V_DrawFixedPatch(amxpos, amypos, scale, splitflags, patch, colormap);
+	return 0;
+}
+
 static int libd_drawNum(lua_State *L)
 {
 	INT32 x, y, flags, num;
@@ -644,6 +819,7 @@ static luaL_Reg lib_draw[] = {
 	{"dupy", libd_dupy},
 	{"renderer", libd_renderer},
 	{"localTransFlag", libd_getlocaltransflag},
+	{"drawOnMinimap", libd_drawOnMinimap},
 	{NULL, NULL}
 };
 

src/p_map.c

@@ -1076,7 +1076,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
 				S_StartSound(tmthing, sfx_bsnipe);
 
 			// Player Damage
-			K_SpinPlayer(tmthing->player, thing->target, 0, tmthing, (thing->type == MT_BANANA || thing->type == MT_BANANA_SHIELD));
+			K_SpinPlayer(tmthing->player, thing->target, 0, thing, (thing->type == MT_BANANA || thing->type == MT_BANANA_SHIELD));
 
 			// Other Item Damage
 			if (thing->eflags & MFE_VERTICALFLIP)
@@ -1111,7 +1111,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
 			if (thing->state == &states[S_MINEEXPLOSION1])
 				K_ExplodePlayer(tmthing->player, thing->target, thing);
 			else
-				K_SpinPlayer(tmthing->player, thing->target, 0, tmthing, false);
+				K_SpinPlayer(tmthing->player, thing->target, 0, thing, false);
 
 			return true;
 		}

src/v_video.c

@@ -2404,7 +2404,7 @@ INT32 V_ThinStringWidth(const char *string, INT32 option)
 
 boolean *heatshifter = NULL;
 INT32 lastheight = 0;
-INT32 heatindex[2] = { 0, 0 };
+INT32 heatindex[MAXSPLITSCREENPLAYERS] = {0, 0, 0, 0};
 
 //
 // V_DoPostProcessor
@@ -2537,11 +2537,6 @@ Unoptimized version
 		UINT8 *srcscr = screens[0];
 		INT32 y;
 
-#if 0
-		if (splitscreen > 1) // 3P/4P has trouble supporting this, anyone want to fix it? :p
-			return;
-#endif
-
 		// Make sure table is built
 		if (heatshifter == NULL || lastheight != viewheight)
 		{
@@ -2556,7 +2551,7 @@ Unoptimized version
 					heatshifter[y] = true;
 			}
 
-			heatindex[0] = heatindex[1] = 0;
+			heatindex[0] = heatindex[1] = heatindex[2] = heatindex[3] = 0;
 			lastheight = viewheight;
 		}