public static List <AbilityTarget> DeSerializeAbilityTargetList(
IBitStream stream)
{
var abilityTargetList = new List <AbilityTarget>();
byte num1 = 0;
stream.Serialize(ref num1);
for (var index = 0; index < (int)num1; ++index)
{
short num2 = -1;
short num3 = -1;
var zero1 = Vector3.Zero;
var zero2 = Vector3.Zero;
stream.Serialize(ref num2);
stream.Serialize(ref num3);
stream.Serialize(ref zero1);
stream.Serialize(ref zero2);
var abilityTarget = new AbilityTarget(new GridPos(
num2,
num3,
-1 // TODO: (int) Board.\u000E().\u000E((int) num2, (int) num3)
), zero2, zero1);
abilityTargetList.Add(abilityTarget);
}
return(abilityTargetList);
}
private bool OnSerializeHelper(IBitStream stream, bool initialState)
{
if (!initialState && m_serializeHelper.ShouldReturnImmediately(ref stream))
{
return(false);
}
int turnToUpdate = m_turnToUpdate;
stream.Serialize(ref turnToUpdate);
bool flag1 = turnToUpdate != m_turnToUpdate;
m_turnToUpdate = turnToUpdate;
int phaseToUpdate = (int)m_phaseToUpdate;
stream.Serialize(ref phaseToUpdate);
bool flag2 = m_phaseToUpdate != (AbilityPriority)phaseToUpdate;
if (flag2 || flag1)
{
m_phaseToUpdate = (AbilityPriority)phaseToUpdate;
m_phaseStartTime = Time.time;
if (flag1)
{
m_turn = new Turn();
}
}
m_turn.OnSerializeHelper(stream);
if (flag2)
{
m_turn.UnknownMethod(m_phaseToUpdate);
}
return(m_serializeHelper.End(initialState, syncVarDirtyBits));
}
public void SerializeToStream(ref IBitStream stream)
{
sbyte triggeringMoverActorIndex = (sbyte)m_triggeringMover.ActorIndex;
stream.Serialize(ref triggeringMoverActorIndex);
MovementUtils.SerializeLightweightPath(m_triggeringPath, stream);
AbilityResultsUtils.SerializeSequenceStartDataListToStream(ref stream, m_seqStartDataList);
if (m_effectResults != null)
{
sbyte responseType = (sbyte)MovementResults_GameplayResponseType.Effect;
stream.Serialize(ref responseType);
m_effectResults.SerializeToStream(ref stream);
}
else if (m_barrierResults != null)
{
sbyte responseType = (sbyte)MovementResults_GameplayResponseType.Barrier;
stream.Serialize(ref responseType);
m_barrierResults.SerializeToStream(ref stream);
}
else if (m_powerupResults != null)
{
sbyte responseType = (sbyte)MovementResults_GameplayResponseType.Powerup;
stream.Serialize(ref responseType);
m_powerupResults.SerializeToStream(ref stream);
}
else if (m_gameModeResults != null)
{
sbyte responseType = (sbyte)MovementResults_GameplayResponseType.GameMode;
stream.Serialize(ref responseType);
m_gameModeResults.SerializeToStream(ref stream);
}
}
public void SerializeToStream(ref IBitStream stream)
{
int barrierGUID = m_barrierGUID;
sbyte casterIndex = (sbyte)m_barrierCaster.ActorIndex;
stream.Serialize(ref barrierGUID);
stream.Serialize(ref casterIndex);
AbilityResultsUtils.SerializeActorHitResultsDictionaryToStream(ref stream, m_actorToHitResults);
AbilityResultsUtils.SerializePositionHitResultsDictionaryToStream(ref stream, m_posToHitResults);
}
public void OnSerializeHelper(IBitStream stream)
{
var dir = m_dir;
var freePos = m_freePos;
m_gridPos.OnSerializeHelper(stream);
stream.Serialize(ref dir);
stream.Serialize(ref freePos);
m_dir = dir;
m_freePos = freePos;
}
public void SerializeToStream(ref IBitStream stream)
{
sbyte casterActorIndex = (sbyte)GetCaster().ActorIndex;
sbyte abilityAction = (sbyte)GetSourceActionType();
stream.Serialize(ref casterActorIndex);
stream.Serialize(ref abilityAction);
AbilityResultsUtils.SerializeSequenceStartDataListToStream(ref stream, m_seqStartDataList);
AbilityResultsUtils.SerializeActorHitResultsDictionaryToStream(ref stream, m_actorToHitResults);
AbilityResultsUtils.SerializePositionHitResultsDictionaryToStream(ref stream, m_posToHitResults);
}
public static void SerializeIntListToStream(ref IBitStream stream, List <int> list)
{
sbyte num = (sbyte)list.Count;
stream.Serialize(ref num);
for (int i = 0; i < num; i++)
{
int id = list[i];
stream.Serialize(ref id);
}
}
public static void SerializePositionHitResultsDictionaryToStream(ref IBitStream stream, Dictionary <Vector3, ClientPositionHitResults> dictionary)
{
sbyte hitResultNum = (sbyte)dictionary.Count;
stream.Serialize(ref hitResultNum);
foreach (var e in dictionary)
{
Vector3 pos = e.Key;
stream.Serialize(ref pos);
e.Value.SerializeToStream(ref stream);
}
}
public static void SerializePowerupsToStealToStream(ref IBitStream stream, List <ClientPowerupStealData> list)
{
sbyte num = (sbyte)list.Count;
stream.Serialize(ref num);
for (int i = 0; i < num; i++)
{
int powerupGUID = list[i].m_powerupGuid;
stream.Serialize(ref powerupGUID);
list[i].m_powerupResults.SerializeToStream(ref stream);
}
}
public static void SerializeActorHitResultsDictionaryToStream(ref IBitStream stream, Dictionary <ActorData, ClientActorHitResults> dictionary)
{
sbyte hitResultNum = (sbyte)dictionary.Count;
stream.Serialize(ref hitResultNum);
foreach (var e in dictionary)
{
sbyte actorIndex = (sbyte)e.Key.ActorIndex;
stream.Serialize(ref actorIndex);
e.Value.SerializeToStream(ref stream);
}
}
public void OnSerializeHelper(IBitStream stream)
{
var valid = m_valid;
var id = m_id;
var connectionId = checked ((sbyte)m_connectionId);
stream.Serialize(ref valid);
stream.Serialize(ref id);
stream.Serialize(ref connectionId);
m_valid = valid;
m_id = id;
m_connectionId = connectionId;
}
public void OnSerializeHelper(IBitStream stream)
{
var x = X;
var y = Y;
var height = Height;
stream.Serialize(ref x);
stream.Serialize(ref y);
stream.Serialize(ref height);
X = x;
Y = y;
Height = height;
}
public void SerializeToStream(ref IBitStream stream)
{
uint effectGUID = (uint)m_effectGUID;
sbyte casterActorIndex = (sbyte)m_effectCaster.ActorIndex;
sbyte sourceAbilityActionType = (sbyte)m_sourceAbilityActionType;
stream.Serialize(ref effectGUID);
stream.Serialize(ref casterActorIndex);
stream.Serialize(ref sourceAbilityActionType);
AbilityResultsUtils.SerializeSequenceStartDataListToStream(ref stream, m_seqStartDataList);
AbilityResultsUtils.SerializeActorHitResultsDictionaryToStream(ref stream, m_actorToHitResults);
AbilityResultsUtils.SerializePositionHitResultsDictionaryToStream(ref stream, m_posToHitResults);
}
public static ClientBarrierResults DeSerializeClientBarrierResultsFromStream(Component context,
ref IBitStream stream)
{
var barrierGUID = -1;
sbyte invalidActorIndex = (sbyte)ActorData.s_invalidActorIndex;
stream.Serialize(ref barrierGUID);
stream.Serialize(ref invalidActorIndex);
var actorToHitResults = DeSerializeActorHitResultsDictionaryFromStream(context, ref stream);
var posToHitResults = DeSerializePositionHitResultsDictionaryFromStream(context, ref stream);
ActorData actorByActorIndex = context.GameFlowData.FindActorByActorIndex(invalidActorIndex);
return(new ClientBarrierResults(barrierGUID, actorByActorIndex, actorToHitResults, posToHitResults));
}
public static ClientAbilityResults DeSerializeClientAbilityResultsFromStream(Component context,
ref IBitStream stream)
{
sbyte invalidActorIndex = (sbyte)ActorData.s_invalidActorIndex;
sbyte num = -1;
stream.Serialize(ref invalidActorIndex);
stream.Serialize(ref num);
var seqStartDataList = DeSerializeSequenceStartDataListFromStream(ref stream);
var actorToHitResults = DeSerializeActorHitResultsDictionaryFromStream(context, ref stream);
var posToHitResults = DeSerializePositionHitResultsDictionaryFromStream(context, ref stream);
return(new ClientAbilityResults(context, invalidActorIndex, num, seqStartDataList, actorToHitResults,
posToHitResults));
}
public static List <int> DeSerializePowerupsToRemoveFromStream(ref IBitStream stream)
{
var intList = new List <int>();
sbyte num1 = 0;
stream.Serialize(ref num1);
for (var index = 0; index < (int)num1; ++index)
{
var num2 = 0;
stream.Serialize(ref num2);
intList.Add(num2);
}
return(intList);
}
public static List <int> DeSerializeClientOverconListFromStream(ref IBitStream stream)
{
var intList = new List <int>();
sbyte num1 = 0;
stream.Serialize(ref num1);
for (var index = 0; index < (int)num1; ++index)
{
var num2 = -1;
stream.Serialize(ref num2);
intList.Add(num2);
}
return(intList);
}
public void ClientResolutionAction_SerializeToStream(ref IBitStream stream)
{
sbyte actionType = (sbyte)m_type;
stream.Serialize(ref actionType);
switch (m_type)
{
case ResolutionActionType.AbilityCast:
m_abilityResults.SerializeToStream(ref stream);
break;
case ResolutionActionType.EffectAnimation:
case ResolutionActionType.EffectPulse:
m_effectResults.SerializeToStream(ref stream);
break;
case ResolutionActionType.EffectOnMove:
case ResolutionActionType.BarrierOnMove:
case ResolutionActionType.PowerupOnMove:
case ResolutionActionType.GameModeOnMove:
m_moveResults.SerializeToStream(ref stream);
break;
}
}
public static List <int> DeSerializeBarriersForRemovalFromStream(ref IBitStream stream)
{
sbyte num1 = 0;
stream.Serialize(ref num1);
var intList = new List <int>(num1);
for (var index = 0; index < (int)num1; ++index)
{
var num2 = -1;
stream.Serialize(ref num2);
intList.Add(num2);
}
return(intList);
}
// public SequenceEndData(
// GameObject prefabToEnd,
// AssociationType associationType,
// int guid,
// Vector3 targetPos)
// {
// m_prefabId = SequenceLookup.Get().GetSequenceIdOfPrefab(prefabToEnd);
// m_associationType = associationType;
// m_association = (uint) Mathf.Max(0, guid);
// m_targetPos = targetPos;
// }
public void SequenceEndData_SerializeToStream(ref IBitStream stream)
{
sbyte associationType = (sbyte)m_associationType;
stream.Serialize(ref m_prefabId);
stream.Serialize(ref associationType);
stream.Serialize(ref m_association);
bool flag = m_targetPos != Vector3.Zero;
stream.Serialize(ref flag);
if (!flag)
{
return;
}
stream.Serialize(ref m_targetPos);
}
public static ClientResolutionAction ClientResolutionAction_DeSerializeFromStream(Component context, ref IBitStream stream)
{
ClientResolutionAction resolutionAction = new ClientResolutionAction();
sbyte num = -1;
stream.Serialize(ref num);
ResolutionActionType resolutionActionType = (ResolutionActionType)num;
resolutionAction.m_type = (ResolutionActionType)num;
switch (resolutionActionType)
{
case ResolutionActionType.AbilityCast:
resolutionAction.m_abilityResults =
AbilityResultsUtils.DeSerializeClientAbilityResultsFromStream(context, ref stream);
break;
case ResolutionActionType.EffectAnimation:
case ResolutionActionType.EffectPulse:
resolutionAction.m_effectResults =
AbilityResultsUtils.DeSerializeClientEffectResultsFromStream(context, ref stream);
break;
case ResolutionActionType.EffectOnMove:
case ResolutionActionType.BarrierOnMove:
case ResolutionActionType.PowerupOnMove:
case ResolutionActionType.GameModeOnMove:
resolutionAction.m_moveResults =
AbilityResultsUtils.DeSerializeClientMovementResultsFromStream(context, ref stream);
break;
}
return(resolutionAction);
}
public void SerializeToStream(ref IBitStream stream)
{
AbilityResultsUtils.SerializeSequenceStartDataListToStream(ref stream, m_seqStartDataList);
m_effectResults.SerializeToStream(ref stream);
byte extraFlags = GetExtraFlags();
stream.Serialize(ref extraFlags);
}
public static void SerializeAbilityTargetList(List <AbilityTarget> targetList, IBitStream stream)
{
var count = checked ((byte)targetList.Count);
stream.Serialize(ref count);
foreach (var target in targetList)
{
var x = checked ((short)target.GridPos.X);
var y = checked ((short)target.GridPos.Y);
var dir = target.m_dir;
var freePos = target.m_freePos;
stream.Serialize(ref x);
stream.Serialize(ref y);
stream.Serialize(ref dir);
stream.Serialize(ref freePos);
}
}
public static ClientGameModeEvent DeSerializeClientGameModeEventFromStream(Component context,
ref IBitStream stream)
{
sbyte num1 = 0;
byte objectGuid = 0;
sbyte num2 = 0;
sbyte num3 = 0;
sbyte num4 = -1;
sbyte num5 = -1;
var eventGuid = 0;
stream.Serialize(ref num1);
stream.Serialize(ref objectGuid);
stream.Serialize(ref num2);
stream.Serialize(ref num3);
stream.Serialize(ref num4);
stream.Serialize(ref num5);
stream.Serialize(ref eventGuid);
var eventType = (GameModeEventType)num1;
var square = num4 != (sbyte)-1 || num5 != (sbyte)-1
? context.Board.method_10(num4, num5)
: null;
var primaryActor = (int)num2 != ActorData.s_invalidActorIndex
? context.GameFlowData.FindActorByActorIndex(num2)
: null;
var secondaryActor = (int)num3 != ActorData.s_invalidActorIndex
? context.GameFlowData.FindActorByActorIndex(num3)
: null;
return(new ClientGameModeEvent(eventType, objectGuid, square, primaryActor, secondaryActor, eventGuid));
}
public void OnSerializeHelper(IBitStream _param1)
{
int turnId = TurnID;
_param1.Serialize(ref turnId);
TurnID = turnId;
sbyte count = (sbyte)u000E.Count;
_param1.Serialize(ref count);
for (int index = 0; index < (int)count; ++index)
{
while (index >= u000E.Count)
{
u000E.Add(new Phase(this));
}
u000E[index].u001C(_param1);
}
}
public static Dictionary <Vector3, ClientPositionHitResults> DeSerializePositionHitResultsDictionaryFromStream(
Component context, ref IBitStream stream)
{
sbyte num = 0;
stream.Serialize(ref num);
var dictionary = new Dictionary <Vector3, ClientPositionHitResults>(num);
for (var index = 0; index < (int)num; ++index)
{
var zero = Vector3.Zero;
stream.Serialize(ref zero);
var positionHitResults = new ClientPositionHitResults(context, ref stream);
dictionary.Add(zero, positionHitResults);
}
return(dictionary);
}
public static SequenceEndData SequenceEndData_DeserializeFromStream(
ref IBitStream stream)
{
short num1 = -1;
uint num2 = 0;
sbyte num3 = -1;
bool flag = false;
Vector3 zero = Vector3.Zero;
stream.Serialize(ref num1);
stream.Serialize(ref num3);
stream.Serialize(ref num2);
stream.Serialize(ref flag);
if (flag)
{
stream.Serialize(ref zero);
}
return(new SequenceEndData(num1, (AssociationType)num3, (int)num2, zero));
}
public static void SerializeClientMovementResultsListToStream(ref IBitStream stream, List <ClientMovementResults> list)
{
sbyte num = (sbyte)list.Count;
stream.Serialize(ref num);
for (int i = 0; i < num; i++)
{
list[i].SerializeToStream(ref stream);
}
}
public static void SerializeClientGameModeEventListToStream(ref IBitStream stream, List <ClientGameModeEvent> list)
{
sbyte num = (sbyte)list.Count;
stream.Serialize(ref num);
for (int i = 0; i < num; i++)
{
SerializeClientGameModeEventToStream(ref stream, list[i]);
}
}
public static void SerializeBarriersToStartToStream(ref IBitStream stream, List <ClientBarrierStartData> barrierStartList)
{
sbyte barrierStartNum = (sbyte)barrierStartList.Count;
stream.Serialize(ref barrierStartNum);
for (int i = 0; i < barrierStartNum; i++)
{
ClientBarrierStartData clientBarrierStartData = barrierStartList[i];
BarrierSerializeInfo info = clientBarrierStartData.m_barrierGameplayInfo;
BarrierSerializeInfo.SerializeBarrierInfo(stream, ref info);
sbyte seqenceStartNum = (sbyte)clientBarrierStartData.m_sequenceStartDataList.Count;
stream.Serialize(ref seqenceStartNum);
for (int j = 0; j < seqenceStartNum; j++)
{
clientBarrierStartData.m_sequenceStartDataList[j].SequenceStartData_SerializeToStream(ref stream);
}
}
}