Beispiel #1
0
        /// ------------------------------------------------------------------------------------
        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">set to <c>true</c> if called from the Dispose() method,
        /// set to <c>false</c> if called by GC. If this parameter is <c>false</c> we shouldn't
        /// access any managed objects since these might already have been destroyed.</param>
        /// ------------------------------------------------------------------------------------
        protected override void Dispose(bool disposing)
        {
            // Debug.WriteLineIf statement disabled because of a bug in .NET DataGridView:
            // DataGridView.AddRange() creates a temporary clone that it doesn't dispose, so we
            // will always get this warning message and we can't do anything about it.
            // Debug.WriteLineIf(!disposing, "****** Missing Dispose() call for " + GetType().Name + ". ****** ");
            if (disposing)
            {
                if (m_textBoxControl != null)
                {
                    m_textBoxControl.Dispose();
                }
                if (m_fontCache != null)
                {
                    foreach (Font fnt in m_fontCache.Values)
                    {
                        fnt.Dispose();
                    }

                    m_fontCache.Clear();
                }
                if (m_DisposeCellTemplate && CellTemplate != null)
                {
                    CellTemplate.Dispose();
                    CellTemplate          = null;
                    m_DisposeCellTemplate = false;
                }
            }

            m_textBoxControl = null;
            m_cache          = null;
            m_fontCache      = null;
            base.Dispose(disposing);
        }
Beispiel #2
0
        public virtual UIElement GenerateCell()
        {
            var cell = CellTemplate == null ? null : CellTemplate.LoadContent() as UIElement;

            cell = cell ?? new TextBlock();
            SetColumn(cell, this);

            var element = cell as FrameworkElement;

            if (element != null)
            {
                var dataPath = string.IsNullOrWhiteSpace(DataMember) ? "(0).Item" : "(0).Item." + DataMember;
                element.SetBinding(FrameworkElement.DataContextProperty, new Binding {
                    Path = new PropertyPath(dataPath, LiteRow.RowProperty.DependencyProperty), Source = element, Mode = BindingMode.OneWay
                });
            }

            var text = cell as TextBlock;

            if (text != null)
            {
                text.SetBinding(TextBlock.TextProperty, new Binding("DataContext")
                {
                    Source = text, Mode = BindingMode.OneWay
                });
            }

            return(cell);
        }
 public void SetCell(int x, CellTemplate cell)
 {
     if (x >= 0 && x < width)
     {
         lineCells[x] = cell;
     }
 }
Beispiel #4
0
        /// ------------------------------------------------------------------------------------
        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">set to <c>true</c> if called from the Dispose() method,
        /// set to <c>false</c> if called by GC. If this parameter is <c>false</c> we shouldn't
        /// access any managed objects since these might already have been destroyed.</param>
        /// ------------------------------------------------------------------------------------
        //[SuppressMessage("Clouseau", "MissingDisposeCall", Justification = "Debug.WriteLineIf statement disabled because of a bug in .NET DataGridView:"
        //	+ "DataGridView.AddRange() creates a temporary clone that it doesn't dispose, so we will always get this warning message and we can't do anything about it.")]
        protected override void Dispose(bool disposing)
        {
            Debug.WriteLineIf(!disposing, "****** Missing Dispose() call for " + GetType().Name + ". ****** (but this might not be your fault)");
            if (disposing)
            {
                if (m_textBoxControl != null)
                {
                    m_textBoxControl.Dispose();
                }
                if (m_fontCache != null)
                {
                    foreach (Font fnt in m_fontCache.Values)
                    {
                        fnt.Dispose();
                    }

                    m_fontCache.Clear();
                }
                if (m_DisposeCellTemplate && CellTemplate != null)
                {
                    CellTemplate.Dispose();
                    CellTemplate          = null;
                    m_DisposeCellTemplate = false;
                }
            }

            m_textBoxControl = null;
            m_cache          = null;
            m_fontCache      = null;
            base.Dispose(disposing);
        }
Beispiel #5
0
    // Returns this cell's template
    public CellTemplate GetCellTemplate()
    {
        CellTemplate template = new CellTemplate();

        template.cellOcc = cellType;

        return(template);
    }
