public override void Serialize(IO.EndianStream s)
        {
            base.Serialize(s);
            var sg = s.Owner as BSaveGame;

            s.Stream(ref ProtoID);
            BSaveGame.StreamArray(s, ref TrainLimits);
            Contract.Assert(TrainLimits.Length <= kTrainLimitsMaxCount);
            BSaveGame.StreamArray(s, ref Hardpoints);
            Contract.Assert(Hardpoints.Length <= BHardpoint.kMaxCount);
            sg.StreamBCost(s, ref Cost);
            s.Stream(ref ProtoVisualIndex);
            s.Stream(ref DesiredVelocity); s.Stream(ref MaxVelocity);
            s.Stream(ref Hitpoints); s.Stream(ref Shieldpoints);
            s.Stream(ref LOS);
            s.Stream(ref SimLOS);
            s.Stream(ref BuildPoints);
            s.Stream(ref Bounty);
            s.StreamNotNull(ref Tactic);
            s.Stream(ref AmmoMax); s.Stream(ref AmmoRegenRate); s.Stream(ref RateAmount);
            s.Stream(ref MaxContained); s.Stream(ref DisplayNameIndex); s.Stream(ref CircleMenuIconID);
            s.Stream(ref DeathSpawnSquad);
            BSaveGame.StreamArray(s, ref CommandDisabled);
            BSaveGame.StreamArray(s, ref CommandSelectable);
            s.Stream(ref Available); s.Stream(ref Forbid); s.Stream(ref AbilityDisabled);
            s.Stream(ref AutoCloak); s.Stream(ref CloakMove); s.Stream(ref CloakAttack);
            s.Stream(ref UniqueInstance);
            s.StreamSignature(cSaveMarker.ProtoObject);
        }
        public override void Serialize(IO.EndianStream s)
        {
            base.Serialize(s);
            var sg = s.Owner as BSaveGame;

            s.Stream(ref NextTickTime);
            s.Stream(ref TargettedSquad);
            s.StreamV(ref LastDirectionInput); s.StreamV(ref TeleportDestination); s.StreamV(ref PositionInput);
            s.Stream(ref TimeUntilTeleport); s.Stream(ref TimeUntilRetarget);
            s.Stream(ref AttackSound);
            s.Stream(JumpSplineCurve);
            s.Stream(CameraEffectData);
            sg.StreamBCost(s, ref CostPerTick); sg.StreamBCost(s, ref CostPerTickAttacking); sg.StreamBCost(s, ref CostPerJump);
            s.Stream(ref TickLength); s.Stream(ref DamageMultiplier); s.Stream(ref DamageTakenMultiplier);
            s.Stream(ref SpeedMultiplier); s.Stream(ref NudgeMultiplier); s.Stream(ref ScanRadius);
            s.Stream(ref ProjectileObject); s.Stream(ref HandAttachObject); s.Stream(ref TeleportAttachObject);
            s.Stream(ref AudioReactionTimer); s.Stream(ref TeleportTime);
            s.Stream(ref TeleportLateralDistance); s.Stream(ref TeleportJumpDistance); s.Stream(ref TimeBetweenRetarget);
            s.Stream(ref MotionBlurAmount); s.Stream(ref MotionBlurDistance); s.Stream(ref MotionBlurTime);
            s.Stream(ref DistanceVsAngleWeight); s.Stream(ref HealPerKillCombatValue); s.Stream(ref AuraRadius); s.Stream(ref AuraDamageBonus);
            s.Stream(ref AuraAttachObjectSmall); s.Stream(ref AuraAttachObjectMedium); s.Stream(ref AuraAttachObjectLarge);
            s.Stream(ref HealAttachObject);
            BSaveGame.StreamArray(s, ref SquadsInAura);
            s.Stream(ref FilterTypeID);
            s.Stream(ref CompletedInitialization); s.Stream(ref HasSuccessfullyAttacked); s.Stream(ref UsePather);
        }
        public override void Serialize(IO.EndianStream s)
        {
            base.Serialize(s);

            s.StreamV(ref PickupLocation);
            BSaveGame.StreamArray(s, ref SquadsToTransport);
            s.Stream(ref GotPickupLocation);
        }
 public void Serialize(IO.EndianStream s)
 {
     for (int x = 0; x < ObjectiveLabels.Length; x++)
     {
         s.Stream(ref ObjectiveLabels[x]);
     }
     BSaveGame.StreamArray(s, ref Objectives);
 }
