public void Serialize(IO.EndianStream s)
 {
     BSaveGame.StreamArray16(s, ref Items);
     s.Stream(ref ProtoPowerID);
     s.Stream(ref TimesUsed); s.Stream(ref IconLocation);
     s.Stream(ref IgnoreCost); s.Stream(ref IgnoreTechPrereqs); s.Stream(ref IgnorePop);
 }
        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);
            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 virtual void Serialize(IO.EndianStream s)
        {
            s.StreamV(ref Position); s.StreamV(ref Up); s.StreamV(ref Forward); s.StreamV(ref Velocity);
            BActionManager.StreamActionList(s, ref Actions);

            bool has_refs = s.IsReading ? false : HasRefs;

            s.Stream(ref has_refs);
            if (has_refs)
            {
                BSaveGame.StreamArray16(s, ref EntityRefs, cMaximumEntityRefs);
            }

            s.Stream(ref ID);
            s.Stream(ref PlayerID);
            s.Stream(ref YDisplacement);
            s.Stream(ref ObstructionRadiusX); s.Stream(ref ObstructionRadiusY); s.Stream(ref ObstructionRadiusZ);

            #region Flags
            s.Stream(ref FlagCollidable);           s.Stream(ref FlagMoving);                       s.Stream(ref FlagDestroy);
            s.Stream(ref FlagFirstUpdate);          s.Stream(ref FlagTiesToGround);         s.Stream(ref FlagUseMaxHeight);
            s.Stream(ref FlagPhysicsControl);       s.Stream(ref FlagRotateObstruction); s.Stream(ref FlagFlying);
            s.Stream(ref FlagValid);                        s.Stream(ref FlagNonMobile);            s.Stream(ref FlagLockedDown);
            s.Stream(ref FlagEntityRefsLocked);     s.Stream(ref FlagFlyingHeightFixup); s.Stream(ref FlagGarrisoned);
            s.Stream(ref FlagPassiveGarrisoned); s.Stream(ref FlagMoved);                    s.Stream(ref FlagTeleported);
            s.Stream(ref FlagInSniper);                     s.Stream(ref FlagIsBuilt);                      s.Stream(ref FlagHasSounds);
            s.Stream(ref FlagHitched);                      s.Stream(ref FlagSprinting);            s.Stream(ref FlagRecovering);
            s.Stream(ref FlagInCover);                      s.Stream(ref FlagSelectable);           s.Stream(ref FlagUngarrisonValid);
            s.Stream(ref FlagGarrisonValid);        s.Stream(ref FlagIsPhysicsReplacement); s.Stream(ref FlagIsDoneBuilding);
            #endregion

            s.StreamSignature(cSaveMarker.Entity1);
        }
Beispiel #5
0
        public override void Serialize(IO.EndianStream s)
        {
            base.Serialize(s);

            s.Stream(Total);
            BSaveGame.StreamArray16(s, ref Events);
        }
Beispiel #6
0
 internal static void Stream(IO.EndianStream s, ref BVisual visual)
 {
     if (BSaveGame.StreamObjectId(s, ref visual, NewVisual, SetProtoId, GetProtoId))
     {
         visual.Serialize(s);
     }
 }
Beispiel #7
0
 public void Serialize(IO.EndianStream s)
 {
     s.Stream(Path);
     s.Stream(ref CurrentWaypoint);
     s.Stream(ref PathTime);
     BSaveGame.StreamFreeListItemPtr(s, ref LinkedPath);
     s.Stream(ref PathLevel);
 }
Beispiel #8
0
        public override void Serialize(IO.EndianStream s)
        {
            base.Serialize(s);

            BSaveGame.StreamCollection(s, Totals);
            s.Stream(Total);
            s.StreamNotNull(ref Combat_);
        }
 public void Serialize(IO.EndianStream s)
 {
     for (int x = 0; x < ObjectiveLabels.Length; x++)
     {
         s.Stream(ref ObjectiveLabels[x]);
     }
     BSaveGame.StreamArray(s, ref Objectives);
 }
Beispiel #10
0
 public void Serialize(IO.EndianStream s)
 {
     BSaveGame.StreamArray16(s, ref UniqueNodes);
     s.Stream(ref ResearchPoints);
     s.Stream(ref ResearchBuilding);
     s.Stream(ref Status, BProtoTechStatusStreamer.Instance);
     s.Stream(ref Unique);
 }
        public override void Serialize(IO.EndianStream s)
        {
            base.Serialize(s);

            s.StreamV(ref PickupLocation);
            BSaveGame.StreamArray(s, ref SquadsToTransport);
            s.Stream(ref GotPickupLocation);
        }
