Elin

https://elin-modding-resources.github.io/Elin-Decompiled
Admin
Documentation for the game Elin's code, intended as a reference for creating mods using BepInEx.
Tokens:421,622
Snippets:1,406
Trust Score:9.7
Update:1 week ago
Show doc for...
Tokens:
Raw
### Start method implementation

Source: https://elin-modding-resources.github.io/Elin-Decompiled/classApplibot_1_1SpriteVertexPositionChanger.html

Initializes the component by getting the Image component, logging an error if missing, enabling useSpriteMesh, and calling ChangeMeshScale. If the sprite is packed, it also scales the rectTransform sizeDelta.

```csharp
_image = GetComponent<Image>();
if (_image == null)
{
    Debug.LogError("Imageコンポーネントが必要です");
    return;
}
_image.useSpriteMesh = true;
Sprite sprite = _image.sprite;
if (sprite.packed)
{
    _image.rectTransform.sizeDelta *= scale;
}
ChangeMeshScale(sprite);
```

--------------------------------

### InstallHook()

Source: https://elin-modding-resources.github.io/Elin-Decompiled/classB83_1_1Win32_1_1UnityDragAndDropHook.html

Installs the Win32 hook to start receiving drag-and-drop events. Must be called before the OnDroppedFiles event can fire.

```APIDOC
## InstallHook()

### Description
Installs the Win32 hook to start receiving drag-and-drop events. Must be called before the OnDroppedFiles event can fire.

### Method
InstallHook

### Signature
`public static void InstallHook()`

### Parameters
None.

### Returns
void

### Remarks
This method sets up the hook and must be called on the main thread. After calling, the OnDroppedFiles event will be triggered when files are dropped onto the window.
```

--------------------------------

### IsItemReady method

Source: https://elin-modding-resources.github.io/Elin-Decompiled/ModManager_8cs.html

Checks if a workshop item is ready for installation. Returns false if the item is not installed, needs update, is downloading, or is download pending. Otherwise checks the install info and directory existence.

```csharp
private static bool IsItemReady(WorkshopItem item, out string path)
{
    path = null;
    if (!item.IsInstalled || item.IsNeedsUpdate || item.IsDownloading || item.IsDownloadPending)
    {
        return false;
    }
    if (UserGeneratedContent.Client.GetItemInstallInfo(item.FileId, out var _, out path, out var _) && !path.IsEmpty())
    {
        return Directory.Exists(path);
    }
    return false;
}
```

--------------------------------

### TryShowGuide overloads

Source: https://elin-modding-resources.github.io/Elin-Decompiled/LayerInventory_8cs_source.html

Two overloads of TryShowGuide that attach a 'guide' highlight to inventory buttons based on various conditions such as trader guides, search selection, equipment dragging, and ability hotkeys.

```csharp
public static void TryShowGuide(UIList list)
{
	List<ButtonGrid> list2 = new List<ButtonGrid>();
	foreach (UIList.ButtonPair button in list.buttons)
	{
		ButtonGrid buttonGrid = button.component as ButtonGrid;
		if ((bool)buttonGrid)
		{
			list2.Add(buttonGrid);
		}
	}
	TryShowGuide(list2);
}

public static void TryShowGuide(List<ButtonGrid> list)
{
	bool flag = InvOwner.HasTrader && InvOwner.Trader.UseGuide;
	if (flag)
	{
		WidgetSearch.selected = null;
	}
	bool flag2 = (bool)WidgetSearch.Instance && WidgetSearch.selected != null && !ELayer.ui.IsDragging;
	if (!flag2 && WidgetEquip.dragEquip == null && LayerAbility.hotElement == null && !flag)
	{
		return;
	}
	foreach (ButtonGrid item in list)
	{
		Thing thing = item.card as Thing;
		if (LayerAbility.hotElement != null)
		{
			if ((bool)item && item.invOwner != null && (thing == null || thing.trait is TraitAbility) && item.invOwner.owner == ELayer.pc && !(item.invOwner is InvOwnerEquip))
			{
				item.Attach("guide", rightAttach: false);
			}
		}
		else if (WidgetEquip.dragEquip != null && !flag)
		{
			if (item.invOwner is InvOwnerEquip invOwnerEquip && invOwnerEquip.slot.elementId == WidgetEquip.dragEquip.category.slot)
			{
				item.Attach("guide", rightAttach: false);
			}
		}
		else if (flag2)
		{
			if (item.card == WidgetSearch.selected || item.card == WidgetSearch.selected.parent)
			{
				item.Attach("guide", rightAttach: false);
			}
		}
		else
		{
			if (thing == null)
			{
				continue;
			}
			bool show = InvOwner.Trader.ShouldShowGuide(thing);
			if (!show && thing.CanSearchContents)
			{
				thing.things.Foreach(delegate(Thing _t)
				{
					if (!show && InvOwner.Trader.ShouldShowGuide(_t))
					{
						show = true;
					}
				});
			}
			if (show)
			{
				item.Attach("guide", rightAttach: false);
			}
		}
	}
}
```

--------------------------------

### InstallWorkshopPackage method

Source: https://elin-modding-resources.github.io/Elin-Decompiled/ModManager_8cs.html

Installs a workshop package by marking it installed, setting its directory info, creating a FileMapping for ModPackage instances, and logging a debug message.

```csharp
private void InstallWorkshopPackage(WorkshopDownload download, string path)
{
    BaseModPackage package = download.package;
    package.installed = true;
    package.dirInfo = new DirectoryInfo(path.NormalizePath());
    if (package is ModPackage modPackage)
    {
        modPackage.Mapping = new FileMapping(package.dirInfo);
    }
    Debug.Log("Downloaded: " + download.Title + " -> " + package.dirInfo.FullName);
}
```