Beispiel #6
0
        private UITableViewCell GetCellForCommand(UITableView tableView, NSIndexPath indexPath)
        {
            var commandBinding = GetCommand(indexPath);

            var commandArguments = new ApplicationCommandArguments(
                _applicationMetadata, MetadataRepository, _dataMap, new DataRepository(), _composite, User.Current, _detailController);

            return(CellTemplate.ConstructCommandCell(tableView, commandBinding, commandArguments, _commandPreCondition));
        }
Beispiel #7
0
    //public int LastMainSelected { private set { _LastMainSelection = value; } get { return _LastMainSelection; } }

    protected override void OnSafeInit()
    {
        base.OnSafeInit();
        if (poolNode == null)
        {
            poolNode = RectTrans;
        }

        CellTemplate.SetParent(poolNode, false);
    }
Beispiel #8
0
    /// <summary>
    /// Creates a new cell in this holder of type celltype.
    /// If type is blocked then it's gonna disable cell by default and the returned cell will be null
    /// </summary>
    /// <param name="cellType"></param>
    /// <param name="animate">Whether to animate the cell or not</param>
    /// <returns>Return null if the cell could not be created</returns>
    public Cell NewCell(Cell.CellOcc cellType, bool animate = true)
    {
        if (!cell)
        {
            // We have a blocking cell, for example a hole filler
            if (cellType == Cell.CellOcc.BLOCKED)
            {
                Disable();

                currentTemplate         = new CellTemplate();
                currentTemplate.cellOcc = cellType;

                return(null);
            }

            cellGameObject = CellPooling.GetCell();

            SpriteRenderer sprR = cellGameObject.GetComponent <SpriteRenderer>();
            sprR.sortingLayerName = "Signs" + cellType.ToString(); // Set sorting layer for dynamic batching
            sprR.color            = SignResourceStorage.Instance.GetColorRelatedTo(cellType);

            if (Grid.cellParent != null)
            {
                cellGameObject.transform.parent = Grid.cellParent.transform;
            }

            // current cell template
            currentTemplate         = new CellTemplate();
            currentTemplate.cellOcc = cellType;

            // Set cell type both for animation and data storage purposes
            cell          = cellGameObject.GetComponent <Cell>();
            cell.cellType = cellType;

            // Animation
            if (animate)
            {
                cell.TriggerDraw();
            }
            else
            {
                cell.TriggerIdle();
            }

            // Subtract .five because the center is the pivot (because we want to rotate it to give it better look)
            cellGameObject.transform.position    = GetRandomPosBasedOnWorldPos();
            cellGameObject.transform.eulerAngles = GetRandomAngles();
        }
        else
        {
            return(null);
        }

        return(cell);
    }
Beispiel #9
0
        /// <summary>
        /// 行オブジェクトのセットアップを行います.
        /// </summary>
        /// <returns>行を構成する <c>GameObject</c>.</returns>
        protected virtual GameObject SetupRowTemplate()
        {
            var cell = CellTemplate.GetComponent <RectTransform>();
            var row  = RowTemplate.GetComponent <RectTransform>();

            row.sizeDelta = Scroller.ScrollDirection == ScrollDirection.Horizontal
                ? new Vector2(cell.rect.width, row.sizeDelta.y)
                : new Vector2(row.sizeDelta.x, cell.rect.height);

            return(row.gameObject);
        }
    // Modify cells
    public CellTemplate GetShipCell(int x, int y)
    {
        CellTemplate outCell = null;

        if (y >= 0 && y < Height)
        {
            outCell = pieceLines[y].GetCell(x);
        }

        return(outCell);
    }
Beispiel #11
0
 public static CellTemplateDto AsDto(this CellTemplate entity)
 {
     return(new CellTemplateDto()
     {
         Row = entity.Row,
         Column = entity.Column,
         RowSpan = entity.RowSpan,
         ColumnSpan = entity.ColumnSpan,
         DefaultValue = entity.DefaultValue,
         InputType = entity.InputType
     });
 }