Example #5
0
 public void Serialize(IO.EndianStream s)
 {
     BSaveGame.StreamArray(s, ref Weapons);
     Contract.Assert(Weapons.Length <= BWeapon.kMaxCount);
     BSaveGame.StreamArray(s, ref ProtoActions);
     Contract.Assert(ProtoActions.Length <= BProtoAction.kMaxCount);
     s.Stream(ref AnimInfoLoaded);
     s.StreamSignature(cSaveMarker.Tactic);
 }
Example #6
0
        public override void Serialize(IO.EndianStream s)
        {
            base.Serialize(s);

            s.Stream(ref SquadSpawnDelay);
            BSaveGame.StreamArray(s, ref ActiveDrops);
            s.Stream(ref ProjectileProtoID); s.Stream(ref ODSTProtoSquadID);
            s.Stream(ref AddToMissionID);
            s.Stream(ref ReadyForShutdown);
        }
Example #7
0
        public override void Serialize(IO.EndianStream s)
        {
            base.Serialize(s);

            BSaveGame.StreamArray(s, ref IgnoreList);
            s.Stream(ref NextTickTime);
            s.Stream(ref CryoObjectID);
            s.StreamV(ref Direction); s.StreamV(ref Right);
            s.Stream(ref CryoObjectProtoID); s.Stream(ref BomberProtoID);
            s.Stream(ref FilterTypeID);
            s.Stream(ref CryoRadius); s.Stream(ref MinCryoFalloff);
            s.Stream(ref TickDuration); s.Stream(ref TicksRemaining);
            s.Stream(ref CryoAmountPerTick); s.Stream(ref KillableHpLeft); s.Stream(ref FreezingThawTime); s.Stream(ref FrozenThawTime);
            s.Stream(BomberData);
            s.Stream(ref ReactionPlayed);
        }
        public override void Serialize(IO.EndianStream s)
        {
            base.Serialize(s);

            BSaveGame.StreamArray(s, ref SquadsRepairing);
            BSaveGame.StreamArray(s, ref IgnoreList);
            s.Stream(ref NextTickTime);
            s.Stream(ref RepairObjectID);
            s.Stream(ref RepairAttachmentProtoID);
            s.Stream(ref FilterTypeID);
            s.Stream(ref RepairRadius);
            s.Stream(ref TickDuration);
            s.Stream(ref RepairCombatValuePerTick);
            s.Stream(ref CooldownTimeIfDamaged); s.Stream(ref TicksRemaining);
            s.Stream(ref SpreadAmongSquads); s.Stream(ref AllowReinforce); s.Stream(ref IgnorePlacement);
            s.Stream(ref HealAny); s.Stream(ref NeverStops);
        }
Example #9
0
        public override void Serialize(IO.EndianStream s)
        {
            base.Serialize(s);

            s.Stream(ref RealTargettingLaserID);
            s.StreamV(ref DesiredTargettingPosition);
            BSaveGame.StreamArray(s, ref Shots);
            s.Stream(ref FiredInitialShot);
            s.Stream(ref ShotsRemaining); s.Stream(ref ImpactsToProcess);
            s.Stream(ref TargetBeamID); s.Stream(ref ProjectileID); s.Stream(ref EffectProtoID);
            s.Stream(ref RockSmallProtoID); s.Stream(ref RockMediumProtoID); s.Stream(ref RockLargeProtoID);
            s.Stream(ref FiredSound);
            s.Stream(ref TargetingDelay); s.Stream(ref AutoShotDelay);
            s.Stream(ref AutoShotInnerRadius); s.Stream(ref AutoShotOuterRadius);
            s.Stream(ref XOffset); s.Stream(ref YOffset); s.Stream(ref ZOffset);
            s.Stream(ref LOSMode);
        }