--------------------------------

### RefreshAll Method

Source: https://elin-modding-resources.github.io/Elin-Decompiled/BaseGameScreen_8cs_source.html

Starts the RefreshAll method, which likely refreshes the screen size and other components.

```csharp
public void RefreshAll()
{
RefreshScreenSize();
```

--------------------------------

### OnInstantiate() method body

Source: https://elin-modding-resources.github.io/Elin-Decompiled/classContentConfigInput.html

Configures dropdowns for middle click, middle press long, mouse3 click, mouse3 press long, mouse4 click, and mouse4 press long actions. Then sets up UIList callbacks for movement, general, menu, etc., and advanced key lists, and refreshes the lists.

```csharp
b_ddMiddleClick.SetList((int)base.config.input.b_middleClick, list2, (CoreConfig.GameFuncBuild a, int b) => a.ToString().lang(), delegate(int a, CoreConfig.GameFuncBuild b)
{
base.config.input.b_middleClick = b;
});
b_ddMiddleClickLong.SetList((int)base.config.input.b_middlePressLong, list2, (CoreConfig.GameFuncBuild a, int b) => a.ToString().lang(), delegate(int a, CoreConfig.GameFuncBuild b)
{
base.config.input.b_middlePressLong = b;
});
b_ddMouse3Click.SetList((int)base.config.input.b_mouse3Click, list2, (CoreConfig.GameFuncBuild a, int b) => a.ToString().lang(), delegate(int a, CoreConfig.GameFuncBuild b)
{
base.config.input.b_mouse3Click = b;
});
b_ddMouse3Long.SetList((int)base.config.input.b_mouse3PressLong, list2, (CoreConfig.GameFuncBuild a, int b) => a.ToString().lang(), delegate(int a, CoreConfig.GameFuncBuild b)
{
base.config.input.b_mouse3PressLong = b;
});
b_ddMouse4Click.SetList((int)base.config.input.b_mouse4Click, list2, (CoreConfig.GameFuncBuild a, int b) => a.ToString().lang(), delegate(int a, CoreConfig.GameFuncBuild b)
{
base.config.input.b_mouse4Click = b;
});
b_ddMouse4Long.SetList((int)base.config.input.b_mouse4PressLong, list2, (CoreConfig.GameFuncBuild a, int b) => a.ToString().lang(), delegate(int a, CoreConfig.GameFuncBuild b)
{
base.config.input.b_mouse4PressLong = b;
});
listMovement.callbacks = new UIList.Callback<EInput.KeyMap, ItemKeymap>
{
onInstantiate = delegate(EInput.KeyMap a, ItemKeymap b)
{
_onInstantiate(a, b);
},
onList = delegate
{
EInput.KeyMapManager keys = base.config.input.keys;
UIList uIList = listMovement;
uIList.Add(keys.axisUp);
uIList.Add(keys.axisDown);
uIList.Add(keys.axisLeft);
uIList.Add(keys.axisRight);
uIList.Add(keys.axisUpLeft);
uIList.Add(keys.axisUpRight);
uIList.Add(keys.axisDownLeft);
uIList.Add(keys.axisDownRight);
uIList.Add(keys.wait);
}
};
listGeneral.callbacks = new UIList.Callback<EInput.KeyMap, ItemKeymap>
{
onInstantiate = delegate(EInput.KeyMap a, ItemKeymap b)
{
_onInstantiate(a, b);
},
onList = delegate
{
EInput.KeyMapManager keys = base.config.input.keys;
UIList uIList = listGeneral;
uIList.Add(keys.mouseLeft);
uIList.Add(keys.mouseMiddle);
uIList.Add(keys.mouseRight);
uIList.Add(keys.fire);
uIList.Add(keys.autoCombat);
uIList.Add(keys.emptyHand);
}
};
listMenu.callbacks = new UIList.Callback<EInput.KeyMap, ItemKeymap>
{
onInstantiate = delegate(EInput.KeyMap a, ItemKeymap b)
{
_onInstantiate(a, b);
},
onList = delegate
{
EInput.KeyMapManager keys = base.config.input.keys;
UIList uIList = listMenu;
uIList.Add(keys.chara);
uIList.Add(keys.inventory);
uIList.Add(keys.ability);
uIList.Add(keys.journal);
uIList.Add(keys.log);
uIList.Add(keys.report);
uIList.Add(keys.search);
}
};
listEtc.callbacks = new UIList.Callback<EInput.KeyMap, ItemKeymap>
{
onInstantiate = delegate(EInput.KeyMap a, ItemKeymap b)
{
_onInstantiate(a, b);
},
onList = delegate
{
EInput.KeyMapManager keys = base.config.input.keys;
UIList uIList = listEtc;
uIList.Add(keys.switchHotbar);
uIList.Add(keys.quickSave);
uIList.Add(keys.quickLoad);
}
};
listAdvanced.callbacks = new UIList.Callback<EInput.KeyMap, ItemKeymap>
{
onInstantiate = delegate(EInput.KeyMap a, ItemKeymap b)
{
_onInstantiate(a, b);
},
onList = delegate
{
EInput.KeyMapManager keys = base.config.input.keys;
UIList uIList = listAdvanced;
uIList.Add(keys.examine);
uIList.Add(keys.getAll);
uIList.Add(keys.dump);
uIList.Add(keys.mute);
uIList.Add(keys.meditate);
uIList.Add(keys.chat);
uIList.Add(keys.console);
}
};
_refreshList();
void _onInstantiate(EInput.KeyMap a, ItemKeymap b)
{
b.text.text = ("key_" + a.action).lang();
string text = a.key.ToString() ?? "";
b.buttonKey.mainText.text = text;
b.buttonKey.SetOnClick(delegate
{
Dialog.Keymap(a).SetOnKill(_refreshList);
});
}
void _refreshList()
{
listMovement.List();
listGeneral.List();
listMenu.List();
listEtc.List();
listAdvanced.List();
}
```

