自学教程：C++ IsNetworkGame函数代码示例

/****  Change player faction.****  @param faction    New faction.*/void CPlayer::SetFaction(const std::string &faction){	for (int i = 0; i < FactionMax; ++i) {		if (!PlayerRaces.FactionNames[this->Race][i].empty() && PlayerRaces.FactionNames[this->Race][i] == faction) {			if (!IsNetworkGame()) { //only set the faction's name as the player's name if this is a single player game				this->SetName(faction);			}			this->Faction = i;			int PrimaryColor;			int SecondaryColor;			for (int j = 0; j < PlayerColorMax; ++j) {				if (PlayerColorNames[j] == PlayerRaces.FactionColors[this->Race][i]) {					PrimaryColor = j;				}				if (PlayerColorNames[j] == PlayerRaces.FactionSecondaryColors[this->Race][i]) {					SecondaryColor = j;				}			}			bool color_used = false;			for (int j = 0; j < PlayerMax; ++j) {				if (this->Index != j && Players[j].Faction != -1 && Players[j].Color == PlayerColors[PrimaryColor][0]) {					color_used = true;				}					}			if (!color_used) {				this->Color = PlayerColors[PrimaryColor][0];				this->UnitColors.Colors = PlayerColorsRGB[PrimaryColor];			} else {				this->Color = PlayerColors[SecondaryColor][0];				this->UnitColors.Colors = PlayerColorsRGB[SecondaryColor];			}		}	}}

/****  Called if message for the network is ready.**  (by WaitEventsOneFrame)*/void NetworkEvent(){	if (!IsNetworkGame()) {		NetworkInSync = true;		return;	}	// Read the packet.	unsigned char buf[1024];	CHost host;	int len = NetworkFildes.Recv(&buf, sizeof(buf), &host);	if (len < 0) {		DebugPrint("Server/Client gone?/n");		// just hope for an automatic recover right now..		NetworkInSync = false;		return;	}	// Setup messages	if (NetConnectRunning) {		if (NetworkParseSetupEvent(buf, len, host)) {			return;		}	}	const unsigned char msgtype = buf[0];	if (msgtype == MessageInit_FromClient || msgtype == MessageInit_FromServer) {		return;	}	NetworkParseInGameEvent(buf, len, host);}

/**** Send command: Diplomacy changed.**** @param player     Player which changes his state.** @param state      New diplomacy state.** @param opponent   Opponent.*/void SendCommandDiplomacy(int player, int state, int opponent){	if (!IsNetworkGame()) {		switch (state) {			case DiplomacyNeutral:				CommandLog("diplomacy", NoUnitP, 0, player, opponent,						   NoUnitP, "neutral", -1);				break;			case DiplomacyAllied:				CommandLog("diplomacy", NoUnitP, 0, player, opponent,						   NoUnitP, "allied", -1);				break;			case DiplomacyEnemy:				CommandLog("diplomacy", NoUnitP, 0, player, opponent,						   NoUnitP, "enemy", -1);				break;			case DiplomacyCrazy:				CommandLog("diplomacy", NoUnitP, 0, player, opponent,						   NoUnitP, "crazy", -1);				break;		}		CommandDiplomacy(player, state, opponent);	} else {		NetworkSendExtendedCommand(ExtendedMessageDiplomacy,								   -1, player, state, opponent, 0);	}}

/****  Draw menu button area.*/void DrawMenuButtonArea(){	if (!IsNetworkGame()) {		DrawMenuButtonArea_noNetwork();	} else {		DrawMenuButtonArea_Network();	}}

/**** Send command: Buy an item from a building.**** @param unit    pointer to unit.** @param pos     map tile position to move to.*/void SendCommandBuy(CUnit &unit, CUnit *sold_unit, int player){	if (!IsNetworkGame()) {		CommandLog("buy", &unit, 0, -1, -1, sold_unit, NULL, player);		CommandBuy(unit, sold_unit, player);	} else {		NetworkSendCommand(MessageCommandBuy, unit, player, 0, sold_unit, 0, 0);	}}

/**** Send command: Set new rally point for unit.**** @param unit    pointer to unit.** @param pos     map tile position to move to.*/void SendCommandRallyPoint(CUnit &unit, const Vec2i &pos, int z){	if (!IsNetworkGame()) {		CommandLog("rally-point", &unit, 0, pos.x, pos.y, NoUnitP, NULL, -1);		CommandRallyPoint(unit, pos, z);	} else {		NetworkSendCommand(MessageCommandMove, unit, pos.x, pos.y, NoUnitP, 0, 0);	}}

/**** Send command: Unit stop.**** @param unit pointer to unit.*/void SendCommandStopUnit(CUnit &unit){	if (!IsNetworkGame()) {		CommandLog("stop", &unit, FlushCommands, -1, -1, NoUnitP, NULL, -1);		CommandStopUnit(unit);	} else {		NetworkSendCommand(MessageCommandStop, unit, 0, 0, NoUnitP, 0, FlushCommands);	}}

/**** Send command: Building starts upgrading to.**** @param unit     pointer to unit.** @param what     pointer to unit-type of the unit upgrade.** @param flush    Flag flush all pending commands.*/void SendCommandUpgradeTo(CUnit &unit, CUnitType &what, int flush){	if (!IsNetworkGame()) {		CommandLog("upgrade-to", &unit, flush, -1, -1, NoUnitP, what.Ident.c_str(), -1);		CommandUpgradeTo(unit, what, flush);	} else {		NetworkSendCommand(MessageCommandUpgrade, unit, 0, 0, NoUnitP, &what, flush);	}}

/**** Send command: Unit harvest resources**** @param unit    pointer to unit.** @param dest    pointer to destination (oil-platform,gold mine).** @param flush   Flag flush all pending commands.*/void SendCommandResource(CUnit &unit, CUnit &dest, int flush){	if (!IsNetworkGame()) {		CommandLog("resource", &unit, flush, -1, -1, &dest, NULL, -1);		CommandResource(unit, dest, flush);	} else {		NetworkSendCommand(MessageCommandResource, unit, 0, 0, &dest, 0, flush);	}}

/**** Send command: Unit unload unit.**** @param unit    pointer to unit.** @param pos     map tile position of unload.** @param what    Passagier to be unloaded.** @param flush   Flag flush all pending commands.*/void SendCommandUnload(CUnit &unit, const Vec2i &pos, CUnit *what, int flush){	if (!IsNetworkGame()) {		CommandLog("unload", &unit, flush, pos.x, pos.y, what, NULL, -1);		CommandUnload(unit, pos, what, flush);	} else {		NetworkSendCommand(MessageCommandUnload, unit, pos.x, pos.y, what, 0, flush);	}}

/**** Send command: Unit patrol between current and position.**** @param unit     pointer to unit.** @param pos      map tile position to patrol between.** @param flush    Flag flush all pending commands.*/void SendCommandPatrol(CUnit &unit, const Vec2i &pos, int flush){	if (!IsNetworkGame()) {		CommandLog("patrol", &unit, flush, pos.x, pos.y, NoUnitP, NULL, -1);		CommandPatrolUnit(unit, pos, flush);	} else {		NetworkSendCommand(MessageCommandPatrol, unit, pos.x, pos.y, NoUnitP, 0, flush);	}}

/**** Send command: Unit attack ground.**** @param unit     pointer to unit.** @param pos      map tile position to fire on.** @param flush    Flag flush all pending commands.*/void SendCommandAttackGround(CUnit &unit, const Vec2i &pos, int flush){	if (!IsNetworkGame()) {		CommandLog("attack-ground", &unit, flush, pos.x, pos.y, NoUnitP, NULL, -1);		CommandAttackGround(unit, pos, flush);	} else {		NetworkSendCommand(MessageCommandGround, unit, pos.x, pos.y, NoUnitP, 0, flush);	}}

/**** Send command: Unit attack unit or at position.**** @param unit     pointer to unit.** @param pos      map tile position to attack.** @param attack   or !=NoUnitP unit to be attacked.** @param flush    Flag flush all pending commands.*/void SendCommandAttack(CUnit &unit, const Vec2i &pos, CUnit *attack, int flush){	if (!IsNetworkGame()) {		CommandLog("attack", &unit, flush, pos.x, pos.y, attack, NULL, -1);		CommandAttack(unit, pos, attack, flush);	} else {		NetworkSendCommand(MessageCommandAttack, unit, pos.x, pos.y, attack, 0, flush);	}}

/**** Send command: Unit repair.**** @param unit    Pointer to unit.** @param pos     map tile position to repair.** @param dest    Unit to be repaired.** @param flush   Flag flush all pending commands.*/void SendCommandRepair(CUnit &unit, const Vec2i &pos, CUnit *dest, int flush){	if (!IsNetworkGame()) {		CommandLog("repair", &unit, flush, pos.x, pos.y, dest, NULL, -1);		CommandRepair(unit, pos, dest, flush);	} else {		NetworkSendCommand(MessageCommandRepair, unit, pos.x, pos.y, dest, 0, flush);	}}

/**** Send command: Pick up item.**** @param unit    pointer to unit.** @param dest    pick up this item.** @param flush   Flag flush all pending commands.*/void SendCommandPickUp(CUnit &unit, CUnit &dest, int flush){	if (!IsNetworkGame()) {		CommandLog("pick-up", &unit, flush, -1, -1, &dest, NULL, -1);		CommandPickUp(unit, dest, flush);	} else {		NetworkSendCommand(MessageCommandPickUp, unit, 0, 0, &dest, 0, flush);	}}

/**** Send command: Unit auto repair.**** @param unit      pointer to unit.** @param on        1 for auto repair on, 0 for off.*/void SendCommandAutoRepair(CUnit &unit, int on){	if (!IsNetworkGame()) {		CommandLog("auto-repair", &unit, FlushCommands, on, -1, NoUnitP, NULL, 0);		CommandAutoRepair(unit, on);	} else {		NetworkSendCommand(MessageCommandAutoRepair, unit, on, -1, NoUnitP, NULL, FlushCommands);	}}

/**** Send command: Unit builds building at position.**** @param unit    pointer to unit.** @param pos     map tile position of construction.** @param what    pointer to unit-type of the building.** @param flush   Flag flush all pending commands.*/void SendCommandBuildBuilding(CUnit &unit, const Vec2i &pos, CUnitType &what, int flush){	if (!IsNetworkGame()) {		CommandLog("build", &unit, flush, pos.x, pos.y, NoUnitP, what.Ident.c_str(), -1);		CommandBuildBuilding(unit, pos, what, flush);	} else {		NetworkSendCommand(MessageCommandBuild, unit, pos.x, pos.y, NoUnitP, &what, flush);	}}

/**** Send command: Unit return goods.**** @param unit    pointer to unit.** @param goal    pointer to destination of the goods. (NULL=search best)** @param flush   Flag flush all pending commands.*/void SendCommandReturnGoods(CUnit &unit, CUnit *goal, int flush){	if (!IsNetworkGame()) {		CommandLog("return", &unit, flush, -1, -1, goal, NULL, -1);		CommandReturnGoods(unit, goal, flush);	} else {		NetworkSendCommand(MessageCommandReturn, unit, 0, 0, goal, 0, flush);	}}

/****  Send command: Unit harvests a location (wood for now).**** @param unit     pointer to unit.** @param pos      map tile position where to harvest.** @param flush    Flag flush all pending commands.*/void SendCommandResourceLoc(CUnit &unit, const Vec2i &pos, int flush){	if (!IsNetworkGame()) {		CommandLog("resource-loc", &unit, flush, pos.x, pos.y, NoUnitP, NULL, -1);		CommandResourceLoc(unit, pos, flush);	} else {		NetworkSendCommand(MessageCommandResourceLoc, unit, pos.x, pos.y, NoUnitP, 0, flush);	}}

/**** Send command: Unit starts upgrading to.**** @param unit     pointer to unit.** @param what     pointer to unit-type of the unit upgrade.** @param flush    Flag flush all pending commands.*/void SendCommandTransformInto(CUnit &unit, CUnitType &what, int flush){	if (!IsNetworkGame()) {		CommandLog("transform-into", &unit, flush, -1, -1, NoUnitP, what.Ident.c_str(), -1);		CommandTransformIntoType(unit, what);	} else {		NetworkSendCommand(MessageCommandUpgrade, unit, 2, 0, NoUnitP, &what, flush); //use X as a way to mark that this is a transformation and not an upgrade	}}

/**** Send command: Defend some unit.**** @param unit    pointer to unit.** @param dest    defend this unit.** @param flush   Flag flush all pending commands.*/void SendCommandDefend(CUnit &unit, CUnit &dest, int flush){	if (!IsNetworkGame()) {		CommandLog("defend", &unit, flush, -1, -1, &dest, NULL, -1);		CommandDefend(unit, dest, flush);	} else {		NetworkSendCommand(MessageCommandDefend, unit, 0, 0, &dest, 0, flush);	}}

/**** Send command: Building starts upgrading to.**** @param unit     pointer to unit.** @param what     pointer to unit-type of the unit upgrade.** @param flush    Flag flush all pending commands.*/void SendCommandTransformInto(CUnit &unit, CUnitType &what, int flush){	if (!IsNetworkGame()) {		CommandLog("transform-into", &unit, flush, -1, -1, NoUnitP, what.Ident.c_str(), -1);		CommandTransformIntoType(unit, what);	} else {		NetworkSendCommand(MessageCommandTransform, unit, 0, 0, NoUnitP, &what, flush);	}}

/**** Send command: Unit stand ground.**** @param unit     pointer to unit.** @param flush    Flag flush all pending commands.*/void SendCommandStandGround(CUnit &unit, int flush){	if (!IsNetworkGame()) {		CommandLog("stand-ground", &unit, flush, -1, -1, NoUnitP, NULL, -1);		CommandStandGround(unit, flush);	} else {		NetworkSendCommand(MessageCommandStand, unit, 0, 0, NoUnitP, 0, flush);	}}

/**** Send command: Follow unit to position.**** @param unit    pointer to unit.** @param dest    follow this unit.** @param flush   Flag flush all pending commands.*/void SendCommandFollow(CUnit &unit, CUnit &dest, int flush){	if (!IsNetworkGame()) {		CommandLog("follow", &unit, flush, -1, -1, &dest, NULL, -1);		CommandFollow(unit, dest, flush);	} else {		NetworkSendCommand(MessageCommandFollow, unit, 0, 0, &dest, 0, flush);	}}

/**** Send command: Accept new quest for the unit's player.**** @param unit    pointer to unit.** @param pos     map tile position to move to.*/void SendCommandQuest(CUnit &unit, CQuest *quest){	if (!IsNetworkGame()) {		CommandLog("quest", &unit, 0, 0, 0, NoUnitP, quest->Ident.c_str(), -1);		CommandQuest(unit, quest);	} else {		NetworkSendCommand(MessageCommandQuest, unit, quest->ID, 0, NoUnitP, NULL, 0);	}}

/****  Wait for interactive input event for one frame.****  Handles system events, joystick, keyboard, mouse.**  Handles the network messages.**  Handles the sound queue.****  All events available are fetched. Sound and network only if available.**  Returns if the time for one frame is over.*/void WaitEventsOneFrame(){	++FrameCounter;	Uint32 ticks = SDL_GetTicks();	if (ticks > NextFrameTicks) { // We are too slow :(		++SlowFrameCounter;	}	InputMouseTimeout(*GetCallbacks(), ticks);	InputKeyTimeout(*GetCallbacks(), ticks);	CursorAnimate(ticks);	int interrupts = 0;	for (;;) {		// Time of frame over? This makes the CPU happy. :(		ticks = SDL_GetTicks();		if (!interrupts && ticks < NextFrameTicks) {			SDL_Delay(NextFrameTicks - ticks);			ticks = SDL_GetTicks();		}		while (ticks >= NextFrameTicks) {			++interrupts;			FrameFraction += FrameRemainder;			if (FrameFraction > 10) {				FrameFraction -= 10;				++NextFrameTicks;			}			NextFrameTicks += FrameTicks;		}		SDL_Event event[1];		const int i = SDL_PollEvent(event);		if (i) { // Handle SDL event			SdlDoEvent(*GetCallbacks(), *event);		}		// Network		int s = 0;		if (IsNetworkGame()) {			s = NetworkFildes.HasDataToRead(0);			if (s > 0) {				GetCallbacks()->NetworkEvent();			}		}		// No more input and time for frame over: return		if (!i && s <= 0 && interrupts) {			break;		}	}	handleInput(NULL);	if (!SkipGameCycle--) {		SkipGameCycle = SkipFrames;	}}

/**** Send command: Unit auto spell cast.**** @param unit      pointer to unit.** @param spellid   Spell type id.** @param on        1 for auto cast on, 0 for off.*/void SendCommandAutoSpellCast(CUnit &unit, int spellid, int on){	if (!IsNetworkGame()) {		CommandLog("auto-spell-cast", &unit, FlushCommands, on, -1, NoUnitP, NULL, spellid);		CommandAutoSpellCast(unit, spellid, on);	} else {		NetworkSendCommand(MessageCommandSpellCast + spellid,						   unit, on, -1, NoUnitP, NULL, FlushCommands);	}}