Example #10
0
 public void Serialize(IO.EndianStream s)
 {
     s.Stream(ref HasCommand); s.Stream(ref NewCommand);
     s.Stream(ref StateChanged); s.Stream(ref NewState);
     s.Stream(ref HasPreconditionResult); s.Stream(ref PreconditionResult);
     s.Stream(ref PreconditionTime);
     s.Stream(ref State);
     s.Stream(ref GamesReinforced); s.Stream(ref TimesReinforced); s.Stream(ref HintDisplayedCount);
     BSaveGame.StreamList(s, Pages, kPagesListInfo);
     s.Stream(ref TimesReinforcedThisGame);
     s.Stream(ref EventReady); s.Stream(ref Active); s.Stream(ref Permission);
     s.Stream(ref InitialWaitTimeRemaining); s.Stream(ref TerminalWaitTimeRemaining);
     s.Stream(ref CoolDownTimer); s.Stream(ref LastCoolDownAmount);
     s.Stream(ref CoolDownTimerAccumulator);
     BSaveGame.StreamArray(s, ref SubHints);
     s.Stream(ref ParentHint); Contract.Assert(ParentHint <= kMaxCount);
     s.Stream(ref PrereqsMet); s.Stream(ref DirtyProfile);
     s.StreamSignature(cSaveMarker.Concept);
 }
Example #11
0
        public override void Serialize(IO.EndianStream s)
        {
            base.Serialize(s);

            BSaveGame.StreamArray(s, ref BombExplodeInfos);
            BSaveGame.StreamCollection(s, NudgedUnits);
            s.StreamV(ref StartLocation); s.StreamV(ref StartDirection); s.StreamV(ref RightVector);
            s.Stream(ref State);
            s.Stream(ref GotStartLocation); s.Stream(ref GotStartDirection);
            s.Stream(ref TickLength); s.Stream(ref NextBombTime); s.Stream(ref LastBombTime);
            s.Stream(ref NumBombClustersDropped);
            s.Stream(ref ProjectileProtoID); s.Stream(ref ImpactProtoID); s.Stream(ref ExplosionProtoID); s.Stream(ref BomberProtoID);
            s.Stream(ref InitialDelay); s.Stream(ref FuseTime);
            s.Stream(ref MaxBombs);
            s.Stream(ref MaxBombOffset); s.Stream(ref BombSpacing); s.Stream(ref LengthMultiplier);
            s.Stream(ref WedgeLengthMultiplier); s.Stream(ref WedgeMinOffset); s.Stream(ref NudgeMultiplier);
            s.Stream(BomberData);
            s.Stream(ref LOSMode);
            s.Stream(ref ReactionPlayed);
        }
        public override void Serialize(IO.EndianStream s)
        {
            base.Serialize(s);
            var sg = s.Owner as BSaveGame;

            BSaveGame.StreamVectorArray(s, ref Waypoints, cMaximumWaypoints);
            s.Stream(ref BeamID); s.Stream(ref AirImpactObjectID);
            s.Stream(ref NextDamageTime);
            s.StreamV(ref DesiredBeamPosition);
            BSaveGame.StreamVectorArray(s, ref BeamPath, cMaximumBeamPathLength);
            BSaveGame.StreamArray(s, ref RevealedTeamIDs);
            sg.StreamBCost(s, ref CostPerTick);
            s.Stream(ref Projectile);
            s.Stream(ref TickLength); s.Stream(ref MinBeamDistance); s.Stream(ref MaxBeamDistance);
            s.Stream(ref CommandInterval);
            s.Stream(ref MaxBeamSpeed);
            s.Stream(ref LOSMode);
            s.Stream(ref UsePath);
            s.Stream(ref AudioReactionTimer);
        }