--------------------------------

### Meeting class: SetChara, Start, and OnEndDrama

Source: https://elin-modding-resources.github.io/Elin-Decompiled/Meeting_8cs_source.html

Defines the Meeting class for Elin, handling meeting setup, character placement, and drama lifecycle. SetChara creates or finds the meeting character, moves it to the active zone, and positions it; Start triggers the drama and registers OnEndDrama to run when the drama layer closes. OnEndDrama moves global characters to the "somewhere" zone or destroys local ones, then calls EClass.Branch.meetings.CallNext() to advance the meeting queue.

```csharp
using Newtonsoft.Json;
using UnityEngine;

public class Meeting : EClass
{
 [JsonProperty]
 public int dateExipire;

 public FactionBranch branch;

 public Chara chara;

 public virtual bool IsGlobalChara => false;

 public virtual string IdChara => "begger";

 public void SetOwner(FactionBranch _branch)
 {
  branch = _branch;
 }

 public void SetChara(Point pos)
 {
  if (IsGlobalChara)
  {
   chara = EClass.game.cards.globalCharas.Find(IdChara);
   if (chara == null)
   {
    Debug.Log("creating chara for meeting:" + IdChara);
    chara = CharaGen.Create(IdChara);
    chara.SetGlobal();
    EClass.game.spatials.Find("somewhere").AddCard(chara);
   }
  }
  else
  {
   chara = EClass._zone.AddCard(CharaGen.Create(IdChara), pos).Chara;
  }
  if (chara.currentZone != EClass.game.activeZone)
  {
   chara.MoveZone(EClass.game.activeZone);
  }
  chara.MoveImmediate(pos);
 }

 public void Start()
 {
  EClass.pc.LookAt(chara);
  chara.LookAt(EClass.pc);
  PlayDrama();
  LayerDrama.Instance.SetOnKill(OnEndDrama);
 }

 public virtual void PlayDrama()
 {
 }

 public virtual void OnEndDrama()
 {
  if (chara.IsGlobal)
  {
   chara.MoveZone(EClass.game.spatials.Find("somewhere"));
  }
  else
  {
   chara.Destroy();
  }
  EClass.Branch.meetings.CallNext();
 }
}
```

--------------------------------

### RegisterSetup method to save party setup

Source: https://elin-modding-resources.github.io/Elin-Decompiled/Party_8cs_source.html

Creates a Player.PartySetup from the current members, recording UIDs and identifying the ride and parasite if present, then stores it in the player's partySetups array at the given index.

```csharp
public void RegisterSetup(int index)
{
 Player.PartySetup partySetup = new Player.PartySetup();
 foreach (Chara member in members)
 {
 partySetup.uids.Add(member.uid);
 if (member == EClass.pc.ride)
 {
 partySetup.ride = member.uid;
 }
 if (member == EClass.pc.parasite)
 {
 partySetup.parasite = member.uid;
 }
 }
 EClass.player.partySetups[index] = partySetup;
}
```

--------------------------------

### Init method for BuildMenu

Source: https://elin-modding-resources.github.io/Elin-Decompiled/BuildMenu_8cs_source.html

Instance method that initializes the menu, setting up info panels, category dictionary, and tab buttons.

```csharp
public void Init()
{
 info1.Init();
 info2.Init();
 info2.transform.position = info1.transform.position;
 orgPos = info1.Rect().anchoredPosition;
 orgPosOption = transOption.anchoredPosition;
 for (int i = 0; i < categories.Length; i++)
 {
 if (!categories[i].IsEmpty())
 {
 catDic.Add(categories[i], i);
 }
 }
 UIButton t = gridTab.CreateMold<UIButton>();
 for (int j = 0; j < categories.Length - 1; j++)
 {
 int _i = j;
 UIButton uIButton = Util.Instantiate(t, gridTab);
 uIButton.onClick.AddListener(delegate
 {
 ClearSearch(refresh: false);
 SelectCategory(categories[_i]);
 });
 }
}
```

--------------------------------

### ResourceCache.cs: Static ResourceCache and generic ResourceCache<T>

Source: https://elin-modding-resources.github.io/Elin-Decompiled/ResourceCache_8cs_source.html

Defines the static ResourceCache class with Load and LoadBundle methods, and the generic ResourceCache<T> class with a dictionary cache, Clear, Get, and generic Get<T2> methods. The generic Get method loads from Resources or StreamingAssets based on ResourceLoadType, while Get<T2> loads from AssetBundles when not using Resources.

```csharp
using System.Collections.Generic;
using System.IO;
using UnityEngine;

public class ResourceCache
{
    public static ResourceCache<Object> caches = new ResourceCache<Object>();

    public static T Load<T>(string path) where T : Object
    {
        return caches.Get<T>(path);
    }

    public static T LoadBundle<T>(string path) where T : Object
    {
        return caches.Get<T>(path, ResourceLoadType.AssetBundle);
    }
}
public class ResourceCache<T> where T : Object
{
    public Dictionary<string, T> dict = new Dictionary<string, T>();

    public string path;

    public ResourceCache(string _path = "")
    {
        path = _path;
    }

    public void Clear()
    {
        foreach (T value in dict.Values)
        {
            Object.DestroyImmediate(value);
        }
        dict.Clear();
    }

    public T Get(string id, ResourceLoadType loadType = ResourceLoadType.Resource, object option = null)
    {
        T value = null;
        string key = typeof(T).Name + id;
        if (!dict.TryGetValue(key, out value))
        {
            value = ((loadType == ResourceLoadType.Streaming) ? IO.LoadObject<T>(path + id, option) : Resources.Load<T>(path + id));
            dict.Add(key, value);
        }
        return value;
    }

    public T2 Get<T2>(string id, ResourceLoadType loadType = ResourceLoadType.Resource) where T2 : Object
    {
        T value = null;
        string key = typeof(T2).Name + id;
        if (!dict.TryGetValue(key, out value))
        {
            T2 val = null;
            val = ((loadType != ResourceLoadType.Resource) ? AssetBundle.LoadFromFile(Application.streamingAssetsPath + "/Bundle/" + id).LoadAsset<GameObject>(new FileInfo(id).Name).GetComponent<T2>() : Resources.Load<T2>(path + id));
            dict.Add(key, val as T);
            return val;
        }
        return value as T2;
    }
}
```

