sealed class ProcessorGame : Processor, ITick
	{
		public ent entity_hero;

		public ProcessorGame()
		{
                        // находим на сцене GameObject и создаем для него сущность.
			entity_hero = Entity.CreateFor("Obj Lopatnik");

                        // даем ему два компонента.
			var cAnimator = entity_hero.Set<ComponentAnimator>();
			var cRenderer = entity_hero.Set<ComponentRenderer>();

			// Component Renderer
			cRenderer.source = entity_hero.GetMono<SpriteRenderer>();

			// Component Animator
			cAnimator.map   = game.locals.animations_pawn_shovel; // анимации для лопатника
			cAnimator.guide = scripts.AnimatorGuidePawn.Instance; // animator guide для юнитов
			cAnimator.frame = 0;

		}

		public void Tick(float delta)
		{
			if (Input.GetKeyDown(KeyCode.Alpha1))
			{
                                // начнет проигрывать анимацию бесконечно
				entity_hero.animation(states.anim.walk);
			}

			if (Input.GetKeyDown(KeyCode.Alpha2))
			{
                                // начнет собирать. Проиграет анимацию 4 раза 
				entity_hero.animation(states.anim.grab, 4);
			}

			if (Input.GetKeyDown(KeyCode.Alpha3))
			{
                               // проиграет анимацию 1 раз.
				entity_hero.animation(states.anim.walk, states.anim.once);
			}

			if (Input.GetKeyDown(KeyCode.Space))
			{
                                // сбросит текущую анимацию и возьмет подходящую анимацию из
                               // animator guide
				entity_hero.animationReset();
			}
		}
	}

public struct sequence
	{
		public Sprite[] sprites;
		public int animation_next;
		public ref Sprite this[int index] => ref sprites[index];
	}

	public class sequences
	{
		sequence[] elements = new sequence[3];
		int[] keys = new int[3];
		int length;

		public ref sequence this[int index]
		{
			get
			{
				for (int i = 0; i < length; i++)
				{
					if (keys[i] == index)
						return ref elements[i];
				}

				#if UNITY_EDITOR
				Debug.LogError($"there is no animation with id {index}");
				#endif

				return ref elements[0];
			}
		}

		public void Add(int key, in sequence sequence)
		{
			if (elements.Length == length)
			{
				Array.Resize(ref elements, length + 2);
				Array.Resize(ref keys, length + 2);
			}

			keys[length]       = key;
			elements[length++] = sequence;
		}
	}

	public struct anim
	{
		public const int none = 0;
		public const int idle = 1;
		public const int walk = 2;
		public const int grab = 3;
	}

	public class ComponentAnimator
	{
		public AnimatorGuide guide = AnimatorGuide.Default; // логика анимаций если нужна

		public sequences map = new sequences(); // контейнер анимаций

		public int frame; // кадр
		public int animation_next; // id анимации
		public int times; // сколько раз нужно проиграть анимацию

		public float animation_time; // сколько занимает времени анимация

		public bool overriding; // включено ли принудительное проигрывание анимации
		public bool pause; // стоит ли анимация на паузе
	}

public abstract class AnimatorGuide
	{
		public static AnimatorGuide Default = new AnimatorGuideDefault();
		public abstract void handle(ent entity, ComponentAnimator cAnimator, float delta);
	}

	public abstract class AnimatorGuide<T> : AnimatorGuide where T : new()
	{
		public static T Instance = new T();
	}

	sealed class AnimatorGuideDefault : AnimatorGuide
	{
		public override void handle(ent entity, ComponentAnimator cAnimator, float delta)
		{
		}
	}

	sealed class AnimatorGuidePawn : AnimatorGuide<AnimatorGuidePawn>
	{
		public override void handle(ent entity, ComponentAnimator cAnimator, float delta)
		{
			if (cAnimator.overriding) return;
			cAnimator.animation_next = states.anim.idle;
		}
	}