Beispiel #12
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);
 }
Beispiel #13
0
        public void Serialize(IO.EndianStream s)
        {
            BSaveGame.StreamVectorArray16(s, ref Waypoints, cMaximumWaypoints);
            s.Stream(ref Flags);
            s.Stream(ref PathLength);
            s.Stream(ref CreationTime);

            s.StreamSignature(cSaveMarker.cSaveMarkerPath1);
        }
Beispiel #14
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);
        }
Beispiel #15
0
 public void Serialize(IO.EndianStream s)
 {
     BSaveGame.StreamList(s, Concepts, kConceptsListInfo);
     s.Stream(ref TimeSinceLastHint);
     s.Stream(ref HintMessageOn);
     BSaveGame.StreamArray16(s, ref AllowedConcepts);
     Contract.Assert(AllowedConcepts.Length <= BConcept.kMaxCount);
     s.Stream(ref WaitForNextRescore);
     s.Stream(ref LastGameTime);
     s.StreamSignature(cSaveMarker.HintEngine);
 }
Beispiel #16
0
 public void Serialize(IO.EndianStream s)
 {
     s.Stream(Target);
     BSaveGame.StreamVectorArray(s, ref Waypoints, cMaximumWaypoints);
     s.Stream(ref OwnerID);
     s.Stream(ref ID); s.Stream(ref RefCount);
     s.Stream(ref Angle);
     s.Stream(ref Mode);
     s.Stream(ref Priority);
     s.Stream(ref AttackMove); s.Stream(ref OverridePosition); s.Stream(ref OverrideRange);
     s.Stream(ref AutoGeneratedAttackMove);
 }
 public void Serialize(IO.EndianStream s)
 {
     BSaveGame.StreamList(s, Callouts, kCalloutsListInfo);
     s.StreamSignature(cSaveMarker.UICallouts1);
     s.StreamSignature(cNumCallouts);
     for (int x = 0; x < CalloutWidgets.Length; x++)
     {
         s.Stream(ref CalloutWidgets[x]);
     }
     s.Stream(ref NextCalloutID);
     s.Stream(ref PanelVisible); s.Stream(ref CalloutsVisible);
     s.StreamSignature(cSaveMarker.UICallouts2);
 }
 public void Serialize(IO.EndianStream s)
 {
     s.Stream(ref Action);
     if (Action)
     {
         s.Stream(ref ActionType, BActionTypeStreamer.Instance);
         BSaveGame.StreamFreeListItemPtr(s, ref ActionPtr);
     }
     else
     {
         ActionType = Phx.BActionType.Invalid;
         ActionPtr  = TypeExtensions.kNone;
     }
 }
Beispiel #19
0
 public void Serialize(IO.EndianStream s)
 {
     s.StreamV(ref Vector);
     BSaveGame.StreamArray16(s, ref SquadList);
     Contract.Assert(SquadList.Length <= kMaxEntitiesPerList);
     BSaveGame.StreamArray16(s, ref UnitList);
     Contract.Assert(SquadList.Length <= kMaxEntitiesPerList);
     s.Stream(EntityFilterSet);
     s.Stream(ref Float);
     s.Stream(ref ObjectType);
     s.Stream(ref LocStringID);
     s.Stream(ref HasVector); s.Stream(ref HasSquadList); s.Stream(ref HasUnitList);
     s.Stream(ref HasEntityFilterSet); s.Stream(ref HasFloat); s.Stream(ref HasObjectType);
     s.Stream(ref HasLocStringID);
 }
Beispiel #20
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);
        }
Beispiel #22
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);
        }
 public void Serialize(IO.EndianStream s)
 {
     BSaveGame.StreamVectorArray(s, ref Path, cMaximumPathLength);
     s.Stream(Target);
     s.Stream(ref Source);
     s.Stream(ref ID);
     s.Stream(ref Type);
     s.Stream(ref UserData);
     s.Stream(ref Priority);
     s.Stream(ref UserData2);
     s.Stream(ref WaitCount);
     s.Stream(ref Evaluated); s.Stream(ref ExistForOneUpdate); s.Stream(ref ExistUntilEvaluated);
     s.Stream(ref AllowComplete); s.Stream(ref NotifySource); s.Stream(ref Leash);
     s.Stream(ref ForceLeash); s.Stream(ref Trigger); s.Stream(ref RemoveActions);
     s.Stream(ref Complete); s.Stream(ref CompleteValue); s.Stream(ref PreserveDPS);
     s.Stream(ref MustComplete); s.Stream(ref UserDataSet);
 }