Example #13
0
        public override void Serialize(IO.EndianStream s)
        {
            base.Serialize(s);
            var sg = s.Owner as BSaveGame;

            s.Stream(ref ProtoID);
            s.Stream(ref BuildPoints);
            sg.StreamBCost(s, ref Cost);
            s.Stream(ref MaxHP); s.Stream(ref MaxSP); s.Stream(ref MaxAmmo);
            s.Stream(ref Level); s.Stream(ref TechLevel); s.Stream(ref DisplayNameIndex);
            s.Stream(ref CircleMenuIconID); s.Stream(ref AltCircleMenuIconID); s.Stream(ref HPBar);
            s.Stream(ref Available); s.Stream(ref Forbid);
            s.Stream(ref OneTimeSpawnUsed); s.Stream(ref KBAware);
            s.Stream(ref HasOverrideNodes);
            if (HasOverrideNodes)
            {
                BSaveGame.StreamArray(s, ref OverrideNodes);
            }
            s.StreamSignature(cSaveMarker.ProtoSquad1);
        }
Example #14
0
        public void Serialize(IO.EndianStream s)
        {
            var sg = s.Owner as BSaveGame;

            if (s.IsReading)
            {
                Players = new BPlayer[sg.Players.Count];
                for (int x = 0; x < Players.Length; x++)
                {
                    Players[x] = new BPlayer();
                }
            }

            BSaveGame.StreamArray16(s, ref NumExplorationGroups, isIterated: true);
            BSaveGame.StreamArray(s, ref ActiveExplorationGroups);
            s.StreamSignature(cSaveMarker.World1);
            foreach (var player in Players)
            {
                s.Stream(player);
            }
            s.StreamSignature(cSaveMarker.Players);
            s.StreamSignature(cMaximumSupportedPlayers);
            s.StreamSignature(cMaxPlayerColorCategories);
            for (int x = 0; x < cMaxPlayerColorCategories; x++)
            {
                for (int y = 0; y < cMaximumSupportedPlayers; y++)
                {
                    s.Stream(ref PlayerColorCategories[x, y]);
                }
            }
            s.StreamSignature(cSaveMarker.World2);
            BSaveGame.StreamFreeList(s, SimOrders, BSimOrder.kFreeListInfo);
            BSaveGame.StreamFreeList(s, UnitOpps, BUnitOpp.kFreeListInfo);
            BSaveGame.StreamFreeList(s, PathMoveData, BPathMoveData.kFreeListInfo);

            //...
        }
Example #15
0
        public override void Serialize(IO.EndianStream s)
        {
            base.Serialize(s);

            var sg = s.Owner as BSaveGame;

            s.Stream(ref NextTickTime);
            s.Stream(ref RealGravityBall);
            s.StreamV(ref DesiredBallPosition);
            BSaveGame.StreamCollection(s, CapturedUnits);
            s.Stream(ref ExplodeCooldownLeft);
            BSaveGame.StreamArray(s, ref UnitsToPull);
            BSaveGame.StreamArray(s, ref QueuedPickupObjects);
            sg.StreamBCost(s, ref CostPerTick);
            s.Stream(ref TickLength);
            s.Stream(ref BallProtoID); s.Stream(ref LightningProtoID); s.Stream(ref LightningBeamVisualProtoID);
            s.Stream(ref DebrisProtoID); s.Stream(ref ExplodeProtoID); s.Stream(ref PickupAttachmentProtoID);
            s.Stream(ref AudioReactionTimer);
            s.Stream(ref LeaderAnimOrderID);

            s.Stream(ref MaxBallSpeedStagnant); s.Stream(ref MaxBallSpeedPulling); s.Stream(ref ExplodeTime);
            s.Stream(ref PullingRange); s.Stream(ref ExplosionForceOnDebris); s.Stream(ref HealthToCapture);
            s.Stream(ref NudgeStrength); s.Stream(ref InitialLateralPullStrength); s.Stream(ref CapturedRadialSpacing);
            s.Stream(ref CapturedSpringStrength); s.Stream(ref CapturedSpringDampening); s.Stream(ref CapturedSpringRestLength);
            s.Stream(ref CapturedMinLateralSpeed); s.Stream(ref RipAttachmentChancePulling); s.Stream(ref PickupObjectRate);
            s.Stream(ref DebrisAngularDamping); s.Stream(ref CurrentExplosionDamageBank); s.Stream(ref MaxPossibleExplosionDamageBank);
            s.Stream(ref MaxExplosionDamageBankPerCaptured); s.Stream(ref ExplosionDamageBankPerTick);
            s.Stream(ref CommandInterval);
            s.Stream(ref MinBallDistance); s.Stream(ref MaxBallDistance);
            s.Stream(ref LightningPerTick); s.Stream(ref MaxCapturedObjects);
            s.Stream(ref NudgeChancePulling); s.Stream(ref ThrowPartChancePulling); s.Stream(ref LightningChancePulling);
            s.Stream(ref ExplodeSound);
            s.Stream(ref MinDamageBankPercentToThrow);
            BSaveGame.StreamArray(s, ref RevealedTeamIDs);
            s.Stream(ref unknown0); s.Stream(ref unknown1); s.Stream(ref unknown2);
            s.Stream(ref CompletedInitialization); s.Stream(ref ThrowUnitsOnExplosion);
        }
        public override void Serialize(IO.EndianStream s)
        {
            BSaveGame.StreamArray(s, ref EntityList);

            base.Serialize(s);
        }
        public override void Serialize(IO.EndianStream s)
        {
            BSaveGame.StreamArray(s, ref Players);

            base.Serialize(s);
        }