sealed class ProcessorAnimator : Processor<ComponentAnimator, ComponentRenderer>, ITick
	{
		float time;

		public void Tick(float delta)
		{
                       // запускаем наш "mecanim"
			foreach (ent entity in source)
			{
				var cAnimator = entity.ComponentAnimator();
				cAnimator.guide.handle(entity, cAnimator, delta);
			}

                       // меняем кадры 
			if ((time += delta) < game.locals.time_between_frames) return;
			time -= game.locals.time_between_frames;

			foreach (ent entity in source)
			{
				var cAnimator = entity.ComponentAnimator();
				var cRenderer = entity.ComponentRenderer();

				if (cAnimator.pause) continue;

				ref var sequence = ref cAnimator.map[cAnimator.animation_next];

				if (cAnimator.frame == sequence.sprites.Length)
				{
					if (--cAnimator.times <= 0)
					{
						if (sequence.animation_next != default)
						{
							cAnimator.animation_next = sequence.animation_next;
							sequence                 = ref cAnimator.map[cAnimator.animation_next];
						}
						else cAnimator.overriding = false;
					}

					cAnimator.frame = 0;
				}


				cRenderer.source.sprite = sequence.sprites[cAnimator.frame++];
			}
		}
	}

		public static float animation(in this ent entity, int animation_id, int times = anim.loop, int frame = 0)
			{
				var cAnimator = entity.ComponentAnimator();
				var cRenderer = entity.ComponentRenderer();

				cAnimator.times = times;

				if (cAnimator.animation_next == animation_id) return cAnimator.animation_time;

				ref var sequence = ref cAnimator.map[animation_id];
				cAnimator.frame          = frame == anim.random_frame ? Random.Range(0, sequence.sprites.Length) : frame;
				cRenderer.source.sprite  = sequence[cAnimator.frame];
				cAnimator.animation_next = animation_id;
				cAnimator.overriding     = true;
				cAnimator.animation_time = times * sequence.sprites.Length * game.locals.time_between_frames - cAnimator.frame * game.locals.time_between_frames;
				return cAnimator.animation_time;
			}

	public struct anim
	{
		public const int random_frame = -1;
		public const int once = 1;
		public const int loop = int.MaxValue;

		public const int none = 0;
		public const int idle = 1;
		public const int walk = 2;
		public const int grab = 3;
	}

	public static void animationReset(in this ent entity)
			{
				var cAnimator = entity.ComponentAnimator();

				if (!cAnimator.overriding) return;

				cAnimator.overriding = false;
				cAnimator.frame      = 0;
				cAnimator.times      = 1;
			}

static class locals
		{
			public const string path_spr = "Content/Sprites/";
			public const float time_between_frames = 0.07f;

			public static sequences animations_pawn_shovel;

			public static void setup()
			{
				animations_pawn_shovel = new sequences();

				animations_pawn_shovel.Add(states.anim.idle, new sequence()
				{
					sprites = new[]
					{
						Box.Load<Sprite>($"{path_spr}tex_digger_idle1_01"),
						Box.Load<Sprite>($"{path_spr}tex_digger_idle1_02"),
						Box.Load<Sprite>($"{path_spr}tex_digger_idle1_03"),
						Box.Load<Sprite>($"{path_spr}tex_digger_idle1_04"),
						Box.Load<Sprite>($"{path_spr}tex_digger_idle1_05"),
						Box.Load<Sprite>($"{path_spr}tex_digger_idle1_04"),
						Box.Load<Sprite>($"{path_spr}tex_digger_idle1_03"),
						Box.Load<Sprite>($"{path_spr}tex_digger_idle1_02"),
					}
				});

				animations_pawn_shovel.Add(states.anim.walk, new sequence()
				{
					sprites = new[]
					{
						Box.Load<Sprite>($"{path_spr}tex_digger_walk_01"),
						Box.Load<Sprite>($"{path_spr}tex_digger_walk_02"),
						Box.Load<Sprite>($"{path_spr}tex_digger_walk_03"),
						Box.Load<Sprite>($"{path_spr}tex_digger_walk_04"),
						Box.Load<Sprite>($"{path_spr}tex_digger_walk_05"),
						Box.Load<Sprite>($"{path_spr}tex_digger_walk_06"),
						Box.Load<Sprite>($"{path_spr}tex_digger_walk_07"),
						Box.Load<Sprite>($"{path_spr}tex_digger_walk_08"),
					}
				});


				animations_pawn_shovel.Add(states.anim.grab, new sequence()
				{
                                       // отыграет states.anim.walk после states.anim.grab.
					animation_next = states.anim.walk,
					sprites = new[]
					{
						Box.Load<Sprite>($"{path_spr}tex_digger_grab_01"),
						Box.Load<Sprite>($"{path_spr}tex_digger_grab_02"),
						Box.Load<Sprite>($"{path_spr}tex_digger_grab_03"),
						Box.Load<Sprite>($"{path_spr}tex_digger_grab_04"),
						Box.Load<Sprite>($"{path_spr}tex_digger_grab_05"),
						Box.Load<Sprite>($"{path_spr}tex_digger_grab_06"),
					}
				});
			}
		}

if (Input.GetKeyDown(KeyCode.Alpha2))
{
        // начнет собирать. Проиграет анимацию 4 раза 
	ntity_hero.animation(states.anim.grab, 4);
}