protected override void OnSpawn()
{
GetComponent <Storage>().SetOffsets(DELIVERY_OFFSETS);
Storage component = GetComponent <Storage>();
Storage storage = component;
storage.OnWorkableEventCB = (Action <Workable.WorkableEvent>)Delegate.Combine(storage.OnWorkableEventCB, new Action <Workable.WorkableEvent>(OnWorkEvent));
KAnimFile anim = Assets.GetAnim("anim_bury_dupe_kanim");
int num = 0;
while (true)
{
KAnim.Anim anim2 = anim.GetData().GetAnim(num);
if (anim2 == null)
{
break;
}
if (anim2.name == "working_pre")
{
float workTime = (float)(anim2.numFrames - 3) / anim2.frameRate;
component.SetWorkTime(workTime);
break;
}
num++;
}
base.OnSpawn();
base.smi.StartSM();
Components.Graves.Add(this);
}
private bool ShouldUseSidewaysSymbol(KBatchedAnimController controller)
{
KAnim.Anim currentAnim = controller.GetCurrentAnim();
if (currentAnim == null)
{
return(false);
}
int currentFrameIndex = controller.GetCurrentFrameIndex();
if (currentFrameIndex <= 0)
{
return(false);
}
KBatchGroupData batchGroupData = KAnimBatchManager.Instance().GetBatchGroupData(currentAnim.animFile.animBatchTag);
KAnim.Anim.Frame frame = batchGroupData.GetFrame(currentFrameIndex);
for (int i = 0; i < frame.numElements; i++)
{
KAnim.Anim.FrameElement frameElement = batchGroupData.GetFrameElement(frame.firstElementIdx + i);
if (frameElement.symbol == HASH_SNAPTO_EYES && frameElement.frame >= FIRST_SIDEWAYS_FRAME)
{
return(true);
}
}
return(false);
}
KAnim.Anim GetAnim(string aniname)
{
//Debug.Log("GetAnim:" + aniname);
if (dataK == null)
{
return(null);
}
aniname = aniname.Replace('\\', '/');
if (dataK.anims.ContainsKey(aniname) == false)
{
var anis = Resources.Load(aniname, typeof(TextAsset)) as TextAsset;
if (anis == null)
{
//Debug.Log("GetAnim Fail:" + aniname);
return(null);
}
using (System.IO.MemoryStream ms = new System.IO.MemoryStream(anis.bytes))
{
KAnim.Anim anim = new KAnim.Anim(dataK);
anim.Read(ms);
dataK.anims[aniname] = anim;
}
}
if (dataK.anims.ContainsKey(aniname) == false)
{
Debug.Log("GetAnim Fail:" + aniname);
return(null);
}
return(dataK.anims[aniname]);
}
public void AddAnims(KAnimFile anim_file)
{
KAnimFileData data = anim_file.GetData();
if (data == null)
{
Debug.LogError("AddAnims() Null animfile data");
}
else
{
maxSymbols = Mathf.Max(maxSymbols, data.maxVisSymbolFrames);
for (int i = 0; i < data.animCount; i++)
{
KAnim.Anim anim = data.GetAnim(i);
if (anim.animFile.hashName != data.hashName)
{
Debug.LogErrorFormat("How did we get an anim from another file? [{0}] != [{1}] for anim [{2}]", data.name, anim.animFile.name, i);
}
anims[anim.hash] = new AnimLookupData
{
animIndex = anim.index
};
}
if (usingNewSymbolOverrideSystem && data.buildIndex != -1 && data.build.symbols != null && data.build.symbols.Length > 0)
{
SymbolOverrideController component = GetComponent <SymbolOverrideController>();
component.AddBuildOverride(anim_file.GetData(), -1);
}
}
}
public static Rect Calc_Bound(KAnim.Anim anim, KAnim.Element elem)
{
//if(anim.parent.seeds.ContainsKey(elem.seednow)==false)
//{
// Debug.LogError("failed Calc_Bound:" + elem.seednow);
//}
var seed = anim.parent.seeds[elem.seednow];
//string filename = System.IO.Path.GetFileNameWithoutExtension(elem.seed.texname);
//block = tmgr.GetTexture(System.IO.Path.Combine(texpath, seed.texname));
var seedorient = seed.orient;
//seedsize = seed.size;
//color = elem.color;
var pos = elem.pos;
var scale = elem.scale;
var rotate = elem.rotate;
Vector2 seed_size = seed.size;
seed_size.x *= scale.x;
seed_size.y *= scale.y;
Vector2 seed_orient = seed.orient;
seed_orient.x *= scale.x;
seed_orient.y *= scale.y;
var bounds = Seed.CalcRotate(seed_size, seed_orient, rotate);
//bounds.Offset(pos.X, pos.Y);
bounds.x += pos.x;
bounds.y += pos.y;
return(bounds);
}
public void Sync(KAnimControllerBase controller)
{
if (!((Object)masterController == (Object)null) && !((Object)controller == (Object)null))
{
KAnim.Anim currentAnim = masterController.GetCurrentAnim();
if (currentAnim != null)
{
KAnim.PlayMode mode = masterController.GetMode();
float playSpeed = masterController.GetPlaySpeed();
float elapsedTime = masterController.GetElapsedTime();
controller.Play(currentAnim.name, mode, playSpeed, elapsedTime);
Facing component = controller.GetComponent <Facing>();
if ((Object)component != (Object)null)
{
Vector3 position = component.transform.GetPosition();
float x = position.x;
x += ((!masterController.FlipX) ? 0.5f : (-0.5f));
component.Face(x);
}
else
{
controller.FlipX = masterController.FlipX;
controller.FlipY = masterController.FlipY;
}
}
}
}
private void RebuildOverrides(KAnimFile kanim_file)
{
bool flag = false;
overrideAnims.Clear();
for (int i = 0; i < overrideAnimFiles.Count; i++)
{
OverrideAnimFileData overrideAnimFileData = overrideAnimFiles[i];
KAnimFileData data = overrideAnimFileData.file.GetData();
for (int j = 0; j < data.animCount; j++)
{
KAnim.Anim anim = data.GetAnim(j);
if (anim.animFile.hashName != data.hashName)
{
Debug.LogError($"How did we get an anim from another file? [{data.name}] != [{anim.animFile.name}] for anim [{j}]");
}
AnimLookupData value = default(AnimLookupData);
value.animIndex = anim.index;
HashedString hashedString = new HashedString(anim.name);
if (!overrideAnims.ContainsKey(hashedString))
{
overrideAnims[hashedString] = value;
}
if (curAnim != null && curAnim.hash == hashedString && (UnityEngine.Object)overrideAnimFileData.file == (UnityEngine.Object)kanim_file)
{
flag = true;
}
}
}
if (flag)
{
Restart(curAnim.name, mode, playSpeed, 0f);
}
}
public bool IsAnimAllowedToPlaySpeech(KAnim.Anim anim)
{
HashSet <HashedString> value = null;
if (animsNotAllowedToPlaySpeech.TryGetValue(anim.animFile.name, out value))
{
return(!value.Contains(anim.hash));
}
return(true);
}
private void ApplyShape(KAnim.Build.Symbol variation_symbol, KBatchedAnimController controller, KAnimFile shapes_file, HashedString symbol_name_in_shape_file, bool should_use_sideways_symbol)
{
HashedString hashedString = HASH_NEUTRAL;
if (currentExpression != null)
{
hashedString = currentExpression.face.hash;
}
KAnim.Anim anim = null;
KAnim.Anim.FrameElement frameElement = default(KAnim.Anim.FrameElement);
bool flag = false;
bool flag2 = false;
for (int i = 0; i < shapes_file.GetData().animCount; i++)
{
if (flag)
{
break;
}
KAnim.Anim anim2 = shapes_file.GetData().GetAnim(i);
if (anim2.hash == hashedString)
{
anim = anim2;
KAnim.Anim.Frame frame = anim.GetFrame(shapes_file.GetData().build.batchTag, 0);
for (int j = 0; j < frame.numElements; j++)
{
KBatchGroupData batchGroupData = KAnimBatchManager.Instance().GetBatchGroupData(shapes_file.GetData().animBatchTag);
frameElement = batchGroupData.GetFrameElement(frame.firstElementIdx + j);
if (!(frameElement.symbol != symbol_name_in_shape_file))
{
if (flag2 || !should_use_sideways_symbol)
{
flag = true;
}
flag2 = true;
break;
}
}
}
}
if (anim == null)
{
DebugUtil.Assert(false, "Could not find shape for expression: " + HashCache.Get().Get(hashedString));
}
if (!flag2)
{
DebugUtil.Assert(false, "Could not find shape element for shape:" + HashCache.Get().Get(variation_symbol.hash));
}
KAnim.Build.Symbol symbol = KAnimBatchManager.Instance().GetBatchGroupData(controller.batchGroupID).GetSymbol(symbol_name_in_shape_file);
KBatchGroupData batchGroupData2 = KAnimBatchManager.Instance().GetBatchGroupData(variation_symbol.build.batchTag);
KAnim.Build.SymbolFrameInstance symbol_frame_instance = batchGroupData2.symbolFrameInstances[variation_symbol.firstFrameIdx + frameElement.frame];
symbol_frame_instance.buildImageIdx = GetComponent <SymbolOverrideController>().GetAtlasIdx(variation_symbol.build.GetTexture(0));
controller.SetSymbolOverride(symbol.firstFrameIdx, symbol_frame_instance);
}
/// <summary>
/// Optimizes the play mode used for animations.
/// </summary>
/// <param name="anim">The anim file that is playing.</param>
/// <param name="currentMode">The current play mode requested by the game.</param>
/// <returns>The play mode to use for playing it taking optimizations into account.</returns>
public KAnim.PlayMode GetAnimState(KAnim.Anim anim, KAnim.PlayMode currentMode)
{
var mode = currentMode;
if (anim != null && idleAnims.TryGetValue(anim.id, out AnimWrapper status) &&
status.anim == anim)
{
mode = status.veryTrivial ? KAnim.PlayMode.Paused : KAnim.PlayMode.Once;
}
return(mode);
}
protected void StartQueuedAnim()
{
StopAnimEventSequence();
previousFrame = -1;
currentFrame = -1;
SuspendUpdates(false);
stopped = false;
OnStartQueuedAnim();
AnimData animData = animQueue.Dequeue();
while (animData.mode == KAnim.PlayMode.Loop && animQueue.Count > 0)
{
animData = animQueue.Dequeue();
}
if (overrideAnims == null || !overrideAnims.TryGetValue(animData.anim, out AnimLookupData value))
{
if (!anims.TryGetValue(animData.anim, out value))
{
bool flag = true;
if ((UnityEngine.Object)showWhenMissing != (UnityEngine.Object)null)
{
showWhenMissing.SetActive(true);
}
if (flag)
{
TriggerStop();
return;
}
}
else if ((UnityEngine.Object)showWhenMissing != (UnityEngine.Object)null)
{
showWhenMissing.SetActive(false);
}
}
curAnim = GetAnim(value.animIndex);
int num = 0;
if (animData.mode == KAnim.PlayMode.Loop && randomiseLoopedOffset)
{
num = UnityEngine.Random.Range(0, curAnim.numFrames - 1);
}
prevAnimFrame = -1;
curAnimFrameIdx = GetFrameIdxFromOffset(num);
currentFrame = curAnimFrameIdx;
mode = animData.mode;
playSpeed = animData.speed * PlaySpeedMultiplier;
SetElapsedTime((float)num / curAnim.frameRate + animData.timeOffset);
synchronizer.Sync();
StartAnimEventSequence();
AnimEnter(animData.anim);
}
protected virtual void OnDestroy()
{
animFiles = null;
curAnim = null;
curBuild = null;
synchronizer = null;
layering = null;
animQueue = null;
overrideAnims = null;
anims = null;
synchronizer = null;
layering = null;
overrideAnimFiles = null;
}
public void AddAnim(KAnim.Anim anim)
{
Debug.Assert(anim.index == anims.Count);
anims.Add(anim);
}
private void UpdateFrame()
{
forceUpdate = false;
bool symbolVisible = false;
KAnim.Anim currentAnim = controller.CurrentAnim;
if (currentAnim != null)
{
Matrix2x3 symbolLocalTransform = controller.GetSymbolLocalTransform(symbol, out symbolVisible);
Vector3 position = controller.transform.GetPosition();
if (symbolVisible && (previousMatrix != symbolLocalTransform || position != previousPosition || useTargetPoint))
{
previousMatrix = symbolLocalTransform;
previousPosition = position;
Matrix2x3 overrideTransformMatrix = controller.GetTransformMatrix() * symbolLocalTransform;
Vector3 position2 = base.transform.GetPosition();
float z = position2.z;
base.transform.SetPosition(overrideTransformMatrix.MultiplyPoint(offset));
if (useTargetPoint)
{
Vector3 position3 = base.transform.GetPosition();
position3.z = 0f;
Vector3 from = targetPoint - position3;
float num = Vector3.Angle(from, Vector3.right);
if (from.y < 0f)
{
num = 360f - num;
}
base.transform.localRotation = Quaternion.identity;
base.transform.RotateAround(position3, new Vector3(0f, 0f, 1f), num);
float sqrMagnitude = from.sqrMagnitude;
KBatchedAnimInstanceData batchInstanceData = myAnim.GetBatchInstanceData();
Vector3 position4 = base.transform.GetPosition();
float x = position4.x;
Vector3 position5 = base.transform.GetPosition();
batchInstanceData.SetClipRadius(x, position5.y, sqrMagnitude, true);
}
else
{
Vector3 v = (!controller.FlipX) ? Vector3.right : Vector3.left;
Vector3 v2 = (!controller.FlipY) ? Vector3.up : Vector3.down;
base.transform.up = overrideTransformMatrix.MultiplyVector(v2);
base.transform.right = overrideTransformMatrix.MultiplyVector(v);
if ((Object)myAnim != (Object)null)
{
myAnim.GetBatchInstanceData()?.SetOverrideTransformMatrix(overrideTransformMatrix);
}
}
Transform transform = base.transform;
Vector3 position6 = base.transform.GetPosition();
float x2 = position6.x;
Vector3 position7 = base.transform.GetPosition();
transform.SetPosition(new Vector3(x2, position7.y, z));
myAnim.SetDirty();
}
}
if ((Object)myAnim != (Object)null && symbolVisible != myAnim.enabled)
{
myAnim.enabled = symbolVisible;
}
}
private void ParseAnims(BinaryReader reader)
{
var animData = new KAnim.Anim
{
Version = reader.ReadInt32(),
ElementCount = reader.ReadInt32(),
FrameCount = reader.ReadInt32(),
AnimCount = reader.ReadInt32(),
Anims = new List <KAnim.AnimBank>()
};
Utilities.LogToDump(
$" Version: {animData.Version}\n" +
$" # elements: {animData.ElementCount}\n" +
$" # frames: {animData.FrameCount}\n" +
$" # anims: {animData.AnimCount}\n" +
"\n<Anims>", Logger);
for (var i = 0; i < animData.AnimCount; i++)
{
var name = reader.ReadPString();
var hash = reader.ReadInt32();
var bank = new KAnim.AnimBank
{
Name = name,
Hash = hash,
Rate = reader.ReadSingle(),
FrameCount = reader.ReadInt32(),
Frames = new List <KAnim.Frame>()
};
Utilities.LogToDump(
$" Anim \"{bank.Name}\" (hash {bank.Hash}): {bank.FrameCount} frames @ {bank.Rate} fps", Logger);
for (var j = 0; j < bank.FrameCount; j++)
{
var frame = new KAnim.Frame
{
X = reader.ReadSingle(),
Y = reader.ReadSingle(),
Width = reader.ReadSingle(),
Height = reader.ReadSingle(),
ElementCount = reader.ReadInt32(),
Elements = new List <KAnim.Element>()
};
Utilities.LogToDump(
$" Frame @ ({frame.X}, {frame.Y}) is {frame.Width}x{frame.Height}. {frame.ElementCount} sub-elements.",
Logger);
for (var k = 0; k < frame.ElementCount; k++)
{
var element = new KAnim.Element
{
ImageHash = reader.ReadInt32(),
Index = reader.ReadInt32(),
Layer = reader.ReadInt32(),
Flags = reader.ReadInt32(),
A = reader.ReadSingle(),
B = reader.ReadSingle(),
G = reader.ReadSingle(),
R = reader.ReadSingle(),
M1 = reader.ReadSingle(),
M2 = reader.ReadSingle(),
M3 = reader.ReadSingle(),
M4 = reader.ReadSingle(),
M5 = reader.ReadSingle(),
M6 = reader.ReadSingle(),
Order = reader.ReadSingle()
};
string plainName;
try
{
plainName = $"(\"{BuildHashes[element.ImageHash]}\")";
} catch (KeyNotFoundException)
{
plainName = "(plain name not found)";
}
Utilities.LogToDump(
$" Sub-element #{element.Index} is {element.ImageHash} {plainName} @ layer {element.Layer}\n" +
$" Matrix: ({element.M1} {element.M2} {element.M3} {element.M4}), translate {element.M5} {element.M6}. Order {element.Order}",
Logger);
frame.Elements.Add(element);
}
bank.Frames.Add(frame);
}
animData.Anims.Add(bank);
}
animData.MaxVisibleSymbolFrames = reader.ReadInt32();
Utilities.LogToDump($" Max visible frames: {animData.MaxVisibleSymbolFrames}", Logger);
AnimData = animData;
}
public static Sprite GetUISpriteFromMultiObjectAnim(KAnimFile animFile, string animName = "ui", bool centered = false, string symbolName = "")
{
Tuple <KAnimFile, string, bool> key = new Tuple <KAnimFile, string, bool>(animFile, animName, centered);
if (knownUISprites.ContainsKey(key))
{
return(knownUISprites[key]);
}
if ((UnityEngine.Object)animFile == (UnityEngine.Object)null)
{
DebugUtil.LogWarningArgs(animName, "missing Anim File");
return(null);
}
KAnimFileData data = animFile.GetData();
if (data == null)
{
DebugUtil.LogWarningArgs(animName, "KAnimFileData is null");
return(null);
}
if (data.build == null)
{
return(null);
}
KAnim.Anim.Frame frame = KAnim.Anim.Frame.InvalidFrame;
for (int i = 0; i < data.animCount; i++)
{
KAnim.Anim anim = data.GetAnim(i);
if (anim.name == animName)
{
frame = anim.GetFrame(data.batchTag, 0);
}
}
if (!frame.IsValid())
{
DebugUtil.LogWarningArgs($"missing '{animName}' anim in '{animFile}'");
return(null);
}
if (data.elementCount == 0)
{
return(null);
}
KAnim.Anim.FrameElement frameElement = default(KAnim.Anim.FrameElement);
if (string.IsNullOrEmpty(symbolName))
{
symbolName = animName;
}
frameElement = data.FindAnimFrameElement(symbolName);
KAnim.Build.Symbol symbol = data.build.GetSymbol(frameElement.symbol);
if (symbol == null)
{
DebugUtil.LogWarningArgs(animFile.name, animName, "placeSymbol [", frameElement.symbol, "] is missing");
return(null);
}
int frame2 = frameElement.frame;
KAnim.Build.SymbolFrameInstance frame3 = symbol.GetFrame(frame2);
KAnim.Build.SymbolFrame symbolFrame = frame3.symbolFrame;
if (symbolFrame == null)
{
DebugUtil.LogWarningArgs(animName, "SymbolFrame [", frameElement.frame, "] is missing");
return(null);
}
Texture2D texture = data.build.GetTexture(0);
float x = symbolFrame.uvMin.x;
float x2 = symbolFrame.uvMax.x;
float y = symbolFrame.uvMax.y;
float y2 = symbolFrame.uvMin.y;
int num = (int)((float)texture.width * Mathf.Abs(x2 - x));
int num2 = (int)((float)texture.height * Mathf.Abs(y2 - y));
float num3 = Mathf.Abs(symbolFrame.bboxMax.x - symbolFrame.bboxMin.x);
Rect rect = default(Rect);
rect.width = (float)num;
rect.height = (float)num2;
rect.x = (float)(int)((float)texture.width * x);
rect.y = (float)(int)((float)texture.height * y);
float pixelsPerUnit = 100f;
if (num != 0)
{
pixelsPerUnit = 100f / (num3 / (float)num);
}
Sprite sprite = Sprite.Create(texture, rect, (!centered) ? Vector2.zero : new Vector2(0.5f, 0.5f), pixelsPerUnit, 0u, SpriteMeshType.FullRect);
sprite.name = $"{texture.name}:{animName}:{frameElement.frame.ToString()}:{centered}";
knownUISprites[key] = sprite;
return(sprite);
}
public static void ParseAnimData(KBatchGroupData data, HashedString fileNameHash, FastReader reader, KAnimFileData animFile)
{
CheckHeader("ANIM", reader);
uint num = reader.ReadUInt32();
Assert(num == 5, "Invalid anim.bytes version");
reader.ReadInt32();
reader.ReadInt32();
int num2 = reader.ReadInt32();
animFile.maxVisSymbolFrames = 0;
animFile.animCount = 0;
animFile.frameCount = 0;
animFile.elementCount = 0;
animFile.firstAnimIndex = data.anims.Count;
animFile.animBatchTag = data.groupID;
data.animIndex.Add(fileNameHash, data.anims.Count);
animFile.firstElementIndex = data.frameElements.Count;
for (int i = 0; i < num2; i++)
{
KAnim.Anim anim = new KAnim.Anim(animFile, data.anims.Count);
anim.name = reader.ReadKleiString();
string text = animFile.name + "." + anim.name;
anim.id = text;
HashCache.Get().Add(anim.name);
HashCache.Get().Add(text);
anim.hash = anim.name;
anim.rootSymbol.HashValue = reader.ReadInt32();
anim.frameRate = reader.ReadSingle();
anim.firstFrameIdx = data.animFrames.Count;
anim.numFrames = reader.ReadInt32();
anim.totalTime = (float)anim.numFrames / anim.frameRate;
anim.scaledBoundingRadius = 0f;
for (int j = 0; j < anim.numFrames; j++)
{
KAnim.Anim.Frame item = default(KAnim.Anim.Frame);
float num3 = reader.ReadSingle();
float num4 = reader.ReadSingle();
float num5 = reader.ReadSingle();
float num6 = reader.ReadSingle();
item.bbox = new AABB3(new Vector3(num3 - num5 * 0.5f, 0f - (num4 + num6 * 0.5f), 0f) * 0.005f, new Vector3(num3 + num5 * 0.5f, 0f - (num4 - num6 * 0.5f), 0f) * 0.005f);
float num7 = Math.Max(Math.Abs(item.bbox.max.x), Math.Abs(item.bbox.min.x));
float num8 = Math.Max(Math.Abs(item.bbox.max.y), Math.Abs(item.bbox.min.y));
float num9 = Math.Max(num7, num8);
anim.unScaledSize.x = Math.Max(anim.unScaledSize.x, num7 / 0.005f);
anim.unScaledSize.y = Math.Max(anim.unScaledSize.y, num8 / 0.005f);
anim.scaledBoundingRadius = Math.Max(anim.scaledBoundingRadius, Mathf.Sqrt(num9 * num9 + num9 * num9));
item.idx = data.animFrames.Count;
item.firstElementIdx = data.frameElements.Count;
item.numElements = reader.ReadInt32();
int num10 = 0;
for (int k = 0; k < item.numElements; k++)
{
KAnim.Anim.FrameElement item2 = default(KAnim.Anim.FrameElement);
item2.fileHash = fileNameHash;
item2.symbol = new KAnimHashedString(reader.ReadInt32());
item2.frame = reader.ReadInt32();
item2.folder = new KAnimHashedString(reader.ReadInt32());
item2.flags = reader.ReadInt32();
float a = reader.ReadSingle();
float b = reader.ReadSingle();
float g = reader.ReadSingle();
float r = reader.ReadSingle();
item2.multColour = new Color(r, g, b, a);
float m = reader.ReadSingle();
float m2 = reader.ReadSingle();
float m3 = reader.ReadSingle();
float m4 = reader.ReadSingle();
float m5 = reader.ReadSingle();
float m6 = reader.ReadSingle();
reader.ReadSingle();
item2.transform.m00 = m;
item2.transform.m01 = m3;
item2.transform.m02 = m5;
item2.transform.m10 = m2;
item2.transform.m11 = m4;
item2.transform.m12 = m6;
int symbolIndex = data.GetSymbolIndex(item2.symbol);
if (symbolIndex == -1)
{
num10++;
item2.symbol = MISSING_SYMBOL;
}
else
{
item2.symbolIdx = symbolIndex;
data.frameElements.Add(item2);
animFile.elementCount++;
}
}
item.numElements -= num10;
data.animFrames.Add(item);
animFile.frameCount++;
}
data.AddAnim(anim);
animFile.animCount++;
}
Debug.Assert(num2 == animFile.animCount);
data.animCount[fileNameHash] = animFile.animCount;
animFile.maxVisSymbolFrames = Math.Max(animFile.maxVisSymbolFrames, reader.ReadInt32());
data.UpdateMaxVisibleSymbols(animFile.maxVisSymbolFrames);
ParseHashTable(reader);
}
internal AnimWrapper(KAnim.Anim anim, int numFrames)
{
this.anim = anim;
veryTrivial = numFrames <= SHORT_THRESHOLD;
}
