private void OnUIUpdate()
{
RecyclingData recyclingData = this._recyclingUI.RecyclingData;
if (recyclingData == null)
{
return;
}
float countLimit = this._recyclingUI.DecidedItemSlotUI.CountLimit;
if (!recyclingData.CreateCountEnabled)
{
Vector3 localScale = ((Component)this._countBarImage).get_transform().get_localScale();
localScale.x = (__Null)0.0;
((Component)this._countBarImage).get_transform().set_localScale(localScale);
}
else if ((double)countLimit <= 0.0)
{
Vector3 localScale = ((Component)this._countBarImage).get_transform().get_localScale();
localScale.x = (__Null)1.0;
((Component)this._countBarImage).get_transform().set_localScale(localScale);
}
else
{
Vector3 localScale = ((Component)this._countBarImage).get_transform().get_localScale();
localScale.x = (__Null)(double)Mathf.Clamp01(recyclingData.CreateCounter / countLimit);
((Component)this._countBarImage).get_transform().set_localScale(localScale);
}
}
public void RefreshCreatePanelUI()
{
RecyclingData recyclingData = this._recyclingUI.RecyclingData;
if (recyclingData != null)
{
if (recyclingData.CreateCountEnabled)
{
recyclingData.CreateCountEnabled = this.CheckCreateable(recyclingData);
}
if (!recyclingData.CreateCountEnabled)
{
recyclingData.CreateCounter = 0.0f;
}
if (this.NeedNumber <= this.ItemCount(recyclingData))
{
this._createPanelUI.DoOpen();
}
else
{
this._createPanelUI.DoClose();
}
((ReactiveProperty <bool>) this.IsCreate).set_Value(recyclingData.CreateCountEnabled);
}
else
{
this._createPanelUI.DoForceClose();
((ReactiveProperty <bool>) this.IsCreate).set_Value(false);
}
}
private void CreateItem(int pointID, RecyclingData data)
{
if (data == null)
{
return;
}
data.CreateCounter = 0.0f;
if (this.CheckCreateable(data))
{
this.RemoveItem(pointID, data);
StuffItem randomCreate = this.GetRandomCreate();
if (randomCreate != null)
{
if (this._recyclingUI.CraftPointID == pointID)
{
this.CreateEvent.OnNext(randomCreate);
}
else
{
data.CreatedItemList.AddItem(randomCreate);
}
}
}
if (data.CreateCountEnabled)
{
data.CreateCountEnabled = this.CheckCreateable(data);
}
if (this._recyclingUI.CraftPointID != pointID)
{
return;
}
((ReactiveProperty <bool>) this.IsCreate).set_Value(data.CreateCountEnabled);
}
private void OnRecyclingDataUpdate()
{
if (!Singleton <Game> .IsInstance())
{
return;
}
AIProject.SaveData.Environment environment = Singleton <Game> .Instance.Environment;
Dictionary <int, RecyclingData> source = environment == null ? (Dictionary <int, RecyclingData>)null : environment.RecyclingDataTable;
if (source.IsNullOrEmpty <int, RecyclingData>())
{
return;
}
foreach (KeyValuePair <int, RecyclingData> keyValuePair in source)
{
RecyclingData data = keyValuePair.Value;
if (data != null)
{
if (!data.CreateCountEnabled)
{
data.CreateCounter = 0.0f;
}
else if ((double)this.CountLimit <= (double)data.CreateCounter)
{
this.CreateItem(keyValuePair.Key, data);
}
}
}
}
public static void PaintNodeColorAnimated(uGUI_CraftNode node)
{
#if SUBNAUTICA
var frontColor = RecyclingData.IsBlackListed(node.techType0) ? Color.black : GUIFormatter.frontColor;
#elif BELOWZERO
var frontColor = RecyclingData.IsBlackListed(node.techType) ? Color.black : GUIFormatter.frontColor;
#endif
AnimateIconColor(node.icon, frontColor, backColor);
}
private void OnCancelClick()
{
RecyclingData recyclingData = this._recyclingUI.RecyclingData;
if (recyclingData == null)
{
return;
}
((ReactiveProperty <bool>) this.IsCreate).set_Value(false);
recyclingData.CreateCountEnabled = false;
recyclingData.CreateCounter = 0.0f;
}
private void OnStartClick()
{
RecyclingData recyclingData = this._recyclingUI.RecyclingData;
if (recyclingData == null || this.ItemCount(recyclingData) < this.NeedNumber || !this._recyclingUI.CreateItemStockUI.IsCreateable)
{
return;
}
((ReactiveProperty <bool>) this.IsCreate).set_Value(true);
recyclingData.CreateCountEnabled = true;
recyclingData.CreateCounter = 0.0f;
}
public void SettingUI(List <StuffItem> itemList)
{
this.ItemList = itemList;
this.ListController.SetItemList(itemList);
this.ListController.Create((IReadOnlyCollection <StuffItem>)itemList);
this._maxCountText.set_text(string.Format("{0}", (object)this.SlotMaxNum));
RecyclingData recyclingData = this._recyclingUI.RecyclingData;
if (recyclingData == null)
{
return;
}
((ReactiveProperty <bool>) this.IsCreate).set_Value(recyclingData.CreateCountEnabled);
}
private static void ReplaceNodeTech(uGUI_CraftNode node)
{
if (node.action != TreeAction.Craft)
{
return;
}
TechType recyclingTech;
if (RecyclingData.TryGet(node.techType0, out recyclingTech))
{
replacedNodeTechs[node] = node.techType0;
node.techType0 = recyclingTech;
}
}
private static void Postfix(uGUI_CraftingMenu __instance, ref bool __result, uGUI_CraftNode sender)
{
if (!Active)
{
return;
}
if (CurrentMenu != __instance)
{
return;
}
if (sender.action != TreeAction.Craft)
{
return;
}
__result &= !RecyclingData.IsBlackListed(sender.techType0);
}
public int ItemCount(RecyclingData data)
{
if (data == null || data.DecidedItemList.IsNullOrEmpty <StuffItem>())
{
return(0);
}
int num = 0;
foreach (StuffItem decidedItem in data.DecidedItemList)
{
if (decidedItem != null)
{
num += decidedItem.Count;
}
}
return(num);
}
public void RefreshButtonUI()
{
RecyclingData recyclingData = this._recyclingUI.RecyclingData;
if (recyclingData == null)
{
return;
}
bool createCountEnabled = recyclingData.CreateCountEnabled;
this.SetActive((Component)this._createButton, !createCountEnabled);
this.SetActive((Component)this._cancelButton, createCountEnabled);
if (!createCountEnabled)
{
recyclingData.CreateCounter = 0.0f;
}
((Selectable)this._createButton).set_interactable(this.IsCreateable);
}
public static void Postfix()
{
foreach (TechType techType in Enum.GetValues(typeof(TechType)))
{
#if SUBNAUTICA
if (SMLHelper.V2.Handlers.CraftDataHandler.GetTechData(techType) != null)
#elif BELOWZERO
if (SMLHelper.V2.Handlers.CraftDataHandler.GetRecipeData(techType) != null)
#endif
{
RecyclingData.TryGet(techType, out TechType recyclingTech, true);
}
}
#if BELOWZERO
TechData.Cache();
#endif
CraftData.RebuildDatabase();
Language.main.LoadLanguageFile(Language.main.GetCurrentLanguage());
}
private static void ReplaceNodeTech(uGUI_CraftNode node)
{
if (node.action != TreeAction.Craft)
{
return;
}
if (!node.techType0.ToString().StartsWith("Defabricated") && RecyclingData.TryGet(node.techType0, out TechType recyclingTech))
{
node.techType0 = recyclingTech;
}
else if (node.techType0.ToString().StartsWith("Defabricated"))
{
TechTypeExtensions.FromString(node.techType0.ToString().Replace("Defabricated", ""), out TechType original, true);
node.techType0 = original;
}
else
{
ErrorMessage.AddMessage($"Failed to change {node.techType0}");
}
}
private void RemoveItem(int pointID, RecyclingData data)
{
if (data == null || data.DecidedItemList.IsNullOrEmpty <StuffItem>())
{
return;
}
if (pointID == this._recyclingUI.CraftPointID)
{
this.RemoveItem();
}
else
{
int needNumber = this.NeedNumber;
for (int index = 0; index < data.DecidedItemList.Count; ++index)
{
StuffItem element = data.DecidedItemList.GetElement <StuffItem>(index);
if (element == null)
{
data.DecidedItemList.RemoveAt(index);
--index;
}
else
{
int num = Mathf.Min(element.Count, needNumber);
needNumber -= num;
element.Count -= num;
if (element.Count <= 0)
{
data.DecidedItemList.RemoveAt(index);
--index;
}
if (needNumber <= 0)
{
break;
}
}
}
}
}
private void SetRecyclingData()
{
this.RecyclingData = (RecyclingData)null;
int num = -1;
this.CraftPointID = num;
this._craftPointID = num;
CraftPoint currentCraftPoint = Manager.Map.GetPlayer()?.CurrentCraftPoint;
if (!Object.op_Inequality((Object)currentCraftPoint, (Object)null))
{
return;
}
int key = this._craftPointID = currentCraftPoint.RegisterID;
WorldData worldData = !Singleton <Game> .IsInstance() ? (WorldData)null : Singleton <Game> .Instance.WorldData;
AIProject.SaveData.Environment environment = worldData == null ? (AIProject.SaveData.Environment)null : worldData.Environment;
Dictionary <int, RecyclingData> dictionary = environment == null ? (Dictionary <int, RecyclingData>)null : environment.RecyclingDataTable;
if (dictionary == null)
{
return;
}
RecyclingData recyclingData1 = (RecyclingData)null;
if (dictionary.TryGetValue(key, out recyclingData1) && recyclingData1 != null)
{
this.RecyclingData = recyclingData1;
}
else
{
RecyclingData recyclingData2 = new RecyclingData();
dictionary[key] = recyclingData2;
this.RecyclingData = recyclingData2;
}
}
public static void PaintNodeColorAnimated(uGUI_CraftNode node)
{
var frontColor = RecyclingData.IsBlackListed(node.techType0) ? Color.black : GUIFormatter.frontColor;
AnimateIconColor(node.icon, frontColor, backColor);
}
public bool CheckCreateable(RecyclingData data)
{
return(data != null && data.CreatedItemList.Count < this.CreatedItemSlotMaxNum && this.NeedNumber <= this.ItemCount(data));
}
public bool CanDelete()
{
if (this._kind != CraftPoint.CraftKind.Recycling || !Singleton <Manager.Map> .IsInstance() || !Singleton <Game> .IsInstance())
{
return(true);
}
WorldData worldData = Singleton <Game> .Instance.WorldData;
AIProject.SaveData.Environment environment = worldData == null ? (AIProject.SaveData.Environment)null : worldData.Environment;
if (environment == null)
{
return(true);
}
RecyclingData recyclingData = (RecyclingData)null;
if (!environment.RecyclingDataTable.TryGetValue(this.RegisterID, out recyclingData) || recyclingData == null)
{
return(true);
}
recyclingData.DecidedItemList.RemoveAll((Predicate <StuffItem>)(x => x == null || x.Count <= 0));
recyclingData.CreatedItemList.RemoveAll((Predicate <StuffItem>)(x => x == null || x.Count <= 0));
if (recyclingData.DecidedItemList.IsNullOrEmpty <StuffItem>() && recyclingData.CreatedItemList.IsNullOrEmpty <StuffItem>())
{
return(true);
}
List <StuffItem> stuffItemList1 = ListPool <StuffItem> .Get();
foreach (StuffItem decidedItem in recyclingData.DecidedItemList)
{
StuffItem itemInstance = CraftPoint.GetItemInstance();
CraftPoint.CopyItem(decidedItem, itemInstance);
stuffItemList1.AddItem(itemInstance);
}
foreach (StuffItem createdItem in recyclingData.CreatedItemList)
{
StuffItem itemInstance = CraftPoint.GetItemInstance();
CraftPoint.CopyItem(createdItem, itemInstance);
stuffItemList1.AddItem(itemInstance);
}
Manager.Map instance = Singleton <Manager.Map> .Instance;
List <ValueTuple <int, List <StuffItem> > > inventoryList = instance.GetInventoryList();
List <ValueTuple <int, List <StuffItem> > > valueTupleList = ListPool <ValueTuple <int, List <StuffItem> > > .Get();
using (List <ValueTuple <int, List <StuffItem> > > .Enumerator enumerator = inventoryList.GetEnumerator())
{
while (enumerator.MoveNext())
{
ValueTuple <int, List <StuffItem> > current = enumerator.Current;
int num = (int)current.Item1;
List <StuffItem> source = (List <StuffItem>)current.Item2;
List <StuffItem> stuffItemList2 = ListPool <StuffItem> .Get();
valueTupleList.Add(new ValueTuple <int, List <StuffItem> >(num, stuffItemList2));
if (!source.IsNullOrEmpty <StuffItem>())
{
foreach (StuffItem from in source)
{
StuffItem itemInstance = CraftPoint.GetItemInstance();
CraftPoint.CopyItem(from, itemInstance);
stuffItemList2.Add(itemInstance);
}
}
}
}
using (List <ValueTuple <int, List <StuffItem> > > .Enumerator enumerator = valueTupleList.GetEnumerator())
{
while (enumerator.MoveNext())
{
ValueTuple <int, List <StuffItem> > current = enumerator.Current;
int num = (int)current.Item1;
List <StuffItem> self = (List <StuffItem>)current.Item2;
for (int index = 0; index < stuffItemList1.Count; ++index)
{
StuffItem element = stuffItemList1.GetElement <StuffItem>(index);
if (element == null || element.Count <= 0)
{
stuffItemList1.RemoveAt(index);
--index;
}
else
{
StuffItem itemInstance = CraftPoint.GetItemInstance();
CraftPoint.CopyItem(element, itemInstance);
int possible = 0;
StuffItemExtensions.CanAddItem((IReadOnlyCollection <StuffItem>)self, num, itemInstance, out possible);
if (0 < possible)
{
possible = Mathf.Min(possible, itemInstance.Count);
self.AddItem(itemInstance, possible, num);
}
element.Count -= possible;
if (element.Count <= 0)
{
stuffItemList1.RemoveAt(index);
--index;
}
}
}
}
}
stuffItemList1.RemoveAll((Predicate <StuffItem>)(x => x == null || x.Count <= 0));
bool flag = stuffItemList1.IsNullOrEmpty <StuffItem>();
if (flag)
{
using (List <ValueTuple <int, List <StuffItem> > > .Enumerator enumerator = inventoryList.GetEnumerator())
{
while (enumerator.MoveNext())
{
ValueTuple <int, List <StuffItem> > current = enumerator.Current;
int slotMax = (int)current.Item1;
List <StuffItem> receiver = (List <StuffItem>)current.Item2;
instance.SendItemListToList(slotMax, recyclingData.DecidedItemList, receiver);
instance.SendItemListToList(slotMax, recyclingData.CreatedItemList, receiver);
}
}
}
using (List <ValueTuple <int, List <StuffItem> > > .Enumerator enumerator = valueTupleList.GetEnumerator())
{
while (enumerator.MoveNext())
{
ValueTuple <int, List <StuffItem> > current = enumerator.Current;
if (current.Item2 != null)
{
foreach (StuffItem stuffItem in (List <StuffItem>)current.Item2)
{
CraftPoint.ReturnItemInstance(stuffItem);
}
ListPool <StuffItem> .Release((List <StuffItem>) current.Item2);
}
}
}
foreach (StuffItem stuffItem in stuffItemList1)
{
CraftPoint.ReturnItemInstance(stuffItem);
}
ListPool <StuffItem> .Release(stuffItemList1);
instance.ReturnInventoryList(inventoryList);
return(flag);
}
