Skip to content

EA 23.356.1 Nightly ​

October 13, 2026

28 files modified.

Important Changes ​

Possible breaking changes. Click the filename to view the chunk.

CharaAbility (2) ​

cs
public void Add(int id, int chance, bool pt)
public void Add(int id, int chance, bool pt, bool permanent = false)
cs
public void Remove(int id)
public void Remove(int id, bool permanent = false)

Point (2) ​

cs
private static List<Card> listCard = new List<Card>();
cs
private static List<Chara> listChara = new List<Chara>();

AI_Shear ​

public override string GetText(string str = "")

cs
{
	string[] list = Lang.GetList("fur");
	string text = list[Mathf.Clamp(target.c_fur / 10, 0, list.Length - 1)];
	return "AI_Shear".lang() + "(" + text + ")";
	return "AI_Shear".lang() + " (" + text + ")";
}

public override bool IsValidTC(Card c)

AI_Trolley ​

using System;

cs
using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

public class AI_Trolley : AIAct

public override IEnumerable<Status> Run()

cs
	}
	EClass.Sound.Stop(idSound, Mathf.Max(1f, trolley.FadeDuration));
}
foreach (Chara item in point.ListCharas().ToList())
foreach (Chara item in point.ListCharas())
{
	owner.Kick(item, ignoreSelf: true, karmaLoss: false);
}

AM_Deconstruct ​

public int Perform(Point point, bool perform = false)

