/**
* @return @c true if are a compatible client and nothing else must be downloaded or no downloads are still running,
* @c false if the start of the match must get a little bit postponed (running downloads).
* @note throws ERR_DISCONNECT if we are not compatible to the server
*/
static bool CL_CanMultiplayerStart (void)
{
const int day = CL_GetConfigStringInteger(CS_LIGHTMAP);
const char* serverVersion = CL_GetConfigString(CS_VERSION);
/* checksum doesn't match with the one the server gave us via configstring */
if (!Q_streq(UFO_VERSION, serverVersion)) {
Com_sprintf(popupText, sizeof(popupText), _("Local game version (%s) differs from the server version (%s)"), UFO_VERSION, serverVersion);
UI_Popup(_("Error"), popupText);
Com_Error(ERR_DISCONNECT, "Local game version (%s) differs from the server version (%s)", UFO_VERSION, serverVersion);
/* amount of objects from script files doesn't match */
} else if (csi.numODs != CL_GetConfigStringInteger(CS_OBJECTAMOUNT)) {
UI_Popup(_("Error"), _("Script files are not the same"));
Com_Error(ERR_DISCONNECT, "Script files are not the same");
}
/* activate the map loading screen for multiplayer, too */
SCR_BeginLoadingPlaque();
/* check download */
if (cls.downloadMaps) { /* confirm map */
if (CL_DownloadMap(CL_GetConfigString(CS_NAME)))
return false;
cls.downloadMaps = false;
}
/* map might still be downloading? */
if (CL_PendingHTTPDownloads())
return false;
if (Com_GetScriptChecksum() != CL_GetConfigStringInteger(CS_UFOCHECKSUM))
Com_Printf("You are using modified ufo script files - might produce problems\n");
CM_LoadMap(CL_GetConfigString(CS_TILES), day, CL_GetConfigString(CS_POSITIONS), CL_GetConfigString(CS_ENTITYSTRING), cl.mapData, cl.mapTiles);
#if 0
if (cl.mapData->mapChecksum != CL_GetConfigStringInteger(CS_MAPCHECKSUM)) {
UI_Popup(_("Error"), _("Local map version differs from server"));
Com_Error(ERR_DISCONNECT, "Local map version differs from server: %u != '%i'",
cl.mapData->mapChecksum, CL_GetConfigStringInteger(CS_MAPCHECKSUM));
}
#endif
return true;
}
/**
* @brief Draws the current loading pic of the map from base/pics/maps/loading
* @sa SCR_DrawLoadingBar
*/
void SCR_DrawLoading (int percent, const char *loadingMessages)
{
const image_t* loadingPic;
const vec4_t color = {0.0, 0.7, 0.0, 0.8};
char *mapmsg;
if (cls.downloadName[0]) {
SCR_DrawDownloading();
return;
}
loadingPic = SCR_SetLoadingBackground(CL_GetConfigString(CS_MAPTITLE));
R_BeginFrame();
/* center loading screen */
R_DrawImage(viddef.virtualWidth / 2 - loadingPic->width / 2, viddef.virtualHeight / 2 - loadingPic->height / 2, loadingPic);
R_Color(color);
if (CL_GetConfigString(CS_TILES)[0] != '\0') {
mapmsg = va(_("Loading Map [%s]"), _(CL_GetConfigString(CS_MAPTITLE)));
UI_DrawString("f_menubig", ALIGN_UC,
(int)(viddef.virtualWidth / 2),
(int)(viddef.virtualHeight / 2 - 60),
(int)(viddef.virtualWidth / 2),
viddef.virtualWidth, 50, mapmsg, 1, 0, NULL, qfalse, 0);
}
UI_DrawString("f_menu", ALIGN_UC,
(int)(viddef.virtualWidth / 2),
(int)(viddef.virtualHeight / 2),
(int)(viddef.virtualWidth / 2),
viddef.virtualWidth, 50, loadingMessages, 1, 0, NULL, qfalse, 0);
SCR_DrawLoadingBar((int)(viddef.virtualWidth / 2) - 300, viddef.virtualHeight - 30, 600, 20, percent);
R_EndFrame();
}
static bool CL_DownloadMap (const char* map)
{
bool startedDownload;
if (map[0] != '+') {
startedDownload = !CL_CheckOrDownloadFile(va("maps/%s.bsp", map));
} else {
startedDownload = !CL_CheckOrDownloadFile(va("maps/%s.ump", map + 1));
if (!startedDownload) {
const char* tiles = CL_GetConfigString(CS_TILES);
startedDownload = CL_DownloadUMPMap(tiles);
}
}
return startedDownload;
}
/**
* @brief Print the configstrings to game console
* @sa SV_PrintConfigStrings_f
*/
static void CL_ShowConfigstrings_f (void)
{
for (int i = 0; i < MAX_CONFIGSTRINGS; i++) {
const char* configString;
/* CS_TILES and CS_POSITIONS can stretch over multiple configstrings,
* so don't print the middle parts */
if (i > CS_TILES && i < CS_POSITIONS)
continue;
if (i > CS_POSITIONS && i < CS_MODELS)
continue;
configString = CL_GetConfigString(i);
if (configString[0] == '\0')
continue;
Com_Printf("configstring[%3i]: %s\n", i, configString);
}
}
/**
* @brief Calculate some radar values that won't change during a mission
* @note Called for every new map (client_state_t is wiped with every
* level change)
*/
static void UI_InitRadar (const uiNode_t* node)
{
int i, j;
const vec3_t offset = {MAP_SIZE_OFFSET, MAP_SIZE_OFFSET, MAP_SIZE_OFFSET};
float distAB, distBC;
vec2_t gridSize; /**< Size of the whole grid (in tiles units) */
vec2_t nodepos;
vec2_t min;
vec2_t max;
UI_FreeRadarImages();
UI_BuildRadarImageList(CL_GetConfigString(CS_TILES), CL_GetConfigString(CS_POSITIONS));
UI_GetNodeAbsPos(node, nodepos);
radar.x = nodepos[0] + node->box.size[0] / 2;
radar.y = nodepos[1] + node->box.size[1] / 2;
/* only check once per map whether all the needed images exist */
for (j = 0; j < radar.numImages; j++) {
hudRadarImage_t* tile = &radar.images[j];
/* map_mins, map_maxs */
for (i = 0; i < PATHFINDING_HEIGHT; i++) {
char imagePath[MAX_QPATH];
const image_t* image;
if (!UI_CheckRadarImage(tile->name, i + 1)) {
if (i == 0) {
/* there should be at least one level */
Com_Printf("No radar images for map: '%s'\n", tile->name);
radar.numImages = 0;
return;
}
continue;
}
Com_sprintf(imagePath, sizeof(imagePath), "radars/%s_%i", tile->name, i + 1);
tile->path[i] = Mem_StrDup(imagePath);
tile->maxlevel++;
image = R_FindImage(va("pics/%s", tile->path[i]), it_pic);
tile->width = image->width;
tile->height = image->height;
if (tile->isTile) {
tile->gridWidth = round(image->width / 94.0f);
tile->gridHeight = round(image->height / 94.0f);
tile->mapWidth = tile->gridWidth * 8 * UNIT_SIZE;
tile->mapHeight = tile->gridHeight * 8 * UNIT_SIZE;
} else {
tile->mapX = cl.mapData->mapBox.getMinX();
tile->mapY = cl.mapData->mapBox.getMinY();
tile->mapWidth = cl.mapData->mapBox.getWidthX();
tile->mapHeight = cl.mapData->mapBox.getWidthY();
}
}
if (tile->isTile) {
tile->mapY = cl.mapData->mapBox.getMaxY() - tile->mapY - tile->mapHeight;
}
}
/* center tiles into the minMap/maxMap */
Vector2Copy(cl.mapData->mapBox.maxs, min);
Vector2Copy(cl.mapData->mapBox.mins, max);
for (j = 0; j < radar.numImages; j++) {
hudRadarImage_t* tile = &radar.images[j];
if (tile->mapX < min[0])
min[0] = tile->mapX;
if (tile->mapY < min[1])
min[1] = tile->mapY;
if (tile->mapX + tile->mapWidth > max[0])
max[0] = tile->mapX + tile->mapWidth;
if (tile->mapY + tile->mapHeight > max[1])
max[1] = tile->mapY + tile->mapHeight;
}
/* compute translation */
min[0] = cl.mapData->mapBox.getMinX() + (cl.mapData->mapBox.getWidthX() - (max[0] - min[0])) * 0.5 - min[0];
min[1] = cl.mapData->mapBox.getMinY() + (cl.mapData->mapBox.getWidthY() - (max[1] - min[1])) * 0.5 - min[1];
for (j = 0; j < radar.numImages; j++) {
hudRadarImage_t* tile = &radar.images[j];
tile->mapX += min[0];
tile->mapY += min[1];
}
/* get the three points of the triangle */
VectorSubtract(cl.mapData->mapBox.mins, offset, radar.a);
VectorAdd(cl.mapData->mapBox.maxs, offset, radar.c);
VectorSet(radar.b, radar.c[0], radar.a[1], 0);
distAB = (Vector2Dist(radar.a, radar.b) / UNIT_SIZE);
distBC = (Vector2Dist(radar.b, radar.c) / UNIT_SIZE);
UI_GetRadarWidth(node, gridSize);
/* get the dimensions for one grid field on the radar map */
radar.gridWidth = radar.w / distAB;
radar.gridHeight = radar.h / distBC;
/* shift the x and y values according to their grid width/height and
* their gridX and gridY position */
{
const float radarLength = std::max(1.0f, fabsf(gridSize[0]));
const float radarHeight = std::max(1.0f, fabsf(gridSize[1]));
/* image grid relations */
const float gridFactorX = radar.w / radarLength;
const float gridFactorY = radar.h / radarHeight;
for (j = 0; j < radar.numImages; j++) {
hudRadarImage_t* image = &radar.images[j];
image->x = (image->gridX - radar.gridMin[0]) * gridFactorX;
image->y = radar.h - (image->gridY - radar.gridMin[1]) * gridFactorY - image->height;
}
}
/* now align the screen coordinates like it's given by the node */
radar.x -= (radar.w / 2);
radar.y -= (radar.h / 2);
}
int CL_GetConfigStringInteger (int index)
{
return atoi(CL_GetConfigString(index));
}
/**
* @brief Call before entering a new level, or after vid_restart
*/
void CL_ViewLoadMedia (void)
{
le_t* le;
int i, max;
float loadingPercent;
CL_ViewUpdateRenderData();
if (CL_GetConfigString(CS_TILES)[0] == '\0')
return; /* no map loaded */
GAME_InitMissionBriefing(_(CL_GetConfigString(CS_MAPTITLE)));
loadingPercent = 0;
/* register models, pics, and skins */
SCR_DrawLoading(loadingPercent);
R_ModBeginLoading(CL_GetConfigString(CS_TILES), CL_GetConfigStringInteger(CS_LIGHTMAP),
CL_GetConfigString(CS_POSITIONS), CL_GetConfigString(CS_NAME), CL_GetConfigString(CS_MAPZONE));
CL_SpawnParseEntitystring();
loadingPercent += 10.0f;
SCR_DrawLoading(loadingPercent);
LM_Register();
CL_ParticleRegisterArt();
for (i = 1, max = 0; i < MAX_MODELS && CL_GetConfigString(CS_MODELS + i)[0] != '\0'; i++)
max++;
max += csi.numODs;
for (i = 1; i < MAX_MODELS; i++) {
const char* name = CL_GetConfigString(CS_MODELS + i);
if (name[0] == '\0')
break;
SCR_DrawLoading(loadingPercent);
cl.model_draw[i] = R_FindModel(name);
if (!cl.model_draw[i]) {
Cmd_ExecuteString("fs_info");
Com_Error(ERR_DROP, "Could not load model '%s'\n", name);
}
/* initialize clipping for bmodels */
if (name[0] == '*')
cl.model_clip[i] = CM_InlineModel(cl.mapTiles, name);
else
cl.model_clip[i] = nullptr;
loadingPercent += 100.0f / (float)max;
}
/* update le model references */
le = nullptr;
while ((le = LE_GetNextInUse(le))) {
if (le->modelnum1 > 0)
le->model1 = LE_GetDrawModel(le->modelnum1);
if (le->modelnum2 > 0)
le->model2 = LE_GetDrawModel(le->modelnum2);
}
refdef.ready = true;
/* waiting for EV_START */
SCR_EndLoadingPlaque();
}