Exemple #1
0
        public static InputCommands SetScrapingType(InputCommands inputCommands)
        {
            var commands = inputCommands;
            var data     = inputCommands.Data;

            if (data == "1")
            {
                commands.SourceType = WebsiteSourceType.Olx;
            }

            if (data == "2")
            {
                commands.SourceType = WebsiteSourceType.Ozone;
            }

            if (data == "3")
            {
                commands.SourceType = WebsiteSourceType.Technomarket;
            }

            if (data == "4")
            {
                commands.SourceType = WebsiteSourceType.Technopolis;
            }

            return(commands);
        }
Exemple #2
0
        public async void Send()
        {
            await PerformNetworkOperation(async() =>
            {
                var queryString = String.Empty;
                foreach (var param in InputCommandParameters)
                {
                    if (!String.IsNullOrEmpty(queryString))
                    {
                        queryString += "&";
                    }

                    queryString += param.ToQueryStringPair();
                }

                var client   = new HttpClient();
                var endPoint = _inputCommandEndPoints.Where(inp => inp.InputCommand.Key == SelectedInputCommand.Key).FirstOrDefault();
                if (endPoint != null)
                {
                    var uri    = String.IsNullOrEmpty(queryString) ? endPoint.EndPoint : $"{endPoint.EndPoint}?{queryString}";
                    var result = await client.GetAsync(uri);
                    if (!result.IsSuccessStatusCode)
                    {
                        await Popups.ShowAsync(result.ReasonPhrase + $" ({result.StatusCode})");
                    }
                }
            });

            SelectedInputCommand = InputCommands.FirstOrDefault();
            DeviceStatusVisible  = true;
            InputCommandVisible  = false;
        }
 public override bool ConditionMatched(InputCommands inputCommands)
 {
     bool changedPosition = inputCommands.mouse.IsAvailable &&
         inputCommands.mouse.Position != lastPosition && lastPosition != UnusedPosition;
     lastPosition = inputCommands.mouse.Position;
     return changedPosition;
 }
Exemple #4
0
        public void Validate(ValidationResult result)
        {
            if (Timers == null)
            {
                Timers = new List <Timer>();
            }


            if (Inputs.Select(param => param.Key).Distinct().Count() != Inputs.Count())
            {
                result.AddUserError("Duplicate Keys found on Inputs.");
            }
            if (Attributes.Select(param => param.Key).Distinct().Count() != Attributes.Count())
            {
                result.AddUserError("Duplicate Keys found on Attributes.");
            }
            if (InputCommands.Select(param => param.Key).Distinct().Count() != InputCommands.Count())
            {
                result.AddUserError("Duplicate Keys found on Input Commands.");
            }
            if (StateMachines.Select(param => param.Key).Distinct().Count() != StateMachines.Count())
            {
                result.AddUserError("Duplicate Keys found on State Machines.");
            }
            if (OutputCommands.Select(param => param.Key).Distinct().Count() != OutputCommands.Count())
            {
                result.AddUserError("Duplicate Keys found on Output Commands.");
            }
            if (Timers.Select(param => param.Key).Distinct().Count() != Timers.Count())
            {
                result.AddUserError("Duplicate Keys found on Timers.");
            }

            foreach (var input in Inputs)
            {
                input.Validate(this, result);
            }
            foreach (var attribute in Attributes)
            {
                attribute.Validate(this, result);
            }
            foreach (var inputCommand in InputCommands)
            {
                inputCommand.Validate(this, result);
            }
            foreach (var stateMachine in StateMachines)
            {
                stateMachine.Validate(this, result);
            }
            foreach (var outputCommand in OutputCommands)
            {
                outputCommand.Validate(this, result);
            }
            foreach (var timer in Timers)
            {
                timer.Validate(this, result);
            }
        }