Beispiel #24
0
 public void Serialize(IO.EndianStream s)
 {
     BSaveGame.StreamMatrix(s, ref Matrix);
     s.Stream(ref SubUpdateNumber);
     s.Stream(ref GrannySubUpdateNumber);
     BSaveGame.StreamMatrix(s, ref Matrix1);
     BSaveGame.StreamMatrix(s, ref Matrix2);
     s.StreamV(ref CombinedMinCorner); s.StreamV(ref CombinedMaxCorner);
     s.StreamV(ref MinCorner); s.StreamV(ref MaxCorner);
     s.Stream(ref ModelAsset);
     if (s.StreamCond(ModelUVOffsets, offsets => !offsets.EqualsZero()))
     {
         s.Stream(ModelUVOffsets);
     }
     StreamFlags(s);
     StreamAttachments(s);
 }
Beispiel #25
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);
 }
Beispiel #26
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);
        }
Beispiel #28
0
        public void Serialize(IO.EndianStream s)
        {
            s.Stream(ref UserMode); s.Stream(ref SubMode);
            if (UserMode == 16)
            {
                SerializeUserMode16(s);
            }

            BSaveGame.StreamArray16(s, ref SelectionList);
            s.Stream(ref CameraZoomMin); s.Stream(ref CameraZoomMax);
            s.Stream(ref CameraPitchMin); s.Stream(ref CameraPitchMax);
            s.Stream(ref CameraPitch); s.Stream(ref CameraYaw);
            s.Stream(ref CameraZoom); s.Stream(ref CameraFOV);
            s.StreamV(ref HoverPoint); s.StreamV(ref CameraHoverPoint);
            s.Stream(ref CameraHoverPointOffsetHeight);
            s.StreamV(ref LastCameraLoc); s.StreamV(ref LastCameraHoverPoint);
            s.Stream(ref HaveHoverPoint); s.Stream(ref HoverPointOverTerrain);
            s.Stream(ref HUDItemEnabled);
            BSaveGame.StreamCollection(s, ObjectiveArrows);
        }
Beispiel #29
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);
        }
        public void Serialize(IO.EndianStream s)
        {
            BSaveGame.StreamCollection(s, Civs);
            BSaveGame.StreamCollection(s, Leaders);
            BSaveGame.StreamCollection(s, Abilities);
            BSaveGame.StreamCollection(s, ProtoVisuals);
            BSaveGame.StreamCollection(s, Models);
            BSaveGame.StreamCollection(s, Animations);
            BSaveGame.StreamCollection(s, TerrainEffects);
            BSaveGame.StreamCollection(s, ProtoImpactEffects);
            BSaveGame.StreamCollection(s, LightEffects);
            BSaveGame.StreamCollection(s, ParticleGateways);
            BSaveGame.StreamCollection(s, GenericProtoObjects);
            BSaveGame.StreamCollection(s, ProtoSquads);
            BSaveGame.StreamCollection(s, ProtoTechs);
            BSaveGame.StreamCollection(s, ProtoPowers);
            BSaveGame.StreamCollection(s, ProtoObjects);
            BSaveGame.StreamCollection(s, Resources);
            BSaveGame.StreamCollection(s, Rates);
            BSaveGame.StreamCollection(s, Populations);
            BSaveGame.StreamCollection(s, WeaponTypes);
            BSaveGame.StreamCollection(s, DamageTypes);
            BSaveGame.StreamCollection(s, Templates);
            BSaveGame.StreamCollection(s, AnimTypes);
            BSaveGame.StreamCollection(s, EffectTypes);
            BSaveGame.StreamCollection(s, Actions);
            BSaveGame.StreamList(s, Tactics, kTacticsListInfo);

            s.Stream(ref NumUniqueProtoObjects);
            s.StreamSignature((uint)NumUniqueProtoObjects);

            BSaveGame.StreamList(s, Shapes, kDataTagsListInfo);
            BSaveGame.StreamList(s, PhysicsInfo, kDataTagsListInfo);

            BSaveGame.StreamCollection(s, ProtoIcons);

            s.StreamSignature(cSaveMarker.DB);
        }