private static void SyncExtendedPawnData(SyncWorker sync, ref object data)
{
if (sync.isWriting)
{
var id = int.MaxValue;
foreach (DictionaryEntry dictionaryEntry in pawnStorageDictionary(extendedDataStorageInstance))
{
if (dictionaryEntry.Value == data)
{
id = (int)dictionaryEntry.Key;
break;
}
}
sync.Write(id);
}
else
{
var id = sync.Read <int>();
if (id != int.MaxValue && thingsById.TryGetValue(id, out var thing) && thing is Pawn)
{
data = getExtendedDataForPawnMethod.Invoke(extendedDataStorageInstance, new object[] { thing });
}
}
}
private static void SyncFacepaintCombination(SyncWorker sync, ref object obj)
{
var defs = (IList)orderedFacepaintDefsField.GetValue(null);
if (sync.isWriting)
{
sync.Write((Color)facepaintColourOneField.GetValue(obj));
sync.Write((Color)facepaintColourTwoField.GetValue(obj));
sync.Write(defs.IndexOf(facepaintDefOneField.GetValue(obj)));
sync.Write(defs.IndexOf(facepaintDefTwoField.GetValue(obj)));
}
else
{
facepaintColourOneField.SetValue(obj, sync.Read <Color>());
facepaintColourTwoField.SetValue(obj, sync.Read <Color>());
int index = sync.Read <int>();
if (index >= 0)
{
facepaintDefOneField.SetValue(obj, defs[index]);
}
index = sync.Read <int>();
if (index >= 0)
{
facepaintDefTwoField.SetValue(obj, defs[index]);
}
}
}
// Token: 0x0600008A RID: 138 RVA: 0x00007634 File Offset: 0x00005834
private static void SyncWriterForDRSettings(SyncWorker sync, ref DRSettings dRSettings)
{
if (!sync.isWriting)
{
dRSettings = Find.World.GetComponent <DRSettings>();
}
}
static void ProxySyncer(SyncWorker sync, ref ExtendedOutfitProxy proxy)
{
if (!sync.isWriting)
{
proxy = Instance;
}
}
private static void SyncSurrogateToHackDesignator(SyncWorker sync, ref Designator designator)
{
if (sync.isWriting)
{
sync.Write((byte)surrogateToHackHackTypeField(designator));
sync.Write(surrogateToHackTargetField(designator));
var map = surrogateToHackMapField(designator);
// Looks like the map and cell are set in only one method, which is never called
// so we'll most likely end up never syncing them. I'm leaving it for safety, though.
if (map == null)
{
sync.Write(IntVec3.Invalid);
}
else
{
sync.Write(surrogateToHackPosField(designator));
sync.Write(map);
}
}
else
{
designator = (Designator)surrogateToHackConstructor.Invoke(new object[] { (int)sync.Read <byte>() });
surrogateToHackTargetField(designator) = sync.Read <Pawn>();
var pos = sync.Read <IntVec3>();
if (pos.IsValid)
{
surrogateToHackPosField(designator) = pos;
surrogateToHackMapField(designator) = sync.Read <Map>();
}
}
}
private static void SyncColor(SyncWorker sync, ref Color color)
{
sync.Bind(ref color.r);
sync.Bind(ref color.g);
sync.Bind(ref color.b);
sync.Bind(ref color.a);
}
private static void SyncDialogChoosePower(SyncWorker sync, ref Window window)
{
if (!sync.isWriting)
{
window = currentDialog ?? Find.WindowStack.windows.FirstOrDefault(x => x.GetType() == choosePowerDialogType);
}
}
// Used for syncing inner, compiler-generated class inside of TempleCardUtility
private static void SyncTemplaCardUtilityInnerClass(SyncWorker sync, object obj)
{
if (sync.isWriting)
{
var altar = templeCardUtilityInnerAltarField(obj) as Building;
var sermon = templeCardUtilityInnerSermonField(obj);
if (TryGetDataForSermon(sermon, altar, out var index))
{
sync.Write(index);
sync.Write(altar);
}
else
{
sync.Write(-1);
}
}
else
{
var index = sync.Read <int>();
if (index >= 0)
{
var altar = sync.Read <Building>();
templeCardUtilityInnerAltarField(obj) = altar;
templeCardUtilityInnerSermonField(obj) = GetSermon(altar, index);
}
}
}
// Sync the religious riot dialog
// It should open up for all players, so we just get it from the WindowStack
private static void SyncReligiousRiotDialog(SyncWorker sync, ref Window obj)
{
if (!sync.isWriting)
{
obj = Find.WindowStack.Windows.First(x => x.GetType() == religiousRiotType);
}
}
// Sync worker for the Dialog_AssignPreacher (and Dialog_AssignAssistant, as it's implicit worker)
private static void SyncDialogAssignPreacher(SyncWorker sync, ref Window obj)
{
if (sync.isWriting)
{
var sermon = assignPreacherSermonField(obj);
var altar = assignPreacherAltarField(obj) as Building;
if (TryGetDataForSermon(sermon, altar, out var index))
{
sync.Write(index);
sync.Write(altar);
sync.Write(obj.GetType() == assignPreacherType);
}
else
{
sync.Write(-1);
}
}
else
{
var index = sync.Read <int>();
if (index >= 0)
{
var altar = sync.Read <Building>();
var sermon = GetSermon(altar, index);
var type = sync.Read <bool>() ? assignPreacherType : assignAssistantType;
obj = Activator.CreateInstance(type, altar, sermon) as Window;
}
}
}
private static void SyncManagedVerb(SyncWorker sync, ref object obj)
{
if (sync.isWriting)
{
// Get the VerbManager from inside of the ManagedVerb itself
var verbManager = mvcfManagerVerbManagerField.GetValue(obj);
// Find the ManagedVerb inside of list of all verbs
var managedVerbsList = mvcfVerbsField.GetValue(verbManager) as IList;
var index = managedVerbsList.IndexOf(obj);
// Sync the index of the verb as well as the manager (if it's valid)
sync.Write(index);
if (index >= 0)
{
SyncVerbManager(sync, ref verbManager);
}
}
else
{
// Read and check if the index is valid
var index = sync.Read <int>();
if (index >= 0)
{
// Read the verb manager
object verbManager = null;
SyncVerbManager(sync, ref verbManager);
// Find the ManagedVerb with specific index inside of list of all verbs
var managedVerbsList = mvcfVerbsField.GetValue(verbManager) as IList;
obj = managedVerbsList[index];
}
}
}
private static void SyncVerbManager(SyncWorker sync, ref object obj)
{
if (sync.isWriting)
{
// Sync the pawn that has the VerbManager
sync.Write((Pawn)mvcfPawnGetter.Invoke(obj, Array.Empty <object>()));
}
else
{
var pawn = sync.Read <Pawn>();
var comp = mvcfGetWorldCompMethod.Invoke(null, Array.Empty <object>());
var weakTable = mvcfManagersTableField.GetValue(comp);
var outParam = new object[] { pawn, null };
// Either try getting the VerbManager from the comp, or create it if it's missing
if ((bool)conditionalWeakTableTryGetValueMethod.Invoke(weakTable, outParam))
{
obj = outParam[1];
}
else
{
obj = InitVerbManager(pawn, (WorldComponent)comp, table: weakTable);
}
}
}
private static void SyncInnerClassWithPawn(SyncWorker sync, ref object inner)
{
var traverse = Traverse.Create(inner);
if (sync.isWriting)
{
var comp = (ThingComp)traverse.Field("<>4__this").GetValue();
var pawn = (Pawn)traverse.Field("p").GetValue();
sync.Write(comp);
sync.Write(pawn.thingIDNumber);
}
else
{
var comp = sync.Read <ThingComp>();
var id = sync.Read <int>();
var pawn = GetPawnFromComp(comp, id);
traverse.Field("<>4__this").SetValue(comp);
if (pawn != null)
{
traverse.Field("p").SetValue(pawn);
}
}
}
private static void SyncFormTrackerInnerClass(SyncWorker sync, ref object inner)
{
if (sync.isWriting)
{
var tracker = innerClassParentField(inner);
var comp = formTrackerCompField(tracker);
sync.Write(comp);
var formList = propsFormsListField(comp.props);
var index = formList.IndexOf(innerClassFormField(inner));
sync.Write(index);
}
else
{
var comp = sync.Read <ThingComp>();
var tracker = pokemonFormTrackerField(comp);
innerClassParentField(inner) = tracker;
var index = sync.Read <int>();
if (index >= 0)
{
var formList = propsFormsListField(comp.props);
innerClassFormField(inner) = formList[index];
}
}
}
private static void ManagerSyncer(SyncWorker sync, ref DefensivePositionsManager inst)
{
if (!sync.isWriting)
{
inst = DefensivePositionsManager.Instance;
}
}
private static void SquadHandlerSyncer(SyncWorker sync, ref PawnSquadHandler inst)
{
if (!sync.isWriting)
{
inst = DefensivePositionsManager.Instance.squadHandler;
}
}
public bool Invoke(SyncWorker worker, ref object obj)
{
if (parent != null)
{
parent.Invoke(worker, ref obj);
}
for (int i = 0; i < syncWorkers.Count; i++)
{
if (syncWorkers[i](worker, ref obj))
{
return(true);
}
if (worker is ReadingSyncWorker reader)
{
reader.Reset();
}
else if (worker is WritingSyncWorker writer)
{
writer.Reset();
}
}
return(false);
}
private static void SyncSetIngredientCommand(SyncWorker sync, ref Command command)
{
var traverse = Traverse.Create(command);
var building = traverse.Field("building");
var ingredientList = traverse.Field("things");
if (sync.isWriting)
{
sync.Write(building.GetValue() as Thing);
var list = ingredientList.GetValue() as List <Thing>;
sync.Write(list.Count);
foreach (var item in list)
{
sync.Write(item as Thing);
}
}
else
{
building.SetValue(sync.Read <Thing>());
int count = sync.Read <int>();
var list = new List <Thing>(count);
for (int i = 0; i < count; i++)
{
list.Add(sync.Read <Thing>());
}
ingredientList.SetValue(list);
}
}
// All the following is for the tiny lock of doom
static void SyncWorkerForSwapControlsHandler(SyncWorker sync, ref object obj)
{
Pawn pawn = null;
if (sync.isWriting)
{
pawn = (Pawn)SwapControlsHandler_PawnProperty.GetValue(obj, new object[] { });
// If Pawn is null, it was saved and got deleted.
if (pawn == null)
{
sync.Write(false);
// Must use more reflection to traverse SimpleSidearms.saveData.handlers
// This will desync if unhandled :(
throw new ArgumentException("About to desync, tiny lock of doom triggered. Refusing to comply");
}
else
{
sync.Write(true);
sync.Write(pawn);
}
}
else
{
bool exists = sync.Read <bool>();
if (exists)
{
pawn = sync.Read <Pawn>();
obj = SwapControlsHandler_GetHandlerForPawnMethod.Invoke(null, new object[] { pawn });
}
}
}
private static void SyncWarcasketCustomizationDialog(SyncWorker sync, ref Window dialog)
{
if (!sync.isWriting)
{
dialog = Find.WindowStack.Windows.FirstOrDefault(w => w.GetType() == warcasketDialogType);
}
}
private static void SyncHediffDialog(SyncWorker sync, ref Window window)
{
if (!sync.isWriting)
{
window = Find.WindowStack.Windows.FirstOrDefault(x => x.GetType() == hediffSelectionDialogType);
}
}
private static void SyncPsykerDisciplineWindowAny(SyncWorker sync, ref object obj, Type windowType)
{
if (sync.isWriting)
{
sync.Write((ThingComp)psykerDisciplineWindowCompField.GetValue(obj));
sync.Write(((Def)psykerDisciplineWindowSelectedDefField.GetValue(obj)).shortHash);
}
else
{
var comp = sync.Read <ThingComp>();
var hash = sync.Read <ushort>();
var def = getDefByShortHash.Invoke(null, new object[] { hash });
// If the window exists, we try to find a window for the discipline field for that pawn
obj = Find.WindowStack.Windows.FirstOrDefault(x => x.GetType() == windowType && (ThingComp)psykerDisciplineWindowCompField.GetValue(x) == comp);
// If a specific player doesn't have the psyker menu open we'll have null here, we need to create it for our synced method
if (obj == null)
{
// The Window_Psyker is needed for constructor and the synced method
// It won't really do anything useful, but is needed
var psykerWindow = Activator.CreateInstance(psykerWindowType, comp);
obj = Activator.CreateInstance(windowType, comp, psykerWindow);
}
// Set the def to the correct one (someone might have another one selected, so make sure the same one is picked for everyone)
psykerDisciplineWindowSelectedDefField.SetValue(obj, def);
}
}
private static void SyncZoneData(SyncWorker sync, ref object zoneData)
{
if (sync.isWriting)
{
int?id = null;
var comp = compCache[Find.CurrentMap];
var zoneRegistry = growZoneRegistryField(comp);
foreach (DictionaryEntry entry in zoneRegistry)
{
if (entry.Value == zoneData)
{
id = (int)entry.Key;
break;
}
}
sync.Write(id);
if (id != null)
{
sync.Write(Find.CurrentMap);
}
}
else
{
var id = sync.Read <int?>();
if (id != null)
{
var comp = compCache[sync.Read <Map>()];
var zoneRegistry = growZoneRegistryField(comp);
zoneData = zoneRegistry[id.Value];
}
}
}
private static void SyncSetIngredientCommand(SyncWorker sync, ref Command command)
{
var traverse = Traverse.Create(command);
var building = traverse.Field("building");
var ingredientList = traverse.Field("things");
if (sync.isWriting)
{
sync.Write(building.GetValue() as Thing);
var ingredientListValue = ingredientList.GetValue();
if (ingredientListValue == null)
{
sync.Write(false);
}
else
{
sync.Write(true);
sync.Write(ingredientList.GetValue() as List <Thing>);
}
}
else
{
building.SetValue(sync.Read <Thing>());
if (sync.Read <bool>())
{
ingredientList.SetValue(sync.Read <List <Thing> >());
}
}
}
static void SyncLearnPsycasts(SyncWorker sync, ref Command_Action command)
{
if (sync.isWriting) {
sync.Write(levelField(command));
sync.Write(parentField(command));
} else {
command = (Command_Action) Activator.CreateInstance(learnPsycastsType, sync.Read<int>(), sync.Read<Pawn>());
}
}
//[SyncWorker(shouldConstruct = false)]
public static void SyncKanbanSettings(SyncWorker sync, ref KanbanSettings ks)
{
sync.Bind(ref ks.srt);
sync.Bind(ref ks.ssl);
//if (sync.isWriting) {
// sync.Write(ks);
//} else {
// ks = sync.Read<KanbanSettings>();
//}
}
private static void PawnHandlerSyncer(SyncWorker sync, ref PawnSavedPositionHandler inst)
{
var ownerPawn = inst?.Owner;
sync.Bind(ref ownerPawn);
if (!sync.isWriting && ownerPawn != null)
{
inst = DefensivePositionsManager.Instance.GetHandlerForPawn(ownerPawn);
}
}
private static void SyncDialog(SyncWorker sync, ref Window dialog)
{
if (!sync.isWriting)
{
if (Find.WindowStack.IsOpen(changeFacepaintDialogType))
{
dialog = Find.WindowStack.Windows.First(x => x.GetType() == changeFacepaintDialogType);
}
}
}
private static void SyncToggleCommand(SyncWorker sync, ref Command_Toggle command)
{
if (sync.isWriting)
{
sync.Write(parentCompGetter.Invoke(command, Array.Empty <object>()) as ThingComp);
}
else
{
command = Activator.CreateInstance(commandType, sync.Read <ThingComp>()) as Command_Toggle;
}
}
private static void SyncComp(SyncWorker sync, ref ThingComp thing)
{
if (sync.isWriting)
{
sync.Write <Thing>(thing.parent);
}
else
{
thing = (ThingComp)getCompUnlockerCheckerMethod.Invoke(null, new object[] { sync.Read <Thing>(), false, false });
}
}