--------------------------------

### PixelPaint.Init method

Source: https://elin-modding-resources.github.io/Elin-Decompiled/PixelPaint_8cs_source.html

Initializes the pixel paint texture, sets up the preview and main image, fills the canvas with the background color, refreshes the size, and initializes the color picker with the start color.

```csharp
public void Init()
{
	tex = new Texture2D(size.x, size.y, TextureFormat.ARGB32, mipChain: false);
	tex.filterMode = FilterMode.Point;
	imagePreview.texture = tex;
	imagePreview.rectTransform.sizeDelta = new Vector2(size.x * 2, size.y * 2);
	imageRect.texture = tex;
	Fill(bgColor);
	RefreshSize();
	picker.Init();
	picker.SelectColor(startColor);
	picker.SelectColor(startColor);
}
```

--------------------------------

### IPathfinder.Init

Source: https://elin-modding-resources.github.io/Elin-Decompiled/IPathfinder_8cs_source.html

Initializes the pathfinder with a grid, weight map, and size.

```APIDOC
## Init(IPathfindGrid _grid, WeightCell[,] _weightMap, int size)

### Description
Initializes the pathfinder with a grid, weight map, and size.

### Method
Init

### Parameters
- **_grid** (IPathfindGrid) - Required - The grid used for pathfinding.
- **_weightMap** (WeightCell[,]) - Required - The weight map for pathfinding.
- **size** (int) - Required - The size of the grid.

### Return Value
void
```

--------------------------------

### WidgetSceneCustomizer.cs - Full Class Implementation

Source: https://elin-modding-resources.github.io/Elin-Decompiled/WidgetSceneCustomizer_8cs_source.html

Complete source of the WidgetSceneCustomizer class. It initializes UI dropdowns and sliders in OnActivate, applies zone config changes via EMono.scene.ApplyZoneConfig(), and provides methods for color picking, refreshing color, and saving/loading/resetting zone configs. Uses StandaloneFileBrowser for file dialogs and IO.SaveFile/LoadFile for persistence.

```csharp
using System.Collections.Generic;
using SFB;
using UnityEngine;
using UnityEngine.UI;

public class WidgetSceneCustomizer : Widget
{
	public UIDropdown ddLiquid;

	public UIDropdown ddRefraction;

	public UIDropdown ddOverlay;

	public UIDropdown ddLut;

	public List<LiquidProfile> liquids;

	public List<RefractionProfile> refractions;

	public List<OverlayProfile> overlays;

	public List<string> luts;

	public UIButton toggleGradientWater;

	public UIButton buttonColorPicker;

	public Slider sliderLutBlend;

	public Slider sliderLutBrightness;

	public Slider sliderLutContrast;

	public UISlider sliderLut;

	public override void OnActivate()
	{
		MapConfig conf = EMono._map.config;
		ddLiquid.SetList(conf.idLiquid, liquids, (LiquidProfile a, int b) => a.name, delegate(int a, LiquidProfile b)
		{
			if (conf.idLiquid != b.name)
			{
				conf.idLiquid = b.name;
				conf.colorLiquid = null;
				EMono.scene.ApplyZoneConfig();
			}
			RefreshColor();
		});
		ddRefraction.SetList(conf.idRefraction, refractions, (RefractionProfile a, int b) => a.name, delegate(int a, RefractionProfile b)
		{
			if (conf.idRefraction != b.name)
			{
				conf.idRefraction = b.name;
				EMono.scene.ApplyZoneConfig();
			}
		});
		ddLut.SetList(conf.idLut, luts, (string a, int b) => a, delegate(int a, string b)
		{
			if (conf.idLut != b)
			{
				conf.idLut = b;
				EMono.scene.ApplyZoneConfig();
			}
		});
		sliderLutBlend.SetSlider(conf.lutBlend, delegate(float a)
		{
			conf.lutBlend = a;
			EMono.scene.ApplyZoneConfig();
			return Lang.Get("lutBlend") + "(" + (int)(a * 100f) + "%)";
		});
		sliderLutBrightness.SetSlider(conf.lutBrightness, delegate(float a)
		{
			conf.lutBrightness = a;
			EMono.scene.ApplyZoneConfig();
			return Lang.Get("lutBrightness") + "(" + (int)(a * 100f) + "%)";
		});
		sliderLutContrast.SetSlider(conf.lutContrast, delegate(float a)
		{
			conf.lutContrast = a;
			EMono.scene.ApplyZoneConfig();
			return Lang.Get("lutContrast") + "(" + (int)(a * 100f) + "%)";
		});
		List<Texture2D> list = new List<Texture2D>(Resources.LoadAll<Texture2D>("Scene/Profile/Lut/"));
		list.Insert(0, null);
		sliderLut.SetList(list.Find((Texture2D a) => (!(a == null)) ? (conf.idLut == a.name) : (conf.idLut == "None")), list, delegate(int a, Texture2D b)
		{
			conf.idLut = ((b == null) ? "None" : b.name);
			EMono.scene.ApplyZoneConfig();
		}, (Texture2D a) => (!(a == null)) ? a.name : "None");
		RefreshColor();
	}

	public void ShowPicker()
	{
		MapConfig conf = EMono._map.config;
		LiquidProfile prof = LiquidProfile.Get(conf.idLiquid);
		EMono.ui.AddLayer<LayerColorPicker>().SetColor(conf.colorLiquid?.Get() ?? prof.modColor, prof.modColor, delegate(PickerState state, Color c)
		{
			prof.Apply(c);
			switch (state)
			{
			case PickerState.Confirm:
				conf.colorLiquid = new SerializableColor(c);
				RefreshColor();
				break;
			case PickerState.Cancel:
				EMono.scene.ApplyZoneConfig();
				break;
			}
		});
	}

	public void RefreshColor()
	{
		LiquidProfile liquidProfile = LiquidProfile.Get(EMono._map.config.idLiquid);
		Color color = EMono._map.config.colorLiquid?.Get() ?? liquidProfile.modColor;
		color.a = 1f;
		buttonColorPicker.icon.color = color;
	}

	public void OnClickSave()
	{
		EMono.core.WaitForEndOfFrame(delegate
		{
			string text = StandaloneFileBrowser.SaveFilePanel("Save Zone Config", CorePath.SceneCustomizerSave, "new zone config", "json");
			if (!string.IsNullOrEmpty(text))
			{
				IO.SaveFile(text, EMono._map.config);
			}
		});
	}

	public void OnClickLoad()
	{
		EMono.core.WaitForEndOfFrame(delegate
		{
			string[] array = StandaloneFileBrowser.OpenFilePanel("Load Zone Config", CorePath.SceneCustomizerSave, "json", multiselect: false);
			if (array.Length != 0)
			{
				EMono._map.config = IO.LoadFile<MapConfig>(array[0]);
				Reactivate();
			}
		});
	}

	public void OnClickReset()
	{
		EMono._map.config = new MapConfig();
		Reactivate();
	}
}
```

