/** * The actual script is sent to the clients. @a script can be NULL. */ void Sv_Finale(finaleid_t id, int flags, const char* script) { size_t scriptLen = 0; if(isClient) return; // How much memory do we need? if(script) { flags |= FINF_SCRIPT; scriptLen = strlen(script); } // First the flags. Msg_Begin(PSV_FINALE); Writer_WriteByte(msgWriter, flags); Writer_WriteUInt32(msgWriter, id); // serverside Id if(script) { // Then the script itself. Writer_WriteUInt32(msgWriter, scriptLen); Writer_Write(msgWriter, script, scriptLen); } Msg_End(); Net_SendBuffer(NSP_BROADCAST, 0); }
void Str_Write(const ddstring_t *str, Writer *writer) { size_t len = Str_Length(str); DENG_ASSERT(str); Writer_WriteUInt32(writer, len); Writer_Write(writer, Str_Text(str), len); }
void StringArray_Write(const StringArray *ar, Writer *writer) { assert(ar); Writer_WriteUInt32(writer, ar->array.size()); // Write each of the strings. for(StringArray::Strings::const_iterator i = ar->array.begin(); i != ar->array.end(); ++i) { Str_Write(**i, writer); } }
static void NetSv_SendFinaleState(fi_state_t* s) { Writer* writer = D_NetWrite(); // First the flags. Writer_WriteByte(writer, s->mode); Writer_WriteUInt32(writer, s->finaleId); // Then the conditions. Writer_WriteByte(writer, 2); // Number of conditions. Writer_WriteByte(writer, s->conditions.secret); Writer_WriteByte(writer, s->conditions.leave_hub); Net_SendPacket(DDSP_ALL_PLAYERS, GPT_FINALE_STATE, Writer_Data(writer), Writer_Size(writer)); }
void Net_SendPing(int player, int count) { client_t *cl = clients + player; // Valid destination? if((player == consolePlayer) || (isClient && player)) return; if(count) { // We can't start a new ping run until the old one is done. if(cl->ping.sent) return; // Start a new ping session. if(count > MAX_PINGS) count = MAX_PINGS; cl->ping.current = 0; cl->ping.total = count; } else { // Continue or finish the current pinger. if(++cl->ping.current >= cl->ping.total) { // We're done. cl->ping.sent = 0; // Print a summary (average ping, loss %). Net_ShowPingSummary(netBuffer.player); return; } } // Send a new ping. Msg_Begin(PKT_PING); cl->ping.sent = Timer_RealMilliseconds(); Writer_WriteUInt32(msgWriter, cl->ping.sent); Msg_End(); // Update the length of the message. netBuffer.player = player; N_SendPacket(10000); }
/** * Serializes the specified thinker and writes it to save state. */ static int writeThinkerWorker(thinker_t *th, void *context) { writethinkerworker_params_t const &p = *static_cast<writethinkerworker_params_t *>(context); // We are only concerned with thinkers we have save info for. ThinkerClassInfo *thInfo = SV_ThinkerInfo(*th); if (!thInfo) return false; // Are we excluding players? if (p.excludePlayers) { if (th->function == P_MobjThinker && ((mobj_t *) th)->player) { return false; } } // Only the server saves this class of thinker? if ((thInfo->flags & TSF_SERVERONLY) && IS_CLIENT) { return false; } // Write the header block for this thinker. Writer_WriteByte(p.msw->writer(), thInfo->thinkclass); // Thinker type byte. Writer_WriteByte(p.msw->writer(), Thinker_InStasis(th)? 1 : 0); // In stasis? // Private identifier of the thinker. de::Id::Type const privateId = (th->d? THINKER_DATA(*th, ThinkerData).id().asUInt32() : 0); Writer_WriteUInt32(p.msw->writer(), privateId); // Write the thinker data. thInfo->writeFunc(th, p.msw); return false; }