Beispiel #12
0
        public void RefreshContent()
        {
            if (isRefreshing)
            {
                return;               // nicht rekusiv ;)
            }
            try
            {
                isRefreshing = true;

                Element cont = GetEmptyView();
                if (SelectedItem != null)
                {
                    if (filledContent == null)
                    {
                        filledContent = (CellTemplate?.CreateContent() as ViewCell).View;
                    }
                    cont = filledContent;
                }

                if (cont == null)
                {
                    cont = GetEmptyView();
                }

                //cont.InputTransparent = true;

                lv.ItemTemplate = this.CellTemplate;

                // to avoid nullreference excetion in Xamarin.Forms.ListView
                //lv.SelectedItem = null;
                //lv.ItemsSource = null;
                lv.ItemsSource  = ItemsSource;
                lv.SelectedItem = SelectedItem;

                var vc = cont as View;
                if (vc != null)
                {
                    frame.Content = vc;

                    frame.Content.Margin = 0;
                    frame.HeightRequest  = ListViewRowHeight;

                    frame.Content.BindingContext = SelectedItem;
                }
            }
            finally
            {
                isRefreshing = false;
            }
        }
        /// <summary>
        /// Dispose the object
        /// </summary>
        protected override void Dispose(bool disposing)
        {
            System.Diagnostics.Debug.WriteLineIf(!disposing, "****** Missing Dispose() call for " + GetType() + ". ****** ");
            base.Dispose(disposing);

            if (disposing)
            {
                if (CellTemplate != null)
                {
                    CellTemplate.Dispose();
                }
                CellTemplate = null;
            }
        }
 private FrameworkElement GenerateElement(object childData)
 {
     if (CellTemplate != null)
     {
         FrameworkElement element = CellTemplate.LoadContent() as FrameworkElement;
         element.DataContext = childData;
         return(element);
     }
     else //we are going to make a ToString() of the element the user tries to show:
     {
         TextBlock textBlock = new TextBlock();
         textBlock.Text = childData.ToString();
         return(textBlock);
     }
 }
Beispiel #15
0
 internal override FrameworkElement GenerateElement(object childData)
 {
     if (CellTemplate != null)
     {
         FrameworkElement element = CellTemplate.INTERNAL_InstantiateFrameworkTemplate();
         element.DataContext = childData;
         return(element);
     }
     else //we are going to make a ToString() of the element the user tries to show:
     {
         TextBlock textBlock = new TextBlock();
         textBlock.Text = childData.ToString();
         return(textBlock);
     }
 }
    public void DebugDrawShip()
    {
        foreach (ShipPiece piece in shipPieces)
        {
            for (int j = 0; j < piece.Height; ++j)
            {
                for (int i = 0; i < piece.Width; ++i)
                {
                    CellTemplate cell = piece.GetShipCell(i, j);

                    if (piece.GetShipCell(i, j).CellState != 0)
                    {
                        Vector3 p = new Vector3(piece.Position.x + i, piece.Position.y + j, 0) * 3.2f;
                        if ((piece.GetShipCell(i, j).CurWallState & WallState.Up) != WallState.None)
                        {
                            Debug.DrawLine(transform.TransformPoint(p + new Vector3(1.5f, 1.5f, 0)), transform.TransformPoint(p + new Vector3(-1.5f, 1.5f, 0)), Color.red);
                        }
                        if ((piece.GetShipCell(i, j).CurWallState & WallState.Right) != WallState.None)
                        {
                            Debug.DrawLine(transform.TransformPoint(p + new Vector3(1.5f, -1.5f, 0)), transform.TransformPoint(p + new Vector3(1.5f, 1.5f, 0)), Color.red);
                        }
                        if ((piece.GetShipCell(i, j).CurWallState & WallState.Down) != WallState.None)
                        {
                            Debug.DrawLine(transform.TransformPoint(p + new Vector3(-1.5f, -1.5f, 0)), transform.TransformPoint(p + new Vector3(1.5f, -1.5f, 0)), Color.red);
                        }
                        if ((piece.GetShipCell(i, j).CurWallState & WallState.Left) != WallState.None)
                        {
                            Debug.DrawLine(transform.TransformPoint(p + new Vector3(-1.5f, 1.5f, 0)), transform.TransformPoint(p + new Vector3(-1.5f, -1.5f, 0)), Color.red);
                        }
                    }
                }
            }

            int connectionCount = piece.GetConnectionCount();

            for (int i = 0; i < connectionCount; ++i)
            {
                ShipConnection connection = piece.GetConnectionByIndex(i);

                Vector3 p0 = new Vector3(connection.LocalCell.x + piece.Position.x, connection.LocalCell.y + piece.Position.y, 0) * 3.2f;
                Vector3 p1 = new Vector3(connection.OtherCell.x + connection.OtherPiece.Position.x, connection.OtherCell.y + connection.OtherPiece.Position.y, 0) * 3.2f;

                Debug.DrawLine(
                    transform.TransformPoint(p0),
                    transform.TransformPoint(p1), Color.green);
            }
        }
    }