Exemple #5
0
        public void StartCore(string filePath, Corel.Interop.VGCore.Application corelApp)
        {
            if (corelApp != null)
            {
                InCorel                      = true;
                CorelAutomation              = new CorelAutomation(corelApp, this);
                this.app                     = corelApp;
                corelApp.OnApplicationEvent += CorelApp_OnApplicationEvent;
            }
            FileInfo file = null;

            try
            {
                FileInfo fileOri = new FileInfo(filePath);
                Title = filePath;
                try
                {
                    if (!Directory.Exists(workerFolder))
                    {
                        Directory.CreateDirectory(workerFolder);
                    }
                }
                catch (IOException ioE)
                {
                    if (ErrorFound != null)
                    {
                        ErrorFound("Erro - " + ioE.Message);
                    }
                    return;
                }
                string newPath = workerFolder + "\\" + fileOri.Name;
                if (File.Exists(newPath))
                {
                    File.Delete(newPath);
                }
                file = fileOri.CopyTo(newPath);
            }
            catch (IOException ioErro)
            {
                if (ErrorFound != null)
                {
                    ErrorFound("Erro - " + ioErro.Message);
                }
                return;
            }
            inputCommands          = new InputCommands(this);
            commands               = (typeof(InputCommands)).GetMethods(BindingFlags.Public | BindingFlags.Instance);
            xmlDecoder             = new XMLDecoder();
            xmlDecoder.LoadFinish += XmlDecoder_LoadFinish;
            Thread thread = new Thread(new ParameterizedThreadStart(LoadFile));

            thread.IsBackground = true;
            thread.Start(file);
        }
Exemple #6
0
        protected T FirstFromEndAttackInput(int totalInputs)
        {
            for (int i = totalInputs - 1; i >= 0; i--)
            {
                if (InputCommands.IsAttackCommand(latestInputs[i].InputCommand))
                {
                    return(latestInputs[i]);
                }
            }

            return(null);
        }
Exemple #7
0
        private void OnReceivedPantsStatus(InputCommands status)
        {
            switch (status)
            {
            case InputCommands.DeviceConnected:
                PantsState = DeviceState.Initializing;
                break;

            case InputCommands.DeviceDisconnected:
                PantsState = DeviceState.Disconnected;
                break;

            case InputCommands.CalibrationStarted:
                PantsState = DeviceState.Calibrating;
                break;

            case InputCommands.CalibrationFinished:
                Disconnect();
                break;

            case InputCommands.ResetOrientation:
                ResetFullBodyBaseOrientation();
                break;

            case InputCommands.ErrorCalibrationFailed:
                PantsState = DeviceState.Connected;
                RaisePantsErrorEvent(DeviceError.CalibrationFailed);
                Debug.LogError(name + ": Device 'Pants' failed to calibrate!");
                break;

            case InputCommands.ErrorNoCalibration:
                PantsState = DeviceState.Connected;
                RaisePantsErrorEvent(DeviceError.NoCalibration);
                Debug.LogError(name + ": Device 'Pants' isn't calibrated. Please calibrate.");
                break;

            case InputCommands.ErrorNoShirtPants:
                PantsState = DeviceState.Connected;
                RaisePantsErrorEvent(DeviceError.UnknownDevice);
                Debug.LogError(name +
                               ": Attempted to connect unknown device. Defaulting to 'Shirt'. Please fix this with the firmware update tools.");
                break;
            }
        }