--------------------------------

### ClassExtension.Rect

Source: https://elin-modding-resources.github.io/Elin-Decompiled/ClassExtension_8cs_source.html

Gets the RectTransform of a Component.

```APIDOC
## Rect

### Description
Gets the RectTransform of a Component.

### Method
Extension Method

### Signature
`static RectTransform Rect(this Component c)`

### Parameters
- **c** (Component) - The component.

### Returns
RectTransform - The RectTransform component.
```

--------------------------------

### ClassExtension.pluralizer

Source: https://elin-modding-resources.github.io/Elin-Decompiled/ClassExtension_8cs_source.html

Gets the pluralizer instance.

```APIDOC
## pluralizer

### Description
Gets the pluralizer instance.

### Method
Property Getter

### Returns
- **IPluralize** - The pluralizer instance.
```

--------------------------------

### OnAfterInit method - dialog initialization

Source: https://elin-modding-resources.github.io/Elin-Decompiled/Dialog_8cs_source.html

Initializes the dialog after creation: hides mouse hint, toggles detail and grid visibility, configures grid layout for 8+ items, populates grid list, refreshes button list, rebuilds layout, disables GraphicRaycaster temporarily, focuses input if present, and waits for key release.

```csharp
public override void OnAfterInit()
{
	ELayer.ui.hud.textMouseHintRight.transform.parent.SetActive(enable: false);
	textDetail.SetActive(!textDetail.text.IsEmpty());
	listGrid.SetActive(gridItems.Count > 0);
	if (gridItems.Count >= 8)
	{
		GridLayoutGroup obj = listGrid.layoutItems as GridLayoutGroup;
		obj.constraint = GridLayoutGroup.Constraint.FixedColumnCount;
		obj.constraintCount = 8;
	}
	if (gridItems.Count > 0)
	{
		listGrid.Clear();
		listGrid.callbacks = new UIList.Callback<GridItem, ButtonGrid>
		{
			onInstantiate = delegate(GridItem a, ButtonGrid b)
			{
				b.SetItem(a);
			},
			onClick = delegate(GridItem a, ButtonGrid b)
			{
				a.OnClick(b);
			}
		};
		foreach (GridItem gridItem in gridItems)
		{
			listGrid.Add(gridItem);
		}
		listGrid.Refresh();
	}
	list.Refresh();
	this.RebuildLayout(recursive: true);
	GraphicRaycaster g = windows[0].GetComponent<GraphicRaycaster>();
	g.enabled = false;
	TweenUtil.Delay(0.3f, delegate
	{
		if ((bool)g)
		{
			g.enabled = true;
		}
	});
	if ((bool)input)
	{
		input.Focus();
	}
	EInput.WaitReleaseKey();
}
```

--------------------------------

### ClassExtension.GetList<T>

Source: https://elin-modding-resources.github.io/Elin-Decompiled/ClassExtension_8cs_source.html

Gets a list of values from an IDictionary.

```APIDOC
## GetList<T>

### Description
Gets a list of values from an IDictionary.

### Method
Extension Method

### Signature
`static List<T> GetList<T>(this IDictionary source)`

### Type Parameters
- **T** - The value type.

### Parameters
- **source** (IDictionary) - The dictionary.

### Returns
List<T> - The list of values.
```

--------------------------------

### Window Constructor and Initialization

Source: https://elin-modding-resources.github.io/Elin-Decompiled/Plugins_8UI_2Window_8cs_source.html

Sets up window menus, canvas, layout, and initializes based on settings. Handles save data loading and tab restoration.