Example #18
0
        public override void Serialize(IO.EndianStream s)
        {
            base.Serialize(s);

            s.StreamV(ref CenterOffset); s.StreamV(ref IconColorSize);
            s.Stream(UVOffsets);
            s.Stream(ref MultiframeTextureIndex);
            s.Stream(ref VisualVariationIndex);
            BVisualManager.Stream(s, ref Visual);
            s.Stream(ref AnimationRate); s.Stream(ref Radius); s.Stream(ref MoveAnimationPosition); s.Stream(ref HighlightIntensity);
            s.Stream(ref SubUpdateNumber);
            s.Stream(ref PlayerVisibility); s.Stream(ref DoppleBits);
            s.Stream(ref SimX); s.Stream(ref SimZ);
            s.Stream(ref LOSScalar);
            s.Stream(ref LastSimLOS);

            if (s.StreamCond(this, me => me.HasObjectAttachments))
            {
                BSaveGame.StreamArray(s, ref ObjectAttachments, cMaximumObjectAttachments);
            }

            if (s.StreamCond(this, me => me.HasAdditionalTextures))
            {
                BSaveGame.StreamArray(s, ref AdditionalTextures, cMaximumAdditionalTextures);
            }

            BSaveGame.StreamArray(s, ref HardpointState, cMaximumHardpoints);
            s.Stream(ref AnimationState);
            s.Stream(ref AnimationLockEnds);
            s.Stream(ref ProtoID);
            s.Stream(ref ColorPlayerID);
            s.Stream(ref OverrideTint);
            s.Stream(ref OverrideFlashInterval); s.Stream(ref OverrideFlashIntervalTimer); s.Stream(ref OverrideFlashDuration);
            s.Stream(ref LifespanExpiration);
            s.Stream(ref CurrentAlphaTime); s.Stream(ref AlphaFadeDuration);
            s.Stream(ref SelectionPulseTime); s.Stream(ref SelectionPulsePercent); s.Stream(ref SelectionFlashTime); s.Stream(ref SelectionPulseSpeed);
            s.Stream(ref LastRealtime);
            s.Stream(ref AOTintValue);
            s.Stream(ref TeamSelectionMask);
            s.Stream(ref LOSRevealTime);

            #region Flags
            s.Stream(ref FlagVisibility); s.Stream(ref FlagLOS); s.Stream(ref FlagHasLifespan); s.Stream(ref FlagDopples);
            s.Stream(ref FlagIsFading); s.Stream(ref FlagAnimationDisabled); s.Stream(ref FlagIsRevealer); s.Stream(ref FlagDontInterpolate);
            s.Stream(ref FlagBlockLOS); s.Stream(ref FlagCloaked); s.Stream(ref FlagCloakDetected); s.Stream(ref FlagGrayMapDopples);
            s.Stream(ref FlagLOSMarked); s.Stream(ref FlagUseLOSScalar); s.Stream(ref FlagLOSDirty); s.Stream(ref FlagAnimationLocked);
            s.Stream(ref FlagUpdateSquadPositionOnAnimationUnlock); s.Stream(ref FlagExistSoundPlaying); s.Stream(ref FlagNoUpdate); s.Stream(ref FlagSensorLockTagged);
            s.Stream(ref FlagNoReveal); s.Stream(ref FlagBuilt); s.Stream(ref FlagBeingCaptured); s.Stream(ref FlagInvulnerable);
            s.Stream(ref FlagVisibleForOwnerOnly); s.Stream(ref FlagVisibleToAll); s.Stream(ref FlagNearLayer); s.Stream(ref FlagIKDisabled);
            s.Stream(ref FlagHasTrackMask); s.Stream(ref FlagLODFading); s.Stream(ref FlagOccluded); s.Stream(ref FlagFadeOnDeath);
            s.Stream(ref FlagObscurable); s.Stream(ref FlagNoRender); s.Stream(ref FlagTurning); s.Stream(ref FlagAppearsBelowDecals);
            s.Stream(ref FlagSkipMotionExtraction); s.Stream(ref FlagOverrideTint); s.Stream(ref FlagMotionCollisionChecked); s.Stream(ref FlagIsDopple);
            s.Stream(ref FlagIsImpactEffect); s.Stream(ref FlagDebugRenderAreaAttackRange); s.Stream(ref FlagDontLockMovementAnimation); s.Stream(ref FlagRemainVisible);
            s.Stream(ref FlagVisibleForTeamOnly); s.Stream(ref FlagDontAutoAttackMe); s.Stream(ref FlagAlwaysAttackReviveUnits); s.Stream(ref FlagNoRenderForOwner);
            s.Stream(ref FlagNoRenderDuringCinematic); s.Stream(ref FlagUseCenterOffset); s.Stream(ref FlagNotDoppleFriendly); s.Stream(ref FlagForceVisibilityUpdateNextFrame);
            s.Stream(ref FlagTurningRight); s.Stream(ref FlagIsUnderCinematicControl); s.Stream(ref FlagNoWorldUpdate);
            #endregion

            s.Stream(ref IsObstruction);

            Contract.Assert(false);            // mpPhysicsObject

            s.StreamSignature(cSaveMarker.Object1);
        }