Beispiel #17
0
    public void Navigate(ShipRuntime targetShip, Vector2Int globalStartPos, Vector2Int globalEndPos)
    {
        Init();
        this.targetShip = targetShip;

        if (globalStartPos == globalEndPos)
        {
            StartCoroutine("DelaySearch");
            return;
        }

        nextIndex = 1;

        CellTemplate startCell = targetShip.GetCellByGlobalPos(globalStartPos);
        CellTemplate endCell   = targetShip.GetCellByGlobalPos(globalEndPos);

        // Invalid path supplied
        if (startCell == null || endCell == null || startCell.CellState == 0 || endCell.CellState == 0)
        {
            return;
        }

        ShipPiece startPiece = targetShip.GetPieceByGlobalCellPos(globalStartPos);
        ShipPiece endPiece   = targetShip.GetPieceByGlobalCellPos(globalEndPos);


        NavGrid startGrid = new NavGrid(startPiece);

        startGrid.Generate();

        NavGrid goalGrid = startGrid;

        if (startPiece != endPiece)
        {
            goalGrid = new NavGrid(endPiece);
            goalGrid.Generate();
        }

        AStarAlgorithm aStarAlgorithm = new AStarAlgorithm(startGrid, goalGrid, globalStartPos, globalEndPos);

        int newTTmp = 0;

        curPath = aStarAlgorithm.AStarSearch(ref newTTmp);

        wiggleTimer = Random.Range(0, 6.28318f);
    }
Beispiel #18
0
    public void Generate()
    {
        cells = new NavCell[width * height];

        for (int w = 0; w < width; w++)
        {
            for (int h = 0; h < height; h++)
            {
                int index = w * height + h;

                CellTemplate shipCell = shipPiece.GetShipCell(w, h);

                var navCell = new NavCell(this, new Vector2Int(w, h) + shipPiece.Position, shipCell);
                cells[index] = navCell;
            }
        }
    }
Beispiel #19
0
 internal override FrameworkElement GenerateElement(object childData)
 {
     if (CellTemplate != null)
     {
         FrameworkElement element = CellTemplate.INTERNAL_InstantiateFrameworkTemplate();
         element.DataContext = childData;
         Binding b = this.INTERNAL_GetBinding(DataGridBoundColumn.BindingProperty); //we get the Binding in the Binding property set by the user.
         if (b != null)
         {
             if (b.Mode == BindingMode.OneWay)
             {
                 if (!b.INTERNAL_WasModeSetByUserRatherThanDefaultValue())
                 {
                     b.Mode = BindingMode.TwoWay;
                 }
             }
             element.SetBinding(FrameworkElement.DataContextProperty, b);
         }
         return(element);
     }
     else //we are going to make a ToString() of the element the user tries to show:
     {
         TextBlock textBlock = new TextBlock();
         textBlock.DataContext = childData;
         Binding b = this.INTERNAL_GetBinding(DataGridBoundColumn.BindingProperty); //we get the Binding in the Binding property set by the user.
         if (b != null)
         {
             if (b.Mode == BindingMode.OneWay)
             {
                 if (!b.INTERNAL_WasModeSetByUserRatherThanDefaultValue())
                 {
                     b.Mode = BindingMode.TwoWay;
                 }
             }
             textBlock.SetBinding(TextBlock.TextProperty, b);
         }
         else
         {
             textBlock.Text = childData.ToString();
         }
         return(textBlock);
     }
 }