```csharp
942 menuRight = new WindowMenu(setting.rightMenuAlias.IsEmpty("Right"), this);
943 menuBottom = new WindowMenu("Bottom", this);
944 menuLeftBottom = new WindowMenu("LeftBottom", this);
945 if (!base.gameObject.GetComponent<Canvas>())
946 {
947 base.gameObject.AddComponent<Canvas>();
948 base.gameObject.AddComponent<GraphicRaycaster>();
949 }
950 cg = base.gameObject.GetComponent<CanvasGroup>();
951 if (cg == null)
952 {
953 cg = base.gameObject.AddComponent<CanvasGroup>();
954 }
955 posTab = rectTab.anchoredPosition;
956 posBottom = rectBottom.anchoredPosition;
957 layoutWindow = GetComponent<LayoutGroup>();
958 posCaption = new Vector2(layoutWindow.padding.left, layoutWindow.padding.top);
959 if (setting.tabAfterCaption)
960 {
961 rectTab.SetSiblingIndex(rectCaption.GetSiblingIndex());
962 }
963 if ((bool)imageBG)
964 {
965 bgShadow = imageBG.GetComponent<Shadow>();
966 }
967 _rect = this.Rect();
968 }
```

```csharp
970 public void Init(Layer _layer = null)
971 {
972 _rect = this.Rect();
973 layer = _layer;
974 if (!setting.asWidget)
975 {
976 setting.allowResize = false;
977 setting.saveWindow = false;
978 }
979 if (setting.saveWindow)
980 {
981 saveData = dictData.TryGetValue(idWindow);
982 }
983 if (saveData != null)
984 {
985 if (saveData.customAnchor != RectPosition.Auto)
986 {
987 saveData.anchor = saveData.customAnchor;
988 }
989 if (AutoAnchor)
990 {
991 _rect.SetAnchor(saveData.anchor);
992 }
993 _rect.anchoredPosition = new Vector2(saveData.x, saveData.y);
994 _rect.sizeDelta = new Vector2(saveData.w, saveData.h);
995 }
996 else if (setting.usePosFix)
997 {
998 _rect.anchoredPosition += setting.posFix;
999 }
1000 if (openLastTab && setting.openLastTab && setting.tabs.Count > idTab && !setting.tabs[dictTab.TryGetValue(idWindow, 0)].disable)
1001 {
1002 idTab = dictTab.TryGetValue(idWindow, 0);
1003 }
1004 if (setting.textCaption.IsEmpty())
1005 {
1006 textCaption.SetActive(enable: false);
1007 iconCaption.SetActive(enable: false);
1008 }
1009 else
1010 {
1011 if (Lang.GetList(setting.textCaption) != null)
1012 {
1013 SetTitles(setting.textCaption);
1014 }
1015 else
1016 {
1017 SetCaption(setting.textCaption.lang());
1018 }
1019 if ((bool)setting.spriteCaption)
1020 {
1021 iconCaption.sprite = setting.spriteCaption;
1022 }
1023 }
1024 BuildTabs();
1025 bool flag = !(layer == null) && layer.option.canClose;
1026 if (flag && setting.bottomBack)
1027 {
1028 AddBottomButton("back", Close, setFirst: true);
1029 }
1030 if ((bool)buttonClose && buttonClose.gameObject.activeSelf)
1031 {
1032 buttonClose.onClick.RemoveAllListeners();
1033 buttonClose.onClick.AddListener(Close);
1034 buttonClose.SetActive(flag);
1035 }
1036 rectBottom.RebuildLayout(recursive: true);
1037 switch (setting.type)
1038 {
1039 case Type.AlignToMouse:
1040 leftSide = Input.mousePosition.x > (float)Screen.width / 1.5f;
1041 _rect.pivot = new Vector2(leftSide ? 1 : 0, _rect.pivot.y);
1042 _rect.position = Input.mousePosition + new Vector3(60f * (leftSide ? (-1f) : 1f), 0f, 0f);
1043 break;
1044 case Type.Side:
1045 {
1046 leftSide = Input.mousePosition.x > (float)Screen.width / 1.7f;
1047 float num = BaseCore.Instance.uiScale * (_rect.sizeDelta.x * 0.5f + 30f);
1048 _rect.position = new Vector3(leftSide ? num : ((float)Screen.width - num), _rect.position.y, 0f);
1049 setting.anime = Resources.Load<Anime>("Media/Anime/" + (leftSide ? "In Window from left" : "In Window from right"));
1050 break;
1051 }
1052 }
1053 RefreshTipPivotPosition();
1054 SwitchContent(idTab);
1055 InitPanel();
1056 ApplySkin();
1057 GameObject go = base.gameObject;
1058 if (!setting.anime || !animateWindow)
1059 {
1060 return;
1061 }
1062 BaseCore.Instance.actionsLateUpdate.Add(delegate
1063 {
1064 if ((bool)setting.anime && go != null)
1065 {
1066 tweenAnime = setting.anime.Play(this.Rect());
1067 }
1068 });
1069 }
```

--------------------------------

### ClassExtension.GetSpecialArticle

Source: https://elin-modding-resources.github.io/Elin-Decompiled/ClassExtension_8cs_source.html

Gets a special article for a string.

```APIDOC
## GetSpecialArticle

### Description
Gets a special article for a string.

### Method
Static Method

### Signature
`static string GetSpecialArticle(string a)`

### Parameters
- **a** (string) - The input string.

### Returns
string - The special article.
```

--------------------------------

### InvOwnerDeliver.ShouldShowGuide method

Source: https://elin-modding-resources.github.io/Elin-Decompiled/InvOwnerDeliver_8cs_source.html

Determines whether a guide should be shown for a given thing based on the mode: Tax requires a bill, Bank requires money, Crop requires a specific bool and category (vegi, fruit, or mushroom).

