# network_command.cpp

Go to the documentation of this file.

    00001 /* $Id$ */
    00002
    00003 /*
    00004  * This file is part of OpenTTD.
    00005  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
    00006  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    00007  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
    00008  */
    00009
    00012 #ifdef ENABLE_NETWORK
    00013
    00014 #include "../stdafx.h"
    00015 #include "network_admin.h"
    00016 #include "network_client.h"
    00017 #include "network_server.h"
    00018 #include "../command_func.h"
    00019 #include "../company_func.h"
    00020 #include "../settings_type.h"
    00021
    00023 static CommandCallback * const _callback_table[] = {
    00024   /* 0x00 */ NULL,
    00025   /* 0x01 */ CcBuildPrimaryVehicle,
    00026   /* 0x02 */ CcBuildAirport,
    00027   /* 0x03 */ CcBuildBridge,
    00028   /* 0x04 */ CcBuildCanal,
    00029   /* 0x05 */ CcBuildDocks,
    00030   /* 0x06 */ CcFoundTown,
    00031   /* 0x07 */ CcBuildRoadTunnel,
    00032   /* 0x08 */ CcBuildRailTunnel,
    00033   /* 0x09 */ CcBuildWagon,
    00034   /* 0x0A */ CcRoadDepot,
    00035   /* 0x0B */ CcRailDepot,
    00036   /* 0x0C */ CcPlaceSign,
    00037   /* 0x0D */ CcPlaySound10,
    00038   /* 0x0E */ CcPlaySound1D,
    00039   /* 0x0F */ CcPlaySound1E,
    00040   /* 0x10 */ CcStation,
    00041   /* 0x11 */ CcTerraform,
    00042   /* 0x12 */ CcAI,
    00043   /* 0x13 */ CcCloneVehicle,
    00044   /* 0x14 */ CcGiveMoney,
    00045   /* 0x15 */ CcCreateGroup,
    00046   /* 0x16 */ CcFoundRandomTown,
    00047   /* 0x17 */ CcRoadStop,
    00048   /* 0x18 */ CcBuildIndustry,
    00049   /* 0x19 */ CcStartStopVehicle,
    00050   /* 0x1A */ CcGame,
    00051 };
    00052
    00058 void CommandQueue::Append(CommandPacket *p)
    00059 {
    00060   CommandPacket *add = MallocT<CommandPacket>(1);
    00061   *add = *p;
    00062   add->next = NULL;
    00063   if (this->first == NULL) {
    00064     this->first = add;
    00065   } else {
    00066     this->last->next = add;
    00067   }
    00068   this->last = add;
    00069   this->count++;
    00070 }
    00071
    00077 CommandPacket *CommandQueue::Pop(bool ignore_paused)
    00078 {
    00079   CommandPacket **prev = &this->first;
    00080   CommandPacket *ret = this->first;
    00081   CommandPacket *prev_item = NULL;
    00082   if (ignore_paused && _pause_mode != PM_UNPAUSED) {
    00083     while (ret != NULL && !IsCommandAllowedWhilePaused(ret->cmd)) {
    00084       prev_item = ret;
    00085       prev = &ret->next;
    00086       ret = ret->next;
    00087     }
    00088   }
    00089   if (ret != NULL) {
    00090     if (ret == this->last) this->last = prev_item;
    00091     *prev = ret->next;
    00092     this->count--;
    00093   }
    00094   return ret;
    00095 }
    00096
    00102 CommandPacket *CommandQueue::Peek(bool ignore_paused)
    00103 {
    00104   if (!ignore_paused || _pause_mode == PM_UNPAUSED) return this->first;
    00105
    00106   for (CommandPacket *p = this->first; p != NULL; p = p->next) {
    00107     if (IsCommandAllowedWhilePaused(p->cmd)) return p;
    00108   }
    00109   return NULL;
    00110 }
    00111
    00113 void CommandQueue::Free()
    00114 {
    00115   CommandPacket *cp;
    00116   while ((cp = this->Pop()) != NULL) {
    00117     free(cp);
    00118   }
    00119   assert(this->count == 0);
    00120 }
    00121
    00123 static CommandQueue _local_wait_queue;
    00125 static CommandQueue _local_execution_queue;
    00126
    00137 void NetworkSendCommand(TileIndex tile, uint32 p1, uint32 p2, uint32 cmd, CommandCallback *callback, const char *text, CompanyID company)
    00138 {
    00139   assert((cmd & CMD_FLAGS_MASK) == 0);
    00140
    00141   CommandPacket c;
    00142   c.company  = company;
    00143   c.tile     = tile;
    00144   c.p1       = p1;
    00145   c.p2       = p2;
    00146   c.cmd      = cmd;
    00147   c.callback = callback;
    00148
    00149   strecpy(c.text, (text != NULL) ? text : "", lastof(c.text));
    00150
    00151   if (_network_server) {
    00152     /* If we are the server, we queue the command in our 'special' queue.
    00153      *   In theory, we could execute the command right away, but then the
    00154      *   client on the server can do everything 1 tick faster than others.
    00155      *   So to keep the game fair, we delay the command with 1 tick
    00156      *   which gives about the same speed as most clients.
    00157      */
    00158     c.frame = _frame_counter_max + 1;
    00159     c.my_cmd = true;
    00160
    00161     _local_wait_queue.Append(&c);
    00162     return;
    00163   }
    00164
    00165   c.frame = 0; // The client can't tell which frame, so just make it 0
    00166
    00167   /* Clients send their command to the server and forget all about the packet */
    00168   MyClient::SendCommand(&c);
    00169 }
    00170
    00180 void NetworkSyncCommandQueue(NetworkClientSocket *cs)
    00181 {
    00182   for (CommandPacket *p = _local_execution_queue.Peek(); p != NULL; p = p->next) {
    00183     CommandPacket c = *p;
    00184     c.callback = 0;
    00185     cs->outgoing_queue.Append(&c);
    00186   }
    00187 }
    00188
    00192 void NetworkExecuteLocalCommandQueue()
    00193 {
    00194   assert(IsLocalCompany());
    00195
    00196   CommandQueue &queue = (_network_server ? _local_execution_queue : ClientNetworkGameSocketHandler::my_client->incoming_queue);
    00197
    00198   CommandPacket *cp;
    00199   while ((cp = queue.Peek()) != NULL) {
    00200     /* The queue is always in order, which means
    00201      * that the first element will be executed first. */
    00202     if (_frame_counter < cp->frame) break;
    00203
    00204     if (_frame_counter > cp->frame) {
    00205       /* If we reach here, it means for whatever reason, we've already executed
    00206        * past the command we need to execute. */
    00207       error("[net] Trying to execute a packet in the past!");
    00208     }
    00209
    00210     /* We can execute this command */
    00211     _current_company = cp->company;
    00212     cp->cmd |= CMD_NETWORK_COMMAND;
    00213     DoCommandP(cp, cp->my_cmd);
    00214
    00215     queue.Pop();
    00216     free(cp);
    00217   }
    00218
    00219   /* Local company may have changed, so we should not restore the old value */
    00220   _current_company = _local_company;
    00221 }
    00222
    00226 void NetworkFreeLocalCommandQueue()
    00227 {
    00228   _local_wait_queue.Free();
    00229   _local_execution_queue.Free();
    00230 }
    00231
    00237 static void DistributeCommandPacket(CommandPacket cp, const NetworkClientSocket *owner)
    00238 {
    00239   CommandCallback *callback = cp.callback;
    00240   cp.frame = _frame_counter_max + 1;
    00241
    00242   NetworkClientSocket *cs;
    00243   FOR_ALL_CLIENT_SOCKETS(cs) {
    00244     if (cs->status >= NetworkClientSocket::STATUS_MAP) {
    00245       /* Callbacks are only send back to the client who sent them in the
    00246        *  first place. This filters that out. */
    00247       cp.callback = (cs != owner) ? NULL : callback;
    00248       cp.my_cmd = (cs == owner);
    00249       cs->outgoing_queue.Append(&cp);
    00250     }
    00251   }
    00252
    00253   cp.callback = (cs != owner) ? NULL : callback;
    00254   cp.my_cmd = (cs == owner);
    00255   _local_execution_queue.Append(&cp);
    00256 }
    00257
    00263 static void DistributeQueue(CommandQueue *queue, const NetworkClientSocket *owner)
    00264 {
    00265 #ifdef DEBUG_DUMP_COMMANDS
    00266   /* When replaying we do not want this limitation. */
    00267   int to_go = UINT16_MAX;
    00268 #else
    00269   int to_go = _settings_client.network.commands_per_frame;
    00270 #endif
    00271
    00272   CommandPacket *cp;
    00273   while (--to_go >= 0 && (cp = queue->Pop(true)) != NULL) {
    00274     DistributeCommandPacket(*cp, owner);
    00275     NetworkAdminCmdLogging(owner, cp);
    00276     free(cp);
    00277   }
    00278 }
    00279
    00281 void NetworkDistributeCommands()
    00282 {
    00283   /* First send the server's commands. */
    00284   DistributeQueue(&_local_wait_queue, NULL);
    00285
    00286   /* Then send the queues of the others. */
    00287   NetworkClientSocket *cs;
    00288   FOR_ALL_CLIENT_SOCKETS(cs) {
    00289     DistributeQueue(&cs->incoming_queue, cs);
    00290   }
    00291 }
    00292
    00299 const char *NetworkGameSocketHandler::ReceiveCommand(Packet *p, CommandPacket *cp)
    00300 {
    00301   cp->company = (CompanyID)p->Recv_uint8();
    00302   cp->cmd     = p->Recv_uint32();
    00303   if (!IsValidCommand(cp->cmd))               return "invalid command";
    00304   if (GetCommandFlags(cp->cmd) & CMD_OFFLINE) return "offline only command";
    00305   if ((cp->cmd & CMD_FLAGS_MASK) != 0)        return "invalid command flag";
    00306
    00307   cp->p1      = p->Recv_uint32();
    00308   cp->p2      = p->Recv_uint32();
    00309   cp->tile    = p->Recv_uint32();
    00310   p->Recv_string(cp->text, lengthof(cp->text), (!_network_server && GetCommandFlags(cp->cmd) & CMD_STR_CTRL) != 0 ? SVS_ALLOW_CONTROL_CODE | SVS_REPLACE_WITH_QUESTION_MARK : SVS_REPLACE_WITH_QUESTION_MARK);
    00311
    00312   byte callback = p->Recv_uint8();
    00313   if (callback >= lengthof(_callback_table))  return "invalid callback";
    00314
    00315   cp->callback = _callback_table[callback];
    00316   return NULL;
    00317 }
    00318
    00324 void NetworkGameSocketHandler::SendCommand(Packet *p, const CommandPacket *cp)
    00325 {
    00326   p->Send_uint8 (cp->company);
    00327   p->Send_uint32(cp->cmd);
    00328   p->Send_uint32(cp->p1);
    00329   p->Send_uint32(cp->p2);
    00330   p->Send_uint32(cp->tile);
    00331   p->Send_string(cp->text);
    00332
    00333   byte callback = 0;
    00334   while (callback < lengthof(_callback_table) && _callback_table[callback] != cp->callback) {
    00335     callback++;
    00336   }
    00337
    00338   if (callback == lengthof(_callback_table)) {
    00339     DEBUG(net, 0, "Unknown callback. (Pointer: %p) No callback sent", cp->callback);
    00340     callback = 0; // _callback_table[0] == NULL
    00341   }
    00342   p->Send_uint8 (callback);
    00343 }
    00344
    00345 #endif /* ENABLE_NETWORK */