Beispiel #20
0
        private void ToggleDatePicker(NSIndexPath target)
        {
            var shouldAttach       = true;
            var targetBeforeOffset = target;

            TableView.BeginUpdates();

            // Do we already have a date picker being
            // displayed? If so, we need to get rid of it.
            if (null != _datePicker)
            {
                // We do have a date picker displayed! If it's attached
                // to another cell we'll detach it first, but we must
                // remember to re-attach ("move") it to the new target.
                // Otherwise we'll simply turn it off.
                shouldAttach = false == _datePicker.IsAttachedTo(target);

                // We'll soon detach the date picker from the table,
                // which can cause our current target path pointing
                // to somewhere else after committing the changes.
                // So we'll "convert" it to its original value, as
                // if the date picker didn't exist.
                targetBeforeOffset = _datePicker.IndexPathBeforeOffset(target);

                _datePicker.Detach();
                _datePicker = null;
            }

            if (shouldAttach)
            {
                var datePickerCell = CellTemplate.ConstructDatePickerCell(TableView);
                var targetField    = GetField(targetBeforeOffset);

                _datePicker = DetailDatePickerCell.Attachment.Attach(TableView, targetBeforeOffset, targetField, datePickerCell);
            }

            TableView.EndUpdates();
        }
    // Connect 2 pieces by index, positions are relative to respective pieces
    public void ConnectPiecesByIndex(int localPieceIndex, int otherPieceIndex, Vector2Int localPos, Vector2Int otherPos)
    {
        if (localPieceIndex >= 0 && localPieceIndex < shipPieces.Count && otherPieceIndex >= 0 && otherPieceIndex < shipPieces.Count)
        {
            ShipPiece localPiece = shipPieces[localPieceIndex];
            ShipPiece otherPiece = shipPieces[otherPieceIndex];

            localPiece.AddConnection(new ShipConnection(localPos, otherPos, shipPieces[otherPieceIndex]));
            otherPiece.AddConnection(new ShipConnection(otherPos, localPos, shipPieces[localPieceIndex]));

            CellTemplate localCell = localPiece.GetShipCell(localPos.x, localPos.y);
            CellTemplate otherCell = otherPiece.GetShipCell(otherPos.x, otherPos.y);

            // Flag the connection cells
            if (localCell != null)
            {
                localCell.HasConnections = true;
            }
            if (otherCell != null)
            {
                otherCell.HasConnections = true;
            }
        }
    }
Beispiel #22
0
 // Updates attributes in cell template
 public void UpdateAttributes(CellTemplate cellTemplate)
 {
     cellType = cellTemplate.cellOcc;
 }
Beispiel #23
0
        private UITableViewCell GetCellForField(UITableView tableView, NSIndexPath indexPath)
        {
            var fieldBinding = GetField(indexPath);

            return(CellTemplate.ConstructFieldCell(tableView, fieldBinding));
        }
 /// <inheritdoc />
 protected override CellTemplate GetItemCellTemplate(TItem item) => CellTemplate.Create(ContextMenu(item));
Beispiel #25
0
 /// <summary>
 /// Both in current and previous cell template
 /// </summary>
 public void StoreTemplate(Cell.CellOcc type, Vector2 position)
 {
     currentTemplate         = new CellTemplate();
     currentTemplate.cellOcc = type;
 }
Beispiel #26
0
 public CellHolder(int[] worldPos)
 {
     this.worldPos           = worldPos;
     currentTemplate         = new CellTemplate();
     currentTemplate.cellOcc = Cell.CellOcc.NONE;
 }
