void recvProcessDebugMappings(NETQUEUE queue)
{
bool val = false;
NETbeginDecode(queue, GAME_DEBUG_MODE);
NETbool(&val);
NETend();
bool oldDebugMode = getDebugMappingStatus();
processDebugMappings(queue.index, val);
bool newDebugMode = getDebugMappingStatus();
char const *cmsg;
if (val)
{
sasprintf((char**)&cmsg, _("%s wants to enable debug mode. Enabled: %s, Disabled: %s."), getPlayerName(queue.index), getWantedDebugMappingStatuses(true).c_str(), getWantedDebugMappingStatuses(false).c_str());
}
else
{
sasprintf((char**)&cmsg, _("%s wants to disable debug mode. Enabled: %s, Disabled: %s."), getPlayerName(queue.index), getWantedDebugMappingStatuses(true).c_str(), getWantedDebugMappingStatuses(false).c_str());
}
addConsoleMessage(cmsg, DEFAULT_JUSTIFY, SYSTEM_MESSAGE);
if (!oldDebugMode && newDebugMode)
{
addConsoleMessage(_("Debug mode now enabled!"), DEFAULT_JUSTIFY, SYSTEM_MESSAGE);
}
else if (oldDebugMode && !newDebugMode)
{
addConsoleMessage(_("Debug mode now disabled!"), DEFAULT_JUSTIFY, SYSTEM_MESSAGE);
}
}
static QScriptValue js_gameOverMessage(QScriptContext *context, QScriptEngine *engine)
{
int player = engine->globalObject().property("me").toInt32();
const MESSAGE_TYPE msgType = MSG_MISSION; // always
bool gameWon = context->argument(0).toBool();
VIEWDATA *psViewData;
if (gameWon)
{
psViewData = getViewData("WIN");
addConsoleMessage(_("YOU ARE VICTORIOUS!"), DEFAULT_JUSTIFY, SYSTEM_MESSAGE);
}
else
{
psViewData = getViewData("WIN");
addConsoleMessage(_("YOU WERE DEFEATED!"), DEFAULT_JUSTIFY, SYSTEM_MESSAGE);
}
ASSERT(psViewData, "Viewdata not found");
MESSAGE *psMessage = addMessage(msgType, false, player);
if (psMessage)
{
//set the data
psMessage->pViewData = (MSG_VIEWDATA *)psViewData;
displayImmediateMessage(psMessage);
stopReticuleButtonFlash(IDRET_INTEL_MAP);
//we need to set this here so the VIDEO_QUIT callback is not called
setScriptWinLoseVideo(gameWon ? PLAY_WIN : PLAY_LOSE);
}
displayGameOver(gameWon);
if (challengeActive)
{
updateChallenge(gameWon);
}
return QScriptValue();
}
// ////////////////////////////////////////////////////////////////////////////
// A remote player has left the game
bool MultiPlayerLeave(UDWORD playerIndex)
{
char buf[255];
if (playerIndex >= MAX_PLAYERS)
{
ASSERT(false, "Bad player number");
return false;
}
NETlogEntry("Player leaving game", SYNC_FLAG, playerIndex);
debug(LOG_NET,"** Player %u [%s], has left the game at game time %u.", playerIndex, getPlayerName(playerIndex), gameTime);
ssprintf(buf, _("%s has Left the Game"), getPlayerName(playerIndex));
if (ingame.localJoiningInProgress)
{
clearPlayer(playerIndex, false);
}
else if (NetPlay.isHost) // If hosting, and game has started (not in pre-game lobby screen, that is).
{
sendPlayerLeft(playerIndex);
}
game.skDiff[playerIndex] = 0;
addConsoleMessage(buf, DEFAULT_JUSTIFY, SYSTEM_MESSAGE);
if (NetPlay.players[playerIndex].wzFile.isSending)
{
char buf[256];
ssprintf(buf, _("File transfer has been aborted for %d.") , playerIndex);
addConsoleMessage(buf, DEFAULT_JUSTIFY, SYSTEM_MESSAGE);
debug(LOG_INFO, "=== File has been aborted for %d ===", playerIndex);
NetPlay.players[playerIndex].wzFile.isSending = false;
NetPlay.players[playerIndex].needFile = false;
}
NetPlay.players[playerIndex].kick = true; // Don't wait for GAME_GAME_TIME messages from them.
if (widgGetFromID(psWScreen, IDRET_FORM))
{
audio_QueueTrack(ID_CLAN_EXIT);
}
// fire script callback to reassign skirmish players.
CBPlayerLeft = playerIndex;
eventFireCallbackTrigger((TRIGGER_TYPE)CALL_PLAYERLEFT);
netPlayersUpdated = true;
return true;
}
/** Writes a screenshot of the current frame to file.
*
* Performs the actual work of writing the frame currently displayed on screen
* to the filename specified by screenDumpToDisk().
*
* @NOTE This function will only dump a screenshot to file if it was requested
* by screenDumpToDisk().
*
* \sa screenDumpToDisk()
*/
void screenDoDumpToDiskIfRequired(void)
{
const char* fileName = screendump_filename;
iV_Image image = { 0, 0, 8, NULL };
if (!screendump_required) return;
debug(LOG_3D, "Saving screenshot %s", fileName);
image.width = screenWidth;
image.height = screenHeight;
image.bmp = (unsigned char *)malloc(channelsPerPixel * image.width * image.height);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glReadPixels(0, 0, image.width, image.height, GL_RGB, GL_UNSIGNED_BYTE, image.bmp);
iV_saveImage_PNG(fileName, &image);
iV_saveImage_JPEG(fileName, &image);
// display message to user about screenshot
snprintf(ConsoleString,sizeof(ConsoleString),"Screenshot %s saved!",fileName);
addConsoleMessage(ConsoleString, LEFT_JUSTIFY,SYSTEM_MESSAGE);
if (image.bmp)
{
free(image.bmp);
}
screendump_required = false;
}
// TODO, should cover scrShowConsoleText, scrAddConsoleText, scrTagConsoleText and scrConsole
static QScriptValue js_console(QScriptContext *context, QScriptEngine *engine)
{
int player = engine->globalObject().property("me").toInt32();
if (player == selectedPlayer)
{
QString result;
for (int i = 0; i < context->argumentCount(); ++i)
{
if (i != 0)
{
result.append(QLatin1String(" "));
}
QString s = context->argument(i).toString();
if (context->state() == QScriptContext::ExceptionState)
{
break;
}
result.append(s);
}
//permitNewConsoleMessages(true);
//setConsolePermanence(true,true);
addConsoleMessage(result.toAscii().constData(), CENTRE_JUSTIFY, SYSTEM_MESSAGE);
//permitNewConsoleMessages(false);
}
return QScriptValue();
}
void ExecutionContext::parseAndSetReferrerPolicy(const String& policies,
bool supportLegacyKeywords) {
ReferrerPolicy referrerPolicy = ReferrerPolicyDefault;
Vector<String> tokens;
policies.split(',', true, tokens);
for (const auto& token : tokens) {
ReferrerPolicy currentResult;
if ((supportLegacyKeywords
? SecurityPolicy::referrerPolicyFromStringWithLegacyKeywords(
token, ¤tResult)
: SecurityPolicy::referrerPolicyFromString(token,
¤tResult))) {
referrerPolicy = currentResult;
}
}
if (referrerPolicy == ReferrerPolicyDefault) {
addConsoleMessage(ConsoleMessage::create(
RenderingMessageSource, ErrorMessageLevel,
"Failed to set referrer policy: The value '" + policies +
"' is not one of " +
(supportLegacyKeywords
? "'always', 'default', 'never', 'origin-when-crossorigin', "
: "") +
"'no-referrer', 'no-referrer-when-downgrade', 'origin', "
"'origin-when-cross-origin', or 'unsafe-url'. The referrer policy "
"has been left unchanged."));
return;
}
setReferrerPolicy(referrerPolicy);
}
// Stop droid driving mode.
//
void StopDriverMode(void)
{
DROID *psDroid;
if(psDrivenDroid != NULL)
{
debug( LOG_NEVER, "Drive mode canceled\n" );
addConsoleMessage("Driver mode canceled.", LEFT_JUSTIFY,SYSTEM_MESSAGE);
// audio_StopObjTrack(psDrivenDroid,ID_SOUND_SMALL_DROID_RUN);
psDrivenDroid = NULL;
for(psDroid = apsDroidLists[selectedPlayer]; psDroid; psDroid = psDroid->psNext) {
if( (psDroid->sMove.Status == MOVEDRIVE) ) {
ASSERT( (psDroid->droidType != DROID_TRANSPORTER),"Tried to control a transporter" );
secondarySetState(psDroid, DSO_HALTTYPE, DSS_HALT_GUARD);
psDroid->sMove.Status = MOVEINACTIVE;
}
}
}
setDrivingStatus(false);
driveInitVars(false); // reset everything again
DriveControlEnabled = false;
DirectControl = false;
}
// ////////////////////////////////////////////////////////////////////////////
// Setup Stuff for a new player.
void setupNewPlayer(UDWORD player)
{
UDWORD i;
ingame.PingTimes[player] = 0; // Reset ping time
ingame.JoiningInProgress[player] = true; // Note that player is now joining
ingame.DataIntegrity[player] = false;
for (i = 0; i < MAX_PLAYERS; i++) // Set all alliances to broken
{
alliances[selectedPlayer][i] = ALLIANCE_BROKEN;
alliances[i][selectedPlayer] = ALLIANCE_BROKEN;
}
resetMultiVisibility(player); // set visibility flags.
setMultiStats(player, getMultiStats(player), true); // get the players score
if (selectedPlayer != player)
{
char buf[255];
ssprintf(buf, _("%s is joining the game"), getPlayerName(player));
addConsoleMessage(buf, DEFAULT_JUSTIFY, SYSTEM_MESSAGE);
}
}
/** This function adds the droid to the command group commanded by psCommander.
* It creates a group if it doesn't exist.
* If the group is not full, it adds the droid to it and sets all the droid's states and orders to the group's.
*/
void cmdDroidAddDroid(DROID *psCommander, DROID *psDroid)
{
DROID_GROUP *psGroup;
if (psCommander->psGroup == NULL)
{
psGroup = grpCreate();
psGroup->add(psCommander);
psDroid->group = UBYTE_MAX;
}
if (psCommander->psGroup->getNumMembers() < cmdDroidMaxGroup(psCommander))
{
psCommander->psGroup->add(psDroid);
psDroid->group = UBYTE_MAX;
// set the secondary states for the unit
secondarySetState(psDroid, DSO_REPAIR_LEVEL, (SECONDARY_STATE)(psCommander->secondaryOrder & DSS_REPLEV_MASK), ModeImmediate);
secondarySetState(psDroid, DSO_ATTACK_LEVEL, (SECONDARY_STATE)(psCommander->secondaryOrder & DSS_ALEV_MASK), ModeImmediate);
orderDroidObj(psDroid, DORDER_GUARD, (BASE_OBJECT *)psCommander, ModeImmediate);
}
else
{
audio_PlayTrack( ID_SOUND_BUILD_FAIL );
addConsoleMessage(_("Commander needs a higher level to command more units"), DEFAULT_JUSTIFY, SYSTEM_MESSAGE);
}
}
void runLimitScreen(void)
{
UDWORD i, id, statid;
frontendMultiMessages(); // network stuff.
id = widgRunScreen(psWScreen); // Run the current set of widgets
// sliders
if((id > IDLIMITS_ENTRIES_START) && (id< IDLIMITS_ENTRIES_END))
{
statid = widgGetFromID(psWScreen,id-1)->UserData ;
if(statid)
{
asStructLimits[0][statid].limit = (UBYTE) ((W_SLIDER*)(widgGetFromID(psWScreen,id)))->pos;
}
}
else
{
// icons that are always about.
switch(id)
{
case IDLIMITS_RETURN:
// reset the sliders..
for (i = 0; i < numStructureStats ; ++i)
{
asStructLimits[0][i].limit = asStructLimits[0][i].globalLimit;
}
// free limiter structure
freeLimitSet();
//inform others
sendOptions();
eventReset();
changeTitleMode(MULTIOPTION);
// make some noize.
if(!ingame.localOptionsReceived)
{
addConsoleMessage(_("Limits reset to default values"),DEFAULT_JUSTIFY, SYSTEM_MESSAGE);
}
else
{
sendTextMessage("Limits Reset To Default Values",true);
}
break;
case IDLIMITS_OK:
resetReadyStatus(false);
createLimitSet();
changeTitleMode(MULTIOPTION);
break;
default:
break;
}
}
widgDisplayScreen(psWScreen); // show the widgets currently running
}
// ////////////////////////////////////////////////////////////////////////////
// Network File packet processor.
bool recvMapFileRequested(NETQUEUE queue)
{
//char mapStr[256],mapName[256],fixedname[256];
uint32_t player;
PHYSFS_sint64 fileSize_64;
PHYSFS_file *pFileHandle;
if(!NetPlay.isHost) // only host should act
{
ASSERT(false, "Host only routine detected for client!");
return false;
}
// Check to see who wants the file
NETbeginDecode(queue, NET_FILE_REQUESTED);
NETuint32_t(&player);
NETend();
if (!NetPlay.players[player].wzFile.isSending)
{
NetPlay.players[player].needFile = true;
NetPlay.players[player].wzFile.isCancelled = false;
NetPlay.players[player].wzFile.isSending = true;
LEVEL_DATASET *mapData = levFindDataSet(game.map, &game.hash);
addConsoleMessage("Map was requested: SENDING MAP!",DEFAULT_JUSTIFY, SYSTEM_MESSAGE);
char *mapStr = mapData->realFileName;
debug(LOG_NET, "Map was requested. Looking for %s", mapStr);
// Checking to see if file is available...
pFileHandle = PHYSFS_openRead(mapStr);
if (pFileHandle == NULL)
{
debug(LOG_ERROR, "Failed to open %s for reading: %s", mapStr, PHYSFS_getLastError());
debug(LOG_FATAL, "You have a map (%s) that can't be located.\n\nMake sure it is in the correct directory and or format! (No map packs!)", mapStr);
// NOTE: if we get here, then the game is basically over, The host can't send the file for whatever reason...
// Which also means, that we can't continue.
debug(LOG_NET, "***Host has a file issue, and is being forced to quit!***");
NETbeginEncode(NETbroadcastQueue(), NET_HOST_DROPPED);
NETend();
abort();
}
// get the file's size.
fileSize_64 = PHYSFS_fileLength(pFileHandle);
debug(LOG_NET, "File is valid, sending [directory: %s] %s to client %u", PHYSFS_getRealDir(mapStr), mapStr, player);
NetPlay.players[player].wzFile.pFileHandle = pFileHandle;
NetPlay.players[player].wzFile.fileSize_32 = (int32_t) fileSize_64; //we don't support 64bit int nettypes.
NetPlay.players[player].wzFile.currPos = 0;
NETsendFile(game.map, game.hash, player);
}
return true;
}
// While not the perfect place for this, it has to do when a HOST joins (hosts) game
// unfortunatly, we don't get the message until after the setup is done.
void ShowMOTD(void)
{
char buf[250] = { '\0' };
// when HOST joins the game, show server MOTD message first
addConsoleMessage(_("Server message:"), DEFAULT_JUSTIFY, NOTIFY_MESSAGE);
addConsoleMessage(NetPlay.MOTD, DEFAULT_JUSTIFY, NOTIFY_MESSAGE);
if (NetPlay.HaveUpgrade)
{
audio_PlayTrack(ID_SOUND_BUILD_FAIL);
ssprintf(buf, _("There is an update to the game, please visit http://wz2100.net to download new version."));
addConsoleMessage(buf, DEFAULT_JUSTIFY, NOTIFY_MESSAGE);
}
else
{
audio_PlayTrack(FE_AUDIO_MESSAGEEND);
}
}
static void addConsolePlayerLeftMessage(unsigned playerIndex)
{
if (selectedPlayer != playerIndex)
{
char buf[256];
ssprintf(buf, _("%s has Left the Game"), getPlayerName(playerIndex));
addConsoleMessage(buf, DEFAULT_JUSTIFY, SYSTEM_MESSAGE);
}
}
void InspectorConsoleAgent::addMessageToConsole(MessageSource source, MessageType type, MessageLevel level, const String& message, PassRefPtrWillBeRawPtr<ScriptCallStack> callStack, unsigned long requestIdentifier)
{
if (type == ClearMessageType) {
ErrorString error;
clearMessages(&error);
}
addConsoleMessage(adoptPtr(new ConsoleMessage(!isWorkerAgent(), source, type, level, message, callStack, requestIdentifier)));
}
void InspectorConsoleAgent::addMessageToConsole(MessageSource source, MessageType type, MessageLevel level, const String& message, ScriptState* state, PassRefPtr<ScriptArguments> arguments, unsigned long requestIdentifier)
{
if (type == ClearMessageType) {
ErrorString error;
clearMessages(&error);
}
addConsoleMessage(adoptPtr(new ConsoleMessage(!isWorkerAgent(), source, type, level, message, arguments, state, requestIdentifier)));
}
UDWORD selDroidSelection( UDWORD player, SELECTION_CLASS droidClass,
SELECTIONTYPE droidType, BOOL bOnScreen )
{
UDWORD retVal;
char selInfo[255];
/* So far, we haven't selected any */
retVal = 0;
/* Establish the class of selection */
switch(droidClass)
{
case DS_ALL_UNITS:
retVal = selSelectAllUnits(player,bOnScreen);
break;
case DS_BY_TYPE:
switch(droidType)
{
case DST_VTOL:
retVal = selSelectAllSameProp(player,PROPULSION_TYPE_LIFT,bOnScreen);
break;
case DST_HOVER:
retVal = selSelectAllSameProp(player,PROPULSION_TYPE_HOVER,bOnScreen);
break;
case DST_WHEELED:
retVal = selSelectAllSameProp(player,PROPULSION_TYPE_WHEELED,bOnScreen);
break;
case DST_TRACKED:
retVal = selSelectAllSameProp(player,PROPULSION_TYPE_TRACKED,bOnScreen);
break;
case DST_HALF_TRACKED:
retVal = selSelectAllSameProp(player,PROPULSION_TYPE_HALF_TRACKED,bOnScreen);
break;
case DST_ALL_COMBAT:
retVal = selSelectAllCombat(player,bOnScreen);
break;
case DST_ALL_DAMAGED:
retVal = selSelectAllDamaged(player,bOnScreen);
break;
case DST_ALL_SAME:
retVal = selSelectAllSame(player,bOnScreen);
break;
default:
ASSERT( false,"Invalid selection type in uniDroidSelection" );
}
break;
default:
ASSERT( false,"Invalid selection attempt in uniDroidSelection" );
break;
}
/* Send back the return value */
snprintf(selInfo, sizeof(selInfo), ngettext("%u unit selected", "%u units selected", retVal), retVal);
addConsoleMessage(selInfo, RIGHT_JUSTIFY,SYSTEM_MESSAGE);
return retVal;
}
void InspectorConsoleAgent::didReceiveResponse(unsigned long identifier, const ResourceResponse& response)
{
if (!m_inspectorAgent->enabled())
return;
if (response.httpStatusCode() >= 400) {
String message = "Failed to load resource: the server responded with a status of " + String::number(response.httpStatusCode()) + " (" + response.httpStatusText() + ')';
addConsoleMessage(adoptPtr(new ConsoleMessage(OtherMessageSource, NetworkErrorMessageType, ErrorMessageLevel, message, response.url().string(), identifier)));
}
}
void InspectorConsoleAgent::addMessageToConsole(MessageSource source, MessageType type, MessageLevel level, const String& message, const String& scriptId, unsigned lineNumber, unsigned columnNumber, ScriptState* state, unsigned long requestIdentifier)
{
if (type == ClearMessageType) {
ErrorString error;
clearMessages(&error);
}
bool canGenerateCallStack = !isWorkerAgent() && m_frontend;
addConsoleMessage(adoptPtr(new ConsoleMessage(canGenerateCallStack, source, type, level, message, scriptId, lineNumber, columnNumber, state, requestIdentifier)));
}
// ---------------------------------------------------------------------
void selNextSpecifiedBuilding(STRUCTURE_TYPE structType)
{
STRUCTURE *psResult = nullptr, *psOldStruct = nullptr, *psFirst = nullptr;
bool bLaterInList = false;
/* Firstly, start coughing if the type is invalid */
ASSERT(structType <= NUM_DIFF_BUILDINGS, "Invalid structure type %u", structType);
for (STRUCTURE *psCurr = apsStructLists[selectedPlayer]; psCurr && !psResult; psCurr = psCurr->psNext)
{
if ((psCurr->pStructureType->type == structType) &&
(psCurr->status == SS_BUILT))
{
if (!psFirst)
{
psFirst = psCurr;
}
if (psCurr->selected)
{
bLaterInList = true;
psOldStruct = psCurr;
}
else if (bLaterInList)
{
psResult = psCurr;
}
}
}
if (!psResult && psFirst)
{
psResult = psFirst;
}
if (psResult && !psResult->died)
{
if (getWarCamStatus())
{
camToggleStatus();
}
setViewPos(map_coord(psResult->pos.x), map_coord(psResult->pos.y), false);
if (psOldStruct)
{
psOldStruct->selected = false;
}
psResult->selected = true;
triggerEventSelected();
jsDebugSelected(psResult);
}
else
{
// Can't find required building
addConsoleMessage("Cannot find required building!", LEFT_JUSTIFY, SYSTEM_MESSAGE);
}
}
void InspectorConsoleAgent::didReceiveResponse(unsigned long identifier, const ResourceResponse& response)
{
if (!developerExtrasEnabled())
return;
if (response.httpStatusCode() >= 400) {
String message = "Failed to load resource: the server responded with a status of " + String::number(response.httpStatusCode()) + " (" + response.httpStatusText() + ')';
String requestId = IdentifiersFactory::requestId(identifier);
addConsoleMessage(adoptPtr(new ConsoleMessage(NetworkMessageSource, LogMessageType, ErrorMessageLevel, message, response.url().string(), requestId)));
}
}
void printConsoleNameChange(const char *oldName, const char *newName)
{
char msg[MAX_CONSOLE_STRING_LENGTH];
// Player changed name.
sstrcpy(msg, oldName); // Old name.
sstrcat(msg, " → "); // Separator
sstrcat(msg, newName); // New name.
addConsoleMessage(msg, DEFAULT_JUSTIFY, selectedPlayer); // display
}
// Write a message to the console.
bool recvTextMessage(NETQUEUE queue)
{
UDWORD playerIndex;
char msg[MAX_CONSOLE_STRING_LENGTH];
char newmsg[MAX_CONSOLE_STRING_LENGTH];
memset(msg, 0x0, sizeof(msg));
memset(newmsg, 0x0, sizeof(newmsg));
NETbeginDecode(queue, NET_TEXTMSG);
// Who this msg is from
NETuint32_t(&playerIndex);
// The message to send
NETstring(newmsg, MAX_CONSOLE_STRING_LENGTH);
NETend();
if (whosResponsible(playerIndex) != queue.index)
{
playerIndex = queue.index; // Fix corrupted playerIndex.
}
if (playerIndex >= MAX_PLAYERS || (!NetPlay.players[playerIndex].allocated && NetPlay.players[playerIndex].ai == AI_OPEN))
{
return false;
}
sstrcpy(msg, NetPlay.players[playerIndex].name);
// Seperator
sstrcat(msg, ": ");
// Add message
sstrcat(msg, newmsg);
addConsoleMessage(msg, DEFAULT_JUSTIFY, playerIndex);
// Multiplayer message callback
// Received a console message from a player, save
MultiMsgPlayerFrom = playerIndex;
MultiMsgPlayerTo = selectedPlayer;
sstrcpy(MultiplayMsg, newmsg);
eventFireCallbackTrigger((TRIGGER_TYPE)CALL_AI_MSG);
// make some noise!
if (titleMode == MULTIOPTION || titleMode == MULTILIMIT)
{
audio_PlayTrack(FE_AUDIO_MESSAGEEND);
}
else if (!ingame.localJoiningInProgress)
{
audio_PlayTrack(ID_SOUND_MESSAGEEND);
}
return true;
}
void InspectorConsoleAgent::didFailLoading(unsigned long identifier, const ResourceError& error)
{
if (!m_inspectorAgent->enabled())
return;
if (error.isCancellation()) // Report failures only.
return;
String message = "Failed to load resource";
if (!error.localizedDescription().isEmpty())
message += ": " + error.localizedDescription();
addConsoleMessage(adoptPtr(new ConsoleMessage(OtherMessageSource, NetworkErrorMessageType, ErrorMessageLevel, message, error.failingURL(), identifier)));
}
void InspectorConsoleAgent::addMessageToConsole(std::unique_ptr<ConsoleMessage> message)
{
if (!m_injectedScriptManager.inspectorEnvironment().developerExtrasEnabled())
return;
if (message->type() == MessageType::Clear) {
ErrorString unused;
clearMessages(unused);
}
addConsoleMessage(WTFMove(message));
}
/** Play an intelligence message.
* This function is used from scripts to give updates to the mission.
*/
void displayImmediateMessage(MESSAGE *psMessage)
{
/*
This has to be changed to support a script calling a message in the intellegence screen
*/
psCurrentMsg = psMessage;
StartMessageSequences(psMessage,true);
// remind the player that the message can be seen again from
// the intelligence screen
addConsoleMessage(_("New Intelligence Report"), CENTRE_JUSTIFY, SYSTEM_MESSAGE);
}
void InspectorConsoleAgent::didFailLoading(unsigned long identifier, const ResourceError& error)
{
if (!developerExtrasEnabled())
return;
if (error.isCancellation()) // Report failures only.
return;
String message = "Failed to load resource";
if (!error.localizedDescription().isEmpty())
message += ": " + error.localizedDescription();
String requestId = IdentifiersFactory::requestId(identifier);
addConsoleMessage(adoptPtr(new ConsoleMessage(NetworkMessageSource, LogMessageType, ErrorMessageLevel, message, error.failingURL(), requestId)));
}
void InspectorConsoleAgent::resourceRetrievedByXMLHttpRequest(unsigned long identifier, const String& url, const String& sendURL, unsigned sendLineNumber)
{
if (!developerExtrasEnabled())
return;
if (m_frontend && m_state->getBoolean(ConsoleAgentState::monitoringXHR)) {
String message = "XHR finished loading: \"" + url + "\".";
String requestId = IdentifiersFactory::requestId(identifier);
addConsoleMessage(adoptPtr(new ConsoleMessage(NetworkMessageSource, LogMessageType, LogMessageLevel, message, sendURL, sendLineNumber, requestId)));
}
}
void InspectorConsoleAgent::addMessageToConsole(MessageSource source, MessageType type, MessageLevel level, const String& message, PassRefPtr<ScriptCallStack> callStack, unsigned long requestIdentifier)
{
if (!developerExtrasEnabled())
return;
if (type == ClearMessageType) {
ErrorString error;
clearMessages(&error);
}
addConsoleMessage(adoptPtr(new ConsoleMessage(source, type, level, message, 0, callStack, requestIdentifier)));
}
void InspectorConsoleAgent::addMessageToConsole(MessageSource source, MessageType type, MessageLevel level, const String& message, const String& scriptId, unsigned lineNumber, unsigned long requestIdentifier)
{
if (!developerExtrasEnabled())
return;
if (type == ClearMessageType) {
ErrorString error;
clearMessages(&error);
}
addConsoleMessage(adoptPtr(new ConsoleMessage(source, type, level, message, scriptId, lineNumber, requestIdentifier)));
}
void InspectorConsoleAgent::addMessageToConsole(MessageSource source, MessageType type, MessageLevel level, const String& message, JSC::ExecState* state, PassRefPtr<ScriptArguments> arguments, unsigned long requestIdentifier)
{
if (!m_injectedScriptManager->inspectorEnvironment().developerExtrasEnabled())
return;
if (type == MessageType::Clear) {
ErrorString error;
clearMessages(&error);
}
addConsoleMessage(adoptPtr(new ConsoleMessage(!isWorkerAgent(), source, type, level, message, arguments, state, requestIdentifier)));
}
