void CMenus::RenderPlayers(CUIRect MainView)
{
CUIRect Button, ButtonBar, Options, Player;
RenderTools()->DrawUIRect(&MainView, ms_ColorTabbarActive, CUI::CORNER_ALL, 10.0f);
// player options
MainView.Margin(10.0f, &Options);
RenderTools()->DrawUIRect(&Options, vec4(1.0f, 1.0f, 1.0f, 0.25f), CUI::CORNER_ALL, 10.0f);
Options.Margin(10.0f, &Options);
Options.HSplitTop(50.0f, &Button, &Options);
UI()->DoLabelScaled(&Button, Localize("Player options"), 34.0f, -1);
// headline
Options.HSplitTop(34.0f, &ButtonBar, &Options);
ButtonBar.VSplitRight(240.0f, &Player, &ButtonBar);
UI()->DoLabelScaled(&Player, Localize("Player"), 24.0f, -1);
ButtonBar.HMargin(1.0f, &ButtonBar);
float Width = ButtonBar.h*2.0f;
ButtonBar.VSplitLeft(Width, &Button, &ButtonBar);
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_GUIICONS].m_Id);
Graphics()->QuadsBegin();
RenderTools()->SelectSprite(SPRITE_GUIICON_MUTE);
IGraphics::CQuadItem QuadItem(Button.x, Button.y, Button.w, Button.h);
Graphics()->QuadsDrawTL(&QuadItem, 1);
Graphics()->QuadsEnd();
ButtonBar.VSplitLeft(20.0f, 0, &ButtonBar);
ButtonBar.VSplitLeft(Width, &Button, &ButtonBar);
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_GUIICONS].m_Id);
Graphics()->QuadsBegin();
RenderTools()->SelectSprite(SPRITE_GUIICON_FRIEND);
QuadItem = IGraphics::CQuadItem(Button.x, Button.y, Button.w, Button.h);
Graphics()->QuadsDrawTL(&QuadItem, 1);
Graphics()->QuadsEnd();
ButtonBar.VSplitLeft(20.0f, 0, &ButtonBar);
ButtonBar.VSplitLeft(Width, &Button, &ButtonBar);
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_GUIICONS].m_Id);
Graphics()->QuadsBegin();
RenderTools()->SelectSprite(SPRITE_GUIICON_ENEMY);
QuadItem = IGraphics::CQuadItem(Button.x, Button.y, Button.w, Button.h);
Graphics()->QuadsDrawTL(&QuadItem, 1);
Graphics()->QuadsEnd();
int NumPlayers = 0;
for(int i = 0; i < MAX_CLIENTS; i++)
{
if(!m_pClient->m_Snap.m_paInfoByTeam[i] || m_pClient->m_Snap.m_paInfoByTeam[i]->m_ClientID == m_pClient->m_Snap.m_LocalClientID)
continue;
NumPlayers++;
}
static float s_ScrollValue = 0.0f;
int OldSelected = -1;
UiDoListboxStart(&s_ScrollValue, &Options, 25.0f, Localize(""), "", NumPlayers, 1, OldSelected, s_ScrollValue);
// options
static int s_aPlayerIDs[MAX_CLIENTS][3] = {{0}};
for(int i = 0, Count = 0; i < MAX_CLIENTS; ++i)
{
if(!m_pClient->m_Snap.m_paInfoByTeam[i])
continue;
int Index = m_pClient->m_Snap.m_paInfoByTeam[i]->m_ClientID;
if(Index == m_pClient->m_Snap.m_LocalClientID)
continue;
Count++;
CListboxItem Item = UiDoListboxNextItem(&m_pClient->m_Snap.m_paInfoByTeam[i], OldSelected == i);
if(!Item.m_Visible)
continue;
Item.m_Rect.HSplitTop(28.0f, &ButtonBar, &Options);
if(Count%2 == 0)
RenderTools()->DrawUIRect(&ButtonBar, vec4(1.0f, 1.0f, 1.0f, 0.25f), CUI::CORNER_ALL, 10.0f);
ButtonBar.VSplitRight(220.0f, &Player, &ButtonBar);
// player info
Player.VSplitLeft(28.0f, &Button, &Player);
CTeeRenderInfo Info = m_pClient->m_aClients[Index].m_RenderInfo;
Info.m_Size = Button.h;
RenderTools()->RenderTee(CAnimState::GetIdle(), &Info, EMOTE_NORMAL, vec2(1.0f, 0.0f), vec2(Button.x+Button.h/2, Button.y+Button.h/2));
Player.HSplitTop(1.5f, 0, &Player);
Player.VSplitMid(&Player, &Button);
CTextCursor Cursor;
TextRender()->SetCursor(&Cursor, Player.x, Player.y, 14.0f, TEXTFLAG_RENDER|TEXTFLAG_STOP_AT_END);
Cursor.m_LineWidth = Player.w;
TextRender()->TextEx(&Cursor, m_pClient->m_aClients[Index].m_aName, -1);
TextRender()->SetCursor(&Cursor, Button.x,Button.y, 14.0f, TEXTFLAG_RENDER|TEXTFLAG_STOP_AT_END);
Cursor.m_LineWidth = Button.w;
TextRender()->TextEx(&Cursor, m_pClient->m_aClients[Index].m_aClan, -1);
// ignore button
ButtonBar.HMargin(2.0f, &ButtonBar);
ButtonBar.VSplitLeft(Width, &Button, &ButtonBar);
Button.VSplitLeft((Width-Button.h)/4.0f, 0, &Button);
Button.VSplitLeft(Button.h, &Button, 0);
if(g_Config.m_ClShowChatFriends && !m_pClient->m_aClients[Index].m_Friend)
DoButton_Toggle(&s_aPlayerIDs[Index][0], 1, &Button, false);
else
if(DoButton_Toggle(&s_aPlayerIDs[Index][0], m_pClient->m_aClients[Index].m_ChatIgnore, &Button, true))
m_pClient->m_aClients[Index].m_ChatIgnore ^= 1;
// friend button
ButtonBar.VSplitLeft(20.0f, &Button, &ButtonBar);
ButtonBar.VSplitLeft(Width, &Button, &ButtonBar);
Button.VSplitLeft((Width-Button.h)/4.0f, 0, &Button);
Button.VSplitLeft(Button.h, &Button, 0);
if(DoButton_Toggle(&s_aPlayerIDs[Index][1], m_pClient->m_aClients[Index].m_Friend == 1, &Button, true))
{
if(m_pClient->m_aClients[Index].m_Friend == 1)
m_pClient->Friends()->RemoveFriend(m_pClient->m_aClients[Index].m_aName, m_pClient->m_aClients[Index].m_aClan);
else
{
m_pClient->Friends()->RemoveFriend(m_pClient->m_aClients[Index].m_aName, m_pClient->m_aClients[Index].m_aClan);
m_pClient->Friends()->AddFriend(m_pClient->m_aClients[Index].m_aName, m_pClient->m_aClients[Index].m_aClan);
}
}
// enemy button
ButtonBar.VSplitLeft(20.0f, &Button, &ButtonBar);
ButtonBar.VSplitLeft(Width, &Button, &ButtonBar);
Button.VSplitLeft((Width - Button.h) / 4.0f, 0, &Button);
Button.VSplitLeft(Button.h, &Button, 0);
if(DoButton_Toggle(&s_aPlayerIDs[Index][2], m_pClient->m_aClients[Index].m_Friend == 2, &Button, true))
{
if(m_pClient->m_aClients[Index].m_Friend == 2)
m_pClient->Friends()->RemoveFriend(m_pClient->m_aClients[Index].m_aName, m_pClient->m_aClients[Index].m_aClan);
else
{
m_pClient->Friends()->RemoveFriend(m_pClient->m_aClients[Index].m_aName, m_pClient->m_aClients[Index].m_aClan);
m_pClient->Friends()->AddEnemy(m_pClient->m_aClients[Index].m_aName, m_pClient->m_aClients[Index].m_aClan);
}
}
}
const int NewSelected = UiDoListboxEnd(&s_ScrollValue, 0);
if(OldSelected != NewSelected)
{
/*if(pSelectedServer->m_aClients[NewSelected].m_FriendState == IFriends::FRIEND_PLAYER)
m_pClient->Friends()->RemoveFriend(pSelectedServer->m_aClients[NewSelected].m_aName, pSelectedServer->m_aClients[NewSelected].m_aClan);
else
m_pClient->Friends()->AddFriend(pSelectedServer->m_aClients[NewSelected].m_aName, pSelectedServer->m_aClients[NewSelected].m_aClan);
FriendlistOnUpdate();
Client()->ServerBrowserUpdate();*/
}
/*
CUIRect bars;
votearea.HSplitTop(10.0f, 0, &votearea);
votearea.HSplitTop(25.0f + 10.0f*3 + 25.0f, &votearea, &bars);
RenderTools()->DrawUIRect(&votearea, color_tabbar_active, CUI::CORNER_ALL, 10.0f);
votearea.VMargin(20.0f, &votearea);
votearea.HMargin(10.0f, &votearea);
votearea.HSplitBottom(35.0f, &votearea, &bars);
if(gameclient.voting->is_voting())
{
// do yes button
votearea.VSplitLeft(50.0f, &button, &votearea);
static int yes_button = 0;
if(UI()->DoButton(&yes_button, "Yes", 0, &button, ui_draw_menu_button, 0))
gameclient.voting->vote(1);
// do no button
votearea.VSplitLeft(5.0f, 0, &votearea);
votearea.VSplitLeft(50.0f, &button, &votearea);
static int no_button = 0;
if(UI()->DoButton(&no_button, "No", 0, &button, ui_draw_menu_button, 0))
gameclient.voting->vote(-1);
// do time left
votearea.VSplitRight(50.0f, &votearea, &button);
char buf[256];
str_format(buf, sizeof(buf), "%d", gameclient.voting->seconds_left());
UI()->DoLabel(&button, buf, 24.0f, 0);
// do description and command
votearea.VSplitLeft(5.0f, 0, &votearea);
UI()->DoLabel(&votearea, gameclient.voting->vote_description(), 14.0f, -1);
votearea.HSplitTop(16.0f, 0, &votearea);
UI()->DoLabel(&votearea, gameclient.voting->vote_command(), 10.0f, -1);
// do bars
bars.HSplitTop(10.0f, 0, &bars);
bars.HMargin(5.0f, &bars);
gameclient.voting->render_bars(bars, true);
}
else
{
UI()->DoLabel(&votearea, "No vote in progress", 18.0f, -1);
}*/
}
void CMenus::RenderGame(CUIRect MainView)
{
CUIRect Button, ButtonBar;
MainView.HSplitTop(45.0f, &ButtonBar, &MainView);
RenderTools()->DrawUIRect(&ButtonBar, ms_ColorTabbarActive, CUI::CORNER_ALL, 10.0f);
// button bar
ButtonBar.HSplitTop(10.0f, 0, &ButtonBar);
ButtonBar.HSplitTop(25.0f, &ButtonBar, 0);
ButtonBar.VMargin(10.0f, &ButtonBar);
ButtonBar.VSplitRight(120.0f, &ButtonBar, &Button);
static int s_DisconnectButton = 0;
if(DoButton_Menu(&s_DisconnectButton, Localize("Disconnect"), 0, &Button))
Client()->Disconnect();
if(m_pClient->m_Snap.m_pLocalInfo && m_pClient->m_Snap.m_pGameInfoObj)
{
if(m_pClient->m_Snap.m_pLocalInfo->m_Team != TEAM_SPECTATORS)
{
ButtonBar.VSplitLeft(10.0f, 0, &ButtonBar);
ButtonBar.VSplitLeft(120.0f, &Button, &ButtonBar);
static int s_SpectateButton = 0;
if(DoButton_Menu(&s_SpectateButton, Localize("Spectate"), 0, &Button))
{
m_pClient->SendSwitchTeam(TEAM_SPECTATORS);
SetActive(false);
}
}
if(m_pClient->m_Snap.m_pGameInfoObj->m_GameFlags & GAMEFLAG_TEAMS)
{
if(m_pClient->m_Snap.m_pLocalInfo->m_Team != TEAM_RED)
{
ButtonBar.VSplitLeft(10.0f, 0, &ButtonBar);
ButtonBar.VSplitLeft(120.0f, &Button, &ButtonBar);
static int s_SpectateButton = 0;
if(DoButton_Menu(&s_SpectateButton, Localize("Join red"), 0, &Button))
{
m_pClient->SendSwitchTeam(TEAM_RED);
SetActive(false);
}
}
if(m_pClient->m_Snap.m_pLocalInfo->m_Team != TEAM_BLUE)
{
ButtonBar.VSplitLeft(10.0f, 0, &ButtonBar);
ButtonBar.VSplitLeft(120.0f, &Button, &ButtonBar);
static int s_SpectateButton = 0;
if(DoButton_Menu(&s_SpectateButton, Localize("Join blue"), 0, &Button))
{
m_pClient->SendSwitchTeam(TEAM_BLUE);
SetActive(false);
}
}
}
else
{
if(m_pClient->m_Snap.m_pLocalInfo->m_Team != 0)
{
ButtonBar.VSplitLeft(10.0f, 0, &ButtonBar);
ButtonBar.VSplitLeft(120.0f, &Button, &ButtonBar);
static int s_SpectateButton = 0;
if(DoButton_Menu(&s_SpectateButton, Localize("Join game"), 0, &Button))
{
m_pClient->SendSwitchTeam(0);
SetActive(false);
}
}
}
}
ButtonBar.VSplitLeft(100.0f, 0, &ButtonBar);
ButtonBar.VSplitLeft(150.0f, &Button, &ButtonBar);
static int s_DemoButton = 0;
bool Recording = DemoRecorder()->IsRecording();
if(DoButton_Menu(&s_DemoButton, Localize(Recording ? "Stop record" : "Record demo"), 0, &Button)) // Localize("Stop record");Localize("Record demo");
{
if(!Recording)
Client()->DemoRecorder_Start("demo", true);
else
Client()->DemoRecorder_Stop();
}
}
void CMenus::RenderNews(CUIRect MainView)
{
RenderTools()->DrawUIRect(&MainView, ms_ColorTabbarActive, CUI::CORNER_ALL, 10.0f);
}
void CMapLayers::OnRender()
{
if(Client()->State() != IClient::STATE_ONLINE && Client()->State() != IClient::STATE_DEMOPLAYBACK)
return;
CUIRect Screen;
Graphics()->GetScreen(&Screen.x, &Screen.y, &Screen.w, &Screen.h);
vec2 Center = m_pClient->m_pCamera->m_Center;
//float center_x = gameclient.camera->center.x;
//float center_y = gameclient.camera->center.y;
bool PassedGameLayer = false;
bool RenderBufferPassed = false;
bool RenderBufferRendered = false;
for(int g = 0; g < m_pLayers->NumGroups(); g++)
{
Graphics()->RenderToScreen();
CMapItemGroup *pGroup = m_pLayers->GetGroup(g);
if (PassedGameLayer && !RenderBufferRendered)
{
RenderBufferRendered = true;
// render tile buffer
RenderTools()->RenderFullScreenLayer();
}
if(!g_Config.m_GfxNoclip && pGroup->m_Version >= 2 && pGroup->m_UseClipping)
{
// set clipping
float Points[4];
MapScreenToGroup(Center.x, Center.y, m_pLayers->GameGroup());
Graphics()->GetScreen(&Points[0], &Points[1], &Points[2], &Points[3]);
float x0 = (pGroup->m_ClipX - Points[0]) / (Points[2]-Points[0]);
float y0 = (pGroup->m_ClipY - Points[1]) / (Points[3]-Points[1]);
float x1 = ((pGroup->m_ClipX+pGroup->m_ClipW) - Points[0]) / (Points[2]-Points[0]);
float y1 = ((pGroup->m_ClipY+pGroup->m_ClipH) - Points[1]) / (Points[3]-Points[1]);
Graphics()->ClipEnable((int)(x0*Graphics()->ScreenWidth()), (int)(y0*Graphics()->ScreenHeight()),
(int)((x1-x0)*Graphics()->ScreenWidth()), (int)((y1-y0)*Graphics()->ScreenHeight()));
}
MapScreenToGroup(Center.x, Center.y, pGroup);
for(int l = 0; l < pGroup->m_NumLayers; l++)
{
CMapItemLayer *pLayer = m_pLayers->GetLayer(pGroup->m_StartLayer+l);
bool Render = false;
bool IsGameLayer = false;
if(pLayer == (CMapItemLayer*)m_pLayers->GameLayer())
{
IsGameLayer = true;
PassedGameLayer = 1;
}
// skip rendering if detail layers if not wanted
if(pLayer->m_Flags&LAYERFLAG_DETAIL && !g_Config.m_GfxHighDetail && !IsGameLayer)
continue;
if(m_Type == -1)
Render = true;
else if(m_Type == 0)
{
if(PassedGameLayer)
return;
Render = true;
}
else
{
if(PassedGameLayer && !IsGameLayer)
Render = true;
}
// render some tile layers to texture for splatter
if (!RenderBufferPassed && PassedGameLayer && Render)
Graphics()->RenderToTexture(RENDERBUFFER_TILES);
else
Graphics()->RenderToScreen();
if(Render && pLayer->m_Type == LAYERTYPE_TILES && Input()->KeyPressed(KEY_LCTRL) && Input()->KeyPressed(KEY_LSHIFT) && Input()->KeyDown(KEY_KP_0))
{
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
CTile *pTiles = (CTile *)m_pLayers->Map()->GetData(pTMap->m_Data);
CServerInfo CurrentServerInfo;
Client()->GetServerInfo(&CurrentServerInfo);
char aFilename[256];
str_format(aFilename, sizeof(aFilename), "dumps/tilelayer_dump_%s-%d-%d-%dx%d.txt", CurrentServerInfo.m_aMap, g, l, pTMap->m_Width, pTMap->m_Height);
IOHANDLE File = Storage()->OpenFile(aFilename, IOFLAG_WRITE, IStorage::TYPE_SAVE);
if(File)
{
for(int y = 0; y < pTMap->m_Height; y++)
{
for(int x = 0; x < pTMap->m_Width; x++)
io_write(File, &(pTiles[y*pTMap->m_Width + x].m_Index), sizeof(pTiles[y*pTMap->m_Width + x].m_Index));
io_write_newline(File);
}
io_close(File);
}
}
if(Render && !IsGameLayer)
{
//layershot_begin();
if(pLayer->m_Type == LAYERTYPE_TILES)
{
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
if(pTMap->m_Image == -1)
Graphics()->TextureSet(-1);
else
Graphics()->TextureSet(m_pClient->m_pMapimages->Get(pTMap->m_Image));
CTile *pTiles = (CTile *)m_pLayers->Map()->GetData(pTMap->m_Data);
Graphics()->BlendNone();
vec4 Color = vec4(pTMap->m_Color.r/255.0f, pTMap->m_Color.g/255.0f, pTMap->m_Color.b/255.0f, pTMap->m_Color.a/255.0f);
RenderTools()->RenderTilemap(pTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_OPAQUE,
EnvelopeEval, this, pTMap->m_ColorEnv, pTMap->m_ColorEnvOffset);
Graphics()->BlendNormal();
RenderTools()->RenderTilemap(pTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_TRANSPARENT,
EnvelopeEval, this, pTMap->m_ColorEnv, pTMap->m_ColorEnvOffset);
}
else if(pLayer->m_Type == LAYERTYPE_QUADS)
{
CMapItemLayerQuads *pQLayer = (CMapItemLayerQuads *)pLayer;
if(pQLayer->m_Image == -1)
Graphics()->TextureSet(-1);
else
Graphics()->TextureSet(m_pClient->m_pMapimages->Get(pQLayer->m_Image));
CQuad *pQuads = (CQuad *)m_pLayers->Map()->GetDataSwapped(pQLayer->m_Data);
Graphics()->BlendNone();
RenderTools()->RenderQuads(pQuads, pQLayer->m_NumQuads, LAYERRENDERFLAG_OPAQUE, EnvelopeEval, this);
Graphics()->BlendNormal();
RenderTools()->RenderQuads(pQuads, pQLayer->m_NumQuads, LAYERRENDERFLAG_TRANSPARENT, EnvelopeEval, this);
}
//layershot_end();
}
}
if(!g_Config.m_GfxNoclip)
Graphics()->ClipDisable();
}
if (!RenderBufferRendered)
{
RenderBufferRendered = true;
// render tile buffer
RenderTools()->RenderFullScreenLayer();
}
if(!g_Config.m_GfxNoclip)
Graphics()->ClipDisable();
Graphics()->RenderToScreen();
Graphics()->BlendNormal();
// reset the screen like it was before
Graphics()->MapScreen(Screen.x, Screen.y, Screen.w, Screen.h);
//Graphics()->RenderToScreen();
//RenderTools()->RenderFullScreenLayer();
}
void CHud::RenderHealthAndAmmo(const CNetObj_Character *pCharacter)
{
if(!pCharacter)
return;
float x = 5;
float y = 5;
int i;
IGraphics::CQuadItem Array[10];
// render ammo
if(pCharacter->m_Weapon == WEAPON_NINJA)
{
Graphics()->TextureClear();
Graphics()->QuadsBegin();
Graphics()->SetColor(0.8f, 0.8f, 0.8f, 0.5f);
RenderTools()->DrawRoundRectExt(x,y+24, 118.0f, 10.0f, 0.0f, 0);
int Max = g_pData->m_Weapons.m_Ninja.m_Duration * Client()->GameTickSpeed() / 1000;
float Width = 116.0f * clamp(pCharacter->m_AmmoCount-Client()->GameTick(), 0, Max) / Max;
Graphics()->SetColor(0.9f, 0.2f, 0.2f, 0.85f);
RenderTools()->DrawRoundRectExt(x+1.0f, y+25.0f, Width, 8.0f, 0.0f, 0);
Graphics()->QuadsEnd();
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_GAME].m_Id);
Graphics()->QuadsBegin();
Graphics()->SetColor(1.0f, 1.0f, 1.0f, 1.0f);
RenderTools()->SelectSprite(g_pData->m_Weapons.m_aId[WEAPON_NINJA].m_pSpriteBody);
RenderTools()->DrawRoundRectExt(x+40.0f,y+25, 32.0f, 8.0f, 0.0f, 0);
}
else
{
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_GAME].m_Id);
Graphics()->QuadsBegin();
RenderTools()->SelectSprite(g_pData->m_Weapons.m_aId[pCharacter->m_Weapon%NUM_WEAPONS].m_pSpriteProj);
for(i = 0; i < min(pCharacter->m_AmmoCount, 10); i++)
Array[i] = IGraphics::CQuadItem(x+i*12,y+24,10,10);
Graphics()->QuadsDrawTL(Array, i);
}
int h = 0;
// render health
RenderTools()->SelectSprite(SPRITE_HEALTH_FULL);
for(; h < min(pCharacter->m_Health, 10); h++)
Array[h] = IGraphics::CQuadItem(x+h*12,y,10,10);
Graphics()->QuadsDrawTL(Array, h);
i = 0;
RenderTools()->SelectSprite(SPRITE_HEALTH_EMPTY);
for(; h < 10; h++)
Array[i++] = IGraphics::CQuadItem(x+h*12,y,10,10);
Graphics()->QuadsDrawTL(Array, i);
// render armor meter
h = 0;
RenderTools()->SelectSprite(SPRITE_ARMOR_FULL);
for(; h < min(pCharacter->m_Armor, 10); h++)
Array[h] = IGraphics::CQuadItem(x+h*12,y+12,10,10);
Graphics()->QuadsDrawTL(Array, h);
i = 0;
RenderTools()->SelectSprite(SPRITE_ARMOR_EMPTY);
for(; h < 10; h++)
Array[i++] = IGraphics::CQuadItem(x+h*12,y+12,10,10);
Graphics()->QuadsDrawTL(Array, i);
Graphics()->QuadsEnd();
}
void CPlayers::RenderPlayer(
const CNetObj_Character *pPrevChar,
const CNetObj_Character *pPlayerChar,
const CNetObj_PlayerInfo *pPrevInfo,
const CNetObj_PlayerInfo *pPlayerInfo,
int ClientID
)
{
CNetObj_Character Prev;
CNetObj_Character Player;
Prev = *pPrevChar;
Player = *pPlayerChar;
CNetObj_PlayerInfo pInfo = *pPlayerInfo;
CTeeRenderInfo RenderInfo = m_aRenderInfo[ClientID];
// set size
RenderInfo.m_Size = 64.0f;
float IntraTick = Client()->IntraGameTick();
float Angle = mix((float)Prev.m_Angle, (float)Player.m_Angle, IntraTick)/256.0f;
//float angle = 0;
if(m_pClient->m_LocalClientID == ClientID && Client()->State() != IClient::STATE_DEMOPLAYBACK)
{
// just use the direct input if it's local player we are rendering
Angle = GetAngle(m_pClient->m_pControls->m_MousePos);
}
else
{
/*
float mixspeed = Client()->FrameTime()*2.5f;
if(player.attacktick != prev.attacktick) // shooting boosts the mixing speed
mixspeed *= 15.0f;
// move the delta on a constant speed on a x^2 curve
float current = g_GameClient.m_aClients[info.cid].angle;
float target = player.angle/256.0f;
float delta = angular_distance(current, target);
float sign = delta < 0 ? -1 : 1;
float new_delta = delta - 2*mixspeed*sqrt(delta*sign)*sign + mixspeed*mixspeed;
// make sure that it doesn't vibrate when it's still
if(fabs(delta) < 2/256.0f)
angle = target;
else
angle = angular_approach(current, target, fabs(delta-new_delta));
g_GameClient.m_aClients[info.cid].angle = angle;*/
}
// use preditect players if needed
if(m_pClient->m_LocalClientID == ClientID && g_Config.m_ClPredict && Client()->State() != IClient::STATE_DEMOPLAYBACK)
{
if(!m_pClient->m_Snap.m_pLocalCharacter ||
(m_pClient->m_Snap.m_pGameData && m_pClient->m_Snap.m_pGameData->m_GameStateFlags&(GAMESTATEFLAG_PAUSED|GAMESTATEFLAG_ROUNDOVER|GAMESTATEFLAG_GAMEOVER)))
{
}
else
{
// apply predicted results
m_pClient->m_PredictedChar.Write(&Player);
m_pClient->m_PredictedPrevChar.Write(&Prev);
IntraTick = Client()->PredIntraGameTick();
}
}
vec2 Direction = GetDirection((int)(Angle*256.0f));
vec2 Position = mix(vec2(Prev.m_X, Prev.m_Y), vec2(Player.m_X, Player.m_Y), IntraTick);
vec2 Vel = mix(vec2(Prev.m_VelX/256.0f, Prev.m_VelY/256.0f), vec2(Player.m_VelX/256.0f, Player.m_VelY/256.0f), IntraTick);
m_pClient->m_pFlow->Add(Position, Vel*100.0f, 10.0f);
RenderInfo.m_GotAirJump = Player.m_Jumped&2?0:1;
bool Stationary = Player.m_VelX <= 1 && Player.m_VelX >= -1;
bool InAir = !Collision()->CheckPoint(Player.m_X, Player.m_Y+16);
bool WantOtherDir = (Player.m_Direction == -1 && Vel.x > 0) || (Player.m_Direction == 1 && Vel.x < 0);
// evaluate animation
float WalkTime = fmod(absolute(Position.x), 100.0f)/100.0f;
CAnimState State;
State.Set(&g_pData->m_aAnimations[ANIM_BASE], 0);
if(InAir)
State.Add(&g_pData->m_aAnimations[ANIM_INAIR], 0, 1.0f); // TODO: some sort of time here
else if(Stationary)
State.Add(&g_pData->m_aAnimations[ANIM_IDLE], 0, 1.0f); // TODO: some sort of time here
else if(!WantOtherDir)
State.Add(&g_pData->m_aAnimations[ANIM_WALK], WalkTime, 1.0f);
static float s_LastGameTickTime = Client()->GameTickTime();
if(m_pClient->m_Snap.m_pGameData && !(m_pClient->m_Snap.m_pGameData->m_GameStateFlags&GAMESTATEFLAG_PAUSED))
s_LastGameTickTime = Client()->GameTickTime();
if (Player.m_Weapon == WEAPON_HAMMER)
{
float ct = (Client()->PrevGameTick()-Player.m_AttackTick)/(float)SERVER_TICK_SPEED + s_LastGameTickTime;
State.Add(&g_pData->m_aAnimations[ANIM_HAMMER_SWING], clamp(ct*5.0f,0.0f,1.0f), 1.0f);
}
if (Player.m_Weapon == WEAPON_NINJA)
{
float ct = (Client()->PrevGameTick()-Player.m_AttackTick)/(float)SERVER_TICK_SPEED + s_LastGameTickTime;
State.Add(&g_pData->m_aAnimations[ANIM_NINJA_SWING], clamp(ct*2.0f,0.0f,1.0f), 1.0f);
}
// do skidding
if(!InAir && WantOtherDir && length(Vel*50) > 500.0f)
{
static int64 SkidSoundTime = 0;
if(time_get()-SkidSoundTime > time_freq()/10)
{
m_pClient->m_pSounds->PlayAt(CSounds::CHN_WORLD, SOUND_PLAYER_SKID, 0.25f, Position);
SkidSoundTime = time_get();
}
m_pClient->m_pEffects->SkidTrail(
Position+vec2(-Player.m_Direction*6,12),
vec2(-Player.m_Direction*100*length(Vel),-50)
);
}
// draw gun
{
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_GAME].m_Id);
Graphics()->QuadsBegin();
Graphics()->QuadsSetRotation(State.GetAttach()->m_Angle*pi*2+Angle);
// normal weapons
int iw = clamp(Player.m_Weapon, 0, NUM_WEAPONS-1);
RenderTools()->SelectSprite(g_pData->m_Weapons.m_aId[iw].m_pSpriteBody, Direction.x < 0 ? SPRITE_FLAG_FLIP_Y : 0);
vec2 Dir = Direction;
float Recoil = 0.0f;
vec2 p;
if (Player.m_Weapon == WEAPON_HAMMER)
{
// Static position for hammer
p = Position + vec2(State.GetAttach()->m_X, State.GetAttach()->m_Y);
p.y += g_pData->m_Weapons.m_aId[iw].m_Offsety;
// if attack is under way, bash stuffs
if(Direction.x < 0)
{
Graphics()->QuadsSetRotation(-pi/2-State.GetAttach()->m_Angle*pi*2);
p.x -= g_pData->m_Weapons.m_aId[iw].m_Offsetx;
}
else
{
Graphics()->QuadsSetRotation(-pi/2+State.GetAttach()->m_Angle*pi*2);
}
RenderTools()->DrawSprite(p.x, p.y, g_pData->m_Weapons.m_aId[iw].m_VisualSize);
}
else if (Player.m_Weapon == WEAPON_NINJA)
{
p = Position;
p.y += g_pData->m_Weapons.m_aId[iw].m_Offsety;
if(Direction.x < 0)
{
Graphics()->QuadsSetRotation(-pi/2-State.GetAttach()->m_Angle*pi*2);
p.x -= g_pData->m_Weapons.m_aId[iw].m_Offsetx;
m_pClient->m_pEffects->PowerupShine(p+vec2(32,0), vec2(32,12));
}
else
{
Graphics()->QuadsSetRotation(-pi/2+State.GetAttach()->m_Angle*pi*2);
m_pClient->m_pEffects->PowerupShine(p-vec2(32,0), vec2(32,12));
}
RenderTools()->DrawSprite(p.x, p.y, g_pData->m_Weapons.m_aId[iw].m_VisualSize);
// HADOKEN
if ((Client()->GameTick()-Player.m_AttackTick) <= (SERVER_TICK_SPEED / 6) && g_pData->m_Weapons.m_aId[iw].m_NumSpriteMuzzles)
{
int IteX = rand() % g_pData->m_Weapons.m_aId[iw].m_NumSpriteMuzzles;
static int s_LastIteX = IteX;
if(Client()->State() == IClient::STATE_DEMOPLAYBACK)
{
const IDemoPlayer::CInfo *pInfo = DemoPlayer()->BaseInfo();
if(pInfo->m_Paused)
IteX = s_LastIteX;
else
s_LastIteX = IteX;
}
else
{
if(m_pClient->m_Snap.m_pGameData && m_pClient->m_Snap.m_pGameData->m_GameStateFlags&GAMESTATEFLAG_PAUSED)
IteX = s_LastIteX;
else
s_LastIteX = IteX;
}
if(g_pData->m_Weapons.m_aId[iw].m_aSpriteMuzzles[IteX])
{
vec2 Dir = vec2(pPlayerChar->m_X,pPlayerChar->m_Y) - vec2(pPrevChar->m_X, pPrevChar->m_Y);
Dir = normalize(Dir);
float HadOkenAngle = GetAngle(Dir);
Graphics()->QuadsSetRotation(HadOkenAngle );
//float offsety = -data->weapons[iw].muzzleoffsety;
RenderTools()->SelectSprite(g_pData->m_Weapons.m_aId[iw].m_aSpriteMuzzles[IteX], 0);
vec2 DirY(-Dir.y,Dir.x);
p = Position;
float OffsetX = g_pData->m_Weapons.m_aId[iw].m_Muzzleoffsetx;
p -= Dir * OffsetX;
RenderTools()->DrawSprite(p.x, p.y, 160.0f);
}
}
}
else
{
// TODO: should be an animation
Recoil = 0;
static float s_LastIntraTick = IntraTick;
if(m_pClient->m_Snap.m_pGameData && !(m_pClient->m_Snap.m_pGameData->m_GameStateFlags&GAMESTATEFLAG_PAUSED))
s_LastIntraTick = IntraTick;
float a = (Client()->GameTick()-Player.m_AttackTick+s_LastIntraTick)/5.0f;
if(a < 1)
Recoil = sinf(a*pi);
p = Position + Dir * g_pData->m_Weapons.m_aId[iw].m_Offsetx - Dir*Recoil*10.0f;
p.y += g_pData->m_Weapons.m_aId[iw].m_Offsety;
RenderTools()->DrawSprite(p.x, p.y, g_pData->m_Weapons.m_aId[iw].m_VisualSize);
}
if (Player.m_Weapon == WEAPON_GUN || Player.m_Weapon == WEAPON_SHOTGUN)
{
// check if we're firing stuff
if(g_pData->m_Weapons.m_aId[iw].m_NumSpriteMuzzles)//prev.attackticks)
{
float Alpha = 0.0f;
int Phase1Tick = (Client()->GameTick() - Player.m_AttackTick);
if (Phase1Tick < (g_pData->m_Weapons.m_aId[iw].m_Muzzleduration + 3))
{
float t = ((((float)Phase1Tick) + IntraTick)/(float)g_pData->m_Weapons.m_aId[iw].m_Muzzleduration);
Alpha = mix(2.0f, 0.0f, min(1.0f,max(0.0f,t)));
}
int IteX = rand() % g_pData->m_Weapons.m_aId[iw].m_NumSpriteMuzzles;
static int s_LastIteX = IteX;
if(Client()->State() == IClient::STATE_DEMOPLAYBACK)
{
const IDemoPlayer::CInfo *pInfo = DemoPlayer()->BaseInfo();
if(pInfo->m_Paused)
IteX = s_LastIteX;
else
s_LastIteX = IteX;
}
else
{
if(m_pClient->m_Snap.m_pGameData && m_pClient->m_Snap.m_pGameData->m_GameStateFlags&GAMESTATEFLAG_PAUSED)
IteX = s_LastIteX;
else
s_LastIteX = IteX;
}
if (Alpha > 0.0f && g_pData->m_Weapons.m_aId[iw].m_aSpriteMuzzles[IteX])
{
float OffsetY = -g_pData->m_Weapons.m_aId[iw].m_Muzzleoffsety;
RenderTools()->SelectSprite(g_pData->m_Weapons.m_aId[iw].m_aSpriteMuzzles[IteX], Direction.x < 0 ? SPRITE_FLAG_FLIP_Y : 0);
if(Direction.x < 0)
OffsetY = -OffsetY;
vec2 DirY(-Dir.y,Dir.x);
vec2 MuzzlePos = p + Dir * g_pData->m_Weapons.m_aId[iw].m_Muzzleoffsetx + DirY * OffsetY;
RenderTools()->DrawSprite(MuzzlePos.x, MuzzlePos.y, g_pData->m_Weapons.m_aId[iw].m_VisualSize);
}
}
}
Graphics()->QuadsEnd();
switch (Player.m_Weapon)
{
case WEAPON_GUN: RenderHand(&RenderInfo, p, Direction, -3*pi/4, vec2(-15, 4)); break;
case WEAPON_SHOTGUN: RenderHand(&RenderInfo, p, Direction, -pi/2, vec2(-5, 4)); break;
case WEAPON_GRENADE: RenderHand(&RenderInfo, p, Direction, -pi/2, vec2(-4, 7)); break;
}
}
// render the "shadow" tee
if(m_pClient->m_LocalClientID == ClientID && g_Config.m_Debug)
{
vec2 GhostPosition = mix(vec2(pPrevChar->m_X, pPrevChar->m_Y), vec2(pPlayerChar->m_X, pPlayerChar->m_Y), Client()->IntraGameTick());
CTeeRenderInfo Ghost = RenderInfo;
for(int p = 0; p < CSkins::NUM_SKINPARTS; p++)
Ghost.m_aColors[p].a *= 0.5f;
RenderTools()->RenderTee(&State, &Ghost, Player.m_Emote, Direction, GhostPosition); // render ghost
}
RenderTools()->RenderTee(&State, &RenderInfo, Player.m_Emote, Direction, Position);
if(pInfo.m_PlayerFlags&PLAYERFLAG_CHATTING)
{
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_EMOTICONS].m_Id);
Graphics()->QuadsBegin();
RenderTools()->SelectSprite(SPRITE_DOTDOT);
IGraphics::CQuadItem QuadItem(Position.x + 24, Position.y - 40, 64,64);
Graphics()->QuadsDraw(&QuadItem, 1);
Graphics()->QuadsEnd();
}
if (m_pClient->m_aClients[ClientID].m_EmoticonStart != -1 && m_pClient->m_aClients[ClientID].m_EmoticonStart + 2 * Client()->GameTickSpeed() > Client()->GameTick())
{
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_EMOTICONS].m_Id);
Graphics()->QuadsBegin();
int SinceStart = Client()->GameTick() - m_pClient->m_aClients[ClientID].m_EmoticonStart;
int FromEnd = m_pClient->m_aClients[ClientID].m_EmoticonStart + 2 * Client()->GameTickSpeed() - Client()->GameTick();
float a = 1;
if (FromEnd < Client()->GameTickSpeed() / 5)
a = FromEnd / (Client()->GameTickSpeed() / 5.0);
float h = 1;
if (SinceStart < Client()->GameTickSpeed() / 10)
h = SinceStart / (Client()->GameTickSpeed() / 10.0);
float Wiggle = 0;
if (SinceStart < Client()->GameTickSpeed() / 5)
Wiggle = SinceStart / (Client()->GameTickSpeed() / 5.0);
float WiggleAngle = sinf(5*Wiggle);
Graphics()->QuadsSetRotation(pi/6*WiggleAngle);
Graphics()->SetColor(1.0f,1.0f,1.0f,a);
// client_datas::emoticon is an offset from the first emoticon
RenderTools()->SelectSprite(SPRITE_OOP + m_pClient->m_aClients[ClientID].m_Emoticon);
IGraphics::CQuadItem QuadItem(Position.x, Position.y - 23 - 32*h, 64, 64*h);
Graphics()->QuadsDraw(&QuadItem, 1);
Graphics()->QuadsEnd();
}
}
void CHud::RenderScoreHud()
{
int GameFlags = m_pClient->m_Snap.m_pGameobj->m_Flags;
float Whole = 300*Graphics()->ScreenAspect();
// render small score hud
if(!(m_pClient->m_Snap.m_pGameobj && m_pClient->m_Snap.m_pGameobj->m_GameOver) && (GameFlags&GAMEFLAG_TEAMS))
{
char aScoreTeam[2][32];
str_format(aScoreTeam[0], sizeof(aScoreTeam)/2, "%d", m_pClient->m_Snap.m_pGameobj->m_TeamscoreRed);
str_format(aScoreTeam[1], sizeof(aScoreTeam)/2, "%d", m_pClient->m_Snap.m_pGameobj->m_TeamscoreBlue);
float aScoreTeamWidth[2] = {TextRender()->TextWidth(0, 14.0f, aScoreTeam[0], -1), TextRender()->TextWidth(0, 14.0f, aScoreTeam[1], -1)};
float ScoreWidthMax = max(max(aScoreTeamWidth[0], aScoreTeamWidth[1]), TextRender()->TextWidth(0, 14.0f, "100", -1));
float Split = 3.0f;
float ImageSize = GameFlags&GAMEFLAG_FLAGS ? 16.0f : Split;
for(int t = 0; t < 2; t++)
{
// draw box
Graphics()->BlendNormal();
Graphics()->TextureSet(-1);
Graphics()->QuadsBegin();
if(t == 0)
Graphics()->SetColor(1.0f, 0.0f, 0.0f, 0.25f);
else
Graphics()->SetColor(0.0f, 0.0f, 1.0f, 0.25f);
RenderTools()->DrawRoundRectExt(Whole-ScoreWidthMax-ImageSize-2*Split, 245.0f+t*20, ScoreWidthMax+ImageSize+2*Split, 18.0f, 5.0f, CUI::CORNER_L);
Graphics()->QuadsEnd();
// draw score
TextRender()->Text(0, Whole-ScoreWidthMax+(ScoreWidthMax-aScoreTeamWidth[t])/2-Split, 245.0f+t*20, 14.0f, aScoreTeam[t], -1);
if(GameFlags&GAMEFLAG_FLAGS && m_pClient->m_Snap.m_paFlags[t])
{
if(m_pClient->m_Snap.m_paFlags[t]->m_CarriedBy == -2 || (m_pClient->m_Snap.m_paFlags[t]->m_CarriedBy == -1 && ((Client()->GameTick()/10)&1)))
{
// draw flag
Graphics()->BlendNormal();
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_GAME].m_Id);
Graphics()->QuadsBegin();
RenderTools()->SelectSprite(t==0?SPRITE_FLAG_RED:SPRITE_FLAG_BLUE);
IGraphics::CQuadItem QuadItem(Whole-ScoreWidthMax-ImageSize, 246.0f+t*20, ImageSize/2, ImageSize);
Graphics()->QuadsDrawTL(&QuadItem, 1);
Graphics()->QuadsEnd();
}
else if(m_pClient->m_Snap.m_paFlags[t]->m_CarriedBy >= 0)
{
// draw name of the flag holder
int Id = m_pClient->m_Snap.m_paFlags[t]->m_CarriedBy%MAX_CLIENTS;
const char *pName = m_pClient->m_aClients[Id].m_aName;
float w = TextRender()->TextWidth(0, 10.0f, pName, -1);
TextRender()->Text(0, Whole-ScoreWidthMax-ImageSize-3*Split-w, 247.0f+t*20, 10.0f, pName, -1);
// draw tee of the flag holder
CTeeRenderInfo Info = m_pClient->m_aClients[Id].m_RenderInfo;
Info.m_Size = 18.0f;
RenderTools()->RenderTee(CAnimState::GetIdle(), &Info, EMOTE_NORMAL, vec2(1,0),
vec2(Whole-ScoreWidthMax-Info.m_Size/2-Split, 246.0f+Info.m_Size/2+t*20));
}
}
}
}
}
void CEmoticon::OnRender()
{
if(!m_Active)
{
if(m_WasActive && m_SelectedEmote != -1)
Emote(m_SelectedEmote);
m_WasActive = false;
return;
}
if(m_pClient->m_Snap.m_SpecInfo.m_Active)
{
m_Active = false;
m_WasActive = false;
return;
}
m_WasActive = true;
if (length(m_SelectorMouse) > 140)
m_SelectorMouse = normalize(m_SelectorMouse) * 140;
float SelectedAngle = GetAngle(m_SelectorMouse) + 2*pi/24;
if (SelectedAngle < 0)
SelectedAngle += 2*pi;
if (length(m_SelectorMouse) > 100)
m_SelectedEmote = (int)(SelectedAngle / (2*pi) * NUM_EMOTICONS);
CUIRect Screen = *UI()->Screen();
Graphics()->MapScreen(Screen.x, Screen.y, Screen.w, Screen.h);
Graphics()->BlendNormal();
Graphics()->TextureSet(-1);
Graphics()->QuadsBegin();
Graphics()->SetColor(0,0,0,0.3f);
DrawCircle(Screen.w/2, Screen.h/2, 160, 64);
Graphics()->QuadsEnd();
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_EMOTICONS].m_Id);
Graphics()->QuadsBegin();
for (int i = 0; i < NUM_EMOTICONS; i++)
{
float Angle = 2*pi*i/NUM_EMOTICONS;
if (Angle > pi)
Angle -= 2*pi;
bool Selected = m_SelectedEmote == i;
float Size = Selected ? 80 : 32;
float NudgeX = 120 * cosf(Angle);
float NudgeY = 120 * sinf(Angle);
RenderTools()->SelectSprite(SPRITE_OOP + i);
IGraphics::CQuadItem QuadItem(Screen.w/2 + NudgeX, Screen.h/2 + NudgeY, Size, Size);
Graphics()->QuadsDraw(&QuadItem, 1);
}
Graphics()->QuadsEnd();
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_CURSOR].m_Id);
Graphics()->QuadsBegin();
Graphics()->SetColor(1,1,1,1);
IGraphics::CQuadItem QuadItem(m_SelectorMouse.x+Screen.w/2,m_SelectorMouse.y+Screen.h/2,24,24);
Graphics()->QuadsDrawTL(&QuadItem, 1);
Graphics()->QuadsEnd();
}
void CEmoticon::OnRender()
{
if(!m_Active)
{
if(m_WasActive)
{
if (m_SelectedEmote != -1)
Emote(m_SelectedEmote);
else if (Client()->IsServerType("ddrace") && m_SelectedEyes != -1)
Eyes(m_SelectedEyes);
}
m_WasActive = false;
return;
}
if(m_pClient->m_Snap.m_SpecInfo.m_Active)
{
m_Active = false;
m_WasActive = false;
return;
}
m_WasActive = true;
if (length(m_SelectorMouse) > 170.0f)
m_SelectorMouse = normalize(m_SelectorMouse) * 170.0f;
float SelectedAngle = GetAngle(m_SelectorMouse) + 2*pi/24;
if (SelectedAngle < 0)
SelectedAngle += 2*pi;
float mouselen = length(m_SelectorMouse);
if (mouselen > 110.0f)
{
m_SelectedEyes = -1;
m_SelectedEmote = (int)(SelectedAngle / (2*pi) * NUM_EMOTICONS);
} else if (Client()->IsServerType("ddrace") && mouselen > 50.0f && mouselen < 110.0f) // H-Client
{
m_SelectedEmote = -1;
m_SelectedEyes = (int)(SelectedAngle / (2*pi) * NUM_EMOTES);
} else
{
m_SelectedEyes = -1;
m_SelectedEmote = -1;
}
CUIRect Screen = *UI()->Screen();
Graphics()->MapScreen(Screen.x, Screen.y, Screen.w, Screen.h);
Graphics()->BlendNormal();
Graphics()->TextureSet(-1);
Graphics()->QuadsBegin();
Graphics()->SetColor(0,0,0,0.3f);
DrawCircle(Screen.w/2, Screen.h/2, 190.0f, 64);
Graphics()->QuadsEnd();
// H-Client
if (Client()->IsServerType("ddrace"))
{
Graphics()->TextureSet(-1);
Graphics()->QuadsBegin();
Graphics()->SetColor(60,60,60,0.3f);
DrawCircle(Screen.w/2, Screen.h/2, 110.0f, 64);
Graphics()->QuadsEnd();
}
//
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_EMOTICONS].m_Id);
Graphics()->QuadsBegin();
for (int i = 0; i < NUM_EMOTICONS; i++)
{
float Angle = 2*pi*i/NUM_EMOTICONS;
if (Angle > pi)
Angle -= 2*pi;
bool Selected = m_SelectedEmote == i;
float Size = Selected ? 80.0f : 50.0f;
float NudgeX = 150.0f * cosf(Angle);
float NudgeY = 150.0f * sinf(Angle);
RenderTools()->SelectSprite(SPRITE_OOP + i);
IGraphics::CQuadItem QuadItem(Screen.w/2 + NudgeX, Screen.h/2 + NudgeY, Size, Size);
Graphics()->QuadsDraw(&QuadItem, 1);
}
Graphics()->QuadsEnd();
if (Client()->IsServerType("ddrace"))
{
for (int i = 0; i < NUM_EMOTES; i++)
{
float Angle = 2*pi*i/NUM_EMOTES;
if (Angle > pi)
Angle -= 2*pi;
bool Selected = m_SelectedEyes == i;
float Size = Selected ? 80.0f : 50.0f;
float NudgeX = 80.0f * cosf(Angle);
float NudgeY = 80.0f * sinf(Angle);
CTeeRenderInfo teeRenderInfo = m_pClient->m_aClients[m_pClient->m_Snap.m_LocalClientID].m_RenderInfo;
teeRenderInfo.m_Size = Size;
Graphics()->TextureSet(teeRenderInfo.m_Texture);
Graphics()->QuadsBegin();
Graphics()->SetColor(teeRenderInfo.m_ColorBody.r, teeRenderInfo.m_ColorBody.g, teeRenderInfo.m_ColorBody.b, teeRenderInfo.m_ColorBody.a);
switch (i)
{
case EMOTE_PAIN:
RenderTools()->SelectSprite(SPRITE_TEE_EYE_PAIN, 0, 0, 0);
break;
case EMOTE_HAPPY:
RenderTools()->SelectSprite(SPRITE_TEE_EYE_HAPPY, 0, 0, 0);
break;
case EMOTE_SURPRISE:
RenderTools()->SelectSprite(SPRITE_TEE_EYE_SURPRISE, 0, 0, 0);
break;
case EMOTE_ANGRY:
RenderTools()->SelectSprite(SPRITE_TEE_EYE_ANGRY, 0, 0, 0);
break;
default:
RenderTools()->SelectSprite(SPRITE_TEE_EYE_NORMAL, 0, 0, 0);
break;
}
vec2 Direction = vec2(-1,0);
float BaseSize = teeRenderInfo.m_Size;
float EyeScale = BaseSize*0.40f;
float h = i == EMOTE_BLINK ? BaseSize*0.15f : EyeScale;
float EyeSeparation = (0.075f - 0.010f*absolute(Direction.x))*BaseSize;
vec2 Offset = vec2(Direction.x*0.125f, -0.05f+Direction.y*0.10f)*BaseSize;
vec2 BodyPos = vec2(Screen.w/2 + NudgeX, Screen.h/2 + NudgeY);
IGraphics::CQuadItem Array[2] = {
IGraphics::CQuadItem(BodyPos.x-EyeSeparation+Offset.x, BodyPos.y+Offset.y, EyeScale, h),
IGraphics::CQuadItem(BodyPos.x+EyeSeparation+Offset.x, BodyPos.y+Offset.y, -EyeScale, h)};
Graphics()->QuadsDraw(Array, 2);
Graphics()->QuadsEnd();
}
}
//Graphics()->QuadsEnd();
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_CURSOR].m_Id);
Graphics()->QuadsBegin();
Graphics()->SetColor(1,1,1,1);
IGraphics::CQuadItem QuadItem(m_SelectorMouse.x+Screen.w/2,m_SelectorMouse.y+Screen.h/2,24,24);
Graphics()->QuadsDrawTL(&QuadItem, 1);
Graphics()->QuadsEnd();
}
void CHud::RenderHealthAndAmmo()
{
//mapscreen_to_group(gacenter_x, center_y, layers_game_group());
float x = 5;
float y = 5;
IGraphics::CQuadItem Weap[10];
char buf[32]; //Ammo indicators
// render ammo count
// render gui stuff
//if(g_Config.m_ClHudShowWeapon != 1)
// Graphics()->TextureSet(g_pData->m_aImages[IMAGE_GAME].m_Id);
Graphics()->MapScreen(0,0,m_Width,300);
Graphics()->BlendNormal();
if(g_Config.m_ClHudShowWeapon != 1)
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_GAME].m_Id);
else
Graphics()->TextureSet(-1);
Graphics()->QuadsBegin();
// if weaponstage is active, put a "glow" around the stage ammo
float vis;
if(g_Config.m_ClHudShowWeapon == 1)
{
for (int i = 0; i < 5; i++)
{
if (m_pClient->m_Snap.m_pLocalCharacter->m_Weapon%NUM_WEAPONS == i)
vis = 0.65f;
else
vis = 0.30f;
if (g_Config.m_ClHighlightWeaponBar == 1)
{
if ((m_pClient->m_AmmoCount[i] >= 8 && m_pClient->m_AmmoCount[i] <= 10) || i == 0)
Graphics()->SetColor(0.5f,1.0f,0.65f,vis);
else if (m_pClient->m_AmmoCount[i] >= 6 && m_pClient->m_AmmoCount[i] <= 7)
Graphics()->SetColor(0.75f,1.0f,0.65f,vis);
else if (m_pClient->m_AmmoCount[i] >= 4 && m_pClient->m_AmmoCount[i] <= 5)
Graphics()->SetColor(0.85f,0.85f,0.65f,vis);
else if (m_pClient->m_AmmoCount[i] >= 2 && m_pClient->m_AmmoCount[i] <= 3)
Graphics()->SetColor(0.95f,0.45f,0.45f,vis);
else if (m_pClient->m_AmmoCount[i] >= 0 && m_pClient->m_AmmoCount[i] <= 1)
Graphics()->SetColor(0.95f,0.25f,0.25f,vis);
else
Graphics()->SetColor(0,0,0,vis);
}
else if (m_pClient->m_Snap.m_pLocalCharacter->m_Weapon%NUM_WEAPONS == i)
Graphics()->SetColor(1,1,1,0.25f);
else
Graphics()->SetColor(0,0,0,0.25f);
RenderTools()->DrawRoundRect(x-1+i*20+5*i, y+25, 20, 18, 2.0f);
}
Graphics()->QuadsEnd();
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_GAME].m_Id);
Graphics()->QuadsBegin();
RenderTools()->SelectSprite(SPRITE_WEAPON_HAMMER_BODY);
Weap[0] = IGraphics::CQuadItem(x,y+27,18,13.5f);
Graphics()->QuadsDrawTL(Weap, 1);
RenderTools()->SelectSprite(SPRITE_WEAPON_GUN_BODY);
Weap[0] = IGraphics::CQuadItem(x+22+5,y+27,15,7.71f);
Graphics()->QuadsDrawTL(Weap, 1);
RenderTools()->SelectSprite(SPRITE_WEAPON_SHOTGUN_BODY);
Weap[0] = IGraphics::CQuadItem(x+41+10,y+27,18,5.14f);
Graphics()->QuadsDrawTL(Weap, 1);
RenderTools()->SelectSprite(SPRITE_WEAPON_GRENADE_BODY);
Weap[0] = IGraphics::CQuadItem(x+60+15,y+27,18,5.14f);
Graphics()->QuadsDrawTL(Weap, 1);
RenderTools()->SelectSprite(SPRITE_WEAPON_RIFLE_BODY);
Weap[0] = IGraphics::CQuadItem(x+80+20,y+27,18,7.71f);
Graphics()->QuadsDrawTL(Weap, 1);
}
RenderTools()->SelectSprite(g_pData->m_Weapons.m_aId[m_pClient->m_Snap.m_pLocalCharacter->m_Weapon%NUM_WEAPONS].m_pSpriteProj);
IGraphics::CQuadItem Array[10];
int i;
if(g_Config.m_ClHudShowAmmo == 1)
{
for (i = 0; i < min(m_pClient->m_Snap.m_pLocalCharacter->m_AmmoCount, 10); i++)
if(g_Config.m_ClHudShowWeapon == 1)
Array[i] = IGraphics::CQuadItem(x+i*12,y+44,10,10);
else
Array[i] = IGraphics::CQuadItem(x+i*12,y+24,10,10);
Graphics()->QuadsDrawTL(Array, i);
}
Graphics()->QuadsEnd();
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_GAME].m_Id);
Graphics()->QuadsBegin();
int h = 0;
// render health
RenderTools()->SelectSprite(SPRITE_HEALTH_FULL);
for(; h < min(m_pClient->m_Snap.m_pLocalCharacter->m_Health, 10); h++)
Array[h] = IGraphics::CQuadItem(x+h*12,y,10,10);
Graphics()->QuadsDrawTL(Array, h);
i = 0;
RenderTools()->SelectSprite(SPRITE_HEALTH_EMPTY);
for(; h < 10; h++)
Array[i++] = IGraphics::CQuadItem(x+h*12,y,10,10);
Graphics()->QuadsDrawTL(Array, i);
// render armor meter
h = 0;
RenderTools()->SelectSprite(SPRITE_ARMOR_FULL);
for(; h < min(m_pClient->m_Snap.m_pLocalCharacter->m_Armor, 10); h++)
Array[h] = IGraphics::CQuadItem(x+h*12,y+12,10,10);
Graphics()->QuadsDrawTL(Array, h);
i = 0;
RenderTools()->SelectSprite(SPRITE_ARMOR_EMPTY);
for(; h < 10; h++)
Array[i++] = IGraphics::CQuadItem(x+h*12,y+12,10,10);
Graphics()->QuadsDrawTL(Array, i);
Graphics()->QuadsEnd();
m_pClient->m_AmmoCount[m_pClient->m_Snap.m_pLocalCharacter->m_Weapon] = m_pClient->m_Snap.m_pLocalCharacter->m_AmmoCount;
if(g_Config.m_ClHudShowWeapon == 1)
{
float w = TextRender()->TextWidth(0x0, 8, buf, -1);
for (int i = 1; i < 5; i++)
{
if (m_pClient->m_AmmoCount[i] == -2)
{
str_format(buf, sizeof(buf), " ");
w = TextRender()->TextWidth(0x0, 8, buf, -1);
TextRender()->Text(0, (x+39+(i-2)*20+(20-w)/2)+5*i, y+32, 8, buf, -1);
}
else if (m_pClient->m_AmmoCount[i] == -1)
{
str_format(buf, sizeof(buf), "inf");
w = TextRender()->TextWidth(0x0, 8, buf, -1);
TextRender()->Text(0, (x+39+(i-2)*20+(20-w)/2)+5*i, y+32, 8, buf, -1);
}
else if (m_pClient->m_AmmoCount[i] > 10)
{
str_format(buf, sizeof(buf), "+10");
w = TextRender()->TextWidth(0x0, 8, buf, -1);
TextRender()->Text(0, (x+39+(i-2)*20+(20-w)/2)+5*i, y+32, 8, buf, -1);
}
else if (m_pClient->m_AmmoCount[i] >= 0 && m_pClient->m_AmmoCount[i] <= 10)
{
str_format(buf, sizeof(buf), "%d", m_pClient->m_AmmoCount[i]);
w = TextRender()->TextWidth(0x0, 8, buf, -1);
TextRender()->Text(0, (x+39+(i-2)*20+(20-w)/2)+5*i, y+32, 8, buf, -1);
}
else
{
str_format(buf, sizeof(buf), "inf");
w = TextRender()->TextWidth(0x0, 8, buf, -1);
TextRender()->Text(0, (x+39+(i-2)*20+(20-w)/2)+5*i, y+32, 8, buf, -1);
}
}
}
}
void CMapLayers::OnRender()
{
if(Client()->State() != IClient::STATE_ONLINE && Client()->State() != IClient::STATE_DEMOPLAYBACK)
return;
CUIRect Screen;
Graphics()->GetScreen(&Screen.x, &Screen.y, &Screen.w, &Screen.h);
vec2 Center = m_pClient->m_pCamera->m_Center;
//float center_x = gameclient.camera->center.x;
//float center_y = gameclient.camera->center.y;
bool PassedGameLayer = false;
for(int g = 0; g < m_pLayers->NumGroups(); g++)
{
CMapItemGroup *pGroup = m_pLayers->GetGroup(g);
if(!pGroup)
{
dbg_msg("MapLayers", "Error:Group was null, Group Number = %d, Total Groups = %d", g, m_pLayers->NumGroups());
dbg_msg("MapLayers", "This is here to prevent a crash but the source of this is unknown, please report this for it to get fixed");
dbg_msg("MapLayers", "we need mapname and crc and the map that caused this if possible, and anymore info you think is relevant");
continue;
}
if(!g_Config.m_GfxNoclip && pGroup->m_Version >= 2 && pGroup->m_UseClipping)
{
// set clipping
float Points[4];
MapScreenToGroup(Center.x, Center.y, m_pLayers->GameGroup(), m_pClient->m_pCamera->m_Zoom);
Graphics()->GetScreen(&Points[0], &Points[1], &Points[2], &Points[3]);
float x0 = (pGroup->m_ClipX - Points[0]) / (Points[2]-Points[0]);
float y0 = (pGroup->m_ClipY - Points[1]) / (Points[3]-Points[1]);
float x1 = ((pGroup->m_ClipX+pGroup->m_ClipW) - Points[0]) / (Points[2]-Points[0]);
float y1 = ((pGroup->m_ClipY+pGroup->m_ClipH) - Points[1]) / (Points[3]-Points[1]);
Graphics()->ClipEnable((int)(x0*Graphics()->ScreenWidth()), (int)(y0*Graphics()->ScreenHeight()),
(int)((x1-x0)*Graphics()->ScreenWidth()), (int)((y1-y0)*Graphics()->ScreenHeight()));
}
MapScreenToGroup(Center.x, Center.y, pGroup, m_pClient->m_pCamera->m_Zoom);
for(int l = 0; l < pGroup->m_NumLayers; l++)
{
CMapItemLayer *pLayer = m_pLayers->GetLayer(pGroup->m_StartLayer+l);
bool Render = false;
bool IsGameLayer = false;
bool IsFrontLayer = false;
bool IsSwitchLayer = false;
bool IsTeleLayer = false;
bool IsSpeedupLayer = false;
if(pLayer == (CMapItemLayer*)m_pLayers->GameLayer())
{
IsGameLayer = true;
PassedGameLayer = 1;
}
if(pLayer == (CMapItemLayer*)m_pLayers->FrontLayer())
IsFrontLayer = true;
if(pLayer == (CMapItemLayer*)m_pLayers->SwitchLayer())
IsSwitchLayer = true;
if(pLayer == (CMapItemLayer*)m_pLayers->TeleLayer())
IsTeleLayer = true;
if(pLayer == (CMapItemLayer*)m_pLayers->SpeedupLayer())
IsSpeedupLayer = true;
// skip rendering if detail layers if not wanted
if(pLayer->m_Flags&LAYERFLAG_DETAIL && !g_Config.m_GfxHighDetail && !IsGameLayer)
continue;
if(m_Type == -1)
Render = true;
else if(m_Type == 0)
{
if(PassedGameLayer)
return;
Render = true;
}
else
{
if(PassedGameLayer && !IsGameLayer)
Render = true;
}
if(Render && pLayer->m_Type == LAYERTYPE_TILES && Input()->KeyPressed(KEY_LCTRL) && Input()->KeyPressed(KEY_LSHIFT) && Input()->KeyDown(KEY_KP0))
{
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
CTile *pTiles = (CTile *)m_pLayers->Map()->GetData(pTMap->m_Data);
CServerInfo CurrentServerInfo;
Client()->GetServerInfo(&CurrentServerInfo);
char aFilename[256];
str_format(aFilename, sizeof(aFilename), "dumps/tilelayer_dump_%s-%d-%d-%dx%d.txt", CurrentServerInfo.m_aMap, g, l, pTMap->m_Width, pTMap->m_Height);
IOHANDLE File = Storage()->OpenFile(aFilename, IOFLAG_WRITE, IStorage::TYPE_SAVE);
if(File)
{
for(int y = 0; y < pTMap->m_Height; y++)
{
for(int x = 0; x < pTMap->m_Width; x++)
io_write(File, &(pTiles[y*pTMap->m_Width + x].m_Index), sizeof(pTiles[y*pTMap->m_Width + x].m_Index));
io_write_newline(File);
}
io_close(File);
}
}
if((Render && !IsGameLayer && !g_Config.m_ClShowEntities) || (g_Config.m_ClShowEntities && IsGameLayer))
{
//layershot_begin();
if(pLayer->m_Type == LAYERTYPE_TILES)
{
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
if(pTMap->m_Image == -1)
{
if(!g_Config.m_ClShowEntities)
Graphics()->TextureSet(-1);
else
Graphics()->TextureSet(m_pClient->m_pMapimages->GetEntities());
}
else
Graphics()->TextureSet(m_pClient->m_pMapimages->Get(pTMap->m_Image));
CTile *pTiles = (CTile *)m_pLayers->Map()->GetData(pTMap->m_Data);
Graphics()->BlendNone();
vec4 Color = vec4(pTMap->m_Color.r/255.0f, pTMap->m_Color.g/255.0f, pTMap->m_Color.b/255.0f, pTMap->m_Color.a/255.0f);
RenderTools()->RenderTilemap(pTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_OPAQUE,
EnvelopeEval, this, pTMap->m_ColorEnv, pTMap->m_ColorEnvOffset);
Graphics()->BlendNormal();
RenderTools()->RenderTilemap(pTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_TRANSPARENT,
EnvelopeEval, this, pTMap->m_ColorEnv, pTMap->m_ColorEnvOffset);
}
else if(pLayer->m_Type == LAYERTYPE_QUADS)
{
CMapItemLayerQuads *pQLayer = (CMapItemLayerQuads *)pLayer;
if(pQLayer->m_Image == -1)
Graphics()->TextureSet(-1);
else
Graphics()->TextureSet(m_pClient->m_pMapimages->Get(pQLayer->m_Image));
CQuad *pQuads = (CQuad *)m_pLayers->Map()->GetDataSwapped(pQLayer->m_Data);
Graphics()->BlendNone();
RenderTools()->RenderQuads(pQuads, pQLayer->m_NumQuads, LAYERRENDERFLAG_OPAQUE, EnvelopeEval, this);
Graphics()->BlendNormal();
RenderTools()->RenderQuads(pQuads, pQLayer->m_NumQuads, LAYERRENDERFLAG_TRANSPARENT, EnvelopeEval, this);
}
//layershot_end();
}
else if(g_Config.m_ClShowEntities && IsFrontLayer)
{
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
Graphics()->TextureSet(m_pClient->m_pMapimages->GetEntities());
CTile *pFrontTiles = (CTile *)m_pLayers->Map()->GetData(pTMap->m_Front);
Graphics()->BlendNone();
vec4 Color = vec4(pTMap->m_Color.r/255.0f, pTMap->m_Color.g/255.0f, pTMap->m_Color.b/255.0f, pTMap->m_Color.a/255.0f);
RenderTools()->RenderTilemap(pFrontTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_OPAQUE,
EnvelopeEval, this, pTMap->m_ColorEnv, pTMap->m_ColorEnvOffset);
Graphics()->BlendNormal();
RenderTools()->RenderTilemap(pFrontTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_TRANSPARENT,
EnvelopeEval, this, pTMap->m_ColorEnv, pTMap->m_ColorEnvOffset);
}
else if(g_Config.m_ClShowEntities && IsSwitchLayer)
{
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
Graphics()->TextureSet(m_pClient->m_pMapimages->GetEntities());
CSwitchTile *pSwitchTiles = (CSwitchTile *)m_pLayers->Map()->GetData(pTMap->m_Switch);
Graphics()->BlendNone();
vec4 Color = vec4(pTMap->m_Color.r/255.0f, pTMap->m_Color.g/255.0f, pTMap->m_Color.b/255.0f, pTMap->m_Color.a/255.0f);
RenderTools()->RenderSwitchmap(pSwitchTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_OPAQUE);
Graphics()->BlendNormal();
RenderTools()->RenderSwitchmap(pSwitchTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_TRANSPARENT);
RenderTools()->RenderSwitchOverlay(pSwitchTiles, pTMap->m_Width, pTMap->m_Height, 32.0f);
}
else if(g_Config.m_ClShowEntities && IsTeleLayer)
{
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
Graphics()->TextureSet(m_pClient->m_pMapimages->GetEntities());
CTeleTile *pTeleTiles = (CTeleTile *)m_pLayers->Map()->GetData(pTMap->m_Tele);
Graphics()->BlendNone();
vec4 Color = vec4(pTMap->m_Color.r/255.0f, pTMap->m_Color.g/255.0f, pTMap->m_Color.b/255.0f, pTMap->m_Color.a/255.0f);
RenderTools()->RenderTelemap(pTeleTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_OPAQUE);
Graphics()->BlendNormal();
RenderTools()->RenderTelemap(pTeleTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_TRANSPARENT);
RenderTools()->RenderTeleOverlay(pTeleTiles, pTMap->m_Width, pTMap->m_Height, 32.0f);
}
else if(g_Config.m_ClShowEntities && IsSpeedupLayer)
{
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
Graphics()->TextureSet(m_pClient->m_pMapimages->GetEntities());
CSpeedupTile *pSpeedupTiles = (CSpeedupTile *)m_pLayers->Map()->GetData(pTMap->m_Speedup);
Graphics()->BlendNone();
vec4 Color = vec4(pTMap->m_Color.r/255.0f, pTMap->m_Color.g/255.0f, pTMap->m_Color.b/255.0f, pTMap->m_Color.a/255.0f);
RenderTools()->RenderSpeedupmap(pSpeedupTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_OPAQUE);
Graphics()->BlendNormal();
RenderTools()->RenderSpeedupmap(pSpeedupTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_TRANSPARENT);
RenderTools()->RenderSpeedupOverlay(pSpeedupTiles, pTMap->m_Width, pTMap->m_Height, 32.0f);
}
}
if(!g_Config.m_GfxNoclip)
Graphics()->ClipDisable();
}
if(!g_Config.m_GfxNoclip)
Graphics()->ClipDisable();
// reset the screen like it was before
Graphics()->MapScreen(Screen.x, Screen.y, Screen.w, Screen.h);
}
int CMenus::DoButton_Menu(const void *pID, const char *pText, int Checked, const CUIRect *pRect)
{
RenderTools()->DrawUIRect(pRect, vec4(1,1,1,0.5f)*ButtonColorMul(pID), CUI::CORNER_ALL, 5.0f);
UI()->DoLabel(pRect, pText, pRect->h*ms_FontmodHeight, 0);
return UI()->DoButtonLogic(pID, pText, Checked, pRect);
}
int CMenus::Render()
{
CUIRect Screen = *UI()->Screen();
Graphics()->MapScreen(Screen.x, Screen.y, Screen.w, Screen.h);
static bool s_First = true;
if(s_First)
{
if(g_Config.m_UiPage == PAGE_INTERNET)
ServerBrowser()->Refresh(IServerBrowser::TYPE_INTERNET);
else if(g_Config.m_UiPage == PAGE_LAN)
ServerBrowser()->Refresh(IServerBrowser::TYPE_LAN);
else if(g_Config.m_UiPage == PAGE_FAVORITES)
ServerBrowser()->Refresh(IServerBrowser::TYPE_FAVORITES);
s_First = false;
}
if(Client()->State() == IClient::STATE_ONLINE)
{
ms_ColorTabbarInactive = ms_ColorTabbarInactiveIngame;
ms_ColorTabbarActive = ms_ColorTabbarActiveIngame;
}
else
{
RenderBackground();
ms_ColorTabbarInactive = ms_ColorTabbarInactiveOutgame;
ms_ColorTabbarActive = ms_ColorTabbarActiveOutgame;
}
CUIRect TabBar;
CUIRect MainView;
// some margin around the screen
Screen.Margin(10.0f, &Screen);
static bool s_SoundCheck = false;
if(!s_SoundCheck && m_Popup == POPUP_NONE)
{
if(Client()->SoundInitFailed())
m_Popup = POPUP_SOUNDERROR;
s_SoundCheck = true;
}
if(m_Popup == POPUP_NONE)
{
// do tab bar
Screen.HSplitTop(24.0f, &TabBar, &MainView);
TabBar.VMargin(20.0f, &TabBar);
RenderMenubar(TabBar);
// news is not implemented yet
if(g_Config.m_UiPage <= PAGE_NEWS || g_Config.m_UiPage > PAGE_SETTINGS || (Client()->State() == IClient::STATE_OFFLINE && g_Config.m_UiPage >= PAGE_GAME && g_Config.m_UiPage <= PAGE_CALLVOTE))
{
ServerBrowser()->Refresh(IServerBrowser::TYPE_INTERNET);
g_Config.m_UiPage = PAGE_INTERNET;
}
// render current page
if(Client()->State() != IClient::STATE_OFFLINE)
{
if(m_GamePage == PAGE_GAME)
RenderGame(MainView);
else if(m_GamePage == PAGE_SERVER_INFO)
RenderServerInfo(MainView);
else if(m_GamePage == PAGE_CALLVOTE)
RenderServerControl(MainView);
else if(m_GamePage == PAGE_SETTINGS)
RenderSettings(MainView);
}
else if(g_Config.m_UiPage == PAGE_NEWS)
RenderNews(MainView);
else if(g_Config.m_UiPage == PAGE_INTERNET)
RenderServerbrowser(MainView);
else if(g_Config.m_UiPage == PAGE_LAN)
RenderServerbrowser(MainView);
else if(g_Config.m_UiPage == PAGE_DEMOS)
RenderDemoList(MainView);
else if(g_Config.m_UiPage == PAGE_FAVORITES)
RenderServerbrowser(MainView);
else if(g_Config.m_UiPage == PAGE_SETTINGS)
RenderSettings(MainView);
}
else
{
// make sure that other windows doesn't do anything funnay!
//UI()->SetHotItem(0);
//UI()->SetActiveItem(0);
char aBuf[128];
const char *pTitle = "";
const char *pExtraText = "";
const char *pButtonText = "";
int ExtraAlign = 0;
if(m_Popup == POPUP_MESSAGE)
{
pTitle = m_aMessageTopic;
pExtraText = m_aMessageBody;
pButtonText = m_aMessageButton;
}
else if(m_Popup == POPUP_CONNECTING)
{
pTitle = Localize("Connecting to");
pExtraText = g_Config.m_UiServerAddress; // TODO: query the client about the address
pButtonText = Localize("Abort");
if(Client()->MapDownloadTotalsize() > 0)
{
pTitle = Localize("Downloading map");
pExtraText = "";
}
}
else if(m_Popup == POPUP_DISCONNECTED)
{
pTitle = Localize("Disconnected");
pExtraText = Client()->ErrorString();
pButtonText = Localize("Ok");
ExtraAlign = -1;
}
else if(m_Popup == POPUP_PURE)
{
pTitle = Localize("Disconnected");
pExtraText = Localize("The server is running a non-standard tuning on a pure game type.");
pButtonText = Localize("Ok");
ExtraAlign = -1;
}
else if(m_Popup == POPUP_DELETE_DEMO)
{
pTitle = Localize("Delete demo");
pExtraText = Localize("Are you sure that you want to delete the demo?");
ExtraAlign = -1;
}
else if(m_Popup == POPUP_RENAME_DEMO)
{
pTitle = Localize("Rename demo");
pExtraText = "";
ExtraAlign = -1;
}
else if(m_Popup == POPUP_REMOVE_FRIEND)
{
pTitle = Localize("Remove friend");
pExtraText = Localize("Are you sure that you want to remove the player from your friends list?");
ExtraAlign = -1;
}
else if(m_Popup == POPUP_SOUNDERROR)
{
pTitle = Localize("Sound error");
pExtraText = Localize("The audio device couldn't be initialised.");
pButtonText = Localize("Ok");
ExtraAlign = -1;
}
else if(m_Popup == POPUP_PASSWORD)
{
pTitle = Localize("Password incorrect");
pExtraText = "";
pButtonText = Localize("Try again");
}
else if(m_Popup == POPUP_QUIT)
{
pTitle = Localize("Quit");
pExtraText = Localize("Are you sure that you want to quit?");
ExtraAlign = -1;
}
else if(m_Popup == POPUP_FIRST_LAUNCH)
{
pTitle = Localize("Welcome to Teeworlds");
pExtraText = Localize("As this is the first time you launch the game, please enter your nick name below. It's recommended that you check the settings to adjust them to your liking before joining a server.");
pButtonText = Localize("Ok");
ExtraAlign = -1;
}
CUIRect Box, Part;
Box = Screen;
Box.VMargin(150.0f/UI()->Scale(), &Box);
Box.HMargin(150.0f/UI()->Scale(), &Box);
// render the box
RenderTools()->DrawUIRect(&Box, vec4(0,0,0,0.5f), CUI::CORNER_ALL, 15.0f);
Box.HSplitTop(20.f/UI()->Scale(), &Part, &Box);
Box.HSplitTop(24.f/UI()->Scale(), &Part, &Box);
UI()->DoLabelScaled(&Part, pTitle, 24.f, 0);
Box.HSplitTop(20.f/UI()->Scale(), &Part, &Box);
Box.HSplitTop(24.f/UI()->Scale(), &Part, &Box);
Part.VMargin(20.f/UI()->Scale(), &Part);
if(ExtraAlign == -1)
UI()->DoLabelScaled(&Part, pExtraText, 20.f, -1, (int)Part.w);
else
UI()->DoLabelScaled(&Part, pExtraText, 20.f, 0, -1);
if(m_Popup == POPUP_QUIT)
{
CUIRect Yes, No;
Box.HSplitBottom(20.f, &Box, &Part);
Box.HSplitBottom(24.f, &Box, &Part);
// additional info
Box.HSplitTop(10.0f, 0, &Box);
Box.VMargin(20.f/UI()->Scale(), &Box);
if(m_pClient->Editor()->HasUnsavedData())
UI()->DoLabelScaled(&Box, Localize("There's an unsaved map in the editor, you might want to save it before you quit the game.\nQuit anyway?"),
20.f, -1, Part.w);
// buttons
Part.VMargin(80.0f, &Part);
Part.VSplitMid(&No, &Yes);
Yes.VMargin(20.0f, &Yes);
No.VMargin(20.0f, &No);
static int s_ButtonAbort = 0;
if(DoButton_Menu(&s_ButtonAbort, Localize("No"), 0, &No) || m_EscapePressed)
m_Popup = POPUP_NONE;
static int s_ButtonTryAgain = 0;
if(DoButton_Menu(&s_ButtonTryAgain, Localize("Yes"), 0, &Yes) || m_EnterPressed)
Client()->Quit();
}
else if(m_Popup == POPUP_PASSWORD)
{
CUIRect Label, TextBox, TryAgain, Abort;
Box.HSplitBottom(20.f, &Box, &Part);
Box.HSplitBottom(24.f, &Box, &Part);
Part.VMargin(80.0f, &Part);
Part.VSplitMid(&Abort, &TryAgain);
TryAgain.VMargin(20.0f, &TryAgain);
Abort.VMargin(20.0f, &Abort);
static int s_ButtonAbort = 0;
if(DoButton_Menu(&s_ButtonAbort, Localize("Abort"), 0, &Abort) || m_EscapePressed)
m_Popup = POPUP_NONE;
static int s_ButtonTryAgain = 0;
if(DoButton_Menu(&s_ButtonTryAgain, Localize("Try again"), 0, &TryAgain) || m_EnterPressed)
{
Client()->Connect(g_Config.m_UiServerAddress);
}
Box.HSplitBottom(60.f, &Box, &Part);
Box.HSplitBottom(24.f, &Box, &Part);
Part.VSplitLeft(60.0f, 0, &Label);
Label.VSplitLeft(100.0f, 0, &TextBox);
TextBox.VSplitLeft(20.0f, 0, &TextBox);
TextBox.VSplitRight(60.0f, &TextBox, 0);
UI()->DoLabel(&Label, Localize("Password"), 18.0f, -1);
static float Offset = 0.0f;
DoEditBox(&g_Config.m_Password, &TextBox, g_Config.m_Password, sizeof(g_Config.m_Password), 12.0f, &Offset, true);
}
else if(m_Popup == POPUP_CONNECTING)
{
Box = Screen;
Box.VMargin(150.0f, &Box);
Box.HMargin(150.0f, &Box);
Box.HSplitBottom(20.f, &Box, &Part);
Box.HSplitBottom(24.f, &Box, &Part);
Part.VMargin(120.0f, &Part);
static int s_Button = 0;
if(DoButton_Menu(&s_Button, pButtonText, 0, &Part) || m_EscapePressed || m_EnterPressed)
{
Client()->Disconnect();
m_Popup = POPUP_NONE;
}
if(Client()->MapDownloadTotalsize() > 0)
{
int64 Now = time_get();
if(Now-m_DownloadLastCheckTime >= time_freq())
{
if(m_DownloadLastCheckSize > Client()->MapDownloadAmount())
{
// map downloaded restarted
m_DownloadLastCheckSize = 0;
}
// update download speed
float Diff = (Client()->MapDownloadAmount()-m_DownloadLastCheckSize)/1024.0f;
m_DownloadSpeed = absolute((m_DownloadSpeed*(1.0f-(1.0f/m_DownloadSpeed))) + (Diff*(1.0f/m_DownloadSpeed)));
m_DownloadLastCheckTime = Now;
m_DownloadLastCheckSize = Client()->MapDownloadAmount();
}
Box.HSplitTop(64.f, 0, &Box);
Box.HSplitTop(24.f, &Part, &Box);
str_format(aBuf, sizeof(aBuf), "%d/%d KiB (%.1f KiB/s)", Client()->MapDownloadAmount()/1024, Client()->MapDownloadTotalsize()/1024, m_DownloadSpeed);
UI()->DoLabel(&Part, aBuf, 20.f, 0, -1);
// time left
const char *pTimeLeftString;
int TimeLeft = (Client()->MapDownloadTotalsize()-Client()->MapDownloadAmount())/(m_DownloadSpeed*1024)+1;
if(TimeLeft >= 60)
{
TimeLeft /= 60;
pTimeLeftString = TimeLeft == 1 ? Localize("%i minute left") : Localize("%i minutes left");
}
else
pTimeLeftString = TimeLeft == 1 ? Localize("%i second left") : Localize("%i seconds left");
Box.HSplitTop(20.f, 0, &Box);
Box.HSplitTop(24.f, &Part, &Box);
str_format(aBuf, sizeof(aBuf), pTimeLeftString, TimeLeft);
UI()->DoLabel(&Part, aBuf, 20.f, 0, -1);
// progress bar
Box.HSplitTop(20.f, 0, &Box);
Box.HSplitTop(24.f, &Part, &Box);
Part.VMargin(40.0f, &Part);
RenderTools()->DrawUIRect(&Part, vec4(1.0f, 1.0f, 1.0f, 0.25f), CUI::CORNER_ALL, 5.0f);
Part.w = max(10.0f, (Part.w*Client()->MapDownloadAmount())/Client()->MapDownloadTotalsize());
RenderTools()->DrawUIRect(&Part, vec4(1.0f, 1.0f, 1.0f, 0.5f), CUI::CORNER_ALL, 5.0f);
}
}
else if(m_Popup == POPUP_LANGUAGE)
{
Box = Screen;
Box.VMargin(150.0f, &Box);
Box.HMargin(150.0f, &Box);
Box.HSplitTop(20.f, &Part, &Box);
Box.HSplitBottom(20.f, &Box, &Part);
Box.HSplitBottom(24.f, &Box, &Part);
Box.HSplitBottom(20.f, &Box, 0);
Box.VMargin(20.0f, &Box);
RenderLanguageSelection(Box);
Part.VMargin(120.0f, &Part);
static int s_Button = 0;
if(DoButton_Menu(&s_Button, Localize("Ok"), 0, &Part) || m_EscapePressed || m_EnterPressed)
m_Popup = POPUP_FIRST_LAUNCH;
}
else if(m_Popup == POPUP_DELETE_DEMO)
{
CUIRect Yes, No;
Box.HSplitBottom(20.f, &Box, &Part);
Box.HSplitBottom(24.f, &Box, &Part);
Part.VMargin(80.0f, &Part);
Part.VSplitMid(&No, &Yes);
Yes.VMargin(20.0f, &Yes);
No.VMargin(20.0f, &No);
static int s_ButtonAbort = 0;
if(DoButton_Menu(&s_ButtonAbort, Localize("No"), 0, &No) || m_EscapePressed)
m_Popup = POPUP_NONE;
static int s_ButtonTryAgain = 0;
if(DoButton_Menu(&s_ButtonTryAgain, Localize("Yes"), 0, &Yes) || m_EnterPressed)
{
m_Popup = POPUP_NONE;
// delete demo
if(m_DemolistSelectedIndex >= 0 && !m_DemolistSelectedIsDir)
{
char aBuf[512];
str_format(aBuf, sizeof(aBuf), "%s/%s", m_aCurrentDemoFolder, m_lDemos[m_DemolistSelectedIndex].m_aFilename);
if(Storage()->RemoveFile(aBuf, m_lDemos[m_DemolistSelectedIndex].m_StorageType))
{
DemolistPopulate();
DemolistOnUpdate(false);
}
else
PopupMessage(Localize("Error"), Localize("Unable to delete the demo"), Localize("Ok"));
}
}
}
else if(m_Popup == POPUP_RENAME_DEMO)
{
CUIRect Label, TextBox, Ok, Abort;
Box.HSplitBottom(20.f, &Box, &Part);
Box.HSplitBottom(24.f, &Box, &Part);
Part.VMargin(80.0f, &Part);
Part.VSplitMid(&Abort, &Ok);
Ok.VMargin(20.0f, &Ok);
Abort.VMargin(20.0f, &Abort);
static int s_ButtonAbort = 0;
if(DoButton_Menu(&s_ButtonAbort, Localize("Abort"), 0, &Abort) || m_EscapePressed)
m_Popup = POPUP_NONE;
static int s_ButtonOk = 0;
if(DoButton_Menu(&s_ButtonOk, Localize("Ok"), 0, &Ok) || m_EnterPressed)
{
m_Popup = POPUP_NONE;
// rename demo
if(m_DemolistSelectedIndex >= 0 && !m_DemolistSelectedIsDir)
{
char aBufOld[512];
str_format(aBufOld, sizeof(aBufOld), "%s/%s", m_aCurrentDemoFolder, m_lDemos[m_DemolistSelectedIndex].m_aFilename);
int Length = str_length(m_aCurrentDemoFile);
char aBufNew[512];
if(Length <= 4 || m_aCurrentDemoFile[Length-5] != '.' || str_comp_nocase(m_aCurrentDemoFile+Length-4, "demo"))
str_format(aBufNew, sizeof(aBufNew), "%s/%s.demo", m_aCurrentDemoFolder, m_aCurrentDemoFile);
else
str_format(aBufNew, sizeof(aBufNew), "%s/%s", m_aCurrentDemoFolder, m_aCurrentDemoFile);
if(Storage()->RenameFile(aBufOld, aBufNew, m_lDemos[m_DemolistSelectedIndex].m_StorageType))
{
DemolistPopulate();
DemolistOnUpdate(false);
}
else
PopupMessage(Localize("Error"), Localize("Unable to rename the demo"), Localize("Ok"));
}
}
Box.HSplitBottom(60.f, &Box, &Part);
Box.HSplitBottom(24.f, &Box, &Part);
Part.VSplitLeft(60.0f, 0, &Label);
Label.VSplitLeft(120.0f, 0, &TextBox);
TextBox.VSplitLeft(20.0f, 0, &TextBox);
TextBox.VSplitRight(60.0f, &TextBox, 0);
UI()->DoLabel(&Label, Localize("New name:"), 18.0f, -1);
static float Offset = 0.0f;
DoEditBox(&Offset, &TextBox, m_aCurrentDemoFile, sizeof(m_aCurrentDemoFile), 12.0f, &Offset);
}
else if(m_Popup == POPUP_REMOVE_FRIEND)
{
CUIRect Yes, No;
Box.HSplitBottom(20.f, &Box, &Part);
Box.HSplitBottom(24.f, &Box, &Part);
Part.VMargin(80.0f, &Part);
Part.VSplitMid(&No, &Yes);
Yes.VMargin(20.0f, &Yes);
No.VMargin(20.0f, &No);
static int s_ButtonAbort = 0;
if(DoButton_Menu(&s_ButtonAbort, Localize("No"), 0, &No) || m_EscapePressed)
m_Popup = POPUP_NONE;
static int s_ButtonTryAgain = 0;
if(DoButton_Menu(&s_ButtonTryAgain, Localize("Yes"), 0, &Yes) || m_EnterPressed)
{
m_Popup = POPUP_NONE;
// remove friend
if(m_FriendlistSelectedIndex >= 0)
{
m_pClient->Friends()->RemoveFriend(m_FriendlistSelectedIndex);
Client()->ServerBrowserUpdate();
}
}
}
else if(m_Popup == POPUP_FIRST_LAUNCH)
{
CUIRect Label, TextBox;
Box.HSplitBottom(20.f, &Box, &Part);
Box.HSplitBottom(24.f, &Box, &Part);
Part.VMargin(80.0f, &Part);
static int s_EnterButton = 0;
if(DoButton_Menu(&s_EnterButton, Localize("Enter"), 0, &Part) || m_EnterPressed)
m_Popup = POPUP_NONE;
Box.HSplitBottom(40.f, &Box, &Part);
Box.HSplitBottom(24.f, &Box, &Part);
Part.VSplitLeft(60.0f, 0, &Label);
Label.VSplitLeft(100.0f, 0, &TextBox);
TextBox.VSplitLeft(20.0f, 0, &TextBox);
TextBox.VSplitRight(60.0f, &TextBox, 0);
UI()->DoLabel(&Label, Localize("Nickname"), 18.0f, -1);
static float Offset = 0.0f;
DoEditBox(&g_Config.m_PlayerName, &TextBox, g_Config.m_PlayerName, sizeof(g_Config.m_PlayerName), 12.0f, &Offset);
}
else
{
Box.HSplitBottom(20.f, &Box, &Part);
Box.HSplitBottom(24.f, &Box, &Part);
Part.VMargin(120.0f, &Part);
static int s_Button = 0;
if(DoButton_Menu(&s_Button, pButtonText, 0, &Part) || m_EscapePressed || m_EnterPressed)
m_Popup = POPUP_NONE;
}
}
return 0;
}
void CMenus::RenderServerInfo(CUIRect MainView)
{
if(!m_pClient->m_Snap.m_pLocalInfo)
return;
// fetch server info
CServerInfo CurrentServerInfo;
Client()->GetServerInfo(&CurrentServerInfo);
// render background
RenderTools()->DrawUIRect(&MainView, ms_ColorTabbarActive, CUI::CORNER_ALL, 10.0f);
CUIRect View, ServerInfo, GameInfo, Motd;
float x = 0.0f;
float y = 0.0f;
char aBuf[1024];
// set view to use for all sub-modules
MainView.Margin(10.0f, &View);
// serverinfo
View.HSplitTop(View.h/2/UI()->Scale()-5.0f, &ServerInfo, &Motd);
ServerInfo.VSplitLeft(View.w/2/UI()->Scale()-5.0f, &ServerInfo, &GameInfo);
RenderTools()->DrawUIRect(&ServerInfo, vec4(1,1,1,0.25f), CUI::CORNER_ALL, 10.0f);
ServerInfo.Margin(5.0f, &ServerInfo);
x = 5.0f;
y = 0.0f;
TextRender()->Text(0, ServerInfo.x+x, ServerInfo.y+y, 32, Localize("Server info"), 250);
y += 32.0f+5.0f;
mem_zero(aBuf, sizeof(aBuf));
str_format(
aBuf,
sizeof(aBuf),
"%s\n\n"
"%s: %s\n"
"%s: %d\n"
"%s: %s\n"
"%s: %s\n",
CurrentServerInfo.m_aName,
Localize("Address"), g_Config.m_UiServerAddress,
Localize("Ping"), m_pClient->m_Snap.m_pLocalInfo->m_Latency,
Localize("Version"), CurrentServerInfo.m_aVersion,
Localize("Password"), CurrentServerInfo.m_Flags &1 ? Localize("Yes") : Localize("No")
);
TextRender()->Text(0, ServerInfo.x+x, ServerInfo.y+y, 20, aBuf, 250);
{
CUIRect Button;
int IsFavorite = ServerBrowser()->IsFavorite(CurrentServerInfo.m_NetAddr);
ServerInfo.HSplitBottom(20.0f, &ServerInfo, &Button);
static int s_AddFavButton = 0;
if(DoButton_CheckBox(&s_AddFavButton, Localize("Favorite"), IsFavorite, &Button))
{
if(IsFavorite)
ServerBrowser()->RemoveFavorite(CurrentServerInfo.m_NetAddr);
else
ServerBrowser()->AddFavorite(CurrentServerInfo.m_NetAddr);
}
}
// gameinfo
GameInfo.VSplitLeft(10.0f, 0x0, &GameInfo);
RenderTools()->DrawUIRect(&GameInfo, vec4(1,1,1,0.25f), CUI::CORNER_ALL, 10.0f);
GameInfo.Margin(5.0f, &GameInfo);
x = 5.0f;
y = 0.0f;
TextRender()->Text(0, GameInfo.x+x, GameInfo.y+y, 32, Localize("Game info"), 250);
y += 32.0f+5.0f;
if(m_pClient->m_Snap.m_pGameInfoObj)
{
mem_zero(aBuf, sizeof(aBuf));
str_format(
aBuf,
sizeof(aBuf),
"\n\n"
"%s: %s\n"
"%s: %s\n"
"%s: %d\n"
"%s: %d\n"
"\n"
"%s: %d/%d\n",
Localize("Game type"), CurrentServerInfo.m_aGameType,
Localize("Map"), CurrentServerInfo.m_aMap,
Localize("Score limit"), m_pClient->m_Snap.m_pGameInfoObj->m_ScoreLimit,
Localize("Time limit"), m_pClient->m_Snap.m_pGameInfoObj->m_TimeLimit,
Localize("Players"), m_pClient->m_Snap.m_NumPlayers, CurrentServerInfo.m_MaxClients
);
TextRender()->Text(0, GameInfo.x+x, GameInfo.y+y, 20, aBuf, 250);
}
// motd
Motd.HSplitTop(10.0f, 0, &Motd);
RenderTools()->DrawUIRect(&Motd, vec4(1,1,1,0.25f), CUI::CORNER_ALL, 10.0f);
Motd.Margin(5.0f, &Motd);
y = 0.0f;
x = 5.0f;
TextRender()->Text(0, Motd.x+x, Motd.y+y, 32, Localize("MOTD"), -1);
y += 32.0f+5.0f;
TextRender()->Text(0, Motd.x+x, Motd.y+y, 16, m_pClient->m_pMotd->m_aServerMotd, (int)Motd.w);
}
void CMenus::RenderIdents(CUIRect MainView)
{
const int NumIdentities = m_pClient->m_pIdentity->NumIdents();
CUIRect Button, Label, Temp;
static float s_Scrollbar = 0;
static float s_ScrollValue = 0;
RenderTools()->DrawUIRect(&MainView, vec4(0.65f, 0.68f, 0.9f, 0.64f), CUI::CORNER_T, 10.0f);
MainView.HSplitTop(8.0f, &Button, &Temp);
Button.VSplitMid(&Button, &Label);
// scrollbar
Temp.HSplitTop(16.0f, &Button, &Temp);
Button.VMargin(4.0f, &Button);
s_ScrollValue = DoScrollbarH(&s_Scrollbar, &Button, s_ScrollValue);
Temp.HSplitTop(68.0f, &Button, &Temp);
UI()->ClipEnable(&Button);
Button.HMargin(5.0f, &Button);
Button.VSplitLeft(7.5f, 0, &Button);
int Offset = 2*30.0f + 80 * (NumIdentities - 4);
if(Offset > 0)
Button.x -= Offset * s_ScrollValue;
for(int i = 0; i < NumIdentities; i++)
{
CIdentity::CIdentEntry *pIdent = m_pClient->m_pIdentity->GetIdent(i);
if(pIdent == NULL)
continue;
const CSkins::CSkin *pSkin = NULL;
CTeeRenderInfo SkinInfo;
pSkin = m_pClient->m_pSkins->Get(m_pClient->m_pSkins->Find(pIdent->m_aSkin));
if(pIdent->m_UseCustomColor)
{
SkinInfo.m_Texture = pSkin->m_ColorTexture;
SkinInfo.m_ColorBody = m_pClient->m_pSkins->GetColorV4(pIdent->m_ColorBody);
SkinInfo.m_ColorFeet = m_pClient->m_pSkins->GetColorV4(pIdent->m_ColorFeet);
}
else
{
SkinInfo.m_Texture = pSkin->m_OrgTexture;
SkinInfo.m_ColorBody = vec4(1.0f, 1.0f, 1.0f, 1.0f);
SkinInfo.m_ColorFeet = vec4(1.0f, 1.0f, 1.0f, 1.0f);
}
Button.VSplitLeft(80.0f, &Label, &Button);
static int s_Button[512] = {0};
if(DoButton_Menu(&s_Button[i], "", 0, &Label, 0, CUI::CORNER_ALL, pIdent->m_UseCustomColor ? mix(SkinInfo.m_ColorBody, SkinInfo.m_ColorFeet, 0.4f)*0.7f :
vec4(pSkin->m_BloodColor.r, pSkin->m_BloodColor.g, pSkin->m_BloodColor.b, 0.7f)))
{
CIdentity::CIdentEntry *pIdent = m_pClient->m_pIdentity->GetIdent(i);
str_format(g_Config.m_PlayerName, sizeof(g_Config.m_PlayerName), pIdent->m_aName);
str_format(g_Config.m_PlayerClan, sizeof(g_Config.m_PlayerClan), pIdent->m_aClan);
str_format(g_Config.m_ClPlayerSkin, sizeof(g_Config.m_ClPlayerSkin), pIdent->m_aSkin);
g_Config.m_ClPlayerUseCustomColor = pIdent->m_UseCustomColor;
g_Config.m_ClPlayerColorBody = pIdent->m_ColorBody;
g_Config.m_ClPlayerColorFeet = pIdent->m_ColorFeet;
m_pClient->SendInfo(false);
}
SkinInfo.m_Size = 50.0f*UI()->Scale();
RenderTools()->RenderTee(CAnimState::GetIdle(), &SkinInfo, 0, vec2(1, 0), vec2(Label.x + Label.w * 0.5f, Label.y + Label.h * 0.5f + 8.0f));
Label.HSplitBottom(15.0f, 0, &Label);
Label.y = Button.y;
// some h4XoRinG right here to get awesome R41NB0W!!
static float s_Hue = 1000.0f;
if(s_Hue > 1.0f) s_Hue = RgbToHsl(vec3(1.0f, 0.0f, 0.0f)).h;
s_Hue += 0.0007f;
vec3 rgb = HslToRgb(vec3(s_Hue, 1.0f, 0.5f));
RenderTools()->DrawUIRect(&Label, GameClient()->m_pIdentity->UsingIdent(i) ? vec4(rgb.r, rgb.g, rgb.b, 0.71f) :
vec4(pSkin->m_BloodColor.r * 0.3f, pSkin->m_BloodColor.g * 0.3f, pSkin->m_BloodColor.b * 0.3f, 0.95f), CUI::CORNER_T, 4.0f);
UI()->DoLabelScaled(&Label, pIdent->m_aName, 10.0f, 0);
Button.VSplitLeft(15.0f, 0, &Button);
}
UI()->ClipDisable();
}
void CMenus::RenderServerControl(CUIRect MainView)
{
static int s_ControlPage = 0;
// render background
CUIRect Bottom, Extended, TabBar, Button;
MainView.HSplitTop(20.0f, &Bottom, &MainView);
RenderTools()->DrawUIRect(&Bottom, ms_ColorTabbarActive, CUI::CORNER_T, 10.0f);
MainView.HSplitTop(20.0f, &TabBar, &MainView);
RenderTools()->DrawUIRect(&MainView, ms_ColorTabbarActive, CUI::CORNER_B, 10.0f);
MainView.Margin(10.0f, &MainView);
MainView.HSplitBottom(90.0f, &MainView, &Extended);
// tab bar
{
TabBar.VSplitLeft(TabBar.w/3, &Button, &TabBar);
static int s_Button0 = 0;
if(DoButton_MenuTab(&s_Button0, Localize("Change settings"), s_ControlPage == 0, &Button, 0))
s_ControlPage = 0;
TabBar.VSplitMid(&Button, &TabBar);
static int s_Button1 = 0;
if(DoButton_MenuTab(&s_Button1, Localize("Kick player"), s_ControlPage == 1, &Button, 0))
s_ControlPage = 1;
static int s_Button2 = 0;
if(DoButton_MenuTab(&s_Button2, Localize("Move player to spectators"), s_ControlPage == 2, &TabBar, 0))
s_ControlPage = 2;
}
// render page
MainView.HSplitBottom(ms_ButtonHeight + 5*2, &MainView, &Bottom);
Bottom.HMargin(5.0f, &Bottom);
if(s_ControlPage == 0)
RenderServerControlServer(MainView);
else if(s_ControlPage == 1)
RenderServerControlKick(MainView, false);
else if(s_ControlPage == 2)
RenderServerControlKick(MainView, true);
// vote menu
{
CUIRect Button;
Bottom.VSplitRight(120.0f, &Bottom, &Button);
static int s_CallVoteButton = 0;
if(DoButton_Menu(&s_CallVoteButton, Localize("Call vote"), 0, &Button))
{
if(s_ControlPage == 0)
m_pClient->m_pVoting->CallvoteOption(m_CallvoteSelectedOption, m_aCallvoteReason);
else if(s_ControlPage == 1)
{
if(m_CallvoteSelectedPlayer >= 0 && m_CallvoteSelectedPlayer < MAX_CLIENTS &&
m_pClient->m_Snap.m_paPlayerInfos[m_CallvoteSelectedPlayer])
{
m_pClient->m_pVoting->CallvoteKick(m_CallvoteSelectedPlayer, m_aCallvoteReason);
SetActive(false);
}
}
else if(s_ControlPage == 2)
{
if(m_CallvoteSelectedPlayer >= 0 && m_CallvoteSelectedPlayer < MAX_CLIENTS &&
m_pClient->m_Snap.m_paPlayerInfos[m_CallvoteSelectedPlayer])
{
m_pClient->m_pVoting->CallvoteSpectate(m_CallvoteSelectedPlayer, m_aCallvoteReason);
SetActive(false);
}
}
m_aCallvoteReason[0] = 0;
}
// render kick reason
CUIRect Reason;
Bottom.VSplitRight(40.0f, &Bottom, 0);
Bottom.VSplitRight(160.0f, &Bottom, &Reason);
Reason.HSplitTop(5.0f, 0, &Reason);
const char *pLabel = Localize("Reason:");
UI()->DoLabelScaled(&Reason, pLabel, 14.0f, -1);
float w = TextRender()->TextWidth(0, 14.0f, pLabel, -1);
Reason.VSplitLeft(w+10.0f, 0, &Reason);
static float s_Offset = 0.0f;
DoEditBox(&m_aCallvoteReason, &Reason, m_aCallvoteReason, sizeof(m_aCallvoteReason), 14.0f, &s_Offset, false, CUI::CORNER_ALL);
// extended features (only available when authed in rcon)
if(Client()->RconAuthed())
{
// background
Extended.Margin(10.0f, &Extended);
Extended.HSplitTop(20.0f, &Bottom, &Extended);
Extended.HSplitTop(5.0f, 0, &Extended);
// force vote
Bottom.VSplitLeft(5.0f, 0, &Bottom);
Bottom.VSplitLeft(120.0f, &Button, &Bottom);
static int s_ForceVoteButton = 0;
if(DoButton_Menu(&s_ForceVoteButton, Localize("Force vote"), 0, &Button))
{
if(s_ControlPage == 0)
m_pClient->m_pVoting->CallvoteOption(m_CallvoteSelectedOption, m_aCallvoteReason, true);
else if(s_ControlPage == 1)
{
if(m_CallvoteSelectedPlayer >= 0 && m_CallvoteSelectedPlayer < MAX_CLIENTS &&
m_pClient->m_Snap.m_paPlayerInfos[m_CallvoteSelectedPlayer])
{
m_pClient->m_pVoting->CallvoteKick(m_CallvoteSelectedPlayer, m_aCallvoteReason, true);
SetActive(false);
}
}
else if(s_ControlPage == 2)
{
if(m_CallvoteSelectedPlayer >= 0 && m_CallvoteSelectedPlayer < MAX_CLIENTS &&
m_pClient->m_Snap.m_paPlayerInfos[m_CallvoteSelectedPlayer])
{
m_pClient->m_pVoting->CallvoteSpectate(m_CallvoteSelectedPlayer, m_aCallvoteReason, true);
SetActive(false);
}
}
m_aCallvoteReason[0] = 0;
}
if(s_ControlPage == 0)
{
// remove vote
Bottom.VSplitRight(10.0f, &Bottom, 0);
Bottom.VSplitRight(120.0f, 0, &Button);
static int s_RemoveVoteButton = 0;
if(DoButton_Menu(&s_RemoveVoteButton, Localize("Remove"), 0, &Button))
m_pClient->m_pVoting->RemovevoteOption(m_CallvoteSelectedOption);
// add vote
Extended.HSplitTop(20.0f, &Bottom, &Extended);
Bottom.VSplitLeft(5.0f, 0, &Bottom);
Bottom.VSplitLeft(250.0f, &Button, &Bottom);
UI()->DoLabelScaled(&Button, Localize("Vote description:"), 14.0f, -1);
Bottom.VSplitLeft(20.0f, 0, &Button);
UI()->DoLabelScaled(&Button, Localize("Vote command:"), 14.0f, -1);
static char s_aVoteDescription[64] = {0};
static char s_aVoteCommand[512] = {0};
Extended.HSplitTop(20.0f, &Bottom, &Extended);
Bottom.VSplitRight(10.0f, &Bottom, 0);
Bottom.VSplitRight(120.0f, &Bottom, &Button);
static int s_AddVoteButton = 0;
if(DoButton_Menu(&s_AddVoteButton, Localize("Add"), 0, &Button))
if(s_aVoteDescription[0] != 0 && s_aVoteCommand[0] != 0)
m_pClient->m_pVoting->AddvoteOption(s_aVoteDescription, s_aVoteCommand);
Bottom.VSplitLeft(5.0f, 0, &Bottom);
Bottom.VSplitLeft(250.0f, &Button, &Bottom);
static float s_OffsetDesc = 0.0f;
DoEditBox(&s_aVoteDescription, &Button, s_aVoteDescription, sizeof(s_aVoteDescription), 14.0f, &s_OffsetDesc, false, CUI::CORNER_ALL);
Bottom.VMargin(20.0f, &Button);
static float s_OffsetCmd = 0.0f;
DoEditBox(&s_aVoteCommand, &Button, s_aVoteCommand, sizeof(s_aVoteCommand), 14.0f, &s_OffsetCmd, false, CUI::CORNER_ALL);
}
}
}
}
void CMenus::RenderServerbrowserServerList(CUIRect View)
{
CUIRect Headers;
CUIRect Status;
View.HSplitTop(ms_ListheaderHeight, &Headers, &View);
View.HSplitBottom(28.0f, &View, &Status);
// split of the scrollbar
RenderTools()->DrawUIRect(&Headers, vec4(1,1,1,0.25f), CUI::CORNER_T, 5.0f);
Headers.VSplitRight(20.0f, &Headers, 0);
struct CColumn
{
int m_Id;
int m_Sort;
CLocConstString m_Caption;
int m_Direction;
float m_Width;
int m_Flags;
CUIRect m_Rect;
CUIRect m_Spacer;
};
enum
{
FIXED=1,
SPACER=2,
COL_FLAG_LOCK=0,
COL_FLAG_PURE,
COL_FLAG_FAV,
COL_NAME,
COL_GAMETYPE,
COL_MAP,
COL_PLAYERS,
COL_PING,
COL_VERSION,
};
static CColumn s_aCols[] = {
{-1, -1, " ", -1, 2.0f, 0, {0}, {0}},
{COL_FLAG_LOCK, -1, " ", -1, 14.0f, 0, {0}, {0}},
{COL_FLAG_PURE, -1, " ", -1, 14.0f, 0, {0}, {0}},
{COL_FLAG_FAV, -1, " ", -1, 14.0f, 0, {0}, {0}},
{COL_NAME, IServerBrowser::SORT_NAME, "Name", 0, 300.0f, 0, {0}, {0}}, // Localize - these strings are localized within CLocConstString
{COL_GAMETYPE, IServerBrowser::SORT_GAMETYPE, "Type", 1, 50.0f, 0, {0}, {0}},
{COL_MAP, IServerBrowser::SORT_MAP, "Map", 1, 100.0f, 0, {0}, {0}},
{COL_PLAYERS, IServerBrowser::SORT_NUMPLAYERS, "Players", 1, 60.0f, 0, {0}, {0}},
{-1, -1, " ", 1, 10.0f, 0, {0}, {0}},
{COL_PING, IServerBrowser::SORT_PING, "Ping", 1, 40.0f, FIXED, {0}, {0}},
};
int NumCols = sizeof(s_aCols)/sizeof(CColumn);
// do layout
for(int i = 0; i < NumCols; i++)
{
if(s_aCols[i].m_Direction == -1)
{
Headers.VSplitLeft(s_aCols[i].m_Width, &s_aCols[i].m_Rect, &Headers);
if(i+1 < NumCols)
{
//Cols[i].flags |= SPACER;
Headers.VSplitLeft(2, &s_aCols[i].m_Spacer, &Headers);
}
}
}
for(int i = NumCols-1; i >= 0; i--)
{
if(s_aCols[i].m_Direction == 1)
{
Headers.VSplitRight(s_aCols[i].m_Width, &Headers, &s_aCols[i].m_Rect);
Headers.VSplitRight(2, &Headers, &s_aCols[i].m_Spacer);
}
}
for(int i = 0; i < NumCols; i++)
{
if(s_aCols[i].m_Direction == 0)
s_aCols[i].m_Rect = Headers;
}
// do headers
for(int i = 0; i < NumCols; i++)
{
if(DoButton_GridHeader(s_aCols[i].m_Caption, s_aCols[i].m_Caption, g_Config.m_BrSort == s_aCols[i].m_Sort, &s_aCols[i].m_Rect))
{
if(s_aCols[i].m_Sort != -1)
{
if(g_Config.m_BrSort == s_aCols[i].m_Sort)
g_Config.m_BrSortOrder ^= 1;
else
g_Config.m_BrSortOrder = 0;
g_Config.m_BrSort = s_aCols[i].m_Sort;
}
}
}
RenderTools()->DrawUIRect(&View, vec4(0,0,0,0.15f), 0, 0);
CUIRect Scroll;
View.VSplitRight(15, &View, &Scroll);
int NumServers = ServerBrowser()->NumSortedServers();
// display important messages in the middle of the screen so no
// users misses it
{
CUIRect MsgBox = View;
MsgBox.y += View.h/3;
if(m_ActivePage == PAGE_INTERNET && ServerBrowser()->IsRefreshingMasters())
UI()->DoLabel(&MsgBox, Localize("Refreshing master servers"), 16.0f, 0);
else if(!ServerBrowser()->NumServers())
UI()->DoLabel(&MsgBox, Localize("No servers found"), 16.0f, 0);
else if(ServerBrowser()->NumServers() && !NumServers)
UI()->DoLabel(&MsgBox, Localize("No servers match your filter criteria"), 16.0f, 0);
}
int Num = (int)(View.h/s_aCols[0].m_Rect.h);
static int s_ScrollBar = 0;
static float s_ScrollValue = 0;
Scroll.HMargin(5.0f, &Scroll);
s_ScrollValue = DoScrollbarV(&s_ScrollBar, &Scroll, s_ScrollValue);
int ScrollNum = NumServers-Num+10;
if(ScrollNum > 0)
{
if(Input()->KeyPresses(KEY_MOUSE_WHEEL_UP))
s_ScrollValue -= 1.0f/ScrollNum;
if(Input()->KeyPresses(KEY_MOUSE_WHEEL_DOWN))
s_ScrollValue += 1.0f/ScrollNum;
}
else
ScrollNum = 0;
if(m_SelectedIndex > -1)
{
for(int i = 0; i < m_NumInputEvents; i++)
{
int NewIndex = -1;
if(m_aInputEvents[i].m_Flags&IInput::FLAG_PRESS)
{
if(m_aInputEvents[i].m_Key == KEY_DOWN) NewIndex = m_SelectedIndex + 1;
if(m_aInputEvents[i].m_Key == KEY_UP) NewIndex = m_SelectedIndex - 1;
}
if(NewIndex > -1 && NewIndex < NumServers)
{
//scroll
if(ScrollNum)
{
if(NewIndex - m_SelectedIndex > 0)
s_ScrollValue += 1.0f/ScrollNum;
else
s_ScrollValue -= 1.0f/ScrollNum;
}
m_SelectedIndex = NewIndex;
const CServerInfo *pItem = ServerBrowser()->SortedGet(m_SelectedIndex);
str_copy(g_Config.m_UiServerAddress, pItem->m_aAddress, sizeof(g_Config.m_UiServerAddress));
}
}
}
if(s_ScrollValue < 0) s_ScrollValue = 0;
if(s_ScrollValue > 1) s_ScrollValue = 1;
// set clipping
UI()->ClipEnable(&View);
CUIRect OriginalView = View;
View.y -= s_ScrollValue*ScrollNum*s_aCols[0].m_Rect.h;
int NewSelected = -1;
int NumPlayers = 0;
m_SelectedIndex = -1;
for (int i = 0; i < NumServers; i++)
{
const CServerInfo *pItem = ServerBrowser()->SortedGet(i);
NumPlayers += pItem->m_NumPlayers;
}
for (int i = 0; i < NumServers; i++)
{
int ItemIndex = i;
const CServerInfo *pItem = ServerBrowser()->SortedGet(ItemIndex);
CUIRect Row;
CUIRect SelectHitBox;
int Selected = str_comp(pItem->m_aAddress, g_Config.m_UiServerAddress) == 0; //selected_index==ItemIndex;
View.HSplitTop(17.0f, &Row, &View);
SelectHitBox = Row;
if(Selected)
m_SelectedIndex = i;
// make sure that only those in view can be selected
if(Row.y+Row.h > OriginalView.y && Row.y < OriginalView.y+OriginalView.h)
{
if(Selected)
{
CUIRect r = Row;
r.Margin(1.5f, &r);
RenderTools()->DrawUIRect(&r, vec4(1,1,1,0.5f), CUI::CORNER_ALL, 4.0f);
}
// clip the selection
if(SelectHitBox.y < OriginalView.y) // top
{
SelectHitBox.h -= OriginalView.y-SelectHitBox.y;
SelectHitBox.y = OriginalView.y;
}
else if(SelectHitBox.y+SelectHitBox.h > OriginalView.y+OriginalView.h) // bottom
SelectHitBox.h = OriginalView.y+OriginalView.h-SelectHitBox.y;
if(UI()->DoButtonLogic(pItem, "", Selected, &SelectHitBox))
{
NewSelected = ItemIndex;
}
}
else
{
// reset active item, if not visible
if(UI()->ActiveItem() == pItem)
UI()->SetActiveItem(0);
// don't render invisible items
continue;
}
for(int c = 0; c < NumCols; c++)
{
CUIRect Button;
char aTemp[64];
Button.x = s_aCols[c].m_Rect.x;
Button.y = Row.y;
Button.h = Row.h;
Button.w = s_aCols[c].m_Rect.w;
int Id = s_aCols[c].m_Id;
if(Id == COL_FLAG_LOCK)
{
if(pItem->m_Flags & SERVER_FLAG_PASSWORD)
DoButton_BrowseIcon(SPRITE_BROWSE_LOCK, &Button);
}
else if(Id == COL_FLAG_PURE)
{
if( str_comp(pItem->m_aGameType, "DM") == 0 ||
str_comp(pItem->m_aGameType, "TDM") == 0 ||
str_comp(pItem->m_aGameType, "CTF") == 0)
{
// pure server
}
else
{
// unpure
DoButton_BrowseIcon(SPRITE_BROWSE_UNPURE, &Button);
}
}
else if(Id == COL_FLAG_FAV)
{
if(pItem->m_Favorite)
DoButton_BrowseIcon(SPRITE_BROWSE_HEART, &Button);
}
else if(Id == COL_NAME)
{
CTextCursor Cursor;
TextRender()->SetCursor(&Cursor, Button.x, Button.y, 12.0f, TEXTFLAG_RENDER|TEXTFLAG_STOP_AT_END);
Cursor.m_LineWidth = Button.w;
if(g_Config.m_BrFilterString[0] && (pItem->m_QuickSearchHit&IServerBrowser::QUICK_SERVERNAME))
{
// highlight the parts that matches
const char *s = str_find_nocase(pItem->m_aName, g_Config.m_BrFilterString);
if(s)
{
TextRender()->TextEx(&Cursor, pItem->m_aName, (int)(s-pItem->m_aName));
TextRender()->TextColor(0.4f,0.4f,1.0f,1);
TextRender()->TextEx(&Cursor, s, str_length(g_Config.m_BrFilterString));
TextRender()->TextColor(1,1,1,1);
TextRender()->TextEx(&Cursor, s+str_length(g_Config.m_BrFilterString), -1);
}
else
TextRender()->TextEx(&Cursor, pItem->m_aName, -1);
}
else
TextRender()->TextEx(&Cursor, pItem->m_aName, -1);
}
else if(Id == COL_MAP)
{
CTextCursor Cursor;
TextRender()->SetCursor(&Cursor, Button.x, Button.y, 12.0f, TEXTFLAG_RENDER|TEXTFLAG_STOP_AT_END);
Cursor.m_LineWidth = Button.w;
TextRender()->TextEx(&Cursor, pItem->m_aMap, -1);
}
else if(Id == COL_PLAYERS)
{
str_format(aTemp, sizeof(aTemp), "%i/%i", pItem->m_NumPlayers, pItem->m_MaxPlayers);
if(g_Config.m_BrFilterString[0] && (pItem->m_QuickSearchHit&IServerBrowser::QUICK_PLAYERNAME))
TextRender()->TextColor(0.4f,0.4f,1.0f,1);
UI()->DoLabel(&Button, aTemp, 12.0f, 1);
TextRender()->TextColor(1,1,1,1);
}
else if(Id == COL_PING)
{
str_format(aTemp, sizeof(aTemp), "%i", pItem->m_Latency);
UI()->DoLabel(&Button, aTemp, 12.0f, 1);
}
else if(Id == COL_VERSION)
{
const char *pVersion = pItem->m_aVersion;
if(str_comp(pVersion, "0.3 e2d7973c6647a13c") == 0) // TODO: remove me later on
pVersion = "0.3.0";
UI()->DoLabel(&Button, pVersion, 12.0f, 1);
}
else if(Id == COL_GAMETYPE)
{
CTextCursor Cursor;
TextRender()->SetCursor(&Cursor, Button.x, Button.y, 12.0f, TEXTFLAG_RENDER|TEXTFLAG_STOP_AT_END);
Cursor.m_LineWidth = Button.w;
TextRender()->TextEx(&Cursor, pItem->m_aGameType, -1);
}
}
}
UI()->ClipDisable();
if(NewSelected != -1)
{
// select the new server
const CServerInfo *pItem = ServerBrowser()->SortedGet(NewSelected);
str_copy(g_Config.m_UiServerAddress, pItem->m_aAddress, sizeof(g_Config.m_UiServerAddress));
if(Input()->MouseDoubleClick())
Client()->Connect(g_Config.m_UiServerAddress);
}
RenderTools()->DrawUIRect(&Status, vec4(1,1,1,0.25f), CUI::CORNER_B, 5.0f);
Status.Margin(5.0f, &Status);
// render quick search
CUIRect QuickSearch, Button;
Status.VSplitLeft(260.0f, &QuickSearch, &Status);
const char *pLabel = Localize("Quick search:");
UI()->DoLabel(&QuickSearch, pLabel, 12.0f, -1);
float w = TextRender()->TextWidth(0, 12.0f, pLabel, -1);
QuickSearch.VSplitLeft(w, 0, &QuickSearch);
QuickSearch.VSplitLeft(5.0f, 0, &QuickSearch);
QuickSearch.VSplitLeft(260.0f-w-22.0f, &QuickSearch, &Button);
static float Offset = 0.0f;
DoEditBox(&g_Config.m_BrFilterString, &QuickSearch, g_Config.m_BrFilterString, sizeof(g_Config.m_BrFilterString), 12.0f, &Offset, false, CUI::CORNER_L);
// clear button
{
static int s_ClearButton = 0;
RenderTools()->DrawUIRect(&Button, vec4(1,1,1,0.33f)*ButtonColorMul(&s_ClearButton), CUI::CORNER_R, 3.0f);
UI()->DoLabel(&Button, "x", Button.h*ms_FontmodHeight, 0);
if(UI()->DoButtonLogic(&s_ClearButton, "x", 0, &Button))
{
g_Config.m_BrFilterString[0] = 0;
UI()->SetActiveItem(&g_Config.m_BrFilterString);
}
}
// render status
char aBuf[128];
str_format(aBuf, sizeof(aBuf), Localize("%d of %d servers, %d players"), ServerBrowser()->NumSortedServers(), ServerBrowser()->NumServers(), NumPlayers);
Status.VSplitRight(TextRender()->TextWidth(0, 14.0f, aBuf, -1), 0, &Status);
UI()->DoLabel(&Status, aBuf, 14.0f, -1);
}
void CHud::RenderScoreHud()
{
// render small score hud
if(!(m_pClient->m_Snap.m_pGameData->m_GameStateFlags&(GAMESTATEFLAG_ROUNDOVER|GAMESTATEFLAG_GAMEOVER)))
{
int GameFlags = m_pClient->m_GameInfo.m_GameFlags;
float Whole = 300*Graphics()->ScreenAspect();
float StartY = 229.0f;
if(GameFlags&GAMEFLAG_TEAMS && m_pClient->m_Snap.m_pGameDataTeam)
{
char aScoreTeam[2][32];
str_format(aScoreTeam[TEAM_RED], sizeof(aScoreTeam)/2, "%d", m_pClient->m_Snap.m_pGameDataTeam->m_TeamscoreRed);
str_format(aScoreTeam[TEAM_BLUE], sizeof(aScoreTeam)/2, "%d", m_pClient->m_Snap.m_pGameDataTeam->m_TeamscoreBlue);
float aScoreTeamWidth[2] = { TextRender()->TextWidth(0, 14.0f, aScoreTeam[TEAM_RED], -1), TextRender()->TextWidth(0, 14.0f, aScoreTeam[TEAM_BLUE], -1) };
float ScoreWidthMax = max(max(aScoreTeamWidth[TEAM_RED], aScoreTeamWidth[TEAM_BLUE]), TextRender()->TextWidth(0, 14.0f, "100", -1));
float Split = 3.0f;
float ImageSize = GameFlags&GAMEFLAG_FLAGS ? 16.0f : Split;
for(int t = 0; t < NUM_TEAMS; t++)
{
// draw box
Graphics()->BlendNormal();
Graphics()->TextureClear();
Graphics()->QuadsBegin();
if(t == 0)
Graphics()->SetColor(1.0f, 0.0f, 0.0f, 0.25f);
else
Graphics()->SetColor(0.0f, 0.0f, 1.0f, 0.25f);
RenderTools()->DrawRoundRectExt(Whole-ScoreWidthMax-ImageSize-2*Split, StartY+t*20, ScoreWidthMax+ImageSize+2*Split, 18.0f, 5.0f, CUI::CORNER_L);
Graphics()->QuadsEnd();
// draw score
TextRender()->Text(0, Whole-ScoreWidthMax+(ScoreWidthMax-aScoreTeamWidth[t])/2-Split, StartY+t*20, 14.0f, aScoreTeam[t], -1);
if(GameFlags&GAMEFLAG_SURVIVAL)
{
// draw number of alive players
char aBuf[32];
str_format(aBuf, sizeof(aBuf), m_pClient->m_Snap.m_AliveCount[t]==1 ? Localize("%d player left") : Localize("%d players left"),
m_pClient->m_Snap.m_AliveCount[t]);
float w = TextRender()->TextWidth(0, 8.0f, aBuf, -1);
TextRender()->Text(0, min(Whole-w-1.0f, Whole-ScoreWidthMax-ImageSize-2*Split), StartY+(t+1)*20.0f-3.0f, 8.0f, aBuf, -1);
}
StartY += 8.0f;
}
if(GameFlags&GAMEFLAG_FLAGS && m_pClient->m_Snap.m_pGameDataFlag)
{
int FlagCarrier[2] = { m_pClient->m_Snap.m_pGameDataFlag->m_FlagCarrierRed, m_pClient->m_Snap.m_pGameDataFlag->m_FlagCarrierBlue };
int FlagDropTick[2] = { m_pClient->m_Snap.m_pGameDataFlag->m_FlagDropTickRed, m_pClient->m_Snap.m_pGameDataFlag->m_FlagDropTickBlue };
StartY = 229.0f;
for(int t = 0; t < 2; t++)
{
int BlinkTimer = (FlagDropTick[t] != 0 && (Client()->GameTick()-FlagDropTick[t])/Client()->GameTickSpeed() >= 25) ? 10 : 20;
if(FlagCarrier[t] == FLAG_ATSTAND || (FlagCarrier[t] == FLAG_TAKEN && ((Client()->GameTick()/BlinkTimer)&1)))
{
// draw flag
Graphics()->BlendNormal();
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_GAME].m_Id);
Graphics()->QuadsBegin();
RenderTools()->SelectSprite(t==0?SPRITE_FLAG_RED:SPRITE_FLAG_BLUE);
IGraphics::CQuadItem QuadItem(Whole-ScoreWidthMax-ImageSize, StartY+1.0f+t*20, ImageSize/2, ImageSize);
Graphics()->QuadsDrawTL(&QuadItem, 1);
Graphics()->QuadsEnd();
}
else if(FlagCarrier[t] >= 0)
{
// draw name of the flag holder
int ID = FlagCarrier[t]%MAX_CLIENTS;
const char *pName = m_pClient->m_aClients[ID].m_aName;
float w = TextRender()->TextWidth(0, 8.0f, pName, -1);
TextRender()->Text(0, min(Whole-w-1.0f, Whole-ScoreWidthMax-ImageSize-2*Split), StartY+(t+1)*20.0f-3.0f, 8.0f, pName, -1);
// draw tee of the flag holder
CTeeRenderInfo Info = m_pClient->m_aClients[ID].m_RenderInfo;
Info.m_Size = 18.0f;
RenderTools()->RenderTee(CAnimState::GetIdle(), &Info, EMOTE_NORMAL, vec2(1,0),
vec2(Whole-ScoreWidthMax-Info.m_Size/2-Split, StartY+1.0f+Info.m_Size/2+t*20));
}
StartY += 8.0f;
}
}
}
else
{
int Local = -1;
int aPos[2] = { 1, 2 };
CGameClient::CPlayerInfoItem aPlayerInfo[2] = {{0}};
int i = 0;
for(int t = 0; t < 2 && i < MAX_CLIENTS && m_pClient->m_Snap.m_aInfoByScore[i].m_pPlayerInfo; ++i)
{
if(m_pClient->m_aClients[m_pClient->m_Snap.m_aInfoByScore[i].m_ClientID].m_Team != TEAM_SPECTATORS)
{
aPlayerInfo[t] = m_pClient->m_Snap.m_aInfoByScore[i];
if(aPlayerInfo[t].m_ClientID == m_pClient->m_LocalClientID)
Local = t;
++t;
}
}
// search local player info if not a spectator, nor within top2 scores
if(Local == -1 && m_pClient->m_aClients[m_pClient->m_LocalClientID].m_Team != TEAM_SPECTATORS)
{
for(; i < MAX_CLIENTS && m_pClient->m_Snap.m_aInfoByScore[i].m_pPlayerInfo; ++i)
{
if(m_pClient->m_aClients[m_pClient->m_Snap.m_aInfoByScore[i].m_ClientID].m_Team != TEAM_SPECTATORS)
++aPos[1];
if(m_pClient->m_Snap.m_aInfoByScore[i].m_ClientID == m_pClient->m_LocalClientID)
{
aPlayerInfo[1] = m_pClient->m_Snap.m_aInfoByScore[i];
Local = 1;
break;
}
}
}
char aScore[2][32];
for(int t = 0; t < 2; ++t)
{
if(aPlayerInfo[t].m_pPlayerInfo)
str_format(aScore[t], sizeof(aScore)/2, "%d", aPlayerInfo[t].m_pPlayerInfo->m_Score);
else
aScore[t][0] = 0;
}
float aScoreWidth[2] = {TextRender()->TextWidth(0, 14.0f, aScore[0], -1), TextRender()->TextWidth(0, 14.0f, aScore[1], -1)};
float ScoreWidthMax = max(max(aScoreWidth[0], aScoreWidth[1]), TextRender()->TextWidth(0, 14.0f, "10", -1));
float Split = 3.0f, ImageSize = 16.0f, PosSize = 16.0f;
// todo: add core hud for LMS
for(int t = 0; t < 2; t++)
{
// draw box
Graphics()->BlendNormal();
Graphics()->TextureClear();
Graphics()->QuadsBegin();
if(t == Local)
Graphics()->SetColor(1.0f, 1.0f, 1.0f, 0.25f);
else
Graphics()->SetColor(0.0f, 0.0f, 0.0f, 0.25f);
RenderTools()->DrawRoundRectExt(Whole-ScoreWidthMax-ImageSize-2*Split-PosSize, StartY+t*20, ScoreWidthMax+ImageSize+2*Split+PosSize, 18.0f, 5.0f, CUI::CORNER_L);
Graphics()->QuadsEnd();
// draw score
TextRender()->Text(0, Whole-ScoreWidthMax+(ScoreWidthMax-aScoreWidth[t])/2-Split, StartY+t*20, 14.0f, aScore[t], -1);
if(aPlayerInfo[t].m_pPlayerInfo)
{
// draw name
int ID = aPlayerInfo[t].m_ClientID;
const char *pName = m_pClient->m_aClients[ID].m_aName;
float w = TextRender()->TextWidth(0, 8.0f, pName, -1);
TextRender()->Text(0, min(Whole-w-1.0f, Whole-ScoreWidthMax-ImageSize-2*Split-PosSize), StartY+(t+1)*20.0f-3.0f, 8.0f, pName, -1);
// draw tee
CTeeRenderInfo Info = m_pClient->m_aClients[ID].m_RenderInfo;
Info.m_Size = 18.0f;
RenderTools()->RenderTee(CAnimState::GetIdle(), &Info, EMOTE_NORMAL, vec2(1,0),
vec2(Whole-ScoreWidthMax-Info.m_Size/2-Split, StartY+1.0f+Info.m_Size/2+t*20));
}
// draw position
char aBuf[32];
str_format(aBuf, sizeof(aBuf), "%d.", aPos[t]);
TextRender()->Text(0, Whole-ScoreWidthMax-ImageSize-Split-PosSize, StartY+2.0f+t*20, 10.0f, aBuf, -1);
StartY += 8.0f;
}
}
}
}
void CMenus::RenderServerbrowserServerDetail(CUIRect View)
{
CUIRect ServerDetails = View;
CUIRect ServerScoreBoard, ServerHeader;
const CServerInfo *pSelectedServer = ServerBrowser()->SortedGet(m_SelectedIndex);
//server_details.VSplitLeft(10.0f, 0x0, &server_details);
// split off a piece to use for scoreboard
ServerDetails.HSplitTop(140.0f, &ServerDetails, &ServerScoreBoard);
ServerDetails.HSplitBottom(10.0f, &ServerDetails, 0x0);
// server details
const float FontSize = 12.0f;
ServerDetails.HSplitTop(20.0f, &ServerHeader, &ServerDetails);
RenderTools()->DrawUIRect(&ServerHeader, vec4(1,1,1,0.25f), CUI::CORNER_T, 4.0f);
RenderTools()->DrawUIRect(&ServerDetails, vec4(0,0,0,0.15f), CUI::CORNER_B, 4.0f);
ServerHeader.VSplitLeft(8.0f, 0x0, &ServerHeader);
UI()->DoLabel(&ServerHeader, Localize("Server details"), FontSize+2.0f, -1);
ServerDetails.VSplitLeft(5.0f, 0x0, &ServerDetails);
ServerDetails.Margin(3.0f, &ServerDetails);
if (pSelectedServer)
{
CUIRect Row;
static CLocConstString s_aLabels[] = {
"Version", // Localize - these strings are localized within CLocConstString
"Game type",
"Ping"};
CUIRect LeftColumn;
CUIRect RightColumn;
//
{
CUIRect Button;
ServerDetails.HSplitBottom(20.0f, &ServerDetails, &Button);
static int s_AddFavButton = 0;
if(DoButton_CheckBox(&s_AddFavButton, Localize("Favorite"), pSelectedServer->m_Favorite, &Button))
{
if(pSelectedServer->m_Favorite)
ServerBrowser()->RemoveFavorite(pSelectedServer->m_NetAddr);
else
ServerBrowser()->AddFavorite(pSelectedServer->m_NetAddr);
}
}
//UI()->DoLabel(&row, temp, font_size, -1);
ServerDetails.VSplitLeft(5.0f, 0x0, &ServerDetails);
ServerDetails.VSplitLeft(80.0f, &LeftColumn, &RightColumn);
for (unsigned int i = 0; i < sizeof(s_aLabels) / sizeof(s_aLabels[0]); i++)
{
LeftColumn.HSplitTop(15.0f, &Row, &LeftColumn);
UI()->DoLabel(&Row, s_aLabels[i], FontSize, -1);
}
RightColumn.HSplitTop(15.0f, &Row, &RightColumn);
UI()->DoLabel(&Row, pSelectedServer->m_aVersion, FontSize, -1);
RightColumn.HSplitTop(15.0f, &Row, &RightColumn);
UI()->DoLabel(&Row, pSelectedServer->m_aGameType, FontSize, -1);
char aTemp[16];
str_format(aTemp, sizeof(aTemp), "%d", pSelectedServer->m_Latency);
RightColumn.HSplitTop(15.0f, &Row, &RightColumn);
UI()->DoLabel(&Row, aTemp, FontSize, -1);
}
// server scoreboard
ServerScoreBoard.HSplitBottom(10.0f, &ServerScoreBoard, 0x0);
ServerScoreBoard.HSplitTop(20.0f, &ServerHeader, &ServerScoreBoard);
RenderTools()->DrawUIRect(&ServerHeader, vec4(1,1,1,0.25f), CUI::CORNER_T, 4.0f);
RenderTools()->DrawUIRect(&ServerScoreBoard, vec4(0,0,0,0.15f), CUI::CORNER_B, 4.0f);
ServerHeader.VSplitLeft(8.0f, 0x0, &ServerHeader);
UI()->DoLabel(&ServerHeader, Localize("Scoreboard"), FontSize+2.0f, -1);
ServerScoreBoard.VSplitLeft(5.0f, 0x0, &ServerScoreBoard);
ServerScoreBoard.Margin(3.0f, &ServerScoreBoard);
if (pSelectedServer)
{
for (int i = 0; i < pSelectedServer->m_NumPlayers; i++)
{
CUIRect Row;
char aTemp[16];
ServerScoreBoard.HSplitTop(16.0f, &Row, &ServerScoreBoard);
str_format(aTemp, sizeof(aTemp), "%d", pSelectedServer->m_aPlayers[i].m_Score);
UI()->DoLabel(&Row, aTemp, FontSize, -1);
Row.VSplitLeft(25.0f, 0x0, &Row);
CTextCursor Cursor;
TextRender()->SetCursor(&Cursor, Row.x, Row.y, FontSize, TEXTFLAG_RENDER|TEXTFLAG_STOP_AT_END);
Cursor.m_LineWidth = Row.w;
const char *pName = pSelectedServer->m_aPlayers[i].m_aName;
if(g_Config.m_BrFilterString[0])
{
// highlight the parts that matches
const char *s = str_find_nocase(pName, g_Config.m_BrFilterString);
if(s)
{
TextRender()->TextEx(&Cursor, pName, (int)(s-pName));
TextRender()->TextColor(0.4f,0.4f,1,1);
TextRender()->TextEx(&Cursor, s, str_length(g_Config.m_BrFilterString));
TextRender()->TextColor(1,1,1,1);
TextRender()->TextEx(&Cursor, s+str_length(g_Config.m_BrFilterString), -1);
}
else
TextRender()->TextEx(&Cursor, pName, -1);
}
else
TextRender()->TextEx(&Cursor, pName, -1);
}
}
}
void CMenus::RenderSettingsTee(CUIRect MainView)
{
CUIRect Button, Label;
MainView.HSplitTop(10.0f, 0, &MainView);
// skin info
const CSkins::CSkin *pOwnSkin = m_pClient->m_pSkins->Get(m_pClient->m_pSkins->Find(g_Config.m_PlayerSkin));
CTeeRenderInfo OwnSkinInfo;
if(g_Config.m_PlayerUseCustomColor)
{
OwnSkinInfo.m_Texture = pOwnSkin->m_ColorTexture;
OwnSkinInfo.m_ColorBody = m_pClient->m_pSkins->GetColorV4(g_Config.m_PlayerColorBody);
OwnSkinInfo.m_ColorFeet = m_pClient->m_pSkins->GetColorV4(g_Config.m_PlayerColorFeet);
}
else
{
OwnSkinInfo.m_Texture = pOwnSkin->m_OrgTexture;
OwnSkinInfo.m_ColorBody = vec4(1.0f, 1.0f, 1.0f, 1.0f);
OwnSkinInfo.m_ColorFeet = vec4(1.0f, 1.0f, 1.0f, 1.0f);
}
OwnSkinInfo.m_Size = 50.0f*UI()->Scale();
MainView.HSplitTop(20.0f, &Label, &MainView);
Label.VSplitLeft(230.0f, &Label, 0);
char aBuf[128];
str_format(aBuf, sizeof(aBuf), "%s:", Localize("Your skin"));
UI()->DoLabelScaled(&Label, aBuf, 14.0f, -1);
MainView.HSplitTop(50.0f, &Label, &MainView);
Label.VSplitLeft(230.0f, &Label, 0);
RenderTools()->DrawUIRect(&Label, vec4(1.0f, 1.0f, 1.0f, 0.25f), CUI::CORNER_ALL, 10.0f);
RenderTools()->RenderTee(CAnimState::GetIdle(), &OwnSkinInfo, 0, vec2(1, 0), vec2(Label.x+30.0f, Label.y+28.0f));
Label.HSplitTop(15.0f, 0, &Label);;
Label.VSplitLeft(70.0f, 0, &Label);
UI()->DoLabelScaled(&Label, g_Config.m_PlayerSkin, 14.0f, -1, 150.0f);
// custom colour selector
MainView.HSplitTop(20.0f, 0, &MainView);
MainView.HSplitTop(20.0f, &Button, &MainView);
Button.VSplitLeft(230.0f, &Button, 0);
if(DoButton_CheckBox(&g_Config.m_PlayerColorBody, Localize("Custom colors"), g_Config.m_PlayerUseCustomColor, &Button))
{
g_Config.m_PlayerUseCustomColor = g_Config.m_PlayerUseCustomColor?0:1;
m_NeedSendinfo = true;
}
MainView.HSplitTop(5.0f, 0, &MainView);
MainView.HSplitTop(82.5f, &Label, &MainView);
if(g_Config.m_PlayerUseCustomColor)
{
CUIRect aRects[2];
Label.VSplitMid(&aRects[0], &aRects[1]);
aRects[0].VSplitRight(10.0f, &aRects[0], 0);
aRects[1].VSplitLeft(10.0f, 0, &aRects[1]);
int *paColors[2];
paColors[0] = &g_Config.m_PlayerColorBody;
paColors[1] = &g_Config.m_PlayerColorFeet;
const char *paParts[] = {
Localize("Body"),
Localize("Feet")};
const char *paLabels[] = {
Localize("Hue"),
Localize("Sat."),
Localize("Lht.")};
static int s_aColorSlider[2][3] = {{0}};
for(int i = 0; i < 2; i++)
{
aRects[i].HSplitTop(20.0f, &Label, &aRects[i]);
UI()->DoLabelScaled(&Label, paParts[i], 14.0f, -1);
aRects[i].VSplitLeft(20.0f, 0, &aRects[i]);
aRects[i].HSplitTop(2.5f, 0, &aRects[i]);
int PrevColor = *paColors[i];
int Color = 0;
for(int s = 0; s < 3; s++)
{
aRects[i].HSplitTop(20.0f, &Label, &aRects[i]);
Label.VSplitLeft(100.0f, &Label, &Button);
Button.HMargin(2.0f, &Button);
float k = ((PrevColor>>((2-s)*8))&0xff) / 255.0f;
k = DoScrollbarH(&s_aColorSlider[i][s], &Button, k);
Color <<= 8;
Color += clamp((int)(k*255), 0, 255);
UI()->DoLabelScaled(&Label, paLabels[s], 14.0f, -1);
}
if(PrevColor != Color)
m_NeedSendinfo = true;
*paColors[i] = Color;
}
}
void CMenus::RenderServerbrowser(CUIRect MainView)
{
RenderTools()->DrawUIRect(&MainView, ms_ColorTabbarActive, CUI::CORNER_ALL, 10.0f);
CUIRect View;
MainView.Margin(10.0f, &View);
/*
+-----------------+ +------+
| | | |
| | | tool |
| | | box |
| | | |
| | +------+
+-----------------+ button
status toolbar box
*/
//CUIRect filters;
CUIRect StatusToolBox;
CUIRect ToolBox;
CUIRect ButtonBox;
// split off a piece for filters, details and scoreboard
View.VSplitRight(200.0f, &View, &ToolBox);
ToolBox.HSplitBottom(80.0f, &ToolBox, &ButtonBox);
View.HSplitBottom(ms_ButtonHeight+5.0f, &View, &StatusToolBox);
RenderServerbrowserServerList(View);
int ToolboxPage = g_Config.m_UiToolboxPage;
ToolBox.VSplitLeft(5.0f, 0, &ToolBox);
// do tabbar
{
CUIRect TabBar;
CUIRect TabButton0, TabButton1;
ToolBox.HSplitTop(22.0f, &TabBar, &ToolBox);
TabBar.VSplitMid(&TabButton0, &TabButton1);
//TabButton0.VSplitRight(5.0f, &TabButton0, 0);
//TabButton1.VSplitLeft(5.0f, 0, &TabButton1);
static int s_FiltersTab = 0;
if (DoButton_MenuTab(&s_FiltersTab, Localize("Filter"), ToolboxPage==0, &TabButton0, CUI::CORNER_TL))
ToolboxPage = 0;
static int s_InfoTab = 0;
if (DoButton_MenuTab(&s_InfoTab, Localize("Info"), ToolboxPage==1, &TabButton1, CUI::CORNER_TR))
ToolboxPage = 1;
}
g_Config.m_UiToolboxPage = ToolboxPage;
RenderTools()->DrawUIRect(&ToolBox, vec4(0,0,0,0.15f), 0, 0);
ToolBox.HSplitTop(5.0f, 0, &ToolBox);
if(ToolboxPage == 0)
RenderServerbrowserFilters(ToolBox);
else if(ToolboxPage == 1)
RenderServerbrowserServerDetail(ToolBox);
{
StatusToolBox.HSplitTop(5.0f, 0, &StatusToolBox);
CUIRect Button;
//buttons.VSplitRight(20.0f, &buttons, &button);
StatusToolBox.VSplitRight(110.0f, &StatusToolBox, &Button);
Button.VMargin(2.0f, &Button);
static int s_RefreshButton = 0;
if(DoButton_Menu(&s_RefreshButton, Localize("Refresh"), 0, &Button))
{
if(g_Config.m_UiPage == PAGE_INTERNET)
ServerBrowser()->Refresh(IServerBrowser::TYPE_INTERNET);
else if(g_Config.m_UiPage == PAGE_LAN)
ServerBrowser()->Refresh(IServerBrowser::TYPE_LAN);
else if(g_Config.m_UiPage == PAGE_FAVORITES)
ServerBrowser()->Refresh(IServerBrowser::TYPE_FAVORITES);
}
char aBuf[512];
if(str_comp(Client()->LatestVersion(), "0") != 0)
str_format(aBuf, sizeof(aBuf), Localize("Teeworlds %s is out! Download it at www.teeworlds.com!"), Client()->LatestVersion());
else
str_format(aBuf, sizeof(aBuf), Localize("Current version: %s"), GAME_VERSION);
UI()->DoLabel(&StatusToolBox, aBuf, 14.0f, -1);
}
// do the button box
{
ButtonBox.VSplitLeft(5.0f, 0, &ButtonBox);
ButtonBox.VSplitRight(5.0f, &ButtonBox, 0);
CUIRect Button;
ButtonBox.HSplitBottom(ms_ButtonHeight, &ButtonBox, &Button);
Button.VSplitRight(120.0f, 0, &Button);
Button.VMargin(2.0f, &Button);
//button.VMargin(2.0f, &button);
static int s_JoinButton = 0;
if(DoButton_Menu(&s_JoinButton, Localize("Connect"), 0, &Button) || m_EnterPressed)
{
dbg_msg("", "%s", g_Config.m_UiServerAddress);
Client()->Connect(g_Config.m_UiServerAddress);
m_EnterPressed = false;
}
ButtonBox.HSplitBottom(5.0f, &ButtonBox, &Button);
ButtonBox.HSplitBottom(20.0f, &ButtonBox, &Button);
static float Offset = 0.0f;
DoEditBox(&g_Config.m_UiServerAddress, &Button, g_Config.m_UiServerAddress, sizeof(g_Config.m_UiServerAddress), 14.0f, &Offset);
ButtonBox.HSplitBottom(20.0f, &ButtonBox, &Button);
UI()->DoLabel(&Button, Localize("Host address"), 14.0f, -1);
}
}
void CPlayers::RenderHook(
const CNetObj_Character *pPrevChar,
const CNetObj_Character *pPlayerChar,
const CNetObj_PlayerInfo *pPrevInfo,
const CNetObj_PlayerInfo *pPlayerInfo,
int ClientID
)
{
CNetObj_Character Prev;
CNetObj_Character Player;
Prev = *pPrevChar;
Player = *pPlayerChar;
CTeeRenderInfo RenderInfo = m_aRenderInfo[ClientID];
float IntraTick = Client()->IntraGameTick();
// set size
RenderInfo.m_Size = 64.0f;
// use preditect players if needed
if(m_pClient->m_LocalClientID == ClientID && g_Config.m_ClPredict && Client()->State() != IClient::STATE_DEMOPLAYBACK)
{
if(!m_pClient->m_Snap.m_pLocalCharacter ||
(m_pClient->m_Snap.m_pGameData && m_pClient->m_Snap.m_pGameData->m_GameStateFlags&(GAMESTATEFLAG_PAUSED|GAMESTATEFLAG_ROUNDOVER|GAMESTATEFLAG_GAMEOVER)))
{
}
else
{
// apply predicted results
m_pClient->m_PredictedChar.Write(&Player);
m_pClient->m_PredictedPrevChar.Write(&Prev);
IntraTick = Client()->PredIntraGameTick();
}
}
vec2 Position = mix(vec2(Prev.m_X, Prev.m_Y), vec2(Player.m_X, Player.m_Y), IntraTick);
// draw hook
if (Prev.m_HookState>0 && Player.m_HookState>0)
{
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_GAME].m_Id);
Graphics()->QuadsBegin();
//Graphics()->QuadsBegin();
vec2 Pos = Position;
vec2 HookPos;
if(pPlayerChar->m_HookedPlayer != -1)
{
if(m_pClient->m_LocalClientID != -1 && pPlayerChar->m_HookedPlayer == m_pClient->m_LocalClientID)
{
if(Client()->State() == IClient::STATE_DEMOPLAYBACK) // only use prediction if needed
HookPos = vec2(m_pClient->m_LocalCharacterPos.x, m_pClient->m_LocalCharacterPos.y);
else
HookPos = mix(vec2(m_pClient->m_PredictedPrevChar.m_Pos.x, m_pClient->m_PredictedPrevChar.m_Pos.y),
vec2(m_pClient->m_PredictedChar.m_Pos.x, m_pClient->m_PredictedChar.m_Pos.y), Client()->PredIntraGameTick());
}
else if(m_pClient->m_LocalClientID == ClientID)
{
HookPos = mix(vec2(m_pClient->m_Snap.m_aCharacters[pPlayerChar->m_HookedPlayer].m_Prev.m_X,
m_pClient->m_Snap.m_aCharacters[pPlayerChar->m_HookedPlayer].m_Prev.m_Y),
vec2(m_pClient->m_Snap.m_aCharacters[pPlayerChar->m_HookedPlayer].m_Cur.m_X,
m_pClient->m_Snap.m_aCharacters[pPlayerChar->m_HookedPlayer].m_Cur.m_Y),
Client()->IntraGameTick());
}
else
HookPos = mix(vec2(pPrevChar->m_HookX, pPrevChar->m_HookY), vec2(pPlayerChar->m_HookX, pPlayerChar->m_HookY), Client()->IntraGameTick());
}
else
HookPos = mix(vec2(Prev.m_HookX, Prev.m_HookY), vec2(Player.m_HookX, Player.m_HookY), IntraTick);
float d = distance(Pos, HookPos);
vec2 Dir = normalize(Pos-HookPos);
Graphics()->QuadsSetRotation(GetAngle(Dir)+pi);
// render head
RenderTools()->SelectSprite(SPRITE_HOOK_HEAD);
IGraphics::CQuadItem QuadItem(HookPos.x, HookPos.y, 24,16);
Graphics()->QuadsDraw(&QuadItem, 1);
// render chain
RenderTools()->SelectSprite(SPRITE_HOOK_CHAIN);
IGraphics::CQuadItem Array[1024];
int i = 0;
for(float f = 24; f < d && i < 1024; f += 24, i++)
{
vec2 p = HookPos + Dir*f;
Array[i] = IGraphics::CQuadItem(p.x, p.y,24,16);
}
Graphics()->QuadsDraw(Array, i);
Graphics()->QuadsSetRotation(0);
Graphics()->QuadsEnd();
RenderHand(&RenderInfo, Position, normalize(HookPos-Pos), -pi/2, vec2(20, 0));
}
}
int CMenus::DoEditBox(void *pID, const CUIRect *pRect, char *pStr, unsigned StrSize, float FontSize, float *Offset, bool Hidden, int Corners)
{
int Inside = UI()->MouseInside(pRect);
bool ReturnValue = false;
bool UpdateOffset = false;
static int s_AtIndex = 0;
static bool s_DoScroll = false;
static float s_ScrollStart = 0.0f;
FontSize *= UI()->Scale();
if(UI()->LastActiveItem() == pID)
{
int Len = str_length(pStr);
if(Len == 0)
s_AtIndex = 0;
if(Inside && UI()->MouseButton(0))
{
s_DoScroll = true;
s_ScrollStart = UI()->MouseX();
int MxRel = (int)(UI()->MouseX() - pRect->x);
for(int i = 1; i <= Len; i++)
{
if(TextRender()->TextWidth(0, FontSize, pStr, i) - *Offset + 10 > MxRel)
{
s_AtIndex = i - 1;
break;
}
if(i == Len)
s_AtIndex = Len;
}
}
else if(!UI()->MouseButton(0))
s_DoScroll = false;
else if(s_DoScroll)
{
// do scrolling
if(UI()->MouseX() < pRect->x && s_ScrollStart-UI()->MouseX() > 10.0f)
{
s_AtIndex = max(0, s_AtIndex-1);
s_ScrollStart = UI()->MouseX();
UpdateOffset = true;
}
else if(UI()->MouseX() > pRect->x+pRect->w && UI()->MouseX()-s_ScrollStart > 10.0f)
{
s_AtIndex = min(Len, s_AtIndex+1);
s_ScrollStart = UI()->MouseX();
UpdateOffset = true;
}
}
for(int i = 0; i < m_NumInputEvents; i++)
{
Len = str_length(pStr);
ReturnValue |= CLineInput::Manipulate(m_aInputEvents[i], pStr, StrSize, &Len, &s_AtIndex);
}
}
bool JustGotActive = false;
if(UI()->ActiveItem() == pID)
{
if(!UI()->MouseButton(0))
{
s_DoScroll = false;
UI()->SetActiveItem(0);
}
}
else if(UI()->HotItem() == pID)
{
if(UI()->MouseButton(0))
{
if (UI()->LastActiveItem() != pID)
JustGotActive = true;
UI()->SetActiveItem(pID);
}
}
if(Inside)
UI()->SetHotItem(pID);
CUIRect Textbox = *pRect;
RenderTools()->DrawUIRect(&Textbox, vec4(1, 1, 1, 0.5f), Corners, 3.0f);
Textbox.VMargin(2.0f, &Textbox);
Textbox.HMargin(2.0f, &Textbox);
const char *pDisplayStr = pStr;
char aStars[128];
if(Hidden)
{
unsigned s = str_length(pStr);
if(s >= sizeof(aStars))
s = sizeof(aStars)-1;
for(unsigned int i = 0; i < s; ++i)
aStars[i] = '*';
aStars[s] = 0;
pDisplayStr = aStars;
}
// check if the text has to be moved
if(UI()->LastActiveItem() == pID && !JustGotActive && (UpdateOffset || m_NumInputEvents))
{
float w = TextRender()->TextWidth(0, FontSize, pDisplayStr, s_AtIndex);
if(w-*Offset > Textbox.w)
{
// move to the left
float wt = TextRender()->TextWidth(0, FontSize, pDisplayStr, -1);
do
{
*Offset += min(wt-*Offset-Textbox.w, Textbox.w/3);
}
while(w-*Offset > Textbox.w);
}
else if(w-*Offset < 0.0f)
{
// move to the right
do
{
*Offset = max(0.0f, *Offset-Textbox.w/3);
}
while(w-*Offset < 0.0f);
}
}
UI()->ClipEnable(pRect);
Textbox.x -= *Offset;
UI()->DoLabel(&Textbox, pDisplayStr, FontSize, -1);
// render the cursor
if(UI()->LastActiveItem() == pID && !JustGotActive)
{
float w = TextRender()->TextWidth(0, FontSize, pDisplayStr, s_AtIndex);
Textbox = *pRect;
Textbox.VSplitLeft(2.0f, 0, &Textbox);
Textbox.x += (w-*Offset-TextRender()->TextWidth(0, FontSize, "|", -1)/2);
if((2*time_get()/time_freq()) % 2) // make it blink
UI()->DoLabel(&Textbox, "|", FontSize, -1);
}
UI()->ClipDisable();
return ReturnValue;
}