Example #19
0
 public void Serialize(IO.EndianStream s)
 {
     s.Stream(ref Id);
     BSaveGame.StreamArray(s, ref Objects);
     BSaveGame.StreamArray(s, ref TriggeredTeams);
 }
Example #20
0
        public void Serialize(IO.EndianStream s)
        {
            var sg = s.Owner as BSaveGame;

            #region Init
            if (s.IsReading)
            {
                ProtoObjects = new List <CondensedListItem16 <BProtoObject> >(sg.Database.GenericProtoObjects.Count);
                ProtoSquads  = new List <CondensedListItem16 <BProtoSquad> >(sg.Database.ProtoSquads.Count);
                ProtoTechs   = new List <CondensedListItem16 <BProtoTech> >(sg.Database.ProtoTechs.Count);

                Powers      = new PowerInfo[sg.Database.ProtoPowers.Count];
                Rates       = new RateInfo[sg.Database.Rates.Count];
                Populations = new BPlayerPop[sg.Database.Populations.Count];

                GenericObjectCounts = new List <CondensedListItemValue16 <UnitCountInfo> >(sg.Database.GenericProtoObjects.Count);
                SquadCounts         = new List <CondensedListItemValue16 <UnitCountInfo> >(sg.Database.ProtoSquads.Count);
                WeaponTypes         = new List <CondensedListItemValue8 <WeaponType> >(sg.Database.WeaponTypes.Count);
            }
            #endregion

            #region Player1
            s.StreamV(ref LookAtPos);
            s.StreamPascalString32(ref Name);
            s.StreamV(ref RallyPoint);
            s.Stream(StatsManager);
            BSaveGame.StreamList(s, ProtoObjects, kProtoUnitsListInfo);
            BSaveGame.StreamList(s, ProtoSquads, kProtoUnitsListInfo);
            BSaveGame.StreamList(s, ProtoTechs, kProtoTechsListInfo);
            BSaveGame.StreamArray16(s, ref UniqueProtoObjects);
            Contract.Assert(UniqueProtoObjects.Length <= kProtoUniqueUnitsListInfo.MaxCount);
            BSaveGame.StreamArray16(s, ref UniqueProtoSquad);
            Contract.Assert(UniqueProtoSquad.Length <= kProtoUniqueUnitsListInfo.MaxCount);
            BSaveGame.StreamArray(s, ref PowerEntries);
            BSaveGame.StreamArray(s, ref Abilities);
            for (int x = 0; x < Powers.Length; x++)
            {
                s.Stream(ref Powers[x]);
            }
            sg.StreamBCost(s, ref Resources);
            for (int x = 0; x < Rates.Length; x++)
            {
                s.Stream(ref Rates[x]);
            }
            sg.StreamBCost(s, ref TotalResources);
            sg.StreamBCost(s, ref ResourceTrickleRate);
            for (int x = 0; x < Populations.Length; x++)
            {
                s.Stream(ref Populations[x]);
            }
            s.StreamSignature(cSaveMarker.Player1);
            #endregion
            #region Player2
            s.StreamNotNull(ref HintEngine);
            BSaveGame.StreamList(s, GenericObjectCounts, kUnitCountsListInfo);
            BSaveGame.StreamList(s, SquadCounts, kUnitCountsListInfo);
            s.StreamSignature(cSaveMarker.Player2);
            #endregion
            #region Player3
            s.Stream(ref TotalFutureUnitCounts); s.Stream(ref TotalDeadUnitCounts);
            s.Stream(ref TotalFutureSquadCounts); s.Stream(ref TotalDeadSquadCounts);
            BSaveGame.StreamArray(s, ref GotoBases);
            BSaveGame.StreamList(s, WeaponTypes, kWeaponTypesListInfo);
            BSaveGame.StreamArray16(s, ref AbilityRecoverTimes);
            s.Stream(TechTree);
            s.StreamSignature(cSaveMarker.Player3);
            #endregion
            #region Player4
            s.Stream(ref MPID); s.Stream(ref ColorIndex);
            s.Stream(ref ID); s.Stream(ref CoopID); s.Stream(ref ScenarioID);
            s.Stream(ref CivID);
            s.Stream(ref TeamID);
            s.Stream(ref PlayerState);
            s.Stream(ref LeaderID); s.Stream(ref BountyResource);
            s.Stream(ref RallyObject);
            s.Stream(ref Strength);
            s.Stream(ref TributeCost);
            sg.StreamBCost(s, ref RepairCost);
            s.Stream(ref RepairTime); s.Stream(ref HandicapMultiplier); s.Stream(ref ShieldRegenRate);
            s.Stream(ref ShieldRegenDelay);
            s.Stream(ref TotalCombatValue);
            s.Stream(ref Difficulty);
            s.Stream(ref GamePlayedTime);
            s.Stream(ref FloodPoofPlayer);
            s.Stream(ref PlayerType); s.Stream(ref SquadSearchAttempts);
            s.Stream(ref WeaponPhysicsMultiplier); s.Stream(ref AIDamageMultiplier); s.Stream(ref AIDamageTakenMultiplier);
            s.Stream(ref AIBuildSpeedMultiplier);
            s.Stream(ref FlagRallyPoint); s.Stream(ref FlagBountyResource); s.Stream(ref FlagMinimapBlocked);
            s.Stream(ref FlagLeaderPowersBlocked); s.Stream(ref FlagDefeatedDestroy);
            s.Stream(ref SquadAISearchIndex); s.Stream(ref SquadAIWorkIndex); s.Stream(ref SquadAISecondaryTurretScanIndex);
            s.StreamSignature(cSaveMarker.Player4);
            #endregion
            s.TraceAndDebugPosition(ref mPositionMarker);
        }