cs
List<Card> list = point.ListCards();
int num = 0;
list.Reverse();
foreach (Card item in list.Copy())
foreach (Card item in list)
{
	if ((!EClass.debug.ignoreBuildRule && (!item.isThing || !item.trait.CanPutAway)) || (ignoreInstalled && item.IsInstalled) || item.IsPCParty)
	{

ActEffect ​

public static bool DamageEle(Card CC, EffectId id, int power, Element e, List<Po…)

cs
{
	EClass._map.TryShatter(p, 911, power, CC);
}
foreach (Card item in p.ListCards().ToList())
foreach (Card item in p.ListCards())
{
	Card c = item;
	if ((!c.isChara && !c.trait.CanBeAttacked) || (c.IsMultisize && item == CC) || (c.isChara && (c.Chara.host == CC || c.Chara.parasite == CC || c.Chara.ride == CC)))

void AddCon<T>(int rate, int p2) where T : Condition

cs
	return;
}
}
List<Card> list11 = tp.ListCards().ToList();
List<Card> list11 = tp.ListCards();
list11.Reverse();
if (list11.Contains(CC))
{

ActMelee ​

void _Attack(BodySlot slot)

cs
}
foreach (Point item2 in list2)
{
	foreach (Card item3 in item2.ListCards().Copy())
	foreach (Card item3 in item2.ListCards())
	{
		if (num4 <= 0 || !Act.CC.IsAliveInCurrentZone)
		{

void Attack(Card _tc, Point _tp, float mtp, bool subAttack)

cs
	p.PlayEffect("smoke_shockwave");
	p.Copy().Animate(AnimeID.QuakeMini, animeBlock: true);
}
foreach (Card item4 in p.ListCards().Copy())
foreach (Card item4 in p.ListCards())
{
	if ((item4.trait.CanBeAttacked || (item4.isChara && item4.Chara.IsHostile(Act.CC))) && !item4.HasElement(430))
	{

ActPlan ​

public void _Update(PointTarget target)

cs
}
Point _pos = new Point(pos);
_ = target.pos.cell;
List<Card> items = _pos.ListCards();
List<Card> cards = _pos.ListCards();
bool isKey = input == ActInput.Key;
altAction = (EInput.isShiftDown && !EInput.isAltDown && !isKey) || input == ActInput.AllAction;
_canInteractNeighbor = dist == 0 || (dist == 1 && cc.CanInteractTo(_pos));

public void _Update(PointTarget target)

cs
		}, null, CursorSystem.MoveZone, 1, isHostileAct: false, localAct: false);
	}
}
items.ForeachReverse(delegate(Card _c)
cards.ForeachReverse(delegate(Card _c)
{
	Chara c = _c.Chara;
	if (c != null && !c.IsPC && EClass.pc.CanSee(c))

public void _Update(PointTarget target)

cs
}
if (IsSelfOrNeighbor)
{
	items.ForeachReverse(delegate(Card _c)
	cards.ForeachReverse(delegate(Card _c)
	{
		Chara c = _c.Chara;
		if (c != null && (c.mimicry == null || c.mimicry.IsChara || c.IsPCParty))

void func()

cs
}
else
{
	IList<Card> _cards = items.Copy();
	TrySetAct("actPickAll", delegate
	{
		foreach (Card item2 in _cards)
		foreach (Card item2 in cards)
		{
			if (item2.isThing && item2.placeState == PlaceState.roaming)
			{

void func()

cs
{
	return;
}
items.ForeachReverse(delegate(Card _c)
cards.ForeachReverse(delegate(Card _c)
{
	if (_c.isThing && _c.trait.CanBeAttacked && !(_c.trait is TraitTrainingDummy))
	{

ActWhirlwind ​

public override bool Perform()

cs
List<Chara> list = Act.CC.pos.ListCharasInNeighbor((Chara c) => !c.pos.Equals(Act.CC.pos));
Act.CC.PlaySound("ab_shred2");
Act.CC.Say("abWhirlwind", Act.CC);
foreach (Chara item in list.Copy())
foreach (Chara item in list)
{
	Act.TC = item;
	if (Act.CC.IsAliveInCurrentZone && Act.TC.IsAliveInCurrentZone)

Chara ​

public void TryPush(Point point)

cs
{
	return;
}
list.Copy().ForeachReverse(delegate(Chara c)
list.ForeachReverse(delegate(Chara c)
{
	if ((trait is TraitSnitch && c.IsPCFactionOrMinion) || (!c.ai.IsMoveAI && !c.IsPC && c.trait.CanBePushed && c != this && !c.noMove && (!EClass._zone.IsRegion || c.IsPCFactionOrMinion)))
	{

CharaAbility ​

string ConvertID(string s)

cs
	}
}

public void Add(int id, int chance, bool pt)
public void Add(int id, int chance, bool pt, bool permanent = false)
{
	if (owner._listAbility == null)
	{

public void Add(int id, int chance, bool pt)

cs
	}
	else if (!(element is Spell))
	{
		element.vPotential = 0;
		if (element.vPotential < 0)
		{
			element.vPotential = 0;
		}
		if (element.vPotential <= 0 && permanent)
		{
			element.vPotential = 1;
		}
	}
}
Refresh();

public void AddRandom()

cs
	Refresh();
}

public void Remove(int id)
public void Remove(int id, bool permanent = false)
{
	owner._listAbility.Remove(id);
	if (owner.IsPC && owner.HasElement(id) && owner._listAbility.IndexOf(id) == -1)
	{
		Element element = EClass.pc.elements.GetElement(id);
		if (!(element is Spell))
		if (!(element is Spell) && (permanent || element.vPotential <= 0))
		{
			element.vPotential = -1;
		}

CoreDebug ​

public void UpdateInput()

cs
}
if (Input.GetKeyDown(KeyCode.F4))
{
	for (int j = 0; j < 1000; j++)
	{
		EClass.pc.ModExp(241, 1000);
	}
	string text2 = new string[4] { "エターナルフォースブリザード", "Eternal Force Blizzard", "ぬるぽ", "Null Pointer" }.RandomItem();
	EClass.pc.renderer.Say("| " + text2 + " ");
	return;

CraftUtil ​

public static Card MixIngredients(Card product, List<Thing> ings, MixType type,…)

cs
}
if (!noMix)
{
	foreach (Element value2 in product.elements.dict.Values)
	foreach (Element item in product.elements.dict.Values.ToList())
	{
		int id = value2.id;
		if ((uint)(id - 914) > 1u && value2.Value >= 0 && (value2.HasTag("noInherit") || IsValidTrait(value2)))
		int id = item.id;
		if ((uint)(id - 914) > 1u && item.Value >= 0 && (item.HasTag("noInherit") || IsValidTrait(item)))
		{
			product.elements.SetTo(value2.id, 0);
			product.elements.SetTo(item.id, 0);
		}
	}
}
if (product.HasCraftBonusTrait())
{
	foreach (Element item in product.ListCraftBonusTraits())
	foreach (Element item2 in product.ListCraftBonusTraits())
	{
		product.elements.ModBase(item.id, item.Value);
		product.elements.ModBase(item2.id, item2.Value);
	}
}
if (isDrink)

void MixElements(Card t)

cs
{
	if (t != null)
	{
		foreach (Element value3 in t.elements.dict.Values)
		foreach (Element value2 in t.elements.dict.Values)
		{
			if (IsValidTrait(value3) && (!noMix || value3.id == 2))
			if (IsValidTrait(value2) && (!noMix || value2.id == 2))
			{
				if (isFoodOrDrink && value3.IsFoodTraitMain)
				if (isFoodOrDrink && value2.IsFoodTraitMain)
				{
					int num5 = value3.Value;
					int num5 = value2.Value;
					if (product.id == "lunch_dystopia")
					{
						num5 *= -1;

void MixElements(Card t)

cs
		{
			num5 = 500;
		}
		product.elements.ModBase(value3.id, num5);
		product.elements.ModBase(value2.id, num5);
	}
	else
	{
		int num6 = product.elements.Base(value3.id);
		if ((num6 <= 0 && value3.Value < 0 && value3.Value < num6) || (value3.Value > 0 && value3.Value > num6))
		int num6 = product.elements.Base(value2.id);
		if ((num6 <= 0 && value2.Value < 0 && value2.Value < num6) || (value2.Value > 0 && value2.Value > num6))
		{
			product.elements.SetTo(value3.id, value3.Value);
			product.elements.SetTo(value2.id, value2.Value);
		}
	}
}

DramaOutcome ​

public void reward_stone_dream()

cs
	Chara chara = EMono.game.cards.globalCharas.Find("farris");
	if (chara != null)
	{
		chara.ability.Add(6754, 50, pt: false);
		chara.ability.Add(6754, 50, pt: false, permanent: true);
		Msg.Say("learnSkill", chara.NameBraced, EMono.sources.elements.map[6754].GetName());
	}
}

ELEMENT ​

public virtual void OnChangeValue()

cs
public void CheckLevelBonus(ElementContainer owner, UINote n = null)
{
	if (owner == null || source.levelBonus.IsEmpty())
	if (owner == null || source.levelBonus.IsEmpty() || (!owner.HasBase(1405) && id == 241))
	{
		return;
	}

ElementContainer ​

public int Base(int ele)

cs
public void Learn(int ele, int v = 1)
{
	ModBase(ele, v);
	Element element = GetElement(ele);
	if (element is Ability && !element.PotentialAsStock)
	{
		element.vPotential = 1;
	}
	OnLearn(ele);
}

ElementContainerCard ​

public void CheckSkillActions()

cs
	TryLearn(6720, 1657, 0);
	TryLearn(6450, 132, 5);
	TryLearn(6603, 6020, 20);
	if (HasBase(1405))
	{
		TryLearn(6750, 241, 3);
		TryLearn(6752, 241, 8);
		TryLearn(6754, 241, 25);
		TryLearn(6753, 241, 36);
	}
}
void TryLearn(int eleAction, int reqEle, int lqlv)
{
	if (!HasBase(eleAction) && HasBase(reqEle) && GetElement(reqEle).ValueWithoutLink >= lqlv)
	if (HasBase(eleAction) || !HasBase(reqEle) || GetElement(reqEle).ValueWithoutLink < lqlv)
	{
		if (HasBase(eleAction) && HasBase(reqEle) && GetElement(reqEle).ValueWithoutLink >= lqlv)
		{
			GetElement(eleAction).vPotential = 1;
		}
	}
	else
	{
		SetBase(eleAction, 1);
		SetBase(eleAction, 1, 1);
		if (EClass.core.IsGameStarted)
		{
			if (owner.IsPC)

Game ​

public void ApplyFix()

cs
		}
	}
});
version.IsBelow(0, 23, 356);
if (version.IsBelow(0, 23, 354))
{
	FixElement(EClass.pc, 1421);

LayerEditPlaylist ​

public void Activate(Mode _mode = Mode.Playlist)

cs
			itemsNight.Add(bgms[item2]);
		}
	}
	UIButton b = null;
	b = windows[0].AddBottomButton(Text(), delegate
	{
		SE.Tab();
		ELayer._map.config.shufflePL = !ELayer._map.config.shufflePL;
		b.mainText.SetText(Text());
	});
}
else
{

public void Activate(Mode _mode = Mode.Playlist)

cs
	{
		owner.OnSwitchContent();
	}
	static string Text()
	{
		return "shufflePL".lang() + ": " + (ELayer._map.config.shufflePL ? "on" : "off").lang();
	}
}

public void Refresh()

LayerSkinDeco ​

using System;

cs
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnityEngine;

public class LayerSkinDeco : ELayer

public class LayerSkinDeco : ELayer

cs
[NonSerialized]
public Widget widget;

public static List<Sprite> customSprites;
public Transform widgetHolder;

public List<SkinDeco> decos => widget.config.skin.decos;

public SkinConfig cfg => widget.config.skin;

public static List<Sprite> GetCustomSprites()
{
	if (customSprites == null)
	{
		customSprites = new List<Sprite>();
		string[] files = Directory.GetFiles(CorePath.custom + "Deco");
		foreach (string text in files)
		{
			FileInfo fileInfo = new FileInfo(text);
			if (fileInfo.Extension == ".png")
			{
				Texture2D texture2D = IO.LoadPNG(text, FilterMode.Bilinear);
				Sprite sprite = Sprite.Create(texture2D, new Rect(0f, 0f, texture2D.width, texture2D.height), new Vector2(0.5f, 0.5f));
				sprite.name = "_" + fileInfo.Name;
				customSprites.Add(sprite);
			}
		}
	}
	return customSprites;
}
public override void OnInit()
{
	base.OnInit();

public override void OnUpdateInput()

cs
	sy = 100,
	color = Color.white
};
skinDeco.id = int.Parse(a.name.Remove(0, 4));
if (a.name.StartsWith("_"))
{
	skinDeco.name = a.name;
	skinDeco.id = 0;
}
else
{
	skinDeco.id = int.Parse(a.name.Remove(0, 4));
}
widget.AddDeco(skinDeco);
SkinDecoActor actor = skinDeco.actor;
Activate(actor);

public override void OnUpdateInput()

cs
			m.Hide();
		}
	};
	Sprite[] array = Resources.LoadAll<Sprite>("Media/Graphics/Deco/");
	foreach (Sprite o in array)
	foreach (Sprite item in Resources.LoadAll<Sprite>("Media/Graphics/Deco/").Concat(GetCustomSprites()))
	{
		uIList.Add(o);
		uIList.Add(item);
	}
	uIList.Refresh();
}

public void Activate(SkinDecoActor actor)

cs
	uIDragPanel.target = actor.Rect();
	uIDragPanel.bound = actor.Rect();
	uIDragPanel.clamp = false;
	foreach (SkinDeco deco in decos)
	{
		deco.actor?.Refresh();
	}
}

public override void OnKill()

public override void OnKill()

cs
			actor.transform.SetParent(widget.transform, worldPositionStays: true);
			deco.x = (int)actor.Rect().anchoredPosition.x;
			deco.y = (int)actor.Rect().anchoredPosition.y;
			actor.Refresh();
			actor.Refresh(editing: false);
		}
	}
}

Map ​

public void RefreshFOV(int x, int z, int radius = 6, bool recalculate = false)

cs
{
	ForeachSphere(x, z, radius, delegate(Point p)
	{
		List<Card> list = p.ListCards();
		if (recalculate)
		CellDetail detail = p.detail;
		if (detail == null)
		{
			foreach (Card item in list)
			return;
		}
		foreach (Thing thing in detail.things)
		{
			if (recalculate)
			{
				item.RecalculateFOV();
				thing.RecalculateFOV();
			}
			else
			{
				thing.CalculateFOV();
			}
			return;
		}
		foreach (Card item2 in list)
		foreach (Chara chara in detail.charas)
		{
			item2.CalculateFOV();
			if (recalculate)
			{
				chara.RecalculateFOV();
			}
			else
			{
				chara.CalculateFOV();
			}
		}
	});
}

MapConfig ​

public class MapConfig : EClass

cs
[JsonProperty]
public bool reverseRoof;

[JsonProperty]
public bool shufflePL;
[JsonProperty]
public Weather.Condition fixedCondition = Weather.Condition.None;

Msg ​

public static string SayRaw(string text)

cs
	currentColor = colors.Default;
	return "";
}
ToUpperFirst(text);
text = text.ToSentenceCase();
if ((bool)feed)
{
	feed.System(text);

Point ​

public class Point : EClass

cs
public static BaseGameScreen _screen;

private static List<Card> listCard = new List<Card>();
private static List<Chara> listChara = new List<Chara>();
public int index => x + z * map.Size;

public Cell cell => map.cells[x, z];

public Point Clamp(bool useBounds = false)

cs
public List<Card> ListCards(bool includeMasked = false)
{
	listCard.Clear();
	List<Card> list = new List<Card>();
	bool flag = EClass.scene.actionMode != null && EClass.scene.actionMode.IsRoofEditMode();
	if (detail != null)
	{

public List<Card> ListCards(bool includeMasked = false)

cs
		{
			if (!thing.isHidden && (includeMasked || !thing.isMasked) && thing.isRoofItem == flag)
			{
				listCard.Add(thing);
				list.Add(thing);
			}
		}
		if (!flag)
		{
			foreach (Chara chara in detail.charas)
			{
				listCard.Add(chara);
				list.Add(chara);
			}
		}
	}
	return listCard;
	return list;
}

public List<Card> ListVisibleCards()
{
	listCard.Clear();
	List<Card> list = new List<Card>();
	if (detail != null)
	{
		foreach (Thing thing in detail.things)
		{
			if (!thing.isHidden && !thing.isMasked && !thing.isRoofItem)
			{
				listCard.Add(thing);
				list.Add(thing);
			}
		}
		foreach (Chara chara in detail.charas)
		{
			if (EClass.pc.CanSee(chara))
			{
				listCard.Add(chara);
				list.Add(chara);
			}
		}
	}
	return listCard;
	return list;
}

public Card FindAttackTarget()

public Thing FindThing(Func<Thing, bool> func)

cs
public List<Card> ListThings<T>(bool onlyInstalled = true) where T : Trait
{
	listCard.Clear();
	List<Card> list = new List<Card>();
	if (detail != null)
	{
		foreach (Thing thing in detail.things)
		{
			if (!thing.isHidden && !thing.isRoofItem && !thing.isMasked && (!onlyInstalled || thing.IsInstalled) && thing.trait is T)
			{
				listCard.Add(thing);
				list.Add(thing);
			}
		}
	}
	return listCard;
	return list;
}

public List<Chara> ListCharas()
{
	listChara.Clear();
	List<Chara> list = new List<Chara>();
	if (detail != null)
	{
		foreach (Chara chara in detail.charas)
		{
			listChara.Add(chara);
			list.Add(chara);
		}
	}
	return listChara;
	return list;
}

public List<Chara> ListVisibleCharas()
{
	listChara.Clear();
	List<Chara> list = new List<Chara>();
	if (detail != null)
	{
		foreach (Chara chara in detail.charas)
		{
			if (EClass.pc.CanSee(chara))
			{
				listChara.Add(chara);
				list.Add(chara);
			}
		}
	}
	return listChara;
	return list;
}

public List<Chara> ListCharasInNeighbor(Func<Chara, bool> func)
{
	listChara.Clear();
	List<Chara> list = new List<Chara>();
	ForeachNeighbor(delegate(Point p)
	{
		if (p.detail == null)

public List<Chara> ListCharasInNeighbor(Func<Chara, bool> func)

cs
		{
			if (func(chara))
			{
				listChara.Add(chara);
				list.Add(chara);
			}
		}
	});
	return listChara;
	return list;
}

public List<Chara> ListCharasInRadius(Chara cc, int dist, Func<Chara, bool> func, bool onlyVisible = true)
{
	listChara.Clear();
	List<Chara> list = new List<Chara>();
	foreach (Chara chara in EClass._map.charas)
	{
		if (func(chara) && chara.Dist(cc) < dist && (!onlyVisible || Los.IsVisible(chara, cc)))
		{
			listChara.Add(chara);
			list.Add(chara);
		}
	}
	return listChara;
	return list;
}

public T GetInstalled<T>() where T : Trait

Recipe ​

public virtual void Build(Chara chara, Card t, Point pos, int mat, int dir, int…)

cs
EClass._map.SetBlock(pos.x, pos.z, mat, ramp, dir);
if (tileType.IsBlockPass && pos.HasChara)
{
	foreach (Chara item in pos.ListCharas().Copy())
	foreach (Chara item in pos.ListCharas())
	{
		chara.Kick(item, ignoreSelf: false, karmaLoss: false);
	}

RecipeCard ​

void CheckBlock(Point _pos)

cs
{
	if (_pos.cell.IsBlocked && _pos.HasChara)
	{
		foreach (Chara item in _pos.ListCharas().Copy())
		foreach (Chara item in _pos.ListCharas())
		{
			chara.Kick(item, ignoreSelf: false, karmaLoss: false);
		}

Thing ​

public override string GetExtraName()

cs
	}
	else if (trait.CanOpenContainer)
	{
		text += "empty".lang();
		text = text + " " + "empty".lang();
	}
}
if ((trait is TraitRoomPlate || trait is TraitHouseBoard) && pos.IsValid)

TraitDoorBig ​

public class TraitDoorBig : TraitDoor

cs
{
	public override int height => 2;

	public override string idSound => "door3";
	public override string idSound => GetParam(1);

	public override void ToggleDoor(bool sound = true, bool refresh = true)
	{

Widget ​

public virtual void OnApplySkin()

cs
public void InstantiateDeco(SkinDeco deco)
{
	SkinDecoActor skinDecoActor = (deco.actor = Util.Instantiate<SkinDecoActor>("UI/Widget/SkinDecoActor", base.transform));
	SkinDecoActor skinDecoActor = Util.Instantiate<SkinDecoActor>("UI/Widget/SkinDecoActor", base.transform);
	deco.actor = skinDecoActor;
	skinDecoActor.owner = deco;
	skinDecoActor.image.sprite = ResourceCache.Load<Sprite>("Media/Graphics/Deco/deco" + deco.id);
	skinDecoActor.image.sprite = GetSprite();
	skinDecoActor.Rect().anchoredPosition = new Vector2(deco.x, deco.y);
	skinDecoActor.Refresh();
	skinDecoActor.Refresh(editing: false);
	Sprite GetSprite()
	{
		if (!deco.name.IsEmpty())
		{
			foreach (Sprite customSprite in LayerSkinDeco.GetCustomSprites())
			{
				if (customSprite.name == deco.name)
				{
					return customSprite;
				}
			}
		}
		return ResourceCache.Load<Sprite>("Media/Graphics/Deco/deco" + deco.id);
	}
}

public void AddDeco(SkinDeco deco)

Zone ​

public void RefreshPlaylist()

cs
	{
		map.plDay = CreatePlaylist(ref map._plDay, EClass.Sound.GetPlaylist(IDPlayList));
	}
	map.plDay.shuffle = EClass._map.config.shufflePL;
}

public void ResetPlaylist()