---

Network.cpp

Go to the documentation of this file.

/*
CS Senior Project 2003
Team : Leftfield
Project : ModernWarfare
Members :
- Russ Christensen              <rchriste@cs.utah.edu>
- Todd Smith                    <tcsmith@cs.utah.edu>
- Usit Duongsaa                 <duongsaa@cs.utah.edu>
Copyright 2003 Russ Christensen, Usit Duongsaa, and Todd Smith. All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 
THIS SOFTWARE IS PROVIDED BY RUSS CHRISTENSEN, USIT DUONGSAA, AND TODD SMITH ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RUSS, USIT, TODD OR OTHER CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include "Network.h"
#include "..\AEngine\AEngine.h"
#include "MilitaryUnit.h"
#include "Globals.h"
#include "HelperFunctions.h"
#include "BattleUnitStat.h"
#include "City.h"
#include "BattleEntry.h"
#include "GameState.h"
#include <iostream>
#include <hash_map>

using namespace std;
using namespace NetworkSubsystem;
using namespace NetworkMessages;
using namespace Helper;

namespace Overhead {
        void deleteMilitaryUnit(MilitaryUnit*);
}

namespace {
        typedef pair<uint, vector<string> > NDataPair;
        typedef hash_map<uint, vector<string> >::iterator NDataPairIter;
        typedef vector<string> VecString;
        typedef VecString::iterator VecStringIter;

        hash_map<int,int> randomNumberList;

        int getGameTick(const string & data)
        {
                istringstream sstr(data);
                string tmp;
                sstr >> tmp;
                sstr >> tmp;
                if (tmp != COMMIT_TIME)
                {
                        sys_console() << WARNING << "assert(tmp == COMMIT_TIME && \"Second command should always be COMMIT_TIME\");" << endl;
                        sys_flushConsole();
                        return 0;
                }
                int result;
                sstr >> result;
                return result;
        }

        class NetworkData {
        public:
                NetworkData(void);
                ~NetworkData(void);
                void addData(string data);
                vector<string> getData(int gameTickWanted);
                bool hasDataForGameTickArrived(int gameTick);
                void clean(int gameTickToClean);
        private:
                hash_map<uint, vector<string> > m_data;
                hash_map<uint, uint> m_syncData;
        };

        NetworkData netData;

        NetworkData::NetworkData(): m_data(), m_syncData()
        {
        }

        NetworkData::~NetworkData()
        {
                //Nothing to do
        }

        void NetworkData::addData(string data)
        {
                int gameTickToCommit = getGameTick(data);
                stringstream sstr(data);
                string command;
                sstr >> command;
                if (command == COMMAND_SYNC)
                {
                        hash_map<uint,uint>::iterator iter = m_syncData.find(gameTickToCommit);
                        if (iter == m_syncData.end())
                        {
                                m_syncData.insert(pair<uint,uint>(gameTickToCommit, 1));
                        } else
                        {
                                ++iter->second;
                        }
                } else
                {
                        if (gameTickToCommit < currGameTick) 
                        {
                                sys_console() << WARNING << "Error received command that should have happened in the past command is:" << data << endl;
                                sys_flushConsole();
                        } else
                        {
                                NDataPairIter iter = m_data.find(gameTickToCommit);
                                if (iter == m_data.end()) 
                                {
                                        vector<string> vstr;
                                        vstr.push_back(data);
                                        m_data.insert(NDataPair(gameTickToCommit, vstr));
                                } else 
                                {
                                        iter->second.push_back(data);
                                }
                        }
                }
        }

        vector<string> NetworkData::getData(int gameTickWanted)
        {
                NDataPairIter iter = m_data.find(gameTickWanted);
                if (iter == m_data.end()) return vector<string>();
                else return iter->second;
        }

        bool NetworkData::hasDataForGameTickArrived(int gameTick)
        {
                //round down to the closest gameTick sync point
                gameTick /= NETWORK_SYNC_RATE;
                gameTick *= NETWORK_SYNC_RATE;
                gameTick += NETWORK_SYNC_RATE;
                assert(gameTick % NETWORK_SYNC_RATE == 0 && "Programming Error: Code above is being optimized out");
                hash_map<uint,uint>::iterator iter = m_syncData.find(gameTick);
                if (iter == m_syncData.end()) return false;
                else 
                {
                        return iter->second >= net_getAllPlayers().size();
                }
        }

        void NetworkData::clean(int gameTickToClean)
        {
                int num(gameTickToClean - Globals::NETWORK_GAME_TICK_LAG);
                if (num > 0)
                {
                        m_syncData.erase(num);
                        m_data.erase(num);
                }
        }

        void sendGameTickEnd(int gameTickToEnd) 
        {
                ostringstream sstr;
                sstr << COMMAND_OVERHEAD << " " << END_GAME_TICK << " " << gameTickToEnd;
                net_send(sstr.str());
        }
        
        bool existsGameTickEnd(const string & str) 
        {
                stringstream sstr(str);
                string cmd;
                sstr >> cmd;
                if (cmd != COMMAND_OVERHEAD) return false;
                sstr >> cmd;
                if (cmd == END_GAME_TICK) return true;
                else return false;
        }
} //end namespace {}

namespace NetworkSubsystem {

bool hasNetworkDataForCurrentTickBeenReceived(void)
{
        if (currGameTick < NETWORK_GAME_TICK_LAG) return true;
        else return netData.hasDataForGameTickArrived(currGameTick);
}

void processNetworkData(void)
{
        static internalGameTick = 0;
        assert(++internalGameTick == currGameTick && "processNetworkData is not getting called once for every game tick");
        VecString commands(netData.getData(currGameTick));
        for(VecStringIter iter = commands.begin(); iter != commands.end(); ++iter)
        {
                //sys_console() << "processNetworkData:" << *iter << endl;
                stringstream sstr(*iter);
                string tmp;
                sstr >> tmp;
                if (tmp == COMMAND_OVERHEAD)
                {
                        sstr >> tmp;
                        //if (tmp != COMMIT_TIME) throw Error("Invalid time in COMMAND_OVERHEAD");
                        int itmp;
                        sstr >> itmp;
                        //if (itmp != currGameTick) throw Error("Dealing with command that is not for currGameTick");
                        sstr >> tmp;
                        if (tmp == COMMAND_GOAL)
                        {
                                uint uID;
                                sstr >> uID;
                                MilitaryUnit* unit(GameState::getMilitaryUnit(uID));
                                if (unit == 0) 
                                {
                                        stringstream sstr;
                                        sstr << "Network Warning: Unit with ID of " << uID << " not found";
                                        sys_console() << sstr.str() << endl;
                                } else
                                {
                                        unit->goal(unserializeVec3D(sstr));
                                }
                        } else if (tmp == COMMAND_BUILD_LIGHTTANK)
                        {
                                uint uID;
                                sstr >> uID;
                                City* city(GameState::getCity(uID));
                                if (city == 0) 
                                {
                                        stringstream sstr;
                                        sstr << "Networking Error: City with ID of " << uID << " not found";
                                        throw Error(sstr.str());
                                }
                                city->trainUnit(UnitTypes::LIGHT_TANK);
                        } else if (tmp == COMMAND_BUILD_HEAVYTANK)
                        {
                                uint uID;
                                sstr >> uID;
                                City* city(GameState::getCity(uID));
                                if (city == 0) 
                                {
                                        stringstream sstr;
                                        sstr << "Networking Error: City with ID of " << uID << " not found";
                                        throw Error(sstr.str());
                                }
                                city->trainUnit(UnitTypes::HEAVY_TANK);
                        } else if (tmp == COMMAND_BUILD_ROCKET_LAUNCHER)
                        {
                                uint uID;
                                sstr >> uID;
                                City* city(GameState::getCity(uID));
                                if (city == 0) 
                                {
                                        stringstream sstr;
                                        sstr << "Networking Error: City with ID of " << uID << " not found";
                                        throw Error(sstr.str());
                                }
                                city->trainUnit(UnitTypes::LAUNCHER);
                        } else if (tmp == COMMAND_BUILD_ARTILLERY)
                        {
                                uint uID;
                                sstr >> uID;
                                City* city(GameState::getCity(uID));
                                if (city == 0) 
                                {
                                        stringstream sstr;
                                        sstr << "Networking Error: City with ID of " << uID << " not found";
                                        throw Error(sstr.str());
                                }
                                city->trainUnit(UnitTypes::ARTILLERY);
                        } else if (tmp == COMMAND_BUILD_JET)
                        {
                                uint uID;
                                sstr >> uID;
                                City* city(GameState::getCity(uID));
                                if (city == 0) 
                                {
                                        stringstream sstr;
                                        sstr << "Networking Error: City with ID of " << uID << " not found";
                                        throw Error(sstr.str());
                                }
                                city->trainUnit(UnitTypes::JET);
                        } else if( tmp == COMMAND_BUILD_ECON )
                        {
                                uint uID;
                                sstr >> uID;
                                City* city(GameState::getCity(uID));
                                if (city == 0) 
                                {
                                        stringstream sstr;
                                        sstr << "Networking Error: City with ID of " << uID << " not found";
                                        throw Error(sstr.str());
                                }
                                city->upgradeEcon();
                        } else if (tmp == COMMAND_SET_RALLY_POINT)
                        {
                                uint uID;
                                sstr >> uID;
                                City* city(GameState::getCity(uID));
                                if (city == 0) 
                                {
                                        stringstream sstr;
                                        sstr << "Networking Error: City with ID of " << uID << " not found";
                                        throw Error(sstr.str());
                                }
                                city->setRallyPoint(unserializeVec3D(sstr));
                        } else 
                        {
                                sys_console() << WARNING << "throw Error(\"Invalid COMMAND_OVERHEAD command\");" << endl;
                                sys_flushConsole();
                        }
                } else if (tmp == COMMAND_BATTLEMODE)
                {
                        uint battleNumber;
                        sstr >> tmp; /*COMMIT_TIME*/
                        sstr >> tmp; /* dido */
                        sstr >> tmp;
                        if (tmp == COMMAND_BATTLE_ID)
                        {
                                sstr >> battleNumber;
                                BattleEntry* battle(GameState::getBattle(battleNumber));
                                if (battle)
                                {
                                        battle->enQueueInput(*iter);
                                } else 
                                {
                                        sys_console() << WARNING << COMMAND_BATTLEMODE << " received and there is no active battle with that ID" << endl;
                                }
                        } else
                        {
                                sys_console() << WARNING << "assert(tmp == COMMAND_BATTLE_ID);" << endl;
                                sys_flushConsole();
                        }
                } else if (tmp == COMMAND_BEGINBATTLE)
                {
                        sys_console() << WARNING << "throw Error(COMMAND_BEGINBATTLE + \" received\");" << endl;
                } else if (tmp == COMMAND_PRINT_A_RANDOM_NUMBER_TO_THE_CONSOLE)
                {
                        sys_console() << "Random Number:" << rand() << endl;
                } else if (tmp == COMMAND_TEXT_MESSAGE)
                {
                        sstr >> tmp >> tmp; //COMMIT TIME
                        getline(sstr,tmp);
                        GameState::messagesReceived().addMessage(tmp);
                } else if (tmp == COMMAND_MORE_MONEY)
                {
                        const int moreMoneyAmount(10000);
                        for(vector<Player*>::iterator iter(GameState::players().begin()); iter != GameState::players().end(); ++iter)
                        {
                                (*iter)->bank().deposit(moreMoneyAmount);
                        }
                } else if (tmp == COMMAND_SEND_MONEY)
                {
                        sstr >> tmp >> tmp; //COMMIT TIME
                        int amount;
                        sstr >> amount;
                        string player;
                        getline(sstr, player);
                        player = Helper::toLower(Helper::eatEarlyWhiteSpace(player));
                        if (player == Helper::toLower(net_getPlayerName())) 
                        {
                                GameState::consolePlayer()->bank().deposit(amount);
                                stringstream outMsg;
                                outMsg << "You just received " << amount;
                                GameState::messagesReceived().addMessage(outMsg.str());
                        }
                } else if (tmp == COMMAND_ASK_FOR_RANDOM_NUMBER)
                {
                        sstr >> tmp >> tmp; //COMMIT TIME
                        int number;
                        sstr >> number;
                        stringstream netOut;
                        int randomNumber(sys_randInt());
                        netOut << COMMAND_RANDOM_NUMBER_ANSWER << " " << COMMIT_TIME << " " << currGameTick + NETWORK_GAME_TICK_LAG
                                   << " " << randomNumber << " " << number;
                        net_send(netOut.str());
                } else if (tmp == COMMAND_RANDOM_NUMBER_ANSWER)
                {
                        if (net_amIServer())
                        {
                                sstr >> tmp >> tmp; //COMMIT TIME
                                int number;
                                int randomNumber;
                                sstr >> randomNumber >> number;
                                hash_map<int,int>::iterator iter = randomNumberList.find(number);
                                if (iter == randomNumberList.end())
                                {
                                        randomNumberList.insert(pair<int,int>(number,randomNumber));
                                } else if (iter->second != randomNumber)
                                {
                                        stringstream msg;
                                        msg << COMMAND_TEXT_MESSAGE << " " << COMMIT_TIME << " " << currGameTick + NETWORK_GAME_TICK_LAG << " "
                                                << "MAJOR ERROR! Games are out of sync at " << currGameTick;
                                        net_send(msg.str());
                                }
                        }
                } else if (tmp == COMMAND_SEND_JET_REINFORCEMENT)
                {
                        sstr >> tmp >> tmp;
                        int battleNumber;
                        sstr >> battleNumber;
                        int unitNumber;
                        sstr >> unitNumber;
                        BattleEntry* entry(GameState::getBattle(battleNumber));
                        MilitaryUnit* unit(GameState::getMilitaryUnit(unitNumber));
                        if (entry != 0 && unit != 0)
                        {
                                entry->sendAirReinforcement( unit->color(), unit->armySize(), dynamic_cast<Jet*>(unit)->getCityID() );
                                Overhead::deleteMilitaryUnit(unit);
                        } else 
                        {
                                sys_console() << WARNING << " entry or unit not found" << endl;
                        }
                } else if (tmp == COMMAND_SEND_UNIT_REINFORCEMENT)
                {
                        sstr >> tmp >> tmp;
                        int battleNumber;
                        sstr >> battleNumber;
                        int unitNumber;
                        sstr >> unitNumber;
                        BattleEntry* entry(GameState::getBattle(battleNumber));
                        MilitaryUnit* unit(GameState::getMilitaryUnit(unitNumber));
                        if (entry != 0 && unit != 0)
                        {
                                entry->sendGroundReinforcement( unit->color(), unit->unitType(), unit->armySize(), unit->shortcutKey() );
                                Overhead::deleteMilitaryUnit(unit);
                        } else
                        {
                                sys_console() << WARNING << " entry or unit not found" << endl;
                        }
                } else 
                {
                        sys_console() << WARNING 
                                << "throw Error(\"Don't know what to do with command received over the network.  Command received is:\" + *iter);" 
                                << *iter << endl;
                        sys_flushConsole();
                }
        }
        commands.clear();
        netData.clean(currGameTick);
}

void enQueueMsg(string s)
{
        netData.addData(s);
}


void receiveNetworkData(void)
{
        string str;
        while((str = net_recv()).size() != 0) 
        {
                istringstream strm( str.c_str() );
                string cmd;
                strm >> cmd;
                if( cmd!="CommandSync" ) sys_console() << NETWORK_DATA << str << endl;          // don't print all sync messages
                sys_flushConsole();
                netData.addData(str);
        }
}

void loadNetworkData(ifstream & in)
{
        sys_console() << "Loading Network Data from a file" << endl;
        string line;
        do 
        {
                getline(in,line);
                if(line.find(NETWORK_DATA) != string::npos)
                {
                        sys_console() << "loading data:" << line.substr(NETWORK_DATA.size()) << endl;
                        netData.addData(line.substr(NETWORK_DATA.size()));
                }
        } while(in.good());
        sys_console() << "Done Loading Data" << endl;
}

} //end namespace

---