public void Press()
 {
     if (state != ActionState.WaitingForReleased) {
         state = ActionState.Pressed;
         amount++;
     }
 }

 public Character(WorldMap worldMap, Vector2 coordinates)
 {
     mCoordinates = coordinates;
     mState = ActionState.Idle;
     mDirection = FacingDirection.Down;
     mWorldMap = worldMap;
 }

 public ActionStateRuleAttribute(string id, string actionId, Nesting targetViewNesting, string normalCriteria,
                                 string emptyCriteria, ViewType viewType, string module, ActionState actionState,
                                 string viewId)
     : base(id, targetViewNesting, normalCriteria, emptyCriteria, viewType, module, viewId) {
     this.actionId = actionId;
     ActionState = actionState;
 }

    public bool Collect()
    {
        GetComponent<NPCFidget>().StopWalking();

        foundObject = false;
        leftHand = findLeftHandRecursive(transform);
        rightHand = findRightHandRecursive(transform);
        if(leftHand != null && rightHand != null)
        {
            armsUp = true;
            if(objToCollect == null)
                currentState = ActionState.Find;
            objToCollect.transform.rotation = transform.rotation;
            objToCollect.transform.position = transform.position + transform.forward*2;
            objToCollect.transform.position = new Vector3(objToCollect.transform.position.x, objToCollect.transform.position.y+1, objToCollect.transform.position.z);
            objToCollect.transform.parent = transform;
            if(objToCollect.GetComponent("Evolvable") != null)
            {
                (objToCollect.GetComponent("Evolvable") as Evolvable).enabled = false;
            }

            if(objToCollect.GetComponent<PickUpableItem>() != null)
            {
                objToCollect.GetComponent<PickUpableItem>().enabled = false;
            }
            return true;
        }
        return false;
    }

        public void update()
        {
            if (actionState == ActionState.Idle)
            {
                if (Constants.bRandom.Next() % 12 == 0)
                    actionState = ActionState.Playing;
                else
                    return;
            }
            else
            {
                // Random idle
                if (Constants.bRandom.Next() % 50 == 0)
                {
                    curA = curB = curUp = curDown = curLeft = curRight = false;
                    actionState = ActionState.Idle;
                    return;
                }
            }

            bool prevA = curA;
            bool prevB = curB;
            bool prevUp = curUp;
            bool prevDown = curDown;
            bool prevLeft = curLeft;
            bool prevRight = curRight;

            curA = Constants.bRandom.Next() % 12 == 0 ? true : false;
            curB = Constants.bRandom.Next() % 12 == 0 ? true : false;
            curUp = Constants.bRandom.Next() % 15 == 0 ? !prevUp : prevUp;
            curDown = Constants.bRandom.Next() % 15 == 0 ? !prevDown : prevDown;
            curLeft = Constants.bRandom.Next() % 15 == 0 ? !prevLeft : prevLeft;
            curRight = Constants.bRandom.Next() % 15 == 0 ? !prevRight : prevRight;
        }

 private StateWrapper BuildCharge()
 {
     StateWrapper stateWrapper = new StateWrapper();
       FSMState state = new ActionState(this.chargeStateName);
       state.WithDefaultBehaviours(this.gameObject);
       if (this.animationBehaviour != null) {
     state.AddStartBehaviour(this.animationBehaviour);
       }
       state.AddStartBehaviour(new SetAnimationSpeedBehaviour(this.gameObject, 0f));
       state.AddStartBehaviour(new SetVariableBehaviour(this.gameObject, this.chargeVariable, this.initialChargeMultiplier));
       foreach (FSMBehaviour behaviour in this.customStartBehaviours) {
     state.AddStartBehaviour(behaviour);
       }
       state.AddUpdateBehaviour(new ChargeBehaviour(this.gameObject, this.chargeVariable, this.maxChargeMultiplier, this.maxChargeSeconds));
       state.AddExitBehaviour(new SetAnimationSpeedBehaviour(this.gameObject, 1f));
       stateWrapper.state = state;
       FSMTransition transition = null;
       foreach (string startingState in this.startingStates) {
     transition = new FSMTransition(startingState, this.chargeStateName);
     transition.AddConditions(
       new VarConditionsBuilder()
       .IgnoringInputs().IgnoringAttributes().IgnoringDirections().IgnoringPositions().IgnoringFlags().IgnoringCombat()
       .WithVar(CharVars.FromInputMode(this.input), new InputCondition(CharVars.FromInputMode(this.input).ToS(), Operators.EQUAL, InputModes.PRESS, InputModes.DOUBLE_TAP))
       .Build()
     );
     stateWrapper.transitions.Add(transition);
       }
       return stateWrapper;
 }

 public ActionStateX(ActionState action, int timeDelay, bool isOnceOnly, int specifer = -1)
 {
     this.TimeDelay = timeDelay;
     IsOnceOnly = isOnceOnly;
     Action = action;
     Specifer = specifer;
 }

	public void Update() {
		inventory.AddToInventory(harvestable.Harvest(), harvestable.amountPerCollection);
		if (harvestable.remainingAmount <= 0) {
			Object.Destroy(harvestable);
		}
		state = ActionState.Done;
	}

 protected Drawer()
 {
     CellCoors = new PointF[Consts.MAP_WIDTH, Consts.MAP_HEIGHT];
     _state = ActionState.None;
     LightenedCell = Consts.MAP_START_POS;
     ShipsInfo = new Dictionary<int, ShipAttributes>();
 }

        public void Begin()
        {
            if (state != ActionState.None)
                throw new InvalidOperationException("Begin should only be called once.");

            state = ActionState.InProgress;
            ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProcess));
        }

        public ActionChangeDialog(ActionState currentState)
        {
            InitializeComponent();

            ExistingState = currentState;
            NewState = currentState;
            ExtraInfo = "";
        }

 protected override void UpdateActionState(ActionState state)
 {
     base.UpdateActionState(state);
     if (this.FComponentCheckedProperty != null)
     {
         this.FComponentCheckedProperty.SetValue(base.Component, (state & ActionState.Checked) > ActionState.None, null);
     }
 }

        public RuntimeLumberjack(ActionState state, Lumberjack prototype)
            : base(state)
        {
            Prototype = prototype;

            var size = new Vector2(8, 8);
            Hitbox = new Bounds(-size, size);

            Occupy(state.Building<RuntimeAdminBuilding>());
        }

 private void SetActionState(ActionState state, bool value)
 {
     if (value)
     {
         this.FState |= state;
     }
     else
     {
         this.FState &= ~state;
     }
 }

    public static ActionState NextAction(List<int> pinFalls)
    {
        ActionMaster actionMaster = new ActionMaster();
        ActionState currentAction = new ActionState();

        foreach (int pinFall in pinFalls) {
            currentAction = actionMaster.Bowl (pinFall);
        }

        return currentAction;
    }

    public ActionState RunAction()
    {
        if (this.CachedFunc != null) {
            this.CurrentState = this.CachedFunc();
        }
        else {
            Debug.LogWarning("Action has no OnAction set");
            this.CurrentState = ActionState.ACTION_CANCELLED;
        }

        return this.CurrentState;
    }

        public SecretAnnouncement(string name, Dictionary<string, Agent> allAgents, Dictionary<string, Agent> audience, Formula announcement)
            : base(name , allAgents , audience , announcement)
        {
            ActionState trueState = new ActionState("TrueState");
            SecretState = new ActionState("Secret");
            SecretState.Precondition = announcement;
            ActionStates.Add(trueState);
            ActionStates.Add(SecretState);

            Relation = new ActionIndecisionPair(SecretState, trueState);
            Relation.TagedAgents = GetSubtractionOfAgentDics(allAgents, audience);
            TransitionRelation.Add(Relation);
        }

        protected override JobStatus ActionDoneOverride(ActionState actionStatus)
        {
            switch (actionStatus)
            {
                case ActionState.Done:
                case ActionState.Fail:
                case ActionState.Abort:
                    return JobStatus.Ok;

                default:
                    throw new Exception();
            }
        }

    protected virtual void Attack(int attackWeight = 1)
    {

        ACC = level - PlayerState._instance.level > 0 ? 0.7f :
                   (0.7 - (PlayerState._instance.level - level) * 0.15f <= 0 ? 0.05f :
                           ((0.7f - (PlayerState._instance.level - level) * 0.15f + 0.05f)));
        PlayerController._instance.TakeDamage(ATK, ACC);
        if (!PlayerState._instance.PlayerAliveNow)
        {
            nowState = ActionState.notFoundPlayer;
        }

    }

        // высота объекта над землей

        public Entity(string url, string id) : base(url) {
            Id = id;
            IsAntialiased = false;
            Direction = 0;
            Speed = 0;
            Tag = Tags.Unknown;
            Hp = new Stat(0);
            AttackDamage = 0;
            ActionState = ActionState.Idle;
            Scale = Settings.Scale;
            MaskW = (int) (Texture.PixelsWide*ScaleX) - MaskLesser;
            MaskH = (int) (Texture.PixelsHigh*ScaleY) - MaskLesser;
        }