630 lines
16 KiB
C#
630 lines
16 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
|
|
// Token: 0x02000065 RID: 101
|
|
[ExecuteInEditMode]
|
|
public class HannahAnimatorSimple : MonoBehaviour
|
|
{
|
|
// Token: 0x06000B57 RID: 2903 RVA: 0x000DD998 File Offset: 0x000DBB98
|
|
private void Awake()
|
|
{
|
|
if (this.randomStart)
|
|
{
|
|
this.delay = Random.Range(0f, 0.1f);
|
|
this.startTime = Time.timeSinceLevelLoad;
|
|
this.updateTime = Time.timeSinceLevelLoad + this.delay;
|
|
if (this.realtime)
|
|
{
|
|
this.updateTime = Time.realtimeSinceStartup + this.delay;
|
|
}
|
|
if (this.animationType == HannahAnimatorSimple.type.sprite || this.animationType == HannahAnimatorSimple.type.image)
|
|
{
|
|
this.currentIndex = Random.Range(0, this.sprites.Count - 1);
|
|
}
|
|
if (this.animationType == HannahAnimatorSimple.type.singleMeshRenderer)
|
|
{
|
|
if (this.meshes.Count < 5)
|
|
{
|
|
this.currentIndex = Random.Range(0, this.meshes.Count - 1);
|
|
}
|
|
else
|
|
{
|
|
this.currentIndex = Random.Range(0, 5);
|
|
}
|
|
}
|
|
if (this.animationType == HannahAnimatorSimple.type.multipleMeshRenderers)
|
|
{
|
|
if (this.meshRenderers.Count < 5)
|
|
{
|
|
this.currentIndex = Random.Range(0, this.meshRenderers.Count - 1);
|
|
}
|
|
else
|
|
{
|
|
this.currentIndex = Random.Range(0, 5);
|
|
}
|
|
}
|
|
}
|
|
if (this.animationType == HannahAnimatorSimple.type.multipleMeshRenderers)
|
|
{
|
|
foreach (MeshRenderer meshRenderer in this.meshRenderers)
|
|
{
|
|
if (meshRenderer)
|
|
{
|
|
meshRenderer.gameObject.SetActive(true);
|
|
meshRenderer.enabled = false;
|
|
}
|
|
}
|
|
foreach (MeshRenderer meshRenderer2 in this.meshRenderersAlternative)
|
|
{
|
|
if (meshRenderer2)
|
|
{
|
|
meshRenderer2.gameObject.SetActive(true);
|
|
meshRenderer2.enabled = false;
|
|
}
|
|
}
|
|
}
|
|
this.SetupGroups();
|
|
}
|
|
|
|
// Token: 0x06000B58 RID: 2904 RVA: 0x000DDB68 File Offset: 0x000DBD68
|
|
public void PlaySecondMeshAnimation()
|
|
{
|
|
this.currentIndex = 0;
|
|
this.secondAnimation = true;
|
|
foreach (MeshRenderer meshRenderer in this.meshRenderers)
|
|
{
|
|
if (meshRenderer)
|
|
{
|
|
meshRenderer.enabled = false;
|
|
}
|
|
}
|
|
bool flag = false;
|
|
foreach (MeshRenderer meshRenderer2 in this.meshRenderersAlternative)
|
|
{
|
|
if (meshRenderer2)
|
|
{
|
|
if (!flag)
|
|
{
|
|
meshRenderer2.enabled = true;
|
|
flag = true;
|
|
}
|
|
else
|
|
{
|
|
meshRenderer2.enabled = false;
|
|
}
|
|
}
|
|
}
|
|
this.updateTime = Time.timeSinceLevelLoad;
|
|
this.canPlay = true;
|
|
}
|
|
|
|
// Token: 0x06000B59 RID: 2905 RVA: 0x000DDC40 File Offset: 0x000DBE40
|
|
public bool HasSecondAnimation()
|
|
{
|
|
return this.meshRenderersAlternative.Count > 0;
|
|
}
|
|
|
|
// Token: 0x06000B5A RID: 2906 RVA: 0x000DDC53 File Offset: 0x000DBE53
|
|
public void PlayAgain()
|
|
{
|
|
this.currentIndex = 0;
|
|
this.canPlay = true;
|
|
}
|
|
|
|
// Token: 0x06000B5B RID: 2907 RVA: 0x000DDC64 File Offset: 0x000DBE64
|
|
private void OnEnable()
|
|
{
|
|
if (this.meshRenderers.Count > 0)
|
|
{
|
|
for (int i = 0; i < this.meshRenderers.Count; i++)
|
|
{
|
|
if (this.meshRenderers[i])
|
|
{
|
|
this.meshRenderers[i].enabled = false;
|
|
}
|
|
}
|
|
}
|
|
if (this.randomStart)
|
|
{
|
|
this.delay = Random.Range(0f, 0.1f);
|
|
this.startTime = Time.timeSinceLevelLoad;
|
|
this.updateTime = Time.timeSinceLevelLoad + this.delay;
|
|
if (this.realtime)
|
|
{
|
|
this.updateTime = Time.realtimeSinceStartup + this.delay;
|
|
}
|
|
if (this.animationType == HannahAnimatorSimple.type.sprite || this.animationType == HannahAnimatorSimple.type.image)
|
|
{
|
|
this.currentIndex = Random.Range(0, this.sprites.Count - 1);
|
|
}
|
|
if (this.animationType == HannahAnimatorSimple.type.singleMeshRenderer)
|
|
{
|
|
if (this.meshes.Count < 5)
|
|
{
|
|
this.currentIndex = Random.Range(0, this.meshes.Count - 1);
|
|
}
|
|
else
|
|
{
|
|
this.currentIndex = Random.Range(0, 5);
|
|
}
|
|
}
|
|
if (this.animationType == HannahAnimatorSimple.type.multipleMeshRenderers)
|
|
{
|
|
this.currentIndex = Random.Range(0, this.meshRenderers.Count - 1);
|
|
}
|
|
}
|
|
this.SetupGroups();
|
|
this.canPlay = true;
|
|
}
|
|
|
|
// Token: 0x06000B5C RID: 2908 RVA: 0x000DDDAC File Offset: 0x000DBFAC
|
|
private void OnDisable()
|
|
{
|
|
if (this.randomStart)
|
|
{
|
|
this.delay = Random.Range(0f, 0.5f);
|
|
this.startTime = Time.timeSinceLevelLoad;
|
|
if (this.animationType == HannahAnimatorSimple.type.sprite || this.animationType == HannahAnimatorSimple.type.image)
|
|
{
|
|
this.currentIndex = Random.Range(0, this.sprites.Count - 1);
|
|
}
|
|
if (this.animationType == HannahAnimatorSimple.type.singleMeshRenderer)
|
|
{
|
|
this.currentIndex = Random.Range(0, this.meshes.Count - 1);
|
|
}
|
|
if (this.animationType == HannahAnimatorSimple.type.multipleMeshRenderers)
|
|
{
|
|
this.currentIndex = Random.Range(0, this.meshRenderers.Count - 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.currentIndex = 0;
|
|
}
|
|
this.canPlay = true;
|
|
this.secondAnimation = false;
|
|
if (this.meshRenderers.Count > 0)
|
|
{
|
|
for (int i = 0; i < this.meshRenderers.Count; i++)
|
|
{
|
|
if (this.meshRenderers[i])
|
|
{
|
|
this.meshRenderers[i].enabled = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000B5D RID: 2909 RVA: 0x000DDEB4 File Offset: 0x000DC0B4
|
|
private void SetupGroups()
|
|
{
|
|
if (this.animationType == HannahAnimatorSimple.type.groups && this.currentIndexes.Count != this.singleRenderers.Count)
|
|
{
|
|
this.currentIndexes.Clear();
|
|
for (int i = 0; i < this.singleRenderers.Count; i++)
|
|
{
|
|
if (this.meshRenderers.Count < 5)
|
|
{
|
|
this.currentIndex = Random.Range(0, this.meshRenderers.Count - 1);
|
|
}
|
|
else
|
|
{
|
|
this.currentIndex = Random.Range(0, 5);
|
|
}
|
|
if (this.randomStart)
|
|
{
|
|
this.currentIndexes.Add(this.currentIndex);
|
|
}
|
|
else
|
|
{
|
|
this.currentIndexes.Add(0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000B5E RID: 2910 RVA: 0x000DDF64 File Offset: 0x000DC164
|
|
private void Update()
|
|
{
|
|
if (!this.canPlay)
|
|
{
|
|
return;
|
|
}
|
|
if (this.speed > 0f)
|
|
{
|
|
if (this.animationType == HannahAnimatorSimple.type.sprite && ((!this.realtime && Time.timeSinceLevelLoad > this.updateTime + this.updateInterval) || (this.realtime && Time.realtimeSinceStartup > this.updateTime + this.updateInterval)))
|
|
{
|
|
this.updateTime = Time.timeSinceLevelLoad;
|
|
if (this.realtime)
|
|
{
|
|
this.updateTime = Time.realtimeSinceStartup;
|
|
}
|
|
this.currentIndex++;
|
|
if (this.currentIndex > this.sprites.Count - 1)
|
|
{
|
|
if (!this.loop)
|
|
{
|
|
this.currentIndex = 0;
|
|
this.canPlay = false;
|
|
if (this.turnOffWhenDone)
|
|
{
|
|
base.gameObject.SetActive(false);
|
|
base.gameObject.transform.SetParent(Links.x.cellar.tr);
|
|
}
|
|
return;
|
|
}
|
|
this.currentIndex = 0;
|
|
}
|
|
this.spriteRenderer.sprite = this.sprites[this.currentIndex];
|
|
if (this.randomRotationY || this.randomRotationY || this.randomRotationZ)
|
|
{
|
|
SpriteRenderer spriteRenderer = this.spriteRenderer;
|
|
this.Rotate(spriteRenderer);
|
|
}
|
|
}
|
|
if ((this.animationType == HannahAnimatorSimple.type.multipleMeshRenderers || this.animationType == HannahAnimatorSimple.type.singleMeshRenderer || this.animationType == HannahAnimatorSimple.type.groups) && ((!this.realtime && Time.timeSinceLevelLoad > this.updateTime + this.updateInterval) || (this.realtime && Time.realtimeSinceStartup > this.updateTime + this.updateInterval)))
|
|
{
|
|
this.updateTime = Time.timeSinceLevelLoad;
|
|
if (this.realtime)
|
|
{
|
|
this.updateTime = Time.realtimeSinceStartup;
|
|
}
|
|
if (this.animationType != HannahAnimatorSimple.type.groups)
|
|
{
|
|
this.currentIndex++;
|
|
if ((this.animationType == HannahAnimatorSimple.type.singleMeshRenderer && this.currentIndex >= this.meshes.Count - 1) || (!this.secondAnimation && this.animationType == HannahAnimatorSimple.type.multipleMeshRenderers && this.currentIndex >= this.meshRenderers.Count) || (this.secondAnimation && this.animationType == HannahAnimatorSimple.type.multipleMeshRenderers && this.currentIndex >= this.meshRenderersAlternative.Count))
|
|
{
|
|
if (!this.loop)
|
|
{
|
|
this.currentIndex = 0;
|
|
this.canPlay = false;
|
|
if (this.turnOffWhenDone)
|
|
{
|
|
base.gameObject.SetActive(false);
|
|
base.gameObject.transform.SetParent(Links.x.cellar.tr);
|
|
}
|
|
return;
|
|
}
|
|
this.currentIndex = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < this.currentIndexes.Count; i++)
|
|
{
|
|
List<int> list = this.currentIndexes;
|
|
int num = i;
|
|
int num2 = list[num];
|
|
list[num] = num2 + 1;
|
|
if (this.currentIndexes[i] >= this.meshes.Count - 1)
|
|
{
|
|
if (!this.loop)
|
|
{
|
|
this.currentIndexes[i] = 0;
|
|
this.canPlay = false;
|
|
return;
|
|
}
|
|
this.currentIndexes[i] = 0;
|
|
}
|
|
}
|
|
}
|
|
if (this.animationType == HannahAnimatorSimple.type.multipleMeshRenderers)
|
|
{
|
|
if (!this.secondAnimation)
|
|
{
|
|
for (int j = 0; j < this.meshRenderers.Count; j++)
|
|
{
|
|
if (this.meshRenderers[j])
|
|
{
|
|
if (j != this.currentIndex)
|
|
{
|
|
this.meshRenderers[j].enabled = false;
|
|
}
|
|
else
|
|
{
|
|
if (!this.meshRenderers[j].gameObject.activeSelf)
|
|
{
|
|
this.meshRenderers[j].gameObject.SetActive(true);
|
|
}
|
|
this.meshRenderers[j].enabled = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int k = 0; k < this.meshRenderersAlternative.Count; k++)
|
|
{
|
|
if (this.meshRenderersAlternative[k])
|
|
{
|
|
if (k != this.currentIndex)
|
|
{
|
|
this.meshRenderersAlternative[k].enabled = false;
|
|
}
|
|
else
|
|
{
|
|
if (!this.meshRenderersAlternative[k].gameObject.activeSelf)
|
|
{
|
|
this.meshRenderersAlternative[k].gameObject.SetActive(true);
|
|
}
|
|
this.meshRenderersAlternative[k].enabled = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (this.animationType == HannahAnimatorSimple.type.groups)
|
|
{
|
|
for (int l = 0; l < this.currentIndexes.Count; l++)
|
|
{
|
|
if (l < this.singleFilters.Count && l < this.singleRenderers.Count)
|
|
{
|
|
this.singleFilters[l].mesh = this.meshes[this.currentIndexes[l]];
|
|
if (!this.singleRenderers[l].enabled)
|
|
{
|
|
this.singleRenderer.enabled = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (this.singleFilter)
|
|
{
|
|
this.singleFilter.mesh = this.meshes[this.currentIndex];
|
|
this.singleRenderer.enabled = true;
|
|
}
|
|
if (this.randomRotationY || this.randomRotationY || this.randomRotationZ)
|
|
{
|
|
if (this.animationType == HannahAnimatorSimple.type.groups)
|
|
{
|
|
for (int m = 0; m < this.currentIndexes.Count; m++)
|
|
{
|
|
if (m < this.singleFilters.Count && m < this.singleRenderers.Count && this.singleRenderers[m])
|
|
{
|
|
this.Rotate(this.singleRenderers[m]);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MeshRenderer meshRenderer = this.singleRenderer;
|
|
if (this.animationType == HannahAnimatorSimple.type.multipleMeshRenderers)
|
|
{
|
|
meshRenderer = this.meshRenderers[this.currentIndex];
|
|
}
|
|
if (meshRenderer)
|
|
{
|
|
this.Rotate(meshRenderer);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int count = this.localRotations.Count;
|
|
int count2 = this.meshRenderers.Count;
|
|
}
|
|
}
|
|
if (this.animationType == HannahAnimatorSimple.type.image && ((!this.realtime && Time.timeSinceLevelLoad > this.updateTime + this.updateInterval) || (this.realtime && Time.realtimeSinceStartup > this.updateTime + this.updateInterval)))
|
|
{
|
|
this.updateTime = Time.timeSinceLevelLoad;
|
|
if (this.realtime)
|
|
{
|
|
this.updateTime = Time.realtimeSinceStartup;
|
|
}
|
|
this.currentIndex++;
|
|
if (this.currentIndex > this.sprites.Count - 1)
|
|
{
|
|
if (!this.loop)
|
|
{
|
|
this.currentIndex = 0;
|
|
this.canPlay = false;
|
|
return;
|
|
}
|
|
this.currentIndex = 0;
|
|
}
|
|
if (base.enabled)
|
|
{
|
|
this.imageRenderer.sprite = this.sprites[this.currentIndex];
|
|
}
|
|
}
|
|
if (this.animationType == HannahAnimatorSimple.type.multipleImages && ((!this.realtime && Time.timeSinceLevelLoad > this.updateTime + this.updateInterval) || (this.realtime && Time.realtimeSinceStartup > this.updateTime + this.updateInterval)))
|
|
{
|
|
this.updateTime = Time.timeSinceLevelLoad;
|
|
if (this.realtime)
|
|
{
|
|
this.updateTime = Time.realtimeSinceStartup;
|
|
}
|
|
this.currentIndex++;
|
|
if (this.currentIndex > this.multipleImages.Count - 1)
|
|
{
|
|
if (!this.loop)
|
|
{
|
|
this.currentIndex = 0;
|
|
this.canPlay = false;
|
|
return;
|
|
}
|
|
this.currentIndex = 0;
|
|
}
|
|
if (base.enabled)
|
|
{
|
|
for (int n = 0; n < this.multipleImages.Count; n++)
|
|
{
|
|
if (this.currentIndex == n)
|
|
{
|
|
this.multipleImages[n].enabled = true;
|
|
}
|
|
else
|
|
{
|
|
this.multipleImages[n].enabled = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000B5F RID: 2911 RVA: 0x000DE728 File Offset: 0x000DC928
|
|
private void Rotate(SpriteRenderer m)
|
|
{
|
|
this.RotateAny(m.gameObject.transform);
|
|
}
|
|
|
|
// Token: 0x06000B60 RID: 2912 RVA: 0x000DE73B File Offset: 0x000DC93B
|
|
private void Rotate(MeshRenderer m)
|
|
{
|
|
this.RotateAny(m.gameObject.transform);
|
|
}
|
|
|
|
// Token: 0x06000B61 RID: 2913 RVA: 0x000DE750 File Offset: 0x000DC950
|
|
private void RotateAny(Transform t)
|
|
{
|
|
Vector3 vector = new Vector3(0f, 0f, 0f);
|
|
if (this.randomRotationY)
|
|
{
|
|
vector.y = Random.Range(0f, 360f);
|
|
}
|
|
if (this.randomRotationX)
|
|
{
|
|
vector.x = Random.Range(0f, 360f);
|
|
}
|
|
if (this.randomRotationZ)
|
|
{
|
|
vector.z = Random.Range(0f, 360f);
|
|
}
|
|
t.localRotation = Quaternion.Euler(vector);
|
|
}
|
|
|
|
// Token: 0x06000B62 RID: 2914 RVA: 0x000DE7DC File Offset: 0x000DC9DC
|
|
public void UpdateMaterials(Material mat)
|
|
{
|
|
foreach (MeshRenderer meshRenderer in this.meshRenderers)
|
|
{
|
|
if (meshRenderer)
|
|
{
|
|
meshRenderer.sharedMaterial = mat;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x040010C0 RID: 4288
|
|
[Header("ANIMATION INFO")]
|
|
private float updateTime;
|
|
|
|
// Token: 0x040010C1 RID: 4289
|
|
public float speed = 1f;
|
|
|
|
// Token: 0x040010C2 RID: 4290
|
|
public bool realtime;
|
|
|
|
// Token: 0x040010C3 RID: 4291
|
|
public float updateInterval = 0.2f;
|
|
|
|
// Token: 0x040010C4 RID: 4292
|
|
public HannahAnimatorSimple.type animationType;
|
|
|
|
// Token: 0x040010C5 RID: 4293
|
|
public int currentIndex;
|
|
|
|
// Token: 0x040010C6 RID: 4294
|
|
public bool randomStart;
|
|
|
|
// Token: 0x040010C7 RID: 4295
|
|
public bool loop = true;
|
|
|
|
// Token: 0x040010C8 RID: 4296
|
|
public bool turnOffWhenDone;
|
|
|
|
// Token: 0x040010C9 RID: 4297
|
|
[Header("FOR MESH RENDERERS (on individual game objects)")]
|
|
public List<MeshRenderer> meshRenderers = new List<MeshRenderer>();
|
|
|
|
// Token: 0x040010CA RID: 4298
|
|
public List<MeshRenderer> meshRenderersAlternative = new List<MeshRenderer>();
|
|
|
|
// Token: 0x040010CB RID: 4299
|
|
[Header("FOR MESHES (on one game object)")]
|
|
public MeshRenderer singleRenderer;
|
|
|
|
// Token: 0x040010CC RID: 4300
|
|
public MeshFilter singleFilter;
|
|
|
|
// Token: 0x040010CD RID: 4301
|
|
[Header("FOR GROUPS (like candelabras)")]
|
|
public List<MeshRenderer> singleRenderers;
|
|
|
|
// Token: 0x040010CE RID: 4302
|
|
public List<MeshFilter> singleFilters;
|
|
|
|
// Token: 0x040010CF RID: 4303
|
|
private List<int> currentIndexes = new List<int>();
|
|
|
|
// Token: 0x040010D0 RID: 4304
|
|
[Header("MESHES TO FLIP BETWEEN")]
|
|
public List<Mesh> meshes = new List<Mesh>();
|
|
|
|
// Token: 0x040010D1 RID: 4305
|
|
[Header("FOR ROTATIONS")]
|
|
public List<Vector3> localRotations = new List<Vector3>();
|
|
|
|
// Token: 0x040010D2 RID: 4306
|
|
public bool randomRotationX;
|
|
|
|
// Token: 0x040010D3 RID: 4307
|
|
public bool randomRotationY;
|
|
|
|
// Token: 0x040010D4 RID: 4308
|
|
public bool randomRotationZ;
|
|
|
|
// Token: 0x040010D5 RID: 4309
|
|
[Header("FOR SPRITES or UI IMAGES")]
|
|
public SpriteRenderer spriteRenderer;
|
|
|
|
// Token: 0x040010D6 RID: 4310
|
|
public Image imageRenderer;
|
|
|
|
// Token: 0x040010D7 RID: 4311
|
|
public List<Image> multipleImages = new List<Image>();
|
|
|
|
// Token: 0x040010D8 RID: 4312
|
|
public List<Sprite> sprites = new List<Sprite>();
|
|
|
|
// Token: 0x040010D9 RID: 4313
|
|
private float t;
|
|
|
|
// Token: 0x040010DA RID: 4314
|
|
private float start;
|
|
|
|
// Token: 0x040010DB RID: 4315
|
|
private float target;
|
|
|
|
// Token: 0x040010DC RID: 4316
|
|
private float delay;
|
|
|
|
// Token: 0x040010DD RID: 4317
|
|
private float startTime;
|
|
|
|
// Token: 0x040010DE RID: 4318
|
|
private bool canPlay;
|
|
|
|
// Token: 0x040010DF RID: 4319
|
|
private bool secondAnimation;
|
|
|
|
// Token: 0x020001CE RID: 462
|
|
public enum type
|
|
{
|
|
// Token: 0x04002E06 RID: 11782
|
|
sprite,
|
|
// Token: 0x04002E07 RID: 11783
|
|
image,
|
|
// Token: 0x04002E08 RID: 11784
|
|
singleMeshRenderer,
|
|
// Token: 0x04002E09 RID: 11785
|
|
multipleMeshRenderers,
|
|
// Token: 0x04002E0A RID: 11786
|
|
groups,
|
|
// Token: 0x04002E0B RID: 11787
|
|
multipleImages
|
|
}
|
|
}
|