WORD CGrid::FindMonsterGroupInRange(DWORD* pFriendsList, CObject* pFinder,VECTOR3* pPos)
{
POS pos = m_NeighborGrid.GetFirstPos();
CGrid* pGrid;
WORD wStartEmptyNum = 0;
DWORD objectList[MAX_FIND_MONSTERNUM] = {0,};
WORD wFindNum = FindMonsterGroupInRange(pFinder, pPos, &objectList[0]);
for(WORD i=0; i<wFindNum; ++i)
{
pFriendsList[wStartEmptyNum] = objectList[i];
wStartEmptyNum++;
}
while( (pGrid = m_NeighborGrid.GetNextPos(pos) ) != NULL)
{
if(wStartEmptyNum >= MAX_FIND_MONSTERNUM)
return wStartEmptyNum;
ZeroMemory(objectList, sizeof(objectList));
wFindNum = pGrid->FindMonsterGroupInRange(pFinder, pPos, &objectList[0]);
for(WORD i=0; i<wFindNum; i++)
{
if(wStartEmptyNum >= MAX_FIND_MONSTERNUM)
return wStartEmptyNum;
pFriendsList[wStartEmptyNum] = objectList[i];
wStartEmptyNum++;
}
}
return wStartEmptyNum;
}
void CMap::Draw( void )
{
CGrid* pEnd = m_pGrid + m_uWidth*m_uHeight;
for ( CGrid* pCur = m_pGrid; pCur!=pEnd; pCur++ )
{
pCur->Draw();
}
}
BOOL CGridManager::RemoveObjectFromGrid( CWorldObject *pWorldObject, FLOAT x, FLOAT z )
{
CGrid *pGrid = GetGridByPos(x, z);
if(pGrid == NULL)
{
return FALSE;
}
return pGrid->RemoveObject(pWorldObject);;
}
//将对象从网格中删除
BOOL CGridManager::RemoveObjectFromGrid(CWorldObject *pWorldObject, INT32 nIndex)
{
CGrid *pGrid = GetGridByIndex(nIndex);
if(pGrid == NULL)
{
return FALSE;
}
return pGrid->RemoveObject(pWorldObject);;
}
BOOL CGridManager::AddObjectToGrid( CWorldObject *pWorldObject, FLOAT x, FLOAT z )
{
CGrid *pGrid = GetGridByPos(x, z);
if(pGrid == NULL)
{
return FALSE;
}
return pGrid->AddObject(pWorldObject);
}
//将对象添加到网格中
BOOL CGridManager::AddObjectToGrid(CWorldObject *pWorldObject, INT32 nIndex)
{
CGrid *pGrid = GetGridByIndex(nIndex);
if(pGrid == NULL)
{
return FALSE;
}
return pGrid->AddObject(pWorldObject);
}
void CGrid::AddGridToPackedDataWithoutOne(DWORD dwID,CPackedData* pPackedData)
{
POS pos = m_NeighborGrid.GetFirstPos();
CGrid* pGrid;
AddObjectToPacket(dwID,pPackedData);
while( (pGrid = m_NeighborGrid.GetNextPos(pos)) != NULL)
{
pGrid->AddObjectToPacket(dwID,pPackedData);
}
}
void CGrid::AddGridToPackedData(CPackedData* pPackedData)
{
POS pos = m_NeighborGrid.GetFirstPos();
CGrid* pGrid;
AddObjectToPacket(0,pPackedData);
while( (pGrid = m_NeighborGrid.GetNextPos(pos)) != NULL)
{
pGrid->AddObjectToPacket(0,pPackedData);
}
}
BOOL CGridManager::IsObjectExist( CWorldObject *pWorldObject, INT32 dwIndex )
{
CGrid *pGrid = GetGridByIndex(dwIndex);
if(pGrid == NULL)
{
ASSERT_FAIELD;
return FALSE;
}
return pGrid->IsObjectExist(pWorldObject);
}
BOOL CDlgImportField::ImportGrid(int nGrid)
{
CGrid *pGrd = &(m_fldGrd[nGrid]);
CGrid grd;
GridInfo gi;
if(pGrd->IsEmpty()) {
gi = grd.GetInfoBrowse();
if( CheckGrid(gi) ) {
pGrd->Open( gi.strFilePath, gi.nType );
return TRUE;
}
}
else {
int ret = AfxMessageBox("Grid is not empty. Replace?", MB_ICONQUESTION | MB_YESNO);
if( ret == IDYES) {
gi = grd.GetInfoBrowse();
if( CheckGrid( gi) ) {
pGrd->Close();
pGrd->Open( gi.strFilePath, gi.nType );
return TRUE;
}
}
}
return FALSE;
}
void CGrid::SendRemoveObjectInfo(CObject* pLeavedObject,CGrid* pCurGrid)
{
/////////////////////////////////////////////////////////////////////////
// 06. 04. 그리드 수정
// 이 함수는 삭제된 오브젝트가 소속된 그리드의 오브젝트들이
// 삭제된 오브젝트에게 연결된 Agent에 메세지를 보내는 부분인데
// 플레이어 이외의 오브젝트는 연결된 Agent가 없으므로 들어올 필요가 없다.
if(pLeavedObject->GetObjectKind() != eObjectKind_Player )
return;
/////////////////////////////////////////////////////////////////////////
POS pos = m_NeighborGrid.GetFirstPos();
CGrid* pGrid;
if(pCurGrid == NULL)
{
SendRemoveCharacterMsg(pLeavedObject);
// SendRemoveItemMsg(pLeavedObject);
while( (pGrid = m_NeighborGrid.GetNextPos(pos)) != NULL)
{
pGrid->SendRemoveCharacterMsg(pLeavedObject);
// pGrid->SendRemoveItemMsg(pLeavedObject);
}
}
else
{
if(!pCurGrid->IsNeighborGrid(this))
{
SendRemoveCharacterMsg(pLeavedObject);
// SendRemoveItemMsg(pLeavedObject);
}
while( (pGrid = m_NeighborGrid.GetNextPos(pos)) != NULL)
{
if(!pCurGrid->IsNeighborGrid(pGrid))
{
pGrid->SendRemoveCharacterMsg(pLeavedObject);
// pGrid->SendRemoveItemMsg(pLeavedObject);
}
}
}
}
void CRABMedium::Init(TConfigurationNode& t_tree) {
try {
CMedium::Init(t_tree);
/* Check occlusions? */
GetNodeAttributeOrDefault(t_tree, "check_occlusions", m_bCheckOcclusions, m_bCheckOcclusions);
/* Get the positional index method */
std::string strPosIndexMethod("grid");
GetNodeAttributeOrDefault(t_tree, "index", strPosIndexMethod, strPosIndexMethod);
/* Get the arena center and size */
CVector3 cArenaCenter;
CVector3 cArenaSize;
TConfigurationNode& tArena = GetNode(CSimulator::GetInstance().GetConfigurationRoot(), "arena");
GetNodeAttribute(tArena, "size", cArenaSize);
GetNodeAttributeOrDefault(tArena, "center", cArenaCenter, cArenaCenter);
/* Create the positional index for embodied entities */
if(strPosIndexMethod == "grid") {
size_t punGridSize[3];
if(!NodeAttributeExists(t_tree, "grid_size")) {
punGridSize[0] = cArenaSize.GetX();
punGridSize[1] = cArenaSize.GetY();
punGridSize[2] = cArenaSize.GetZ();
}
else {
std::string strPosGridSize;
GetNodeAttribute(t_tree, "grid_size", strPosGridSize);
ParseValues<size_t>(strPosGridSize, 3, punGridSize, ',');
}
CGrid<CRABEquippedEntity>* pcGrid = new CGrid<CRABEquippedEntity>(
cArenaCenter - cArenaSize * 0.5f, cArenaCenter + cArenaSize * 0.5f,
punGridSize[0], punGridSize[1], punGridSize[2]);
m_pcRABEquippedEntityGridUpdateOperation = new CRABEquippedEntityGridEntityUpdater(*pcGrid);
pcGrid->SetUpdateEntityOperation(m_pcRABEquippedEntityGridUpdateOperation);
m_pcRABEquippedEntityIndex = pcGrid;
}
else {
THROW_ARGOSEXCEPTION("Unknown method \"" << strPosIndexMethod << "\" for the positional index.");
}
}
catch(CARGoSException& ex) {
THROW_ARGOSEXCEPTION_NESTED("Error in initialization of the range-and-bearing medium", ex);
}
}
void CDlgDefineModel::OnBnClickedBrowseModel()
{
CGrid grd;
grd.Open();
m_nX = grd.GetCols();
m_nY = grd.GetRows();
m_x0 = grd.GetX0();
m_y0 = grd.GetY0();
m_xCs = grd.GetXSize();
m_yCs = grd.GetYSize();
UpdateData(FALSE);
}
CObject* CGrid::FindFirstMonsterInRange(CObject* pFinder,VECTOR3* pPos,float Range)
{
POS pos = m_NeighborGrid.GetFirstPos();
CGrid* pGrid;
CObject* pObject;
FindFirstMonsterInRange(pFinder,pPos,Range,&pObject);
if(pObject)
return pObject;
while( (pGrid = m_NeighborGrid.GetNextPos(pos) ) != NULL)
{
pGrid->FindFirstMonsterInRange(pFinder,pPos,Range,&pObject);
if(pObject)
return pObject;
}
return NULL;
}
void CGrid::AddGridToPackedDataExceptLastGrid(DWORD ExceptID,CGrid* pLastGrid,CPackedData* pPackedData)
{
if(pLastGrid == NULL)
{
AddGridToPackedDataWithoutOne(ExceptID,pPackedData);
return;
}
POS pos = m_NeighborGrid.GetFirstPos();
CGrid* pGrid;
if(!pLastGrid->IsNeighborGrid(this))
AddObjectToPacket(ExceptID,pPackedData);
while( (pGrid = m_NeighborGrid.GetNextPos(pos) ) != NULL)
{
if(!pLastGrid->IsNeighborGrid(pGrid))
pGrid->AddObjectToPacket(ExceptID,pPackedData);
}
}
void CEasyGenView::OnCameraFloor()
{
CEasyGenDoc *pDoc = GetDocument();
S_POSINFO inf;
if (g_Grid.GetInfo(m_Eye.x, m_Eye.y, &inf))
{
m_Eye.z = inf.z + 50;
InvalidateRect(NULL, FALSE);
}
}
CObject* CGrid::FindPlayerRandom()
{
POS pos = m_NeighborGrid.GetFirstPos();
CGrid* pGrid;
CObject* pObject[9];
CObject* temp;
WORD count = 0;
/// 우선 자기 그리드 내에서 플레이어를 고른다.
FindPlayerRandom( &temp );
if( temp )
{
pObject[count++] = temp;
}
/// 각 그리드에서 플레이어를 골라온다.
while( ( pGrid = m_NeighborGrid.GetNextPos( pos ) ) != NULL)
{
temp = NULL;
pGrid->FindPlayerRandom( &temp );
if( temp )
{
pObject[count++] = temp;
if(count == 9)
break;
}
}
/// 선택된 플레이어가 1인 이상일때
if(count > 0)
{
/// 리턴할 플레이어를 고른다
WORD select = WORD( rand() % count);
return pObject[select];
}
/// 선택된 플레이어가 없으면 NULL 리턴
return NULL;
}
void CGrid::sample(CGrid &points,
void (*sample)(iterator starta, iterator enda,
iterator startb, iterator endb, double radius)) {
static int corner[8*3] = { 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1,
0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1 };
static int diagonals[14*2] = { 0, 0, //remove this line to avoid self intesextion
0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7,
2, 3, 1, 3, 1, 2,
1, 4, 2, 5, 3, 6 };
for(int z = 0; z < zside; z++) {
for(int y = 0; y < yside; y++) {
for(int x = 0; x < xside; x++) {
int origin = cell(x, y, z);
if(!isEmpty(origin) && !points.isEmpty(origin))
sample(startV(origin), endV(origin),
points.startV(origin), points.endV(origin), radius);
for(int d = 2; d < 28; d += 2) { //skipping self
int *cs = corner + 3*diagonals[d];
int *ce = corner + 3*diagonals[d+1];
if((x+cs[0] < xside) && (y+cs[1] < yside) && (z+cs[2] < zside) &&
(x+ce[0] < xside) && (y+ce[1] < yside) && (z+ce[2] < zside)) {
origin = cell(x+cs[0], y+cs[1], z+cs[2]);
int dest = cell(x+ce[0], y+ce[1], z+ce[2]);
if(!isEmpty(origin) && !points.isEmpty(dest)) // Locally
sample(startV(origin), endV(origin),
points.startV(dest), points.endV(dest), radius);
if(!isEmpty(dest) && !points.isEmpty(origin))
sample(startV(dest), endV(dest),
points.startV(origin), points.endV(origin), radius);
}
}
}
}
}
}
void PrintGridCells(CGrid<CLEDEntity>& g) {
for(SInt32 k = g.GetSizeK()-1; k >= 0; --k) {
for(SInt32 j = g.GetSizeJ()-1; j >= 0; --j) {
for(SInt32 i = 0; i < g.GetSizeI(); ++i) {
CGrid<CLEDEntity>::SCell& c = g.GetCellAt(i, j, k);
fprintf(stdout, "[ %d, %d, %d ] %u entities, timestamp = %u\n", i, j, k, c.Entities.size(), c.Timestamp);
if(!c.Entities.empty()) {
for(CSet<CLEDEntity*>::iterator it = c.Entities.begin();
it != c.Entities.end();
++it) {
fprintf(stdout, " %s\t%.3f\t%.3f\t%.3f\n",
(**it).GetId().c_str(),
(**it).GetPosition().GetX(),
(**it).GetPosition().GetY(),
(**it).GetPosition().GetZ());
}
}
}
}
}
fprintf(stdout, "\n");
}
CObject* CGrid::FindMonsterInRange(CObject* pFinder,VECTOR3* pPos,float Range)
{
POS pos = m_NeighborGrid.GetFirstPos();
CGrid* pGrid;
CObject* pObject;
CObject* pClosestObject;
float dist;
float mindist;
FindMonsterInRange(pFinder,pPos,Range,mindist,&pClosestObject);
while( (pGrid = m_NeighborGrid.GetNextPos(pos)) != NULL)
{
pGrid->FindMonsterInRange(pFinder,pPos,Range,dist,&pObject);
if(dist < mindist)
{
mindist = dist;
pClosestObject = pObject;
}
}
return pClosestObject;
}
void CEasyGenView::OnRButtonDown(UINT nFlags, CPoint point)
{
CEasyGenDoc *pDoc = GetDocument();
CNmVec3 ray;
CNmVec3 p;
int tab;
BOOL kCTRL = nFlags & MK_CONTROL;
BOOL kSHIFT = nFlags & MK_SHIFT;
BOOL GotPoint = GetXYZ(point, p);
BOOL GotRay = GetRay(point, ray);
m_RDP = point;
SetCapture();
switch (tab = pDoc->GetActiveTab())
{
case (TAB_GRID):
break;
case (TAB_MODIFIER):
break;
case (TAB_ALPHAMAP):
break;
case (TAB_MODELS):
// MD3 - Move an Md3Highlighted model
if (!kCTRL && kSHIFT && GotRay && m_Md3Highlight)
{
CNmVec3 pos;
float dist;
if (g_Grid.GetDistanceTrisRay(m_Eye, ray, pos, dist))
{
m_Md3Highlight->m_egvPos = pos;
InvalidateRect(NULL, FALSE);
}
}
break;
}
CView::OnRButtonDown(nFlags, point);
}
void CEasyGenView::OnRButtonDblClk(UINT nFlags, CPoint point)
{
CEasyGenDoc *pDoc = GetDocument();
S_POSINFO inf;
CNmVec3 p;
BOOL kCTRL = nFlags & MK_CONTROL;
BOOL kSHIFT = nFlags & MK_SHIFT;
BOOL GotPoint = GetXYZ(point, p);
switch (pDoc->GetActiveTab())
{
case (TAB_GRID):
break;
case (TAB_MODIFIER):
// Modifier get height
if (kCTRL && GotPoint)
{
if (g_Grid.GetInfo(p.x, p.y, &inf))
{
g_Mod.HeightSet(inf.z);
InvalidateRect(NULL, FALSE);
pDoc->m_bInvalidateGridPreview = TRUE;
}
}
break;
case (TAB_ALPHAMAP):
break;
case (TAB_MODELS):
break;
}
CView::OnRButtonDblClk(nFlags, point);
}
void ScorePanel::FillGrid()
{
CSchemeManager *pSchemes = gViewPort->GetSchemeManager();
SchemeHandle_t hScheme = pSchemes->getSchemeHandle("Scoreboard Text");
SchemeHandle_t hTitleScheme = pSchemes->getSchemeHandle("Scoreboard Title Text");
SchemeHandle_t hSmallScheme = pSchemes->getSchemeHandle("Scoreboard Small Text");
SchemeHandle_t hTinyScheme = pSchemes->getSchemeHandle("Scoreboard Tiny Text");
Font *sfont = pSchemes->getFont(hScheme);
Font *tfont = pSchemes->getFont(hTitleScheme);
Font *smallfont = pSchemes->getFont(hSmallScheme);
Font *tinyfont = pSchemes->getFont(hTinyScheme);
// update highlight position
int x, y;
getApp()->getCursorPos(x, y);
cursorMoved(x, y, this);
// remove highlight row if we're not in squelch mode
if (!GetClientVoiceMgr()->IsInSquelchMode())
{
m_iHighlightRow = -1;
}
bool bNextRowIsGap = false;
for(int row=0; row < NUM_ROWS; row++)
{
CGrid *pGridRow = &m_PlayerGrids[row];
pGridRow->SetRowUnderline(0, false, 0, 0, 0, 0, 0);
if(row >= m_iRows)
{
for(int col=0; col < NUM_COLUMNS; col++)
m_PlayerEntries[col][row].setVisible(false);
continue;
}
bool bRowIsGap = false;
if (bNextRowIsGap)
{
bNextRowIsGap = false;
bRowIsGap = true;
}
// Get the player's data
int theSortedRow = m_iSortedRows[row];
hud_player_info_t* pl_info = &g_PlayerInfoList[theSortedRow];
extra_player_info_t* theExtraPlayerInfo = &g_PlayerExtraInfo[theSortedRow];
int thePlayerClass = theExtraPlayerInfo->playerclass;
short theTeamNumber = theExtraPlayerInfo->teamnumber;
string theCustomIcon = (string)theExtraPlayerInfo->customicon;
// puzl: 0001073
short thePlayerAuthentication = theExtraPlayerInfo->auth;
bool thePlayerIsDead = false;
switch( thePlayerClass )
{
case PLAYERCLASS_DEAD_MARINE:
case PLAYERCLASS_DEAD_ALIEN:
case PLAYERCLASS_REINFORCING:
thePlayerIsDead = true;
break;
}
// Code to test DEBUG
#if 0
#ifdef DEBUG
extern int gGlobalDebugAuth;
thePlayerAuthentication = 1;
thePlayerAuthentication <<= gGlobalDebugAuth;
#endif
#endif
team_info_t* team_info = &g_TeamInfo[m_iSortedRows[row]];
int theColorIndex = theTeamNumber % iNumberOfTeamColors;
int theLocalPlayerTeam = 0;
if(gEngfuncs.GetLocalPlayer())
{
theLocalPlayerTeam = gEngfuncs.GetLocalPlayer()->curstate.team;
}
for(int col=0; col < NUM_COLUMNS; col++)
{
CLabelHeader *pLabel = &m_PlayerEntries[col][row];
pLabel->setVisible(true);
pLabel->setText2("");
pLabel->setImage(NULL);
pLabel->setFont(sfont);
pLabel->setTextOffset(0, 0);
int rowheight = 13;
if (ScreenHeight() > 480)
{
rowheight = YRES(rowheight);
}
else
{
// more tweaking, make sure icons fit at low res
rowheight = 15;
}
pLabel->setSize(pLabel->getWide(), rowheight);
pLabel->setBgColor(0, 0, 0, 255);
char sz[128];
Color gammaAdjustedTeamColor = BuildColor(kTeamColors[theColorIndex][0], kTeamColors[theColorIndex][1], kTeamColors[theColorIndex][2], gHUD.GetGammaSlope());
pLabel->setFgColor(gammaAdjustedTeamColor[0], gammaAdjustedTeamColor[1], gammaAdjustedTeamColor[2], 0);
if (m_iIsATeam[row] == TEAM_BLANK)
{
pLabel->setText(" ");
continue;
}
else if ( m_iIsATeam[row] == TEAM_YES )
{
theColorIndex = team_info->teamnumber % iNumberOfTeamColors;
// team color text for team names
// different height for team header rows
rowheight = 20;
if (ScreenHeight() >= 480)
{
rowheight = YRES(rowheight);
}
pLabel->setSize(pLabel->getWide(), rowheight);
pLabel->setFont(tfont);
pGridRow->SetRowUnderline( 0,
true,
YRES(3),
gammaAdjustedTeamColor[0],
gammaAdjustedTeamColor[1],
gammaAdjustedTeamColor[2],
0 );
}
else if ( m_iIsATeam[row] == TEAM_SPECTATORS )
{
// grey text for spectators
pLabel->setFgColor(100, 100, 100, 0);
// different height for team header rows
rowheight = 20;
if (ScreenHeight() >= 480)
{
rowheight = YRES(rowheight);
}
pLabel->setSize(pLabel->getWide(), rowheight);
pLabel->setFont(tfont);
pGridRow->SetRowUnderline(0, true, YRES(3), 100, 100, 100, 0);
}
else
{
if(thePlayerIsDead)
{
pLabel->setFgColor(255, 0, 0, 0);
}
else
{
// team color text for player names
pLabel->setFgColor(gammaAdjustedTeamColor[0], gammaAdjustedTeamColor[1], gammaAdjustedTeamColor[2], 0);
}
// Set background color
if ( pl_info && pl_info->thisplayer ) // if it is their name, draw it a different color
{
// Highlight this player
pLabel->setFgColor(Scheme::sc_white);
pLabel->setBgColor(gammaAdjustedTeamColor[0], gammaAdjustedTeamColor[1], gammaAdjustedTeamColor[2], 196 );
}
else if ( theSortedRow == m_iLastKilledBy && m_fLastKillTime && m_fLastKillTime > gHUD.m_flTime )
{
// Killer's name
pLabel->setBgColor( 255,0,0, 255 - ((float)15 * (float)(m_fLastKillTime - gHUD.m_flTime)) );
}
}
// Align
switch(col)
{
case COLUMN_NAME:
case COLUMN_CLASS:
pLabel->setContentAlignment( vgui::Label::a_west );
break;
case COLUMN_TRACKER:
case COLUMN_RANK_ICON:
case COLUMN_VOICE:
pLabel->setContentAlignment( vgui::Label::a_center );
break;
case COLUMN_SCORE:
case COLUMN_KILLS:
case COLUMN_DEATHS:
case COLUMN_LATENCY:
default:
pLabel->setContentAlignment( vgui::Label::a_east );
break;
}
// Fill out with the correct data
strcpy(sz, "");
if ( m_iIsATeam[row] )
{
char sz2[128];
switch (col)
{
case COLUMN_NAME:
if ( m_iIsATeam[row] == TEAM_SPECTATORS )
{
sprintf( sz2, CHudTextMessage::BufferedLocaliseTextString( "#Spectators" ) );
}
else
{
if(team_info)
{
sprintf( sz2, gViewPort->GetTeamName(team_info->teamnumber) );
}
}
strcpy(sz, sz2);
// Append the number of players
if ( m_iIsATeam[row] == TEAM_YES && team_info)
{
if (team_info->players == 1)
{
sprintf(sz2, "(%d %s)", team_info->players, CHudTextMessage::BufferedLocaliseTextString( "#Player" ) );
}
else
{
sprintf(sz2, "(%d %s)", team_info->players, CHudTextMessage::BufferedLocaliseTextString( "#Player_plural" ) );
}
pLabel->setText2(sz2);
pLabel->setFont2(smallfont);
}
break;
case COLUMN_VOICE:
break;
case COLUMN_CLASS:
break;
case COLUMN_SCORE:
// Don't show score for enemies unless spectating or in RR
if ((m_iIsATeam[row] == TEAM_YES) && team_info && ((theLocalPlayerTeam == 0) || (theLocalPlayerTeam == team_info->teamnumber)))
sprintf(sz, "%d", team_info->score);
break;
case COLUMN_KILLS:
if ((m_iIsATeam[row] == TEAM_YES) && team_info)
sprintf(sz, "%d", team_info->frags );
break;
case COLUMN_DEATHS:
if ((m_iIsATeam[row] == TEAM_YES) && team_info)
sprintf(sz, "%d", team_info->deaths );
break;
case COLUMN_LATENCY:
if ((m_iIsATeam[row] == TEAM_YES) && team_info)
sprintf(sz, "%d", team_info->ping );
break;
default:
break;
}
}
else
{
// Are these stats for an enemy? Score and other stats shouldn't be drawn for enemies.
bool theIsForEnemy = false;
int theLocalPlayerTeam = 0;
if(gEngfuncs.GetLocalPlayer())
{
theLocalPlayerTeam = gEngfuncs.GetLocalPlayer()->curstate.team;
}
if((theLocalPlayerTeam != 0) && (theExtraPlayerInfo->teamnumber != theLocalPlayerTeam))
{
theIsForEnemy = true;
}
switch (col)
{
case COLUMN_NAME:
if (g_pTrackerUser)
{
int playerSlot = m_iSortedRows[row];
int trackerID = gEngfuncs.GetTrackerIDForPlayer(playerSlot);
const char *trackerName = g_pTrackerUser->GetUserName(trackerID);
if (trackerName && *trackerName)
{
sprintf(sz, " (%s)", trackerName);
pLabel->setText2(sz);
}
}
if(pl_info)
{
sprintf(sz, "%s ", pl_info->name);
}
break;
case COLUMN_VOICE:
sz[0] = 0;
// in HLTV mode allow spectator to turn on/off commentator voice
if (pl_info && (!pl_info->thisplayer || gEngfuncs.IsSpectateOnly()))
{
GetClientVoiceMgr()->UpdateSpeakerImage(pLabel, theSortedRow);
}
break;
case COLUMN_CLASS:
// No class for other team's members (unless allied or spectator, and make sure player is on our team)
strcpy(sz, "");
if(team_info && ((theLocalPlayerTeam == theTeamNumber) || (gHUD.GetPlayMode() == PLAYMODE_OBSERVER)))
{
switch(thePlayerClass)
{
case (int)(PLAYERCLASS_DEAD_MARINE):
case (int)(PLAYERCLASS_DEAD_ALIEN):
sprintf(sz, "%s", CHudTextMessage::BufferedLocaliseTextString(kClassDead));
break;
case (int)(PLAYERCLASS_REINFORCING):
sprintf(sz, "%s", CHudTextMessage::BufferedLocaliseTextString(kClassReinforcing));
break;
case (int)(PLAYERCLASS_REINFORCINGCOMPLETE):
sprintf(sz, "%s", CHudTextMessage::BufferedLocaliseTextString(kClassReinforcingComplete));
break;
case (int)(PLAYERCLASS_ALIVE_JETPACK_MARINE):
sprintf(sz, "%s", CHudTextMessage::BufferedLocaliseTextString(kClassJetpackMarine));
break;
case (int)(PLAYERCLASS_ALIVE_HEAVY_MARINE):
sprintf(sz, "%s", CHudTextMessage::BufferedLocaliseTextString(kClassHeavyMarine));
break;
case (int)(PLAYERCLASS_COMMANDER):
sprintf(sz, "%s", CHudTextMessage::BufferedLocaliseTextString(kClassCommander));
break;
case (int)(PLAYERCLASS_ALIVE_LEVEL1):
sprintf(sz, "%s", CHudTextMessage::BufferedLocaliseTextString(kClassLevel1));
break;
case (int)(PLAYERCLASS_ALIVE_LEVEL2):
sprintf(sz, "%s", CHudTextMessage::BufferedLocaliseTextString(kClassLevel2));
break;
case (int)(PLAYERCLASS_ALIVE_LEVEL3):
sprintf(sz, "%s", CHudTextMessage::BufferedLocaliseTextString(kClassLevel3));
break;
case (int)(PLAYERCLASS_ALIVE_LEVEL4):
sprintf(sz, "%s", CHudTextMessage::BufferedLocaliseTextString(kClassLevel4));
break;
case (int)(PLAYERCLASS_ALIVE_LEVEL5):
sprintf(sz, "%s", CHudTextMessage::BufferedLocaliseTextString(kClassLevel5));
break;
case (int)(PLAYERCLASS_ALIVE_DIGESTING):
sprintf(sz, "%s", CHudTextMessage::BufferedLocaliseTextString(kClassDigesting));
break;
case (int)(PLAYERCLASS_ALIVE_GESTATING):
sprintf(sz, "%s", CHudTextMessage::BufferedLocaliseTextString(kClassGestating));
break;
default:
break;
}
}
break;
case COLUMN_RANK_ICON:
// puzl: 0001073
#ifdef USE_OLDAUTH
// Check if we have authority. Right now these override the tracker icons. Listed in increasing order of "importance".
if(thePlayerAuthentication & PLAYERAUTH_CHEATINGDEATH)
{
// Red
pLabel->setImage(m_pCheatingDeathIcon);
pLabel->setFgColorAsImageColor(false);
m_pCheatingDeathIcon->setColor(BuildColor(255, 69, 9, gHUD.GetGammaSlope()));
}
if(thePlayerAuthentication & PLAYERAUTH_VETERAN)
{
// Yellow
pLabel->setImage(m_pVeteranIcon);
pLabel->setFgColorAsImageColor(false);
m_pVeteranIcon->setColor(BuildColor(248, 252, 0, gHUD.GetGammaSlope()));
}
if(thePlayerAuthentication & PLAYERAUTH_BETASERVEROP)
{
// Whitish
pLabel->setImage(m_pServerOpIcon);
pLabel->setFgColorAsImageColor(false);
m_pServerOpIcon->setColor(BuildColor(220, 220, 220, gHUD.GetGammaSlope()));
}
if(thePlayerAuthentication & PLAYERAUTH_CONTRIBUTOR)
{
// Light blue
pLabel->setImage(m_pContribIcon);
pLabel->setFgColorAsImageColor(false);
m_pContribIcon->setColor(BuildColor(117, 214, 241, gHUD.GetGammaSlope()));
}
if(thePlayerAuthentication & PLAYERAUTH_GUIDE)
{
// Magenta
pLabel->setImage(m_pGuideIcon);
pLabel->setFgColorAsImageColor(false);
m_pGuideIcon->setColor(BuildColor(208, 16, 190, gHUD.GetGammaSlope()));
}
if(thePlayerAuthentication & PLAYERAUTH_PLAYTESTER)
{
// Orange
pLabel->setImage(m_pPTIcon);
pLabel->setFgColorAsImageColor(false);
m_pPTIcon->setColor(BuildColor(255, 167, 54, gHUD.GetGammaSlope()));
}
if(thePlayerAuthentication & PLAYERAUTH_DEVELOPER)
{
// TSA blue
pLabel->setImage(m_pDevIcon);
pLabel->setFgColorAsImageColor(false);
m_pDevIcon->setColor(BuildColor(100, 215, 255, gHUD.GetGammaSlope()));
}
if(thePlayerAuthentication & PLAYERAUTH_SERVEROP)
{
// Bright green
pLabel->setImage(m_pServerOpIcon);
pLabel->setFgColorAsImageColor(false);
m_pServerOpIcon->setColor(BuildColor(0, 255, 0, gHUD.GetGammaSlope()));
}
// Allow custom icons to override other general icons
if(thePlayerAuthentication & PLAYERAUTH_CUSTOM)
{
if(theCustomIcon != "")
{
string theIconName = theCustomIcon.substr(0, strlen(theCustomIcon.c_str()) - 3);
string theFullCustomIconString = string("gfx/vgui/640_") + theIconName + string(".tga");
vgui::BitmapTGA *pIcon = GetIconPointer(theCustomIcon);
//Icon hasnt been loaded, load it now and add it to list of icons.
if(pIcon == NULL)
{
pIcon = vgui_LoadTGANoInvertAlpha(theFullCustomIconString.c_str());
if(pIcon)
m_CustomIconList.push_back( make_pair(pIcon, theCustomIcon) );
}
if(pIcon)
{
pLabel->setImage(pIcon);
pLabel->setFgColorAsImageColor(false);
// Parse color (last 3 bytes are the RGB values 1-9)
string theColor = theCustomIcon.substr( strlen(theCustomIcon.c_str())-3, 3);
int theRed = (MakeIntFromString(theColor.substr(0, 1))/9.0f)*255;
int theGreen = (MakeIntFromString(theColor.substr(1, 1))/9.0f)*255;
int theBlue = (MakeIntFromString(theColor.substr(2, 1))/9.0f)*255;
pIcon->setColor(BuildColor(theRed, theGreen, theBlue, gHUD.GetGammaSlope()));
}
}
}
if(g_pTrackerUser)
{
int playerSlot = theSortedRow;
int trackerID = gEngfuncs.GetTrackerIDForPlayer(playerSlot);
if (g_pTrackerUser->IsFriend(trackerID) && trackerID != g_pTrackerUser->GetTrackerID())
{
pLabel->setImage(m_pTrackerIcon);
pLabel->setFgColorAsImageColor(false);
m_pTrackerIcon->setColor(Color(255, 255, 255, 0));
}
}
#else
if( theExtraPlayerInfo->icon )
{
vgui::Bitmap* image = theExtraPlayerInfo->icon->getImage( this->GetIconFrame() );
if( image ) { pLabel->setImage( image ); }
}
#endif
break;
case COLUMN_SCORE:
if(!theIsForEnemy)
{
const float kDeltaDisplayTime = 3.0f;
float theTimeSinceChange = gHUD.GetTimeOfLastUpdate() - theExtraPlayerInfo->timeOfLastScoreChange;
if((theExtraPlayerInfo->score > theExtraPlayerInfo->lastScore) && (theTimeSinceChange > 0) && (theTimeSinceChange < kDeltaDisplayTime) && (theExtraPlayerInfo->teamnumber != 0))
{
// draw score with change
int theDelta = (theExtraPlayerInfo->score - theExtraPlayerInfo->lastScore);
sprintf(sz, "(+%d) %d", theDelta, theExtraPlayerInfo->score);
}
else
{
sprintf(sz, "%d", theExtraPlayerInfo->score);
}
}
break;
case COLUMN_KILLS:
sprintf(sz, "%d", theExtraPlayerInfo->frags);
break;
case COLUMN_DEATHS:
sprintf(sz, "%d", theExtraPlayerInfo->deaths);
break;
case COLUMN_LATENCY:
if(pl_info)
{
sprintf(sz, "%d", pl_info->ping );
}
break;
default:
break;
}
}
pLabel->setText(sz);
}
}
for(row=0; row < NUM_ROWS; row++)
{
CGrid *pGridRow = &m_PlayerGrids[row];
pGridRow->AutoSetRowHeights();
pGridRow->setSize(PanelWidth(pGridRow), pGridRow->CalcDrawHeight());
pGridRow->RepositionContents();
}
// hack, for the thing to resize
m_PlayerList.getSize(x, y);
m_PlayerList.setSize(x, y);
}
//-----------------------------------------------------------------------------
// Purpose: Create the ScoreBoard panel
//-----------------------------------------------------------------------------
ScorePanel::ScorePanel(int x,int y,int wide,int tall) : Panel(x,y,wide,tall)
{
CSchemeManager *pSchemes = gViewPort->GetSchemeManager();
SchemeHandle_t hTitleScheme = pSchemes->getSchemeHandle("Scoreboard Title Text");
SchemeHandle_t hSmallScheme = pSchemes->getSchemeHandle("Scoreboard Small Text");
SchemeHandle_t hTinyScheme = pSchemes->getSchemeHandle("Scoreboard Tiny Text");
Font *tfont = pSchemes->getFont(hTitleScheme);
Font *smallfont = pSchemes->getFont(hSmallScheme);
Font *tinyfont = pSchemes->getFont(hTinyScheme);
setBgColor(0, 0, 0, 96);
m_pCurrentHighlightLabel = NULL;
m_iHighlightRow = -1;
// puzl: 0001073
m_pTrackerIcon = NULL;
m_pDevIcon = NULL;
m_pPTIcon = NULL;
m_pGuideIcon = NULL;
m_pServerOpIcon = NULL;
m_pContribIcon = NULL;
m_pCheatingDeathIcon = NULL;
m_pVeteranIcon = NULL;
m_pTrackerIcon = vgui_LoadTGANoInvertAlpha("gfx/vgui/640_scoreboardtracker.tga");
m_pDevIcon = vgui_LoadTGANoInvertAlpha("gfx/vgui/640_scoreboarddev.tga");
m_pPTIcon = vgui_LoadTGANoInvertAlpha("gfx/vgui/640_scoreboardpt.tga");
m_pGuideIcon = vgui_LoadTGANoInvertAlpha("gfx/vgui/640_scoreboardguide.tga");
m_pServerOpIcon = vgui_LoadTGANoInvertAlpha("gfx/vgui/640_scoreboardserverop.tga");
m_pContribIcon = vgui_LoadTGANoInvertAlpha("gfx/vgui/640_scoreboardcontrib.tga");
m_pCheatingDeathIcon = vgui_LoadTGANoInvertAlpha("gfx/vgui/640_scoreboardcd.tga");
m_pVeteranIcon = vgui_LoadTGANoInvertAlpha("gfx/vgui/640_scoreboardveteran.tga");
m_iIconFrame = 0;
m_iLastFrameIncrementTime = gHUD.GetTimeOfLastUpdate();
// Initialize the top title.
m_TitleLabel.setFont(tfont);
m_TitleLabel.setText("");
m_TitleLabel.setBgColor( 0, 0, 0, 255 );
m_TitleLabel.setFgColor( Scheme::sc_primary1 );
m_TitleLabel.setContentAlignment( vgui::Label::a_west );
LineBorder *border = new LineBorder(Color(60, 60, 60, 128));
setBorder(border);
setPaintBorderEnabled(true);
int xpos = g_ColumnInfo[0].m_Width + 3;
if (ScreenWidth() >= 640)
{
// only expand column size for res greater than 640
xpos = XRES(xpos);
}
m_TitleLabel.setBounds(xpos, 4, wide, SBOARD_TITLE_SIZE_Y);
m_TitleLabel.setContentFitted(false);
m_TitleLabel.setParent(this);
// Setup the header (labels like "name", "class", etc..).
m_HeaderGrid.SetDimensions(NUM_COLUMNS, 1);
m_HeaderGrid.SetSpacing(0, 0);
for(int i=0; i < NUM_COLUMNS; i++)
{
if (g_ColumnInfo[i].m_pTitle && g_ColumnInfo[i].m_pTitle[0] == '#')
m_HeaderLabels[i].setText(CHudTextMessage::BufferedLocaliseTextString(g_ColumnInfo[i].m_pTitle));
else if(g_ColumnInfo[i].m_pTitle)
m_HeaderLabels[i].setText(g_ColumnInfo[i].m_pTitle);
int xwide = g_ColumnInfo[i].m_Width;
if (ScreenWidth() >= 640)
{
xwide = XRES(xwide);
}
else if (ScreenWidth() == 400)
{
// hack to make 400x300 resolution scoreboard fit
if (i == 1)
{
// reduces size of player name cell
xwide -= 28;
}
else if (i == 0)
{
// tracker icon cell
xwide -= 8;
}
}
m_HeaderGrid.SetColumnWidth(i, xwide);
m_HeaderGrid.SetEntry(i, 0, &m_HeaderLabels[i]);
m_HeaderLabels[i].setBgColor(0,0,0,255);
m_HeaderLabels[i].setBgColor(0,0,0,255);
int theColorIndex = 0;
Color gammaAdjustedTeamColor = BuildColor(kTeamColors[theColorIndex][0], kTeamColors[theColorIndex][1], kTeamColors[theColorIndex][2], gHUD.GetGammaSlope());
int theR, theG, theB, theA;
gammaAdjustedTeamColor.getColor(theR, theG, theB, theA);
m_HeaderLabels[i].setFgColor(theR, theG, theB, theA);
m_HeaderLabels[i].setFont(smallfont);
m_HeaderLabels[i].setContentAlignment(g_ColumnInfo[i].m_Alignment);
int yres = 12;
if (ScreenHeight() >= 480)
{
yres = YRES(yres);
}
m_HeaderLabels[i].setSize(50, yres);
}
// Set the width of the last column to be the remaining space.
int ex, ey, ew, eh;
m_HeaderGrid.GetEntryBox(NUM_COLUMNS - 2, 0, ex, ey, ew, eh);
m_HeaderGrid.SetColumnWidth(NUM_COLUMNS - 1, (wide - X_BORDER) - (ex + ew));
m_HeaderGrid.AutoSetRowHeights();
m_HeaderGrid.setBounds(X_BORDER, SBOARD_TITLE_SIZE_Y, wide - X_BORDER*2, m_HeaderGrid.GetRowHeight(0));
m_HeaderGrid.setParent(this);
m_HeaderGrid.setBgColor(0,0,0,255);
// Now setup the listbox with the actual player data in it.
int headerX, headerY, headerWidth, headerHeight;
m_HeaderGrid.getBounds(headerX, headerY, headerWidth, headerHeight);
m_PlayerList.setBounds(headerX, headerY+headerHeight, headerWidth, tall - headerY - headerHeight - 6);
m_PlayerList.setBgColor(0,0,0,255);
m_PlayerList.setParent(this);
for(int row=0; row < NUM_ROWS; row++)
{
CGrid *pGridRow = &m_PlayerGrids[row];
pGridRow->SetDimensions(NUM_COLUMNS, 1);
for(int col=0; col < NUM_COLUMNS; col++)
{
m_PlayerEntries[col][row].setContentFitted(false);
m_PlayerEntries[col][row].setRow(row);
m_PlayerEntries[col][row].addInputSignal(this);
pGridRow->SetEntry(col, 0, &m_PlayerEntries[col][row]);
}
pGridRow->setBgColor(0,0,0,255);
// pGridRow->SetSpacing(2, 0);f
pGridRow->SetSpacing(0, 0);
pGridRow->CopyColumnWidths(&m_HeaderGrid);
pGridRow->AutoSetRowHeights();
pGridRow->setSize(PanelWidth(pGridRow), pGridRow->CalcDrawHeight());
pGridRow->RepositionContents();
m_PlayerList.AddItem(pGridRow);
}
// Add the hit test panel. It is invisible and traps mouse clicks so we can go into squelch mode.
m_HitTestPanel.setBgColor(0,0,0,255);
m_HitTestPanel.setParent(this);
m_HitTestPanel.setBounds(0, 0, wide, tall);
m_HitTestPanel.addInputSignal(this);
m_pCloseButton = new CommandButton( "x", wide-XRES(12 + 4), YRES(2), XRES( 12 ) , YRES( 12 ) );
m_pCloseButton->setParent( this );
m_pCloseButton->addActionSignal( new CMenuHandler_StringCommandWatch( "-showscores", true ) );
m_pCloseButton->setBgColor(0,0,0,255);
m_pCloseButton->setFgColor( 255, 255, 255, 0 );
m_pCloseButton->setFont(tfont);
m_pCloseButton->setBoundKey( (char)255 );
m_pCloseButton->setContentAlignment(Label::a_center);
Initialize();
}
bool ConvertToShopItemTable(IN CGroupNode* pNode, OUT TShopTableEx& shopTable)
{
if (!pNode->GetValue("vnum", 0, shopTable.dwVnum))
{
sys_err("Group %s does not have vnum.", pNode->GetNodeName().c_str());
return false;
}
if (!pNode->GetValue("name", 0, shopTable.name))
{
sys_err("Group %s does not have name.", pNode->GetNodeName().c_str());
return false;
}
if (shopTable.name.length() >= SHOP_TAB_NAME_MAX)
{
sys_err("Shop name length must be less than %d. Error in Group %s, name %s", SHOP_TAB_NAME_MAX, pNode->GetNodeName().c_str(), shopTable.name.c_str());
return false;
}
std::string stCoinType;
if (!pNode->GetValue("cointype", 0, stCoinType))
{
stCoinType = "Gold";
}
if (boost::iequals(stCoinType, "Gold"))
{
shopTable.coinType = SHOP_COIN_TYPE_GOLD;
}
else if (boost::iequals(stCoinType, "SecondaryCoin"))
{
shopTable.coinType = SHOP_COIN_TYPE_SECONDARY_COIN;
}
else
{
sys_err("Group %s has undefine cointype(%s).", pNode->GetNodeName().c_str(), stCoinType.c_str());
return false;
}
CGroupNode* pItemGroup = pNode->GetChildNode("items");
if (!pItemGroup)
{
sys_err("Group %s does not have 'group items'.", pNode->GetNodeName().c_str());
return false;
}
int itemGroupSize = pItemGroup->GetRowCount();
std::vector <TShopItemTable> shopItems(itemGroupSize);
if (itemGroupSize >= SHOP_HOST_ITEM_MAX_NUM)
{
sys_err("count(%d) of rows of group items of group %s must be smaller than %d", itemGroupSize, pNode->GetNodeName().c_str(), SHOP_HOST_ITEM_MAX_NUM);
return false;
}
for (int i = 0; i < itemGroupSize; i++)
{
if (!pItemGroup->GetValue(i, "vnum", shopItems[i].vnum))
{
sys_err("row(%d) of group items of group %s does not have vnum column", i, pNode->GetNodeName().c_str());
return false;
}
if (!pItemGroup->GetValue(i, "count", shopItems[i].count))
{
sys_err("row(%d) of group items of group %s does not have count column", i, pNode->GetNodeName().c_str());
return false;
}
if (!pItemGroup->GetValue(i, "price", shopItems[i].price))
{
sys_err("row(%d) of group items of group %s does not have price column", i, pNode->GetNodeName().c_str());
return false;
}
}
std::string stSort;
if (!pNode->GetValue("sort", 0, stSort))
{
stSort = "None";
}
if (boost::iequals(stSort, "Asc"))
{
std::sort(shopItems.begin(), shopItems.end(), CompareShopItemName);
}
else if(boost::iequals(stSort, "Desc"))
{
std::sort(shopItems.rbegin(), shopItems.rend(), CompareShopItemName);
}
CGrid grid = CGrid(5, 9);
int iPos;
memset(&shopTable.items[0], 0, sizeof(shopTable.items));
for (int i = 0; i < shopItems.size(); i++)
{
TItemTable * item_table = ITEM_MANAGER::instance().GetTable(shopItems[i].vnum);
if (!item_table)
{
sys_err("vnum(%d) of group items of group %s does not exist", shopItems[i].vnum, pNode->GetNodeName().c_str());
return false;
}
iPos = grid.FindBlank(1, item_table->bSize);
grid.Put(iPos, 1, item_table->bSize);
shopTable.items[iPos] = shopItems[i];
}
shopTable.byItemCount = shopItems.size();
return true;
}
void CEasyGenView::OnCameraZeroh()
{
CEasyGenDoc *pDoc = GetDocument();
m_Eye.z = g_Grid.GetMaxHeight();
InvalidateRect(NULL, FALSE);
}
void CEasyGenView::OnLButtonDown(UINT nFlags, CPoint point)
{
CEasyGenDoc *pDoc = GetDocument();
S_POSINFO inf;
CTris *t;
CNmVec3 p;
int tab;
m_LDP = point;
BOOL kCTRL = nFlags & MK_CONTROL;
BOOL kSHIFT = nFlags & MK_SHIFT;
BOOL Refresh = FALSE;
int mod = pDoc->GetModifier();
switch (tab = pDoc->GetActiveTab())
{
case (TAB_GRID):
break;
case (TAB_MODIFIER):
// Get a vertex to drag(CTRL+SHIFT+LeftBut)
if (kCTRL && kSHIFT)
{
if (GetXYZ(point, p))
{
if (g_Grid.GetInfo(p.x, p.y, &inf))
{
m_VertexGot = g_Grid.GetK(inf.i, inf.j);
}
}
}
// Exclude triangle from export | to prevent erroneus exclusion
if (!kCTRL && kSHIFT && g_Grid.OptionExcludedTrisGet())
{
if (GetXYZ(point, p))
{
t = g_Grid.GetTris(g_Grid.GetTris(p.x, p.y));
if (t)
{
t->SetExcluded(!t->GetExcluded());
pDoc->m_bInvalidateGridColor = TRUE;
Refresh = TRUE;
}
}
}
break;
case (TAB_ALPHAMAP):
int curindex;
curindex = g_AlphamapMan.GetCurSel();
// paint the alphamap (CTRL+SHIFT+LeftBut)
if (kCTRL && kSHIFT && curindex != -1)
{
if (GetXYZ(point, p))
{
if (g_Grid.GetInfo(p.x, p.y, &inf))
{
m_VertexGot = g_Grid.GetK(inf.i, inf.j);
// g_Grid.SetAlphaIndex(m_VertexGot, curindex );
g_Grid.PaintAlphaIndex(inf.i, inf.j, pDoc->m_dwPaintRadius, curindex);
Refresh = TRUE;
}
}
}
int indexgot;
// copy alphamap index (SHIFT+LeftBut)
if (!kCTRL && kSHIFT)
{
if (GetXYZ(point, p))
{
if (g_Grid.GetInfo(p.x, p.y, &inf))
{
m_VertexGot = g_Grid.GetK(inf.i, inf.j);
indexgot = g_Grid.GetAlphaIndex(m_VertexGot);
if (indexgot != g_AlphamapMan.GetCurSel())
{
g_AlphamapMan.SetCurSel(indexgot);
pDoc->UpdateFormView(TAB_ALPHAMAP);
}
}
}
}
break;
case (TAB_MODELS):
// MD3 - Selecting
if (!kCTRL && kSHIFT)
{
CNmVec3 ray, dummy;
float md3_dist, hitterra_dist;
bool hitterra;
S_MD3PTR *oldh = m_Md3Highlight;
S_MD3PTR *hit_md3;
if (GetRay(point, ray))
{
if (g_Md3Man.GetByRay(m_Eye, ray, hit_md3, md3_dist))
{
// check if is covered by terrain!!!
hitterra = g_Grid.GetDistanceTrisRay(m_Eye, ray, dummy, hitterra_dist);
if (!hitterra)
{
m_Md3Highlight = hit_md3;
}
else if (hitterra_dist > md3_dist)
{
m_Md3Highlight = hit_md3;
}
}
}
if (m_Md3Highlight != oldh)
{
Refresh = TRUE;
}
}
break;
}
// rotate tris (CTRL+LeftBut)
if ((tab == TAB_GRID || tab == TAB_MODIFIER || tab == TAB_ALPHAMAP) &&
mod == MOD_NONE && kCTRL && !kSHIFT)
{
if (GetXYZ(point, p))
{
if (g_Grid.GetInfo(p.x, p.y, &inf))
{
int i, j, k;
int mt1;
S_FACEDATAEX *f;
mt1 = g_Grid.GetTris(p.x, p.y);
mt1 &= ~1;
k = mt1 / 2;
i = k % g_Grid.GetCellsX();
j = k / g_Grid.GetCellsX();
f = g_Grid.GetFace(k);
if ((f->flags & FACE_FL_TRISINV))
{
f->flags &= ~FACE_FL_TRISINV;
}
else
{
f->flags |= FACE_FL_TRISINV;
}
g_Grid.FaceOrientateTris(i, j, f->flags & FACE_FL_TRISINV);
Refresh = TRUE;
}
}
}
if (Refresh)
{
InvalidateRect(NULL, FALSE);
} //
SetCapture();
CView::OnLButtonDown(nFlags, point);
}
void CEasyGenView::OnMouseMove(UINT nFlags, CPoint point)
{
CView::OnMouseMove(nFlags, point);
CEasyGenDoc *pDoc = GetDocument();
BOOL Refresh = FALSE;
BOOL UpdStatus = FALSE;
CNmVec3 p;
S_POSINFO inf;
int tab;
int mod = pDoc->GetModifier();
BOOL kCTRL = nFlags & MK_CONTROL;
BOOL kSHIFT = nFlags & MK_SHIFT;
BOOL m_LBD = nFlags & MK_LBUTTON;
BOOL m_RBD = nFlags & MK_RBUTTON;
CPoint Ldelta = point - m_LDP;
CPoint Rdelta = point - m_RDP;
if (!m_LBD)
{
m_VertexGot = -1;
}
switch (tab = pDoc->GetActiveTab())
{
case (TAB_GRID):
break;
case (TAB_MODIFIER):
// move Modifier CTRL + Left
if (m_LBD && kCTRL && !kSHIFT)
{
float f = (float)u_deg2rad(-m_yRot + 90);
float dx = -(float)(Ldelta.x) * pDoc->m_modXYstep;
float dy = (float)(Ldelta.y) * pDoc->m_modXYstep;
pDoc->m_modY += float(sin(f) * dx + cos(f) * dy);
pDoc->m_modX += float(cos(f) * dx - sin(f) * dy);
g_Mod.MoveDelta(float(cos(f) * dx - sin(f) * dy), float(sin(f) * dx + cos(f) * dy));
UpdStatus = TRUE;
pDoc->m_bInvalidateGridPreview = TRUE;
Refresh = TRUE;
}
// inc Strength CTRL + Right
if (m_RBD && kCTRL && !kSHIFT && (mod != MOD_NONE))
{
pDoc->m_modStrength -= (float)(Rdelta.y) * 4.f;
g_Mod.HeightDelta(-(float)(Rdelta.y) * 4.f);
UpdStatus = TRUE;
pDoc->m_bInvalidateGridPreview = TRUE;
Refresh = TRUE;
}
// inc Radius SHIFT + Right
if (m_RBD && !kCTRL && kSHIFT && (mod != MOD_NONE))
{
pDoc->m_modRadius -= (float)(Rdelta.y) * 4.f;
g_Mod.RadiusDelta(-(float)(Rdelta.y) * 4.f);
if (pDoc->m_modRadius < 0)
{
pDoc->m_modRadius = 0;
}
UpdStatus = TRUE;
pDoc->m_bInvalidateGridPreview = TRUE;
Refresh = TRUE;
}
// Vertex dragging
if (m_LBD && kCTRL && kSHIFT && (m_VertexGot != -1) && (mod == MOD_NONE))
{
float *z = g_Grid.GetPtr(m_VertexGot);
*z = floor(*z - g_Prefs.m_fVertexDragStep * (float)Ldelta.y);
if (*z < ASSUME_ZERO)
{
*z = 0;
}
m_vGenericPos.Set(g_Grid.GetX(m_VertexGot), g_Grid.GetY(m_VertexGot), *z);
UpdStatus = TRUE;
pDoc->m_bInvalidateGridPreview = TRUE;
Refresh = TRUE;
}
break;
case (TAB_ALPHAMAP):
int curindex;
curindex = g_AlphamapMan.GetCurSel();
// Alphamap paint
if (m_LBD && kCTRL && kSHIFT && curindex != -1)
{
if (GetXYZ(point, p))
{
if (g_Grid.GetInfo(p.x, p.y, &inf))
{
m_VertexGot = g_Grid.GetK(inf.i, inf.j);
// g_Grid.SetAlphaIndex(m_VertexGot, curindex );
g_Grid.PaintAlphaIndex(inf.i, inf.j, pDoc->m_dwPaintRadius, curindex);
Refresh = TRUE;
}
}
}
break;
case (TAB_MODELS):
break;
}
// rotate X/Y
if (m_LBD && !m_RBD && !kCTRL && !kSHIFT)
{
m_yRot += (float)(Ldelta.x) / 2.0f; // left / right
m_xRot += (float)(Ldelta.y) / 2.0f; // up / dn
if (m_xRot > 85)
{
m_xRot = 85;
}
if (m_xRot < -85)
{
m_xRot = -85;
}
Refresh = TRUE;
}
// pan
if (m_RBD && !m_LBD && !kCTRL && !kSHIFT)
{
float f = (float)u_deg2rad(-m_yRot + 90);
float dx = -(float)(Ldelta.x) * 16;
float dy = (float)(Ldelta.y) * 16;
m_Eye.y += float(sin(f) * dx + cos(f) * dy);
m_Eye.x += float(cos(f) * dx - sin(f) * dy);
Refresh = TRUE;
}
// up/dn
if (m_RBD && m_LBD && !kCTRL && !kSHIFT)
{
m_Eye.z -= (float)(Rdelta.y) * 32;
Refresh = TRUE;
}
if (Refresh)
{
InvalidateRect(NULL, FALSE);
}
if (UpdStatus)
{
UpdateStatusBar();
}
m_LDP = point;
m_RDP = point;
}
void CEasyGenView::OnLButtonDblClk(UINT nFlags, CPoint point)
{
CEasyGenDoc *pDoc = GetDocument();
CNmVec3 ray;
CNmVec3 p;
BOOL kCTRL = nFlags & MK_CONTROL;
BOOL kSHIFT = nFlags & MK_SHIFT;
BOOL GotPoint = GetXYZ(point, p);
BOOL GotRay = GetRay(point, ray);
switch (pDoc->GetActiveTab())
{
case (TAB_GRID):
// player place
if (!kCTRL && kSHIFT && GotPoint && g_Grid.PtInGrid(p.x, p.y))
{
pDoc->m_vPlayer.x = p.x;
pDoc->m_vPlayer.y = p.y;
S_POSINFO inf;
if (g_Grid.GetInfo(pDoc->m_vPlayer.x, pDoc->m_vPlayer.y, &inf))
{
pDoc->m_vPlayer.z = inf.z;
}
m_vGenericPos.Set(p.x, p.y, pDoc->m_vPlayer.z);
UpdateStatusBar();
InvalidateRect(NULL, FALSE);
}
break;
case (TAB_MODIFIER):
// modifier place
if (kCTRL && !kSHIFT && GotPoint && g_Grid.PtInGrid(p.x, p.y))
{
pDoc->m_modX = p.x;
pDoc->m_modY = p.y;
g_Mod.PositionSet(p.x, p.y);
UpdateStatusBar();
InvalidateRect(NULL, FALSE);
pDoc->m_bInvalidateGridPreview = TRUE;
}
break;
case (TAB_ALPHAMAP):
break;
case (TAB_MODELS):
// MD3 - Insert model
if (kCTRL && !kSHIFT && GotRay)
{
CNmVec3 pos;
float dist;
S_MD3PTR *md3ptr;
if (g_Grid.GetDistanceTrisRay(m_Eye, ray, pos, dist))
{
md3ptr = g_Md3Man.m_Placed.Append(); // g_Md3Man.m_Placed.Append( pDoc->GetMd3SelectedTabModels() );
if (md3ptr)
{
md3ptr->pMd3 = pDoc->GetMd3SelectedTabModels();
md3ptr->m_egvPos = pos;
InvalidateRect(NULL, FALSE);
}
}
}
break;
}
// CAMERA - camera place [EVERY TAB]
if (!kSHIFT && !kCTRL && GotPoint && g_Grid.PtInGrid(p.x, p.y))
{
m_Eye.x = p.x;
m_Eye.y = p.y;
InvalidateRect(NULL, FALSE);
}
CView::OnLButtonDblClk(nFlags, point);
}
void ScorePanel::FillGrid()
{
CSchemeManager *pSchemes = gViewPort->GetSchemeManager();
SchemeHandle_t hScheme = pSchemes->getSchemeHandle("Scoreboard Text");
SchemeHandle_t hTitleScheme = pSchemes->getSchemeHandle("Scoreboard Title Text");
SchemeHandle_t hSmallScheme = pSchemes->getSchemeHandle("Scoreboard Small Text");
Font *sfont = pSchemes->getFont(hScheme);
Font *tfont = pSchemes->getFont(hTitleScheme);
/* Font *smallfont = */
pSchemes->getFont(hSmallScheme);
int i = 0;
// update highlight position
int x, y;
getApp()->getCursorPos(x, y);
cursorMoved(x, y, this);
// remove highlight row if we're not in squelch mode
if (!GetClientVoiceMgr()->IsInSquelchMode())
{
m_iHighlightRow = -1;
}
for(int row=0; row < NUM_ROWS; row++)
{
CGrid *pGridRow = &m_PlayerGrids[row];
pGridRow->SetRowUnderline(0, false, 0, 0, 0, 0, 0);
if(row >= m_iRows)
{
for(int col=0; col < NUM_COLUMNS; col++)
m_PlayerEntries[col][row].setVisible(false);
continue;
}
for(int col=0; col < NUM_COLUMNS; col++)
{
CLabelHeader *pLabel = &m_PlayerEntries[col][row];
pLabel->setVisible(true);
pLabel->setText2("");
pLabel->setImage(NULL);
pLabel->setFont(sfont);
pLabel->setTextOffset(0, 0);
int rowheight = 13;
if (ScreenHeight > 480)
{
rowheight = YRES(rowheight);
}
else
{
// more tweaking, make sure icons fit at low res
rowheight = 15;
}
pLabel->setSize(pLabel->getWide(), rowheight);
pLabel->setBgColor(0, 0, 0, 255);
char sz[128];
hud_player_info_t *pl_info = NULL;
team_info_t *team_info = NULL;
if (m_iIsATeam[row] == TEAM_SPECTATORS)
{
pLabel->setText(" ");
continue;
}
else if ( m_iIsATeam[row] == TEAM_YES )
{
// Get the team's data
team_info = &g_TeamInfo[ m_iSortedRows[row] ];
// team color text for team names
pLabel->setFgColor( iTeamColors[team_info->teamnumber % 5][0],
iTeamColors[team_info->teamnumber % 5][1],
iTeamColors[team_info->teamnumber % 5][2],
0 );
// different height for team header rows
rowheight = 20;
if (ScreenHeight >= 480)
{
rowheight = YRES(rowheight);
}
pLabel->setSize(pLabel->getWide(), rowheight);
pLabel->setFont(tfont);
pGridRow->SetRowUnderline( 0,
true,
YRES(3),
iTeamColors[team_info->teamnumber % 5][0],
iTeamColors[team_info->teamnumber % 5][1],
iTeamColors[team_info->teamnumber % 5][2],
0 );
}
else if ( m_iIsATeam[row] == TEAM_SPECTATORS )
{
// grey text for spectators
pLabel->setFgColor(100, 100, 100, 0);
// different height for team header rows
rowheight = 20;
if (ScreenHeight >= 480)
{
rowheight = YRES(rowheight);
}
pLabel->setSize(pLabel->getWide(), rowheight);
pLabel->setFont(tfont);
pGridRow->SetRowUnderline(0, true, YRES(3), 100, 100, 100, 0);
}
else
{
// team color text for player names
pLabel->setFgColor( g_iaDiscColors[ g_PlayerExtraInfo[ m_iSortedRows[row] ].teamnumber % iNumberOfTeamColors ][0],
g_iaDiscColors[ g_PlayerExtraInfo[ m_iSortedRows[row] ].teamnumber % iNumberOfTeamColors ][1],
g_iaDiscColors[ g_PlayerExtraInfo[ m_iSortedRows[row] ].teamnumber % iNumberOfTeamColors ][2],
0 );
// Get the player's data
pl_info = &g_PlayerInfoList[ m_iSortedRows[row] ];
// Set background color
if ( pl_info->thisplayer ) // if it is their name, draw it a different color
{
// Highlight this player
pLabel->setFgColor(Scheme::sc_white);
pLabel->setBgColor( g_iaDiscColors[ g_PlayerExtraInfo[ m_iSortedRows[row] ].teamnumber % iNumberOfTeamColors ][0],
g_iaDiscColors[ g_PlayerExtraInfo[ m_iSortedRows[row] ].teamnumber % iNumberOfTeamColors ][1],
g_iaDiscColors[ g_PlayerExtraInfo[ m_iSortedRows[row] ].teamnumber % iNumberOfTeamColors ][2],
196 );
}
else if ( m_iSortedRows[row] == m_iLastKilledBy && m_fLastKillTime && m_fLastKillTime > gHUD.m_flTime )
{
// Killer's name
pLabel->setBgColor( 255,0,0, 255 - ((float)15 * (float)(m_fLastKillTime - gHUD.m_flTime)) );
}
}
// Align
if (col == COLUMN_NAME )
{
pLabel->setContentAlignment( vgui::Label::a_west );
}
else if (col == COLUMN_TRACKER)
{
pLabel->setContentAlignment( vgui::Label::a_center );
}
else
{
pLabel->setContentAlignment( vgui::Label::a_east );
}
// Fill out with the correct data
strcpy(sz, "");
if ( m_iIsATeam[row] )
{
char sz2[128];
switch (col)
{
case COLUMN_NAME:
if ( m_iIsATeam[row] == TEAM_UNASSIGNED )
{
sprintf( sz2, "%s", CHudTextMessage::BufferedLocaliseTextString( "#Queue" ) );
}
else if ( m_iIsATeam[row] == TEAM_SPECTATORS )
{
sprintf( sz2, "%s", CHudTextMessage::BufferedLocaliseTextString( "#Spectators" ) );
}
else
{
sprintf( sz2, "%s", CHudTextMessage::BufferedLocaliseTextString( team_info->name ) );
}
// Uppercase it
for ( i = 0; i < (int)strlen(sz2); i++)
{
if ( *(sz2 + i) )
sz[i] = toupper( *(sz2 + i) );
}
sz[i] = '\0';
// Append the number of players
if ( m_iIsATeam[row] == TEAM_YES )
{
const char *pszTemp = NULL;
if ( team_info->players == 1 )
{
pszTemp = "#Player";
}
else
{
pszTemp = "#Player_plural";
}
sprintf(sz, "%s (%d %s)", sz, team_info->players, CHudTextMessage::BufferedLocaliseTextString( pszTemp ) );
}
break;
case COLUMN_VOICE:
break;
case COLUMN_CLASS:
break;
case COLUMN_KILLS: //Wins
if ( g_iArenaMode == FALSE )
strcpy ( sz, " " );
else
{
if ( m_iIsATeam[row] == TEAM_YES )
sprintf(sz, "%d", team_info->deaths );
}
break;
case COLUMN_DEATHS: //Points
if ( m_iIsATeam[row] == TEAM_YES )
sprintf(sz, "%d", team_info->frags );
break;
case COLUMN_LATENCY:
if ( m_iIsATeam[row] == TEAM_YES )
sprintf(sz, "%d", team_info->ping );
break;
default:
break;
}
}
else
{
switch (col)
{
case COLUMN_NAME:
/*
if (g_pTrackerUser)
{
int playerSlot = m_iSortedRows[row];
int trackerID = gEngfuncs.GetTrackerIDForPlayer(playerSlot);
const char *trackerName = g_pTrackerUser->GetUserName(trackerID);
if (trackerName && *trackerName)
{
sprintf(sz, " (%s)", trackerName);
pLabel->setText2(sz);
}
}
*/
sprintf(sz, "%s ", pl_info->name);
break;
case COLUMN_VOICE:
sz[0] = 0;
GetClientVoiceMgr()->UpdateSpeakerImage(pLabel, m_iSortedRows[row]);
break;
case COLUMN_CLASS:
if ( g_PlayerExtraInfo[ m_iSortedRows[row] ].teamnumber == 0 && g_iArenaMode == TRUE )
{
sprintf(sz, "%d", g_PlayerExtraInfo[ m_iSortedRows[row] ].playerclass );
}
else
{
strcpy(sz, "");
}
break;
case COLUMN_TRACKER:
/*
if (g_pTrackerUser)
{
int playerSlot = m_iSortedRows[row];
int trackerID = gEngfuncs.GetTrackerIDForPlayer(playerSlot);
if (g_pTrackerUser->IsFriend(trackerID) && trackerID != g_pTrackerUser->GetTrackerID())
{
pLabel->setImage(m_pTrackerIcon);
pLabel->setFgColorAsImageColor(false);
m_pTrackerIcon->setColor(Color(255, 255, 255, 0));
}
}*/
break;
case COLUMN_KILLS: //Wins
if ( g_iArenaMode == TRUE )
sprintf(sz, "%d", g_PlayerExtraInfo[ m_iSortedRows[row] ].deaths );
break;
case COLUMN_DEATHS: //Points
sprintf(sz, "%d", g_PlayerExtraInfo[ m_iSortedRows[row] ].frags );
break;
case COLUMN_LATENCY:
sprintf(sz, "%d", g_PlayerInfoList[ m_iSortedRows[row] ].ping );
break;
default:
break;
}
}
pLabel->setText(sz);
}
}
for(int row = 0; row < NUM_ROWS; row++)
{
CGrid *pGridRow = &m_PlayerGrids[row];
pGridRow->AutoSetRowHeights();
pGridRow->setSize(PanelWidth(pGridRow), pGridRow->CalcDrawHeight());
pGridRow->RepositionContents();
}
// hack, for the thing to resize
m_PlayerList.getSize(x, y);
m_PlayerList.setSize(x, y);
}