Exemple #8
0
        public void BeginWaitForInput()
        {
            var                           commandMapper   = new CommandMapper();
            InputCommands                 commands        = null;
            var                           consoleMessages = new ConsoleMesseges();
            IWebsiteSourceAdapter         scraperSource   = null;
            IEnumerable <ScrapingResults> results         = null;

            consoleMessages.DisplayHelp();

            while (true)
            {
                Console.Write("> ");

                try
                {
                    string input = Console.ReadLine();
                    commands = InputParser.ParseInputCommands(input);

                    InputParser.ValidateInput(commands);

                    if (commands.Action is "mount" && commands.Data is not null)
                    {
                        commands      = InputParser.SetScrapingType(commands);
                        scraperSource = commandMapper.MapScrapeToSource(commands);
                    }
                    else if (commands.Action is "begin" && commands.Data is "now")
                    {
                        if (scraperSource is not null)
                        {
                            Print <ScrapingResults> .Info("Be patient data is being loaded...");

                            results = scraperSource.InitiateScraping();
                            Print <ScrapingResults> .Table(results);

                            Print <ScrapingResults> .Success("Data loaded");

                            Console.WriteLine();
                        }
                        else
                        {
                            throw new Exception("First mount a scraper");
                        }
                    }
Exemple #9
0
        public LabelsEditorControl()
        {
            InitializeComponent();

            InputCommands.Stub(this);

            _flipper = new Flipper(TimeSpan.FromMilliseconds(400), CheckExistingLabel);

            // If labels are updated from elsewhere in the message we are currently viewing
            // (and we are not the one causing the updated), rebuild the labels
            subscription = EventBroker.Subscribe(AppEvents.MessageLabelsUpdated,
                                                 (Message message) => Thread.CurrentThread.ExecuteOnUIThread(delegate
            {
                if (message == Message && !Editor.IsFocused)
                {
                    Reset();
                }
            }));
        }
 public void AccumulateInputsToBePlayedOnServerFromClient(InputCommands inputCommands)
 {
     if (inputCommands.sequenceNumber > playerSequenceNumberProcessed)
     {
         InputCommands dataPackage;
         if (inputUpdatesFromClientToServerDic.TryGetValue(inputCommands.sequenceNumber, out dataPackage))
         {
             //Debug.Log("<color=orange>dataPackage already exists for sequence no. </color>" + dataPackage.sequenceNumber);
         }
         else
         {
             //Debug.Log("<color=green>Added successfully to processing buffer dic </color>" + inputCommands.sequenceNumber+"  processed sequence number: "+playerSequenceNumberProcessed);
             inputUpdatesFromClientToServerDic.Add(inputCommands.sequenceNumber, inputCommands);
         }
     }
     else
     {
         //Debug.Log("<color=red>Already processed this sequence no </color>" + playerSequenceNumberProcessed);
     }
 }
Exemple #11
0
        public IWebsiteSourceAdapter MapScrapeToSource(InputCommands inputCommands)
        {
            IWebsiteSourceAdapter websiteSourceAdapter;

            Print <ScrapingResults> .Info($"Setting source for scraping");

            if (inputCommands.SourceType == WebsiteSourceType.Olx)
            {
                Print <ScrapingResults> .Success($"Source set to {inputCommands.SourceType.ToString()} waiting for command [begin] [scrape]");

                websiteSourceAdapter = new OlxWebsiteSourceAdapter();
                return(websiteSourceAdapter);
            }

            if (inputCommands.SourceType == WebsiteSourceType.Ozone)
            {
                Print <ScrapingResults> .Success($"Source set to {inputCommands.SourceType.ToString()} waiting for command [begin] [scrape]");

                websiteSourceAdapter = new OzoneWebsiteSourceAdapter();
                return(websiteSourceAdapter);
            }

            if (inputCommands.SourceType == WebsiteSourceType.Technomarket)
            {
                Print <ScrapingResults> .Success($"Source set to {inputCommands.SourceType.ToString()} waiting for command [begin] [scrape]");

                websiteSourceAdapter = new TechnomarketWebsiteSourceAdapter();
                return(websiteSourceAdapter);
            }

            if (inputCommands.SourceType == WebsiteSourceType.Technopolis)
            {
                Print <ScrapingResults> .Success($"Source set to {inputCommands.SourceType.ToString()} waiting for command [begin] [scrape]");

                websiteSourceAdapter = new TechnopolisWebisteSourceAdapter();
                return(websiteSourceAdapter);
            }

            return(null);
        }
Exemple #12
0
        private static InputCommands SplitCommands(string input)
        {
            try
            {
                var inputArray = input.Split();

                var action = inputArray[0].ToLower();
                var data   = inputArray[1].ToLower();

                var commands = new InputCommands()
                {
                    Action = action,
                    Data   = data
                };

                return(commands);
            }
            catch
            {
                throw new Exception("input not in right format should be - [action] [data]");
            }
        }
Exemple #13
0
        private void InputCommand_Changed(InputCommands command)
        {
            switch (command)
            {
            case InputCommands.NextCommand:
                GotoNextPart();
                break;

            case InputCommands.PreviousCommand:
                break;

            case InputCommands.DeleteCommand:
                break;

            case InputCommands.Backspace:
                ExecuteBackspace();
                break;

            case InputCommands.SerializeCommand:
                SerializeEquations();
                break;

            case InputCommands.DeserializeCommand:
                DeserializeEquation();
                break;

            case InputCommands.MoveLeft:
                MoveCaretLeft();
                break;

            case InputCommands.MoveRight:
                MoveCaretRight();
                break;

            default:
                break;
            }
        }
Exemple #14
0
        public static void ValidateInput(InputCommands inputCommands)
        {
            var action = inputCommands.Action;
            var data   = inputCommands.Data;

            if (string.IsNullOrEmpty(action))
            {
                throw new Exception(typeof(InputCommands).GetProperties()[0].ToString());
            }
            if (string.IsNullOrEmpty(data))
            {
                throw new Exception(typeof(InputCommands).GetProperties()[1].ToString());
            }

            if (string.IsNullOrWhiteSpace(action))
            {
                throw new Exception(typeof(InputCommands).GetProperties()[0].ToString());
            }
            if (string.IsNullOrWhiteSpace(data))
            {
                throw new Exception(typeof(InputCommands).GetProperties()[1].ToString());
            }
        }
Exemple #15
0
        public RecipientsEditorControl()
        {
            InitializeComponent();

            InputCommands.Stub(this);

            mailbox    = VirtualMailBox.VirtualMailBox.Current;
            recipients = new AdvancedObservableCollection <SourceAddress>();

            wordFlipper         = new Flipper(TimeSpan.FromMilliseconds(400), ProcessCurrentWord);
            autocompleteFlipper = new Flipper(TimeSpan.FromMilliseconds(500), SearchContacts);

            // Default the validation is enabled
            ValidationEnabled = true;

            DataContext = this;

            var channel = ChannelsManager.GetDefaultChannel();

            if (channel != null)
            {
                TargetChannel = channel;
            }
        }
 public void AddTouchCallback()
 {
     var input = new InputCommands(null, null, null, null);
     input.Add(touch => {});
     Assert.AreEqual(1, input.Count);
 }
Exemple #17
0
 public void CancelSend()
 {
     SelectedInputCommand = InputCommands.FirstOrDefault();
     DeviceStatusVisible  = true;
     InputCommandVisible  = false;
 }
    private void FixedUpdate()
    {
        serverInstanceHero.ProcessAuthoratativeEvents();

        for (int i = 0; i < (int)currentInputProcessingModeOnServer; i++)
        {
            CheckForPushRequestOnServer(playerSequenceNumberProcessed + 1);
            CheckForPlaceBoulderRequestOnServer(playerSequenceNumberProcessed + 1);
            CheckForRemovingBoulderRequestOnServer(playerSequenceNumberProcessed + 1);
            CheckForPetrificationRequestOnPlayer(playerSequenceNumberProcessed + 1);

            InputCommands inputPackageCorrespondingToSeq;

            if (inputUpdatesFromClientToServerDic.TryGetValue(playerSequenceNumberProcessed + 1, out inputPackageCorrespondingToSeq))
            {
                inputUpdatesFromClientToServerDic.Remove(inputPackageCorrespondingToSeq.sequenceNumber);
                latestPlayerInputPackage      = inputPackageCorrespondingToSeq;
                playerSequenceNumberProcessed = inputPackageCorrespondingToSeq.sequenceNumber;

                serverInstanceHero.ProcessMovementInputs(inputPackageCorrespondingToSeq.commands
                                                         , inputPackageCorrespondingToSeq.previousCommands);
                serverInstanceHero.ProcessEventsInputs(inputPackageCorrespondingToSeq.commands, inputPackageCorrespondingToSeq.previousCommands);
                serverInstanceHero.ProcessAnimationsInputs(inputPackageCorrespondingToSeq.commands, inputPackageCorrespondingToSeq.previousCommands);

                serverInstanceHero.ProcessInputMovementsControl();
                serverInstanceHero.ProcessInputEventControl();
                serverInstanceHero.ProcessInputAnimationControl();
                //Debug.Log(serverInstanceHero.movePoint.position + "Block pos "+serverInstanceHero.GetBlockPosition()+"<color=yellow>Processing seqence no </color>" + inputPackageCorrespondingToSeq.sequenceNumber + "<color=green>position </color>" + serverInstanceHero.actorTransform.position + "<color=green>inputs </color>" + inputPackageCorrespondingToSeq.commands[0] + inputPackageCorrespondingToSeq.commands[1] + inputPackageCorrespondingToSeq.commands[2] + inputPackageCorrespondingToSeq.commands[3]+" Previous Commands "+ inputPackageCorrespondingToSeq.previousCommands[0] + inputPackageCorrespondingToSeq.previousCommands[1] + inputPackageCorrespondingToSeq.previousCommands[2] + inputPackageCorrespondingToSeq.previousCommands[3]);
            }
            else
            {
                if (latestPlayerInputPackage.sequenceNumber != 0)
                {
                    //Debug.LogError("Could not find any inputToProcess for  seq: " + (sequenceNumberProcessed + 1));
                    playerSequenceNumberProcessed = playerSequenceNumberProcessed + 1;

                    serverInstanceHero.ProcessMovementInputs(latestPlayerInputPackage.commands
                                                             , latestPlayerInputPackage.previousCommands);
                    serverInstanceHero.ProcessEventsInputs(latestPlayerInputPackage.commands, latestPlayerInputPackage.previousCommands);
                    serverInstanceHero.ProcessAnimationsInputs(latestPlayerInputPackage.commands, latestPlayerInputPackage.previousCommands);

                    serverInstanceHero.ProcessInputMovementsControl();
                    serverInstanceHero.ProcessInputEventControl();
                    serverInstanceHero.ProcessInputAnimationControl();
                }
            }
        }

        serverLocalSequenceNumber++;

        //////Debug.Log("<color=blue>inputsequence </color>"+ playerMovingCommandSequenceNumber + "<color=blue>inputs </color> "+ inputs[0]+" "+inputs[1]+" "+inputs[2]+" "+inputs[3]);
        PlayerAuthoratativeStates playerAuthoratativeStates = new PlayerAuthoratativeStates(serverInstanceHero.isPetrified, serverInstanceHero.isPushed);
        PositionUpdates           positionUpdates           = new PositionUpdates(serverInstanceHero.actorTransform.position, serverInstanceHero.currentMovePointCellPosition, serverInstanceHero.previousMovePointCellPosition);
        PlayerEvents          playerEvents          = new PlayerEvents(serverInstanceHero.isFiringPrimaryProjectile);
        PlayerAnimationEvents playerAnimationEvents = new PlayerAnimationEvents(serverInstanceHero.primaryMoveUseAnimationAction.isBeingUsed, serverInstanceHero.isPlacingBoulderAnimationPlayed);

        PlayerStateUpdates       playerStateUpdates       = new PlayerStateUpdates(serverLocalSequenceNumber, playerSequenceNumberProcessed, playerAuthoratativeStates, positionUpdates, playerEvents, playerAnimationEvents);
        PlayerStateServerUpdates playerStateServerUpdates = new PlayerStateServerUpdates(id, playerStateUpdates);

        //Debug.LogError("Server sequence number : "+ serverLocalSequenceNumber+" player sequence number processeed: "+ playerSequenceNumberProcessed+" player position : "+serverInstanceHero.actorTransform.position);

        playerStateListOnServer.Add(playerStateServerUpdates);

        if (playerStateListOnServer.Count >= snapShotsInOnePacket)
        {
            if (previousPlayerUpdatedStatePacks.Count > packetHistorySize)
            {
                previousPlayerUpdatedStatePacks.RemoveAt(0);
            }
            ServerSend.PlayerStateSend(playerStateListOnServer, previousPlayerUpdatedStatePacks);

            previousPlayerUpdatedStatePacks.Add(new PreviousPlayerUpdatedStatePacks(playerStateListOnServer.ToArray()));

            playerStateListOnServer.Clear();

            //Debug.Log("<color=red>--------------------------------------------------------------------</color>");
        }

        UpdateClientInputsProcessMode();
        snapShotBufferSize = GetTheLastestSequenceNoInDic() - playerSequenceNumberProcessed;
        //Debug.Log("<color=cyan>Dic Count </color>"+inputUpdatesFromClientToServerDic.Count);
    }
Exemple #19
0
 public abstract bool ConditionMatched(InputCommands inputCommands);
Exemple #20
0
 public static async void ExecuteAction(InputCommands command)
 {           
     await ConnectionManager.ExecuteRPCRequest("Input." + command.ToString());
 }
Exemple #21
0
 public static async Task ExecuteAction(InputCommands command)
 {
     await ConnectionManager.ExecuteRPCRequest("Input." + command.ToString());
 }
Exemple #22
0
    // Compare command against read input
    public bool GetInput(InputCommands inputToCheck)
    {
        InputCommands scancode = InputCommands.INPUT_NONE;

        // Put in checks for all applicable keys here.
        if (Input.GetKeyDown(KeyCode.Space) ||
            Input.GetKeyDown(KeyCode.UpArrow) ||
            Input.GetKeyDown(KeyCode.W))
        {
            if (debugMode)
            {
                Debug.Log("Moving up.");
            }
            scancode = InputCommands.MOVE_JUMP;
        }


        if (Input.GetKeyDown(KeyCode.LeftArrow))
        {
            if (debugMode)
            {
                Debug.Log("Moving left.");
            }
            scancode = InputCommands.MOVE_LEFT;
        }


        if (Input.GetKeyDown(KeyCode.RightArrow))
        {
            if (debugMode)
            {
                Debug.Log("Moving right.");
            }
            scancode = InputCommands.MOVE_RIGHT;
        }

        if (Input.GetKey(KeyCode.LeftControl) ||
            Input.GetKey(KeyCode.RightControl) ||
            Input.GetKey(KeyCode.DownArrow))
        {
            if (debugMode)
            {
                Debug.Log("Shhh! Sneaking...");
            }
            scancode = InputCommands.MODE_SNEAK;
        }

        if (Input.GetKey(KeyCode.LeftShift) ||
            Input.GetKey(KeyCode.RightShift))
        {
            if (debugMode)
            {
                Debug.Log("Running!");
            }
            scancode = InputCommands.MODE_RUN;
        }

        if (Input.GetKeyUp(KeyCode.LeftShift) ||
            Input.GetKeyUp(KeyCode.RightShift) ||
            Input.GetKeyUp(KeyCode.LeftControl) ||
            Input.GetKeyUp(KeyCode.RightControl) ||
            Input.GetKeyUp(KeyCode.DownArrow))
        {
            if (debugMode)
            {
                Debug.Log("Walking.");
            }
            scancode = InputCommands.MODE_WALK;
        }

        if (Input.GetMouseButtonDown(0))
        {
            if (debugMode)
            {
                Debug.Log("Firing.");
            }
            scancode = InputCommands.ACTION_FIRE;
        }


        // Gives us a readout on the inspector
        currentInput = scancode;


        // This compares the input against the command being checked
        if (scancode == inputToCheck)
        {
            return(true);
        }


        // Debug.Log ("Assigning None to input controller.");
        scancode = InputCommands.INPUT_NONE;
        return(false);
    }
Exemple #23
0
 private void Update()
 {
     input = GetKeyboardValue(Time.deltaTime);
 }
Exemple #24
0
 private void Update()
 {
     input = GetKeyboardValue();
 }
Exemple #25
0
 public void Bind(Keys key, int playerId, InputCommands command)
 {
     bindings.Add(key, new InputBinding(playerId, command));
 }
Exemple #26
0
 public InputBinding(int playerId, InputCommands command)
 {
     this.playerId = playerId;
     this.command  = command;
 }
Exemple #27
0
    private void CheckKeyboard()
    {
        InputCommands command = Manager.GetUserCommand();

        if (commandSystem.IsPlayerTurn)
        {
            switch (command)
            {
            case InputCommands.None:
                return;

            case InputCommands.UpLeft:
                Player.MovesCompleted += commandSystem.MovePlayer(Direction.UpLeft);
                break;

            case InputCommands.Up:
                Player.MovesCompleted += commandSystem.MovePlayer(Direction.Up);
                break;

            case InputCommands.UpRight:
                Player.MovesCompleted += commandSystem.MovePlayer(Direction.UpRight);
                break;

            case InputCommands.Left:
                Player.MovesCompleted += commandSystem.MovePlayer(Direction.Left);
                break;

            case InputCommands.Right:
                Player.MovesCompleted += commandSystem.MovePlayer(Direction.Right);
                break;

            case InputCommands.DownLeft:
                Player.MovesCompleted += commandSystem.MovePlayer(Direction.DownLeft);
                break;

            case InputCommands.Down:
                Player.MovesCompleted += commandSystem.MovePlayer(Direction.Down);
                break;

            case InputCommands.DownRight:
                Player.MovesCompleted += commandSystem.MovePlayer(Direction.DownRight);
                break;

            case InputCommands.Wait:
                World.UpdatePlayerFieldOfView(Player);
                Player.MovesCompleted = Player.Moves;
                break;

            case InputCommands.Stairs:
                ConfirmStairs();
                break;

            case InputCommands.CloseGame:
                SceneManager.LoadScene("MenuScene");
                break;

            default:
                break;
            }

            if (Player.MovesCompleted >= Player.Moves)
            {
                renderRequired = true;
                commandSystem.EndPlayerTurn();
            }
            else
            {
                renderRequired = true;
            }
        }
        else
        {
            commandSystem.ActivateMonsters();
            renderRequired = true;
        }
    }
        private void CheckKeyboard()
        {
            bool didPlayerAct = false;

            InputCommands command = rootConsole.GetUserCommand();

            if (commandSystem.IsPlayerTurn)
            {
                switch (command)
                {
                case InputCommands.UpLeft:
                    didPlayerAct = commandSystem.MovePlayer(Direction.UpLeft);
                    break;

                case InputCommands.Up:
                    didPlayerAct = commandSystem.MovePlayer(Direction.Up);
                    break;

                case InputCommands.UpRight:
                    didPlayerAct = commandSystem.MovePlayer(Direction.UpRight);
                    break;

                case InputCommands.Left:
                    didPlayerAct = commandSystem.MovePlayer(Direction.Left);
                    break;

                case InputCommands.Right:
                    didPlayerAct = commandSystem.MovePlayer(Direction.Right);
                    break;

                case InputCommands.DownLeft:
                    didPlayerAct = commandSystem.MovePlayer(Direction.DownLeft);
                    break;

                case InputCommands.Down:
                    didPlayerAct = commandSystem.MovePlayer(Direction.Down);
                    break;

                case InputCommands.DownRight:
                    didPlayerAct = commandSystem.MovePlayer(Direction.DownRight);
                    break;

                case InputCommands.StairsDown:
                    if (World.CanMoveDownToNextLevel())
                    {
                        MoveMapLevelDown();
                        didPlayerAct = true;
                    }
                    break;

                case InputCommands.CloseGame:
                    rootConsole.CloseApplication();
                    break;

                default:
                    break;
                }

                if (didPlayerAct)
                {
                    renderRequired = true;
                    commandSystem.EndPlayerTurn();
                }
            }
            else
            {
                commandSystem.ActivateMonsters();
                renderRequired = true;
            }
        }
Exemple #29
0
        private void CheckKeyboard()
        {
            bool didPlayerAct = false;

            InputCommands command = rootConsole.GetUserCommand();

            if (commandSystem.IsPlayerTurn)
            {
                if (command.ToString() != "None")
                {
                    Debug.Log("KeyInput: '" + command.ToString() + "'");
                }

                switch (command)
                {
                case InputCommands.UpLeft:
                    didPlayerAct = commandSystem.MovePlayer(Direction.UpLeft);
                    break;

                case InputCommands.Up:
                    didPlayerAct = commandSystem.MovePlayer(Direction.Up);
                    break;

                case InputCommands.UpRight:
                    didPlayerAct = commandSystem.MovePlayer(Direction.UpRight);
                    break;

                case InputCommands.Left:
                    didPlayerAct = commandSystem.MovePlayer(Direction.Left);
                    break;

                case InputCommands.Wait:
                    didPlayerAct = true;
                    break;

                case InputCommands.Right:
                    didPlayerAct = commandSystem.MovePlayer(Direction.Right);
                    break;

                case InputCommands.DownLeft:
                    didPlayerAct = commandSystem.MovePlayer(Direction.DownLeft);
                    break;

                case InputCommands.Down:
                    didPlayerAct = commandSystem.MovePlayer(Direction.Down);
                    break;

                case InputCommands.DownRight:
                    didPlayerAct = commandSystem.MovePlayer(Direction.DownRight);
                    break;

                case InputCommands.Inventory:
                    UIController.ToggleInventoryVisibility();
                    didPlayerAct = true;
                    break;

                case InputCommands.StairsDown:
                    if (World.CanMoveDownToNextLevel())
                    {
                        MoveMapLevelDown();
                        didPlayerAct = true;
                    }
                    break;

                case InputCommands.CloseGame:
                    rootConsole.CloseApplication();
                    break;

                default:
                    break;
                }

                if (didPlayerAct)
                {
                    renderRequired = true;
                    commandSystem.EndPlayerTurn();
                }
            }
            else
            {
                commandSystem.ActivateMonsters();
                renderRequired = true;
            }
        }
 private async void fire(InputCommands command)
 {
     while (isHolding)
     {
         await Input.ExecuteAction(command);
         await Task.Delay(250);
     }
 }
Exemple #31
0
    private InputCommands GetKeyboardValue(float time)
    {
        elapsedTime += time;

        if (elapsedTime < delay)
        {
            return(InputCommands.None);
        }

        InputCommands command = InputCommands.None;

        if (Input.GetKey(KeyCode.Keypad1) || Input.GetKey(KeyCode.Q) || Input.GetKey(KeyCode.Y))
        {
            command = InputCommands.UpLeft;
        }
        else if (Input.GetKey(KeyCode.Keypad2) || Input.GetKey(KeyCode.UpArrow) || Input.GetKey(KeyCode.W) || Input.GetKey(KeyCode.K))
        {
            command = InputCommands.Up;
        }
        else if (Input.GetKey(KeyCode.Keypad3) || Input.GetKey(KeyCode.E) || Input.GetKey(KeyCode.U))
        {
            command = InputCommands.UpRight;
        }
        else if (Input.GetKey(KeyCode.Keypad4) || Input.GetKey(KeyCode.LeftArrow) || Input.GetKey(KeyCode.A) || Input.GetKey(KeyCode.H))
        {
            command = InputCommands.Left;
        }
        else if (Input.GetKey(KeyCode.Keypad6) || Input.GetKey(KeyCode.RightArrow) || Input.GetKey(KeyCode.D) || Input.GetKey(KeyCode.L))
        {
            command = InputCommands.Right;
        }
        else if (Input.GetKey(KeyCode.Keypad7) || Input.GetKey(KeyCode.Z) || Input.GetKey(KeyCode.B))
        {
            command = InputCommands.DownLeft;
        }
        else if (Input.GetKey(KeyCode.Keypad8) || Input.GetKey(KeyCode.DownArrow) || Input.GetKey(KeyCode.S) || Input.GetKey(KeyCode.J) || Input.GetKey(KeyCode.X))
        {
            command = InputCommands.Down;
        }
        else if (Input.GetKey(KeyCode.Keypad9) || Input.GetKey(KeyCode.C) || Input.GetKey(KeyCode.N))
        {
            command = InputCommands.DownRight;
        }
        else if (Input.GetKey(KeyCode.Keypad5) || Input.GetKey(KeyCode.Space))
        {
            command = InputCommands.Wait;
        }
        else if (Input.GetKey(KeyCode.Period) || Input.GetKey(KeyCode.Comma) || Input.GetKey(KeyCode.Return))
        {
            command = InputCommands.Stairs;
        }
        else if (Input.GetKey(KeyCode.Escape))
        {
            command = InputCommands.CloseGame;
        }

        if (command != InputCommands.None)
        {
            elapsedTime = 0;
        }

        return(command);
    }