Esempio n. 1
0
//
// Display level completion time and par,
//  or "sucks" message if overflow.
//
void WI_drawTime(int x, int y, int t)
{
	int     div;
	int     n;

	if(t < 0)
		return;

	if(t <= 61 * 59)
	{
		div = 1;
		do
		{
			n = (t / div) % 60;
			x = WI_drawNum(x, y, n, 2) - SHORT(colon.width);
			div *= 60;

			// draw
			if(div == 60 || t / div)
				WI_DrawPatch(x, y, colon.lump);

		} while(t / div);
	}
	else
	{
		// "sucks"
		WI_DrawPatch(x - SHORT(sucks.width), y, sucks.lump);
	}
}
Esempio n. 2
0
void WI_drawStats(void)
{
	// line height
	int     lh;

	lh = (3 * SHORT(num[0].height)) / 2;

	WI_slamBackground();

	// draw animated background
	WI_drawAnimatedBack();

	WI_drawLF();

	WI_DrawPatch(SP_STATSX, SP_STATSY, kills.lump);
	WI_drawPercent(SCREENWIDTH - SP_STATSX, SP_STATSY, cnt_kills[0]);

	WI_DrawPatch(SP_STATSX, SP_STATSY + lh, items.lump);
	WI_drawPercent(SCREENWIDTH - SP_STATSX, SP_STATSY + lh, cnt_items[0]);

	WI_DrawPatch(SP_STATSX, SP_STATSY + 2 * lh, sp_secret.lump);
	WI_drawPercent(SCREENWIDTH - SP_STATSX, SP_STATSY + 2 * lh, cnt_secret[0]);

	WI_DrawPatch(SP_TIMEX, SP_TIMEY, time.lump);
	WI_drawTime(SCREENWIDTH / 2 - SP_TIMEX, SP_TIMEY, cnt_time);

	if(wbs->epsd < 3)
	{
		WI_DrawPatch(SCREENWIDTH / 2 + SP_TIMEX, SP_TIMEY, par.lump);
		WI_drawTime(SCREENWIDTH - SP_TIMEX, SP_TIMEY, cnt_par);
	}

}
Esempio n. 3
0
// Draws "Entering <LevelName>"
void WI_drawEL(void)
{
	int     y = WI_TITLEY;

	// draw "Entering"
	WI_DrawPatch((SCREENWIDTH - SHORT(entering.width)) / 2, y, entering.lump);

	// draw level
	y += (5 * SHORT(lnames[wbs->next].height)) / 4;

	WI_DrawPatch((SCREENWIDTH - SHORT(lnames[wbs->next].width)) / 2, y,
				 lnames[wbs->next].lump);
}
Esempio n. 4
0
// Draws "<Levelname> Finished!"
void WI_drawLF(void)
{
	int     y = WI_TITLEY;

	// draw <LevelName> 
	WI_DrawPatch((SCREENWIDTH - SHORT(lnames[wbs->last].width)) / 2, y,
				 lnames[wbs->last].lump);

	// draw "Finished!"
	y += (5 * SHORT(lnames[wbs->last].height)) / 4;

	WI_DrawPatch((SCREENWIDTH - SHORT(finished.width)) / 2, y, finished.lump);
}
Esempio n. 5
0
// 
// A fairly efficient way to draw a number
//  based on differences from the old number.
// Note: worth the trouble?
//
void STlib_drawNum(st_number_t * n, boolean refresh)
{
	int     numdigits = n->width;
	int     num = *n->num;

	int     w = SHORT(n->p[0].width);
	int     x = n->x;

	int     neg;

	n->oldnum = *n->num;

	neg = num < 0;

	if(neg)
	{
		if(numdigits == 2 && num < -9)
			num = -9;
		else if(numdigits == 3 && num < -99)
			num = -99;
		num = -num;
	}

	// clear the area
	x = n->x - numdigits * w;

	// if non-number, do not draw it
	if(num == 1994)
		return;

	x = n->x;

	// in the special case of 0, you draw 0
	if(!num)
		WI_DrawPatch(x - w, n->y, n->p[0].lump);

	// draw the new number
	while(num && numdigits--)
	{
		x -= w;
		WI_DrawPatch(x, n->y, n->p[num % 10].lump);
		num /= 10;
	}

	// draw a minus sign if necessary
	if(neg)
		WI_DrawPatch(x - 8, n->y, sttminus_i);
}
Esempio n. 6
0
void STlib_updateMultIcon(st_multicon_t * mi, boolean refresh)
{
	/*int           w;
	   int          h;
	   int          x;
	   int          y; */

	if(*mi->on && (mi->oldinum != *mi->inum || refresh) && (*mi->inum != -1))
	{
		/*if (mi->oldinum != -1)
		   {
		   x = mi->x - SHORT(mi->p[mi->oldinum].patch->leftoffset);
		   y = mi->y - SHORT(mi->p[mi->oldinum].patch->topoffset);
		   w = SHORT(mi->p[mi->oldinum].patch->width);
		   h = SHORT(mi->p[mi->oldinum].patch->height);

		   if (y - ST_Y < 0)
		   I_Error("updateMultIcon: y - ST_Y < 0");

		   //           V_CopyRect(x, y-ST_Y, BG, w, h, x, y, FG);
		   } */
		WI_DrawPatch(mi->x, mi->y, mi->p[*mi->inum].lump);
		mi->oldinum = *mi->inum;
	}
}
Esempio n. 7
0
void STlib_updatePercent(st_percent_t * per, int refresh)
{
	if(refresh && *per->n.on)
		WI_DrawPatch(per->n.x, per->n.y, per->p->lump);

	STlib_updateNum(&per->n, refresh);
}
Esempio n. 8
0
void WI_drawOnLnode(int n, dpatch_t * c)
{
	int     i;
	int     left;
	int     top;
	int     right;
	int     bottom;
	boolean fits = false;

	i = 0;
	do
	{
		left = lnodes[wbs->epsd][n].x - SHORT(c[i].leftoffset);
		top = lnodes[wbs->epsd][n].y - SHORT(c[i].topoffset);
		right = left + SHORT(c[i].width);
		bottom = top + SHORT(c[i].height);
		if(left >= 0 && right < SCREENWIDTH && top >= 0 &&
		   bottom < SCREENHEIGHT)
			fits = true;
		else
			i++;
	} while(!fits && i != 2);

	if(fits && i < 2)
	{
		WI_DrawPatch(lnodes[wbs->epsd][n].x, lnodes[wbs->epsd][n].y,
					 c[i].lump);
	}
	else
	{
		// DEBUG
		Con_Message("Could not place patch on level %d", n + 1);
	}
}
Esempio n. 9
0
int WI_drawNum(int x, int y, int n, int digits)
{
	int     fontwidth = SHORT(num[0].width);
	int     neg;
	int     temp;

	if(digits < 0)
	{
		if(!n)
		{
			// make variable-length zeros 1 digit long
			digits = 1;
		}
		else
		{
			// figure out # of digits in #
			digits = 0;
			temp = n;
			while(temp)
			{
				temp /= 10;
				digits++;
			}
		}
	}
	neg = n < 0;
	if(neg)
		n = -n;

	// if non-number, do not draw it
	if(n == 1994)
		return 0;

	// draw the new number
	while(digits--)
	{
		x -= fontwidth;
		WI_DrawPatch(x, y, num[n % 10].lump);
		n /= 10;
	}

	// draw a minus sign if necessary
	if(neg)
		WI_DrawPatch(x -= 8, y, wiminus.lump);

	return x;
}
Esempio n. 10
0
void STlib_updateBinIcon(st_binicon_t * bi, boolean refresh)
{
	if(*bi->on && (bi->oldval != *bi->val || refresh))
	{
		WI_DrawPatch(bi->x, bi->y, bi->p->lump);
		bi->oldval = *bi->val;
	}
}
Esempio n. 11
0
void WI_drawPercent(int x, int y, int p)
{
	if(p < 0)
		return;

	WI_DrawPatch(x, y, percent.lump);
	WI_drawNum(x, y, p, -1);
}
Esempio n. 12
0
void WI_drawAnimatedBack(void)
{
	int     i;
	wianim_t *a;

	if(gamemode == commercial)
		return;
	if(wbs->epsd > 2)
		return;

	for(i = 0; i < NUMANIMS[wbs->epsd]; i++)
	{
		a = &anims[wbs->epsd][i];
		if(a->ctr >= 0)
			WI_DrawPatch(a->loc.x, a->loc.y, a->p[a->ctr].lump);
	}

}
Esempio n. 13
0
void LabelWidget::draw() const
{
    fontid_t fontId           = mnRendState->textFonts[font()];
    Vector4f const &textColor = mnRendState->textColors[color()];
//    float t = (isFocused()? 1 : 0);

//    // Flash if focused.
//    if(isFocused() && cfg.common.menuTextFlashSpeed > 0)
//    {
//        float const speed = cfg.common.menuTextFlashSpeed / 2.f;
//        t = (1 + sin(page().timer() / (float)TICSPERSEC * speed * DD_PI)) / 2;
//    }

//    Vector4f const color = de::lerp(textColor, Vector4f(Vector3f(cfg.common.menuTextFlashColor), textColor.w), t);

    const Vector4f color = selectionFlashColor(textColor);

    const float fadeout = scrollingFadeout();
    if (fadeout < .001f) return;

    DGL_Color4f(1, 1, 1, color.w * fadeout);
    FR_SetFont(fontId);
    FR_SetColorAndAlpha(color.x, color.y, color.z, color.w * fadeout);

    if (d->patch)
    {
        String replacement;
        if(!(d->flags & MNTEXT_NO_ALTTEXT))
        {
            replacement = Hu_ChoosePatchReplacement(patchreplacemode_t(cfg.common.menuPatchReplaceMode), *d->patch, d->text);
        }

        DGL_Enable(DGL_TEXTURE_2D);
        WI_DrawPatch(*d->patch, replacement, geometry().topLeft, ALIGN_TOPLEFT, 0, Hu_MenuMergeEffectWithDrawTextFlags(0));
        DGL_Disable(DGL_TEXTURE_2D);

        return;
    }

    DGL_Enable(DGL_TEXTURE_2D);
    FR_DrawTextXY3(d->text.toUtf8().constData(), geometry().topLeft.x, geometry().topLeft.y, ALIGN_TOPLEFT, Hu_MenuMergeEffectWithDrawTextFlags(0));
    DGL_Disable(DGL_TEXTURE_2D);
}
Esempio n. 14
0
void D_Display(void)
{
	static boolean viewactivestate = false;
	static boolean menuactivestate = false;
	static boolean inhelpscreensstate = false;
	static boolean fullscreen = false;
	static gamestate_t oldgamestate = -1;
	int     y;
	boolean redrawsbar;
	player_t *player = &players[displayplayer];
	boolean iscam = (player->plr->flags & DDPF_CAMERA) != 0;	// $democam

	if(nodrawers)
		return;					// for comparative timing / profiling

	redrawsbar = false;

	// $democam: can be set on every frame
	if(setblocks > 10 || iscam)
	{
		// Full screen.
		R_ViewWindow(0, 0, 320, 200);
	}
	else
	{
		int     w = setblocks * 32;
		int     h = setblocks * (200 - ST_HEIGHT * cfg.sbarscale / 20) / 10;

		R_ViewWindow(160 - (w >> 1),
					 (200 - ST_HEIGHT * cfg.sbarscale / 20 - h) >> 1, w, h);
	}

	// Do buffered drawing.
	switch (gamestate)
	{
	case GS_LEVEL:
		if(IS_CLIENT && (!Get(DD_GAME_READY) || !Get(DD_GOTFRAME)))
			break;
		if(leveltime < 2)
		{
			// Don't render too early; the first couple of frames 
			// might be a bit unstable -- this should be considered
			// a bug, but since there's an easy fix...
			break;
		}
		if(!automapactive || cfg.automapAlpha < 1)
		{
			// Draw the player view.
			if(IS_CLIENT)
			{
				// Server updates mobj flags in NetSv_Ticker.
				R_SetAllDoomsdayFlags();
			}
			// Don't draw self.
			Set(DD_VIEWANGLE_OFFSET, ANGLE_MAX * -lookOffset);
			GL_SetFilter(players[displayplayer].plr->filter);	// $democam
			// How about fullbright?
			Set(DD_FULLBRIGHT, (player->powers[pw_infrared] > 4 * 32) ||
				(player->powers[pw_infrared] & 8) ||
				player->powers[pw_invulnerability] > 30);

			// Render the view with possible custom filters.
			R_RenderPlayerView(players[displayplayer].plr);

			R_DrawSpecialFilter();
			// Crosshair.
			if(!iscam)
				X_Drawer();		// $democam
		}
		if(automapactive)
			AM_Drawer();

		// Level information is shown for a few seconds in the 
		// beginning of a level.
		R_DrawLevelTitle();

		if((viewheight != 200))
			redrawsbar = true;
		if(inhelpscreensstate && !inhelpscreens)
			redrawsbar = true;	// just put away the help screen
		if(!iscam)
			ST_Drawer(viewheight == 200, redrawsbar);	// $democam
		fullscreen = viewheight == 200;
		HU_Drawer();
		// Need to update the borders?
		if(oldgamestate != GS_LEVEL ||
		   ((Get(DD_VIEWWINDOW_WIDTH) != 320 || menuactive ||
			 cfg.sbarscale < 20)))
		{
			// Update the borders.
			GL_Update(DDUF_BORDER);
		}
		break;

	case GS_INTERMISSION:
		WI_Drawer();
		break;

	case GS_WAITING:
		gl.Clear(DGL_COLOR_BUFFER_BIT);
		M_WriteText2(5, 188, "WAITING... PRESS ESC FOR MENU", hu_font_a, 1, 0,
					 0);

	default:
		break;
	}

	GL_Update(DDUF_FULLSCREEN);

	menuactivestate = menuactive;
	viewactivestate = viewactive;
	inhelpscreensstate = inhelpscreens;
	oldgamestate = wipegamestate = gamestate;

	// draw pause pic (but not if InFine active)
	if(paused && !fi_active)
	{
		if(automapactive)
			y = 4;
		else
			y = viewwindowy + 4;

		WI_DrawPatch(126, y, W_GetNumForName("M_PAUSE"));
	}

	// InFine is drawn whenever active.
	FI_Drawer();
}
Esempio n. 15
0
void WI_drawNetgameStats(void)
{
	int     i;
	int     x;
	int     y;
	int     pwidth = SHORT(percent.width);

	WI_slamBackground();

	// draw animated background
	WI_drawAnimatedBack();

	WI_drawLF();

	// draw stat titles (top line)
	WI_DrawPatch(NG_STATSX + NG_SPACINGX - SHORT(kills.width), NG_STATSY,
				 kills.lump);

	WI_DrawPatch(NG_STATSX + 2 * NG_SPACINGX - SHORT(items.width), NG_STATSY,
				 items.lump);

	WI_DrawPatch(NG_STATSX + 3 * NG_SPACINGX - SHORT(secret.width), NG_STATSY,
				 secret.lump);

	if(dofrags)
		WI_DrawPatch(NG_STATSX + 4 * NG_SPACINGX - SHORT(frags.width),
					 NG_STATSY, frags.lump);

	// draw stats
	y = NG_STATSY + SHORT(kills.height);

	for(i = 0; i < NUM_TEAMS; i++)
	{
		if(!teaminfo[i].members)
			continue;

		x = NG_STATSX;
		WI_DrawPatch(x - SHORT(p[i].width), y, p[i].lump);
		// If more than 1 member, show the member count.
		if(teaminfo[i].members > 1)
		{
			char    tmp[40];

			sprintf(tmp, "%i", teaminfo[i].members);
			M_WriteText2(x - p[i].width + 1, y + p[i].height - 8, tmp,
						 hu_font_a, 1, 1, 1);
		}

		if(i == myteam)
			WI_DrawPatch(x - SHORT(p[i].width), y, star.lump);

		x += NG_SPACINGX;
		WI_drawPercent(x - pwidth, y + 10, cnt_kills[i]);
		x += NG_SPACINGX;
		WI_drawPercent(x - pwidth, y + 10, cnt_items[i]);
		x += NG_SPACINGX;
		WI_drawPercent(x - pwidth, y + 10, cnt_secret[i]);
		x += NG_SPACINGX;

		if(dofrags)
			WI_drawNum(x, y + 10, cnt_frags[i], -1);

		y += WI_SPACINGY;
	}
}
Esempio n. 16
0
void WI_drawDeathmatchStats(void)
{
	int     i;
	int     j;
	int     x;
	int     y;
	int     w;

	int     lh;					// line height

	lh = WI_SPACINGY;

	WI_slamBackground();

	// draw animated background
	WI_drawAnimatedBack();
	WI_drawLF();

	// draw stat titles (top line)
	WI_DrawPatch(DM_TOTALSX - SHORT(total.width) / 2,
				 DM_MATRIXY - WI_SPACINGY + 10, total.lump);

	WI_DrawPatch(DM_KILLERSX, DM_KILLERSY, killers.lump);
	WI_DrawPatch(DM_VICTIMSX, DM_VICTIMSY, victims.lump);

	// draw P?
	x = DM_MATRIXX + DM_SPACINGX;
	y = DM_MATRIXY;

	for(i = 0; i < NUM_TEAMS; i++)
	{
		if(teaminfo[i].members)
		{
			WI_DrawPatch(x - SHORT(p[i].width) / 2, DM_MATRIXY - WI_SPACINGY,
						 p[i].lump);

			WI_DrawPatch(DM_MATRIXX - SHORT(p[i].width) / 2, y, p[i].lump);

			if(i == myteam)
			{
				WI_DrawPatch(x - SHORT(p[i].width) / 2,
							 DM_MATRIXY - WI_SPACINGY, bstar.lump);

				WI_DrawPatch(DM_MATRIXX - SHORT(p[i].width) / 2, y, star.lump);
			}

			// If more than 1 member, show the member count.
			if(teaminfo[i].members > 1)
			{
				char    tmp[20];

				sprintf(tmp, "%i", teaminfo[i].members);
				M_WriteText2(x - p[i].width / 2 + 1,
							 DM_MATRIXY - WI_SPACINGY + p[i].height - 8, tmp,
							 hu_font_a, 1, 1, 1);
				M_WriteText2(DM_MATRIXX - p[i].width / 2 + 1,
							 y + p[i].height - 8, tmp, hu_font_a, 1, 1, 1);
			}
		}
		else
		{
			WI_DrawPatch(x - SHORT(bp[i].width) / 2, DM_MATRIXY - WI_SPACINGY,
						 bp[i].lump);
			WI_DrawPatch(DM_MATRIXX - SHORT(bp[i].width) / 2, y, bp[i].lump);
		}
		x += DM_SPACINGX;
		y += WI_SPACINGY;
	}

	// draw stats
	y = DM_MATRIXY + 10;
	w = SHORT(num[0].width);

	for(i = 0; i < NUM_TEAMS; i++)
	{
		x = DM_MATRIXX + DM_SPACINGX;
		if(teaminfo[i].members)
		{
			for(j = 0; j < NUM_TEAMS; j++)
			{
				if(teaminfo[j].members)
					WI_drawNum(x + w, y, dm_frags[i][j], 2);
				x += DM_SPACINGX;
			}
			WI_drawNum(DM_TOTALSX + w, y, dm_totals[i], 2);
		}
		y += WI_SPACINGY;
	}
}