static void Postfix(ItemPutInfo info, ref bool __result)
{
if (!__result)
{
Dbgl($"couldn't put down unit");
}
}
static void Prefix(Region __instance, Unit unit, ItemPutInfo info, ItemObject item, bool immobile, HomeRegionType ___regionType, int fromArchive = -1)
{
if (!enabled || ___regionType != HomeRegionType.Farm || __instance.IsValidCell(info.cellIndex))
{
return;
}
ItemHomeSystemUnitCmpt component = item.GetComponent <ItemHomeSystemUnitCmpt>();
Area area = Module <UnitFactory> .Self.GetArea(info.cellIndex, info.areaRot, component, component.Rotate > 0, fromArchive);
Slot slot = new Slot
{
unit = unit,
info = info,
immobile = immobile,
unitObjInfo = new UnitObjInfo(item, area)
};
if (outsideUnits.ContainsKey(info.cellIndex))
{
outsideUnits[info.cellIndex] = slot;
}
else
{
outsideUnits.Add(info.cellIndex, slot);
}
}
static void Postfix(RegionViewer __instance, ItemPutInfo info, ref Transform transform)
{
if (!enabled || Module <ScenarioModule> .Self.CurrentScenarioName != "Main" || !(__instance is FarmViewer) || !outsideUnits.ContainsKey(info.cellIndex))
{
return;
}
Vector3 vector = GetValidPos(transform.position);
if (vector != Vector3.zero)
{
transform.position = vector;
}
}
static bool Prefix(Unit item, ref ItemPutInfo __result, HomeRegionType ___regionType)
{
if (!enabled || ___regionType != HomeRegionType.Farm)
{
return(true);
}
Slot slot = outsideUnits.Values.ToList().Find((Slot e) => e.unit == item);
if (slot != null)
{
Dbgl($"Got outside put info");
__result = slot.info;
return(false);
}
return(true);
}
static bool Prefix(Unit unit)
{
if (!enabled)
{
return(true);
}
if (Module <TakeHomeItemModule> .Self.IsTaking)
{
return(false);
}
Slot slot = outsideUnits.Values.ToList().Find((Slot e) => e.unit == unit);
if (slot == null)
{
return(true);
}
Dbgl("taking up outside item");
ItemPutInfo putInfoByUnit = slot.info;
ItemObject itemByCellIndex = slot.unitObjInfo.Item;
string resPath = itemByCellIndex.ItemBase.GetMountData().resPath;
LayeredRegion layeredRegion = (LayeredRegion)typeof(FarmModule).GetField("layeredRegion", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(Module <FarmModule> .Self);
Region itemLayer = (Region)typeof(LayeredRegion).GetField("itemLayer", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(layeredRegion);
var mySlot = AccessTools.FieldRefAccess <Region, List <object> >(itemLayer, "slots").Find((object o) => typeof(Region).GetNestedType("Slot", BindingFlags.NonPublic | BindingFlags.Instance).GetField("unit").GetValue(o) == slot.unit);
UnitHandle unitHandle = (UnitHandle)mySlot;
if (unitHandle != null)
{
typeof(Region).GetMethod("RemoveSlot", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(itemLayer, new object[] { mySlot });
Dbgl("unit handle is not null");
Module <TakeHomeItemModule> .Self.TakeUp(new HomeItemThing(true, string.Empty, putInfoByUnit, unitHandle, resPath, itemByCellIndex));
}
return(false);
}
static bool Prefix(RegionViewer __instance, string path, Area area, ItemPutInfo info, ref GameObject __result, bool isFloorLayer)
{
if (!enabled || Module <ScenarioModule> .Self.CurrentScenarioName != "Main" || !outsideUnits.ContainsKey(info.cellIndex))
{
return(true);
}
GameObject gameObject = (GameObject)typeof(RegionViewer).GetMethod("CreateGameObj", BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { typeof(string) }, new ParameterModifier[0]).Invoke(__instance, new object[] { path });
typeof(RegionViewer).GetMethod("FreshLocalPosition", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(__instance, new object[] { gameObject.transform, info, area });
typeof(RegionViewer).GetMethod("FreshLocalRotation", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(__instance, new object[] { gameObject.transform, info });
UnitViewer unitViewer = gameObject.GetComponentInChildren <UnitViewer>();
if (unitViewer == null)
{
unitViewer = gameObject.AddComponent <UnitViewer>();
}
if (unitViewer != null)
{
Unit unitByCell = outsideUnits[info.cellIndex].unit;
unitViewer.SetUnit(unitByCell);
typeof(RegionViewer).GetMethod("SetRegionName", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(__instance, new object[] { unitViewer });
if (!unitByCell.immobile && !(unitByCell is FloorCell))
{
MethodInfo method = __instance.GetType().GetMethod("TakeUpHomeItem", BindingFlags.NonPublic | BindingFlags.Instance);
Action <Unit> action = (Action <Unit>)Delegate.CreateDelegate(typeof(Action <Unit>), __instance, method);
unitViewer.InitHomeItemThing(action);
}
if (!unitByCell.immobile && unitByCell.CustomColorCount > 0)
{
unitViewer.InitColorChange();
}
}
gameObject.SetActive(true);
__result = gameObject;
return(false);
}
static bool Prefix(Region __instance, ref bool __result, UnitHandle unitHandle, ItemPutInfo putInfo, bool changed, HomeRegionType ___regionType)
{
if (!enabled || ___regionType != HomeRegionType.Farm)
{
return(true);
}
Slot slot = CreateSlotFromRSlot(unitHandle);
if (slot == null)
{
Dbgl("slot is null");
return(true);
}
if (__instance.IsValidCell(putInfo.cellIndex))
{
Dbgl("valid cell");
return(true);
}
CellIndex oldSlot = slot.info.cellIndex;
slot.info = putInfo;
ItemHomeSystemUnitCmpt component = slot.unitObjInfo.Item.GetComponent <ItemHomeSystemUnitCmpt>();
if (changed)
{
slot.unit.PutDownVersion = 71;
}
Area area = Module <UnitFactory> .Self.GetArea(putInfo.cellIndex, putInfo.areaRot, component, component.Rotate > 0, slot.unit.PutDownVersion);
if (area == null)
{
__result = false;
return(false);
}
slot.area = area;
slot.unitObjInfo = new UnitObjInfo(slot.unitObjInfo.Item, area);
outsideUnits.Remove(oldSlot);
if (!outsideUnits.ContainsKey(slot.info.cellIndex))
{
outsideUnits.Add(slot.info.cellIndex, slot);
}
else
{
outsideUnits[slot.info.cellIndex] = slot;
}
var mySlot = CreateRSlotFromSlot(slot);
typeof(Region).GetMethod("AddSlot", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(__instance, new object[] { mySlot });
__result = true;
return(false);
}