Beispiel #27
0
        public Board GetRandomBoard(Game game)
        {
            _game = game;

            var template = new BoardTemplate(game.RuleSet.BoardSize);
            var fleet    = game.RuleSet.GetFleet().OrderByDescending(t => t.Size);
            List <List <Point> > mapped = new List <List <Point> >();
            int          shipId = 0;
            int          x, y;
            List <Point> fallback;
            int          fallbackIndex;

            foreach (var ship in fleet)
            {
                for (int i = 0; i < ship.Count; i++)
                {
                    List <Point> placed = new List <Point>();
                    IEnumerable <CellTemplate> tmp;
                    int toPlace = ship.Size;
                    int it      = 0;
                    do
                    {
                        randomxy(out x, out y);
                        if (++it > 1000000)
                        {
                            return(GetRandomBoard(game));
                        }
                    } while (template.Cells[x, y].State != CellTemplateState.EMPTY || template.GetZone(x, y).Count(t => t.State == CellTemplateState.EMPTY) < toPlace);

                    template.PlaceCore(x, y, shipId);
                    placed.Add(new Point(x, y));
                    toPlace--;

                    while (toPlace > 0)
                    {
                        fallback = new List <Point>(placed);
                        do
                        {
                            fallbackIndex = _random.Next(0, fallback.Count);
                            Point item = fallback[fallbackIndex];
                            fallback.RemoveAt(fallbackIndex);
                            tmp = template.GetSides((int)item.X, (int)item.Y).Where(t => t.State == CellTemplateState.EMPTY || (t.State == CellTemplateState.ZONE && t.ShipID == shipId));//.Where(t => template.GetZone(t.X, t.Y).All(t2 => t2.IsNotColliding(shipId)));
                        }while ((tmp == null || tmp.Count() == 0) && fallback.Count > 0);
                        if (tmp.Count() == 0)
                        {
                            throw new Exception();
                        }
                        CellTemplate target = tmp.ElementAt(_random.Next(0, tmp.Count()));
                        template.PlaceCore(target.X, target.Y, shipId);
                        placed.Add(new Point(target.X, target.Y));


                        toPlace--;
                    }
                    mapped.Add(placed);
                    shipId++;
                }
            }

            Board board = new Board(game.RuleSet.BoardSize);

            for (int i = 0; i < mapped.Count; i++)
            {
                var ship = new Ship(mapped[i].Count);
                foreach (var pt in mapped[i])
                {
                    ship.AddCell(new SeaCell((int)pt.X, (int)pt.Y));
                }
                board.AddShip(ship);
            }
            //var ship1 = new Ship(5);
            //ship1.AddCells(new SeaCell[] { new SeaCell(0, 0), new SeaCell(0, 1), new SeaCell(0, 2), new SeaCell(0, 3), new SeaCell(0, 4) });
            //board.AddShip(ship1);
            //var ship2 = new Ship(4);
            //ship2.AddCells(new SeaCell[] { new SeaCell(2, 0), new SeaCell(2, 1), new SeaCell(2, 2), new SeaCell(2, 3) });
            //board.AddShip(ship2);
            //var ship3 = new Ship(3);
            //ship3.AddCells(new SeaCell[] { new SeaCell(4, 0), new SeaCell(4, 1), new SeaCell(4, 2) });
            //board.AddShip(ship3);
            //var ship4 = new Ship(2);
            //ship4.AddCells(new SeaCell[] { new SeaCell(6, 0), new SeaCell(6, 1) });
            //board.AddShip(ship4);
            //var ship5 = new Ship(1);
            //ship5.AddCells(new SeaCell[] { new SeaCell(8, 0) });
            //board.AddShip(ship5);

            return(board);
        }
    public bool Navigate(ShipRuntime targetShip, Vector2Int globalStartPos, Vector2Int globalEndPos)
    {
        if (globalStartPos == globalEndPos)
        {
            return(false);
        }

        NavCell[] overrideStart = null;

        // Cur, prev and T evaluation
        if (curPath != null)
        {
            if (nextIndex < curPath.Length)
            {
                overrideStart = new NavCell[2];

                // Store C0 and C1
                overrideStart[0] = curPath[nextIndex - 1];
                overrideStart[1] = curPath[nextIndex];
            }
        }

        nextIndex = 1;

        CellTemplate startCell = targetShip.GetCellByGlobalPos(globalStartPos);
        CellTemplate endCell   = targetShip.GetCellByGlobalPos(globalEndPos);

        // Invalid path supplied
        if (startCell == null || endCell == null || startCell.CellState == 0 || endCell.CellState == 0)
        {
            return(false);
        }

        ShipPiece startPiece = targetShip.GetPieceByGlobalCellPos(globalStartPos);
        ShipPiece endPiece   = targetShip.GetPieceByGlobalCellPos(globalEndPos);


        NavGrid startGrid = new NavGrid(startPiece);

        startGrid.Generate();

        NavGrid goalGrid = startGrid;

        if (startPiece != endPiece)
        {
            goalGrid = new NavGrid(endPiece);
            goalGrid.Generate();
        }

        AStarAlgorithm aStarAlgorithm = new AStarAlgorithm(startGrid, goalGrid, globalStartPos, globalEndPos);

        int newTState = -1;

        curPath = aStarAlgorithm.AStarSearch(ref newTState, overrideStart);

        // Either reset, invert or leave move timer
        switch (newTState)
        {
        case -1:
            moveTimer = 0;
            break;

        case 1:
            moveTimer = 1 - moveTimer;
            break;
        }

        pathTracer.SetPositions(GetNavArray());

        return(curPath != null);
    }