protected override void SerializeWeaponsAndEquipment(IO.BitStream s)
{
base.SerializeWeaponsAndEquipment(s);
s.Stream(ref TacticalPackage);
s.Stream(ref SupportUpgrade);
}
protected override void SerializeImpl(IO.BitStream s)
{
#region struct
// 0x BaseVariant
// 0x734 StringTable
// 0x5DBC EncodingVersion
// 0x5DC0 PlayerTraits
// 0x60C4 UserDefinedOptions
// 0x63A8 EngineDefinition
// 0xE668 BaseNameStringIndex
// 0x EngineIconIndex
// 0x EngineCategory
// 0x MapPermissions
// 0x PlayerRatingParameters
// 0x ScoreToWinRound
// 0xE66C DisabledEngineOptions
// 0xE70C HiddenEngineOptions
// 0xE7AC DisabledUserOptions
// 0xE7B0 HiddenUserOptions
#endregion
s.Stream(ref FireTeamsEnabled);
s.Stream(ref SymmetricGametype);
SerializeOptionToggles(s);
s.StreamObject(EngineDefinition); // 0x63A8
if (mEncodingVersion >= kEncodingVersionTU1)
{
s.StreamObject(TU1);
}
}
public override void Serialize(IO.BitStream s)
{
base.Serialize(s);
s.Stream(ref IsHidden);
s.Stream(ref IsRuntime);
}
void SerializeData(MegaloScriptModel model, IO.BitStream s, Proto.MegaloScriptValueType valueType)
{
var base_type = valueType.BaseType;
switch (base_type)
{
case Proto.MegaloScriptValueBaseType.Int:
s.Stream(ref Data, valueType.BitLength, signExtend: true);
break;
case Proto.MegaloScriptValueBaseType.UInt:
case Proto.MegaloScriptValueBaseType.Var:
s.Stream(ref Data, valueType.BitLength);
break;
case Proto.MegaloScriptValueBaseType.Enum:
MegaloScriptEnumValue.SerializeValue(model, s, valueType, ref Data);
break;
case Proto.MegaloScriptValueBaseType.Index:
MegaloScriptIndexValue.SerializeValue(model, s, valueType, ref Data);
break;
default: throw new KSoft.Debug.UnreachableException(base_type.ToString());
}
}
public void Serialize(IO.BitStream s)
{
s.Stream(ref Transparent);
s.Stream(ref Red);
s.Stream(ref Green);
s.Stream(ref Blue);
}
public void Serialize(IO.BitStream s, GameEngineMegaloVariant megalo)
{
megalo.StreamStringTableIndexReference(s, ref NameStringIndex);
megalo.StreamStringTableIndexReference(s, ref DescriptionStringIndex);
s.Stream(ref IsRangeValue);
if (IsRangeValue)
{
s.Stream(ref Value, 10, signExtend: true);
// min, max
if (s.IsReading)
{
ValuesRead(s, megalo, 2, IsRangeValue);
}
else if (s.IsWriting)
{
ValuesWrite(s, megalo, IsRangeValue);
}
}
else
{
megalo.StreamUserDefinedValueIndex(s, ref DefaultValueIndex);
if (s.IsReading)
{
ValuesRead(s, megalo, TypeExtensions.kNone, IsRangeValue);
}
else if (s.IsWriting)
{
int count = Values.Count;
megalo.StreamUserDefinedValuesCount(s, ref count);
ValuesWrite(s, megalo, IsRangeValue);
}
}
}
public void Serialize(IO.BitStream s)
{
s.Stream(ref PlayerRequisitionFrequencySeconds);
s.Stream(ref InitialGameCurrency);
s.StreamElements(RequisitionItems, 7); // 0x26E0 0x26E4
Contract.Assert(RequisitionItems.Count == 0);
}
public void Serialize(IO.BitStream s)
{
using (s.EnterOwnerBookmark(this))
{
s.Stream(ref mEncodingVersion);
if (s.IsReading && !VerifyEncodingVersion())
{
throw new IO.VersionMismatchException("Megalo encoding", (uint)mEncodingVersion);
}
s.Stream(ref EngineVersion); // global, not a c_game_engine_megalo_variant member
s.StreamObject(BaseVariant);
s.StreamElements(PlayerTraits,
MegaloDatabase.Limits.PlayerTraits.CountBitLength,
this, _this => _this.NewMegaloPlayerTraits());
s.StreamElements(UserDefinedOptions,
MegaloDatabase.Limits.UserDefinedOptions.CountBitLength);
s.StreamObject(StringTable);
StreamStringTableIndexPointer(s, ref BaseNameStringIndex);
SerializeDescriptionLocaleStrings(s);
s.StreamNoneable(ref EngineIconIndex,
MegaloDatabase.Limits.EngineCategories.IndexBitLength);
s.StreamNoneable(ref EngineCategory,
MegaloDatabase.Limits.EngineCategories.IndexBitLength);
s.StreamObject(MapPermissions);
s.StreamObject(PlayerRatingParameters);
s.Stream(ref ScoreToWinRound);
SerializeImpl(s);
}
}
protected virtual void SerializeImpl(IO.BitStream s)
{
MegaloVariant.Serialize(s);
s.Stream(ref Flags, 2, GameEngineSandboxVariantFlagsBitStreamer.Instance);
s.Stream(ref EditMode, 1, SandboxEditingModeBitStreamer.Instance);
s.Stream(ref RespawnTime, 6);
EditorTraits.Serialize(s);
}
public override void Serialize(IO.BitStream s)
{
base.Serialize(s);
s.Stream(ref InitialGrenadeCount, 5);
s.Stream(ref PrimaryWeaponSkin, 3);
s.Stream(ref SecondaryWeaponSkin, 3);
}
public override void Serialize(IO.BitStream s)
{
s.Stream(ref Speed, 5);
s.Stream(ref GravityMultiplier, 4);
s.Stream(ref VehicleUsage, 4);
s.Stream(ref DoubleJump, 2);
s.StreamIndexPos(ref JumpMultiplier, 9);
}
public override void Serialize(IO.BitStream s)
{
s.Stream(ref ActiveCamo, 3);
s.Stream(ref Waypoint, 2);
s.Stream(ref GamertagVisible, 2);
s.Stream(ref Aura, 3);
s.Stream(ref ForcedChangeColor, 4);
}
public override void Serialize(IO.BitStream s)
{
base.SerializeFlags(s);
s.Stream(ref RoundTimeLimit);
s.Stream(ref RoundLimit, 5);
s.Stream(ref EarlyVictoryWinCount, 4);
s.StreamNoneable(ref SuddenDeathTimeLimit, 7);
s.Stream(ref GracePeriod, 5);
}
public override void Serialize(IO.BitStream s)
{
Modifiers.Serialize(s);
s.Stream(ref HeadshotImmunity, 2);
s.Stream(ref AssassinationImmunity, 2);
s.Stream(ref Deathless, 2);
s.Stream(ref FastTrackArmor, 2);
s.Stream(ref PowerupCancellation, 2);
}
public override void Serialize(IO.BitStream s)
{
s.Stream(ref TeamScoringMethod, 3); // 0x730
SerializeModelOverride(s);
s.Stream(ref DesignatorSwitchType, 2);
foreach (var opt in mTeams)
{
s.StreamObject(opt);
}
}
public override void Serialize(IO.BitStream s)
{
SerializeFlags(s, 4);
s.StreamObject(NameString);
s.StreamNoneable(ref InitialDesignator, 4);
SerializeModelOverride(s);
s.Stream(ref PrimaryColorOverride);
s.Stream(ref SecondaryColorOverride);
s.Stream(ref TextColorOverride);
s.Stream(ref FireteamCount, 5);
}
public override void Serialize(IO.BitStream s)
{
SerializeFlags(s);
s.StreamObject(BaseTraits);
s.Stream(ref WeaponSet, 8, signExtend: true);
s.Stream(ref VehicleSet, 8, signExtend: true);
s.Stream(ref EquipmentSet, 8, signExtend: true);
foreach (var pu in Powerups)
{
s.StreamObject(pu); // 0x4E0
}
}
protected virtual int SerializeImpl(MegaloScriptModel model, IO.BitStream s)
{
int type = s.IsReading ? TypeExtensions.kNone : ProtoData.DBID;
model.Database.StreamConditionType(s, ref type);
if (type != 0)
{
s.Stream(ref mInverted);
model.StreamLocalUnionGroupIndex(s, ref mUnionGroup);
s.Stream(ref ExecuteBeforeAction, model.Database.Limits.Actions.IndexBitLength);
}
return(type);
}
public override void Serialize(IO.BitStream s)
{
SerializeFlags(s);
s.StreamObject(BaseTraits);
s.Stream(ref WeaponSet, 8, signExtend: true);
s.Stream(ref VehicleSet, 8, signExtend: true);
s.StreamObject(Red);
s.StreamObject(Blue);
s.StreamObject(Yellow);
s.Stream(ref RedDuration, 7); // 0xB8
s.Stream(ref BlueDuration, 7); // 0xB9
s.Stream(ref YellowDuration, 7); // 0xBA
}
public override void Serialize(IO.BitStream s)
{
s.Stream(ref DamageResistance, 4);
s.Stream(ref BodyMultiplier, 3);
s.Stream(ref BodyRechargeRate, 4);
s.Stream(ref ShieldMultiplier, 3);
s.Stream(ref ShieldRechargeRate, 4);
s.Stream(ref OverShieldRechargeRate, 4);
s.Stream(ref HeadshotImmunity, 2);
s.Stream(ref Vampirism, 3);
s.Stream(ref AssassinationImmunity, 2);
s.Stream(ref Deathless, 2);
}
public override void Serialize(MegaloScriptModel model, IO.BitStream s)
{
int encoding_index = ValueType.EncodingIndex;
if (encoding_index.IsNone())
{
s.Stream(ref mValue);
}
else
{
var encoding = model.Database.SingleEncodings[encoding_index];
s.Stream(ref mValue, encoding.Min, encoding.Max, encoding.BitLength, encoding.IsSigned, encoding.Flag1);
}
}
public override void Serialize(IO.BitStream s)
{
base.SerializeFlags(s);
s.Stream(ref RoundTimeLimit);
s.Stream(ref RoundLimit, 5);
s.Stream(ref EarlyVictoryWinCount, 4);
s.Stream(ref KillCamEnabled);
s.Stream(ref PointsSystemEnabled);
s.Stream(ref FinalKillCamEnabled);
s.Stream(ref SuddenDeathTimeLimit, 8);
s.Stream(ref unk0_bit4);
s.Stream(ref unk0_bit5);
s.Stream(ref MoshDifficulty, 2);
}
public void Serialize(IO.BitStream s)
{
s.Stream(ref TimeStamp);
s.Stream(ref Xuid);
if (s.IsWriting && Name_NeedsDevHack)
{
s.Write(kDeveloperNameCode);
}
else
{
s.Stream(ref Name, Memory.Strings.StringStorage.CStringAscii, maxLength: kNameLength - 1);
}
s.Stream(ref IsOnlineId);
}
public override void Serialize(MegaloScriptModel model, IO.BitStream s)
{
s.Stream(ref mExecutionMode, kExecutionModeBitLength, MegaloScriptTriggerExecutionModeBitStreamer.Instance);
s.Stream(ref mTriggerType, kTypeBitLength, MegaloScriptTriggerTypeBitStreamer.Instance);
if (ExecutionMode == MegaloScriptTriggerExecutionMode.OnObjectFilter)
{
model.Database.StreamObjectFilterIndex(s, ref mObjectFilterIndex);
}
else if (ExecutionMode == MegaloScriptTriggerExecutionMode.OnCandySpawnerFilter)
{
s.Stream(ref mGameObjectType, 1, MegaloScriptGameObjectTypeBitStreamer.Instance);
model.Database.StreamGameObjectFilterIndex(s, ref mGameObjectFilterIndex);
}
References.Serialize(model, s);
}
public override void Serialize(MegaloScriptModel model, IO.BitStream s)
{
s.Stream(ref mShapeType, 2, MegaloScriptShapeTypeBitStreamer.Instance);
switch (ShapeType)
{
case MegaloScriptShapeType.Sphere:
mRadius.SerializeCustom(model, s);
break;
case MegaloScriptShapeType.Cylinder:
mRadius.SerializeCustom(model, s);
mTop.SerializeCustom(model, s);
mBottom.SerializeCustom(model, s);
break;
case MegaloScriptShapeType.Box:
mRadius.SerializeCustom(model, s);
mLength.SerializeCustom(model, s);
mTop.SerializeCustom(model, s);
mBottom.SerializeCustom(model, s);
break;
case MegaloScriptShapeType.None: break;
default: throw new KSoft.Debug.UnreachableException(ShapeType.ToString());
}
}
void Serialize(MegaloScriptModel model, IO.BitStream s, Proto.MegaloScriptProtoVariableReference protoType)
{
s.Stream(ref Type, protoType.TypeBitLength);
if (Type < 0 || Type >= protoType.Members.Count)
{
throw new System.IO.InvalidDataException(string.Format(Util.InvariantCultureInfo,
"{0}/{1}: Encountered invalid {2} type data",
s.StreamName, model.MegaloVariant.BaseVariant.Header.Title, mReferenceKind));
}
var member = protoType.Members[Type];
if (member.HasDataType)
{
MegaloScriptEnumValue.SerializeValue(model, s, member.EnumValueType, ref DataType);
}
else
{
DataType = TypeExtensions.kNone;
}
if (member.HasDataValue)
{
SerializeData(model, s, member.ValueType);
}
else
{
Data = TypeExtensions.kNone;
}
}
public override void Serialize(MegaloScriptModel model, IO.BitStream s)
{
s.Stream(ref mIconType, 5, NavpointIconTypeBitStreamer.Instance);
if (mIconType == MegaloScriptNavpointIconType.Territory)
{
mNumeric.SerializeCustom(model, s);
}
}
public virtual void Serialize(IO.BitStream s)
{
var model = (MegaloScriptModel)s.Owner;
model.MegaloVariant.StreamStringTableIndexReference(s, ref mNameStringIndex);
s.Stream(ref mFormat, 2, StatFormatBitStreamer.Instance);
s.Stream(ref mSortOrder, 2, StatSortOrderBitStreamer.Instance);
s.Stream(ref mGrouping, 1, StatGroupingBitStreamer.Instance);
if (SupportsUnk5)
{
s.Stream(ref mUnk5);
}
if (SupportsIsScoreToWin)
{
s.Stream(ref mIsScoreToWin);
}
}
protected virtual void SerializeGameObjectFilters(IO.BitStream s)
{
int game_object_filter_count = s.IsReading ? 0 : CandySpawnerFilters.Count;
s.Stream(ref game_object_filter_count, Database.Limits.GameObjectFilters.CountBitLength);
s.StreamElements(CandySpawnerFilters, Database.Limits.GameObjectFilters.CountBitLength);
Contract.Assert(CandySpawnerFilters.Count == game_object_filter_count);
}
public override void Serialize(IO.BitStream s)
{
SerializeFlags(s, 5);
s.Stream(ref LivesPerRound, 6);
s.Stream(ref TeamLivesPerRound, 7);
s.Stream(ref MinRespawnTime);
s.Stream(ref RespawnTime);
s.Stream(ref SuicideTime);
s.Stream(ref BetrayalTime);
s.Stream(ref RespawnGrowthTime, 4);
s.Stream(ref InitialLoadoutSelectionTime, 4);
s.Stream(ref TraitsDuration, 6);
s.StreamObject(Traits);
}