```csharp
public override bool ShouldShowGuide(Thing t)
{
 switch (mode)
 {
 case Mode.Tax:
 return t.c_bill != 0;
 case Mode.Bank:
 return t.id == "money";
 case Mode.Crop:
 if (!t.GetBool(115))
 {
 return false;
 }
 if (!(t.category.id == "vegi") && !(t.category.id == "fruit"))
 {
 return t.category.id == "mushroom";
 }
 return true;
 default:
 return false;
 }
}
```

--------------------------------

### ClassExtension.GetLastChild

Source: https://elin-modding-resources.github.io/Elin-Decompiled/ClassExtension_8cs_source.html

Gets the last child of a Transform.

```APIDOC
## GetLastChild(this Transform trans)

### Description
Gets the last child of a Transform.

### Method
Extension Method

### Target Type
Transform

### Parameters
- **trans** (Transform) - The transform.

### Returns
- **Transform** - The last child transform.
```

--------------------------------

### RectTransform.GetAnchor

Source: https://elin-modding-resources.github.io/Elin-Decompiled/ClassExtension_8cs_source.html

Gets the anchor position of a RectTransform.

```APIDOC
## GetAnchor

### Description
Gets the anchor position of a RectTransform.

### Method
Extension method

### Signature
`static RectPosition GetAnchor(this RectTransform _rect)`

### Parameters
- **_rect** (RectTransform) - The RectTransform.

### Returns
- **RectPosition** - The anchor position.
```

--------------------------------

### GameObject.GetSelectable

Source: https://elin-modding-resources.github.io/Elin-Decompiled/ClassExtension_8cs_source.html

Gets the Selectable component from a GameObject.

```APIDOC
## GetSelectable

### Description
Gets the Selectable component from a GameObject.

### Method
Extension method

### Signature
`static Selectable GetSelectable(this GameObject go)`

### Parameters
- **go** (GameObject) - The GameObject to search.

### Returns
- **Selectable** - The Selectable component if found, otherwise null.
```

--------------------------------

### Activate method for BuildMenu

Source: https://elin-modding-resources.github.io/Elin-Decompiled/BuildMenu_8cs_source.html

Static method that instantiates the BuildMenu if not already present, reveals the map in god build mode, builds the recipe list, and activates the menu.

```csharp
public static void Activate()
{
 if (!Instance)
 {
 Instance = Util.Instantiate<BuildMenu>("UI/BuildMenu/BuildMenu", EMono.ui);
 Instance.Init();
 }
 if (EMono.debug.godBuild)
 {
 EMono._map.RevealAll();
 }
 RecipeManager.BuildList();
 Instance.OnActivate();
 EMono.screen.focusPos = null;
}
```

--------------------------------

### ColorsEx Property

Source: https://elin-modding-resources.github.io/Elin-Decompiled/classBaseSkinRoot.html

Virtual property that gets a SkinColorProfileEx.

```APIDOC
## ColorsEx Property

### Description
Virtual property that gets a SkinColorProfileEx.

### Property
`virtual SkinColorProfileEx BaseSkinRoot.ColorsEx { get; }`

### Returns
- `SkinColorProfileEx` - The extended color profile.
```

--------------------------------

### ContextMenuProxy Constructor

Source: https://elin-modding-resources.github.io/Elin-Decompiled/classContextMenuProxy.html

Initializes a new instance of the ContextMenuProxy class with the specified display name and menu entry.

```APIDOC
## ContextMenuProxy Constructor

### Description
Initializes a new instance of the ContextMenuProxy class with the specified display name and menu entry.

### Method
Constructor

### Signature
`public ContextMenuProxy(string displayName, string menuEntry)`

### Parameters
- **displayName** (string) - Required - The display name for the context menu item.
- **menuEntry** (string) - Required - The menu entry identifier.

### Remarks
This constructor sets the DisplayName and MenuEntry properties.

### Example
```csharp
var proxy = new ContextMenuProxy("My Menu", "my_menu");
```
```

--------------------------------

### AM_MoveInstalled.OnProcessTiles method

Source: https://elin-modding-resources.github.io/Elin-Decompiled/AM__MoveInstalled_8cs_source.html

Handles the main logic for moving an installed object. Checks for nearby enemies, shows a context menu if the target has ShowContextOnPick, and processes the move including roof item handling and shackle restraint in debug mode.

```csharp
public override void OnProcessTiles(Point point, int dir)
{
	if (target == null)
	{
		Card t = GetTarget(point);
		if (CheckEnemyNearBy(t, t.pos))
		{
			return;
		}
		if (t.trait.ShowContextOnPick)
		{
			ActPlan actPlan = new ActPlan
			{
				pos = point.Copy(),
				ignoreAddCondition = true,
				input = ActInput.AllAction,
				altAction = true
			};
			t.trait.TrySetAct(actPlan);
			if (actPlan.list.Count > 0)
			{
				UIContextMenu uIContextMenu = EClass.ui.CreateContextMenuInteraction();
				uIContextMenu.AddButton("move", delegate
				{
					SetTarget(t);
					SE.Click();
				});
				foreach (ActPlan.Item i in actPlan.list)
				{
					uIContextMenu.AddButton(i.GetTextContext(showName: false), delegate
					{
						i.act.Perform();
					});
				}
				uIContextMenu.Show();
				return;
			}
		}
		SetTarget(t);
		SE.Click();
	}
	else
	{
		if (CheckEnemyNearBy(target, point))
		{
			return;
		}
		mold.dir = moldCard.dir;
		mold.altitude = moldCard.altitude;
		if (target.isChara)
		{
			target.Chara.orgPos?.Set(point);
		}
		base.OnProcessTiles(point, dir);
		target.ignoreStackHeight = moldCard.ignoreStackHeight;
		target.freePos = moldCard.freePos;
		target.fx = (FreePos ? moldCard.fx : 0f);
		target.fy = (FreePos ? moldCard.fy : 0f);
		if (target.isChara && (bool)EClass.debug)
		{
			foreach (Thing thing in point.Things)
			{
				if (thing.trait is TraitShackle traitShackle)
				{
					traitShackle.Restrain(target.Chara);
				}
			}
		}
		if (target.isThing)
		{
			bool isRoofItem = target.isRoofItem;
			target.isRoofItem = IsRoofEditMode();
			if (target.isRoofItem)
			{
				target.SetPlaceState(PlaceState.roaming);
			}
			else if (isRoofItem)
			{
				target.SetPlaceState(PlaceState.installed);
			}
			if (!target.isRoofItem)
			{
				target.ForeachPoint(delegate(Point p, bool center)
				{
					if (p.IsBlocked && p.HasChara)
					{
						foreach (Chara item in p.ListCharas())
						{
							EClass.pc.Kick(item, ignoreSelf: true, karmaLoss: false, show: false);
						}
					}
				});
			}
		}
		SE.Click();
		if (target.renderer.hasActor)
		{
			target.renderer.RefreshSprite();
		}
		target = null;
	}
}
```

--------------------------------

### ClassExtension.LastItem<TValue>

Source: https://elin-modding-resources.github.io/Elin-Decompiled/ClassExtension_8cs_source.html

Gets the last item of an IList.

```APIDOC
## LastItem<TValue>

### Description
Gets the last item of an IList.

### Method
Extension Method

### Signature
`static TValue LastItem<TValue>(this IList<TValue> source)`

### Type Parameters
- **TValue** - The item type.

### Parameters
- **source** (IList<TValue>) - The list.

### Returns
TValue - The last item.
```

--------------------------------

### Generate method implementation

Source: https://elin-modding-resources.github.io/Elin-Decompiled/classCustomMerchantStock.html

Loads the stock and creates a list of Thing objects from the items. Logs errors for items that fail to create.

```csharp
Load();
List<Thing> list = new List<Thing>();
int createLv = owner?.trait?.ShopLv ?? (-1);
foreach (CustomThingContent item in items)
{
    try
    {
        Thing thing = item.Create(createLv);
        if (thing != null)
        {
            list.Add(thing);
            continue;
        }
        ModUtil.LogModError("can't create stock item '" + item.id + "' in '" + base.ContentId + "'", base.Owner);
    }
    catch (Exception ex)
    {
        ModUtil.LogModError("can't create stock item '" + item.id + "' in '" + base.ContentId + "'\n" + ex.Message, base.Owner);
        Debug.LogException(ex);
    }
}
return list;
```

--------------------------------

### ClassExtension.GetComponentInDirectChildren< T >

Source: https://elin-modding-resources.github.io/Elin-Decompiled/ClassExtension_8cs_source.html

Gets a component in direct children of a component.

```APIDOC
## GetComponentInDirectChildren< T >(this Component comp)

### Description
Gets a component in direct children of a component.

### Method
Extension Method

### Target Type
Component

### Type Parameters
- **T** - The component type.

### Parameters
- **comp** (Component) - The parent component.

### Returns
- **T** - The component found in direct children.
```

--------------------------------

### WidgetMainText context menu setup and resolution change

Source: https://elin-modding-resources.github.io/Elin-Decompiled/WidgetMainText_8cs_source.html

Configures a context menu with a slider for background selection and a button for color picking, then sets the base context menu. Also overrides OnChangeResolution to adjust the widget width based on screen resolution.

```csharp
uIContextMenu2.AddSlider("changeBG", (float n) => n + "/" + (EMono.core.refs.bg_msg.Count - 1), extra.bg, delegate(float a)
{
	extra.bg = (int)a;
	cfg.bgColor = EMono.core.refs.bg_msg[extra.bg].color;
	RefreshBG();
}, 0f, EMono.core.refs.bg_msg.Count - 1, isInt: true);
uIContextMenu2.AddButton("colorBG", delegate
{
	EMono.ui.AddLayer<LayerColorPicker>().SetColor(cfg.bgColor, EMono.ui.skins.skinSets[cfg.id].bgs[cfg.bg].color, delegate(PickerState state, Color _c)
	{
		cfg.bgColor = _c;
		RefreshBG();
	});
});
SetBaseContextMenu(m);
}

public override void OnChangeResolution()
{
	base.OnChangeResolution();
	RectTransform rectTransform = this.Rect();
	rectTransform.sizeDelta = new Vector2(0.01f * (float)Screen.width * (float)extra.width, rectTransform.sizeDelta.y);
}
```

--------------------------------

### byte.GetBit

Source: https://elin-modding-resources.github.io/Elin-Decompiled/ClassExtension_8cs_source.html

Gets the value of a specific bit in a byte.

```APIDOC
## GetBit

### Description
Gets the value of a specific bit in a byte.

### Method
Extension method

### Signature
`static bool GetBit(this byte pByte, int bitNo)`

### Parameters
- **pByte** (byte) - The byte to read.
- **bitNo** (int) - The bit position (0-7).

### Returns
- **bool** - True if the bit is set, false otherwise.
```

--------------------------------

### ClassExtension.GetForwardDiffPoint

Source: https://elin-modding-resources.github.io/Elin-Decompiled/ClassExtension_8cs_source.html

Gets a forward difference point from a Vector2.

```APIDOC
## GetForwardDiffPoint

### Description
Gets a forward difference point from a Vector2.

### Method
Static method

### Signature
`static float GetForwardDiffPoint(Vector2 forward)`

### Parameters
- **forward** (Vector2) - The forward vector.

### Returns
float - The forward difference point.
```
Tokens:
Raw