public void GenerateBoard() { cells = new CellController[boardWidth, boardHeight]; string holderName = "Generated Board"; GameObject board = transform.Find(holderName).gameObject; if (board != null) { DestroyImmediate(board); } board = new GameObject(holderName); board.transform.parent = transform; for (int x = 0; x < boardWidth; x++) { for (int y = 0; y < boardHeight; y++) { Vector2 cellPosition = new Vector2(-boardWidth / 2 + .5f + x, boardHeight / 2 - .5f - y); GameObject newCell = Instantiate(cellPrefab, cellPosition, Quaternion.identity, board.transform); newCell.name = "cell(" + x + "," + y + ")"; CellController cellController = newCell.GetComponent <CellController>(); cellController.x = x; cellController.y = y; cells[x, y] = cellController; } } }
private TokenMenuCloseButton m_tmcb; // entire-screen button in the background that will close the menu when clicked public void OpenMenuAtCell(GameObject cell) { m_selectedCell = cell.GetComponent <CellController>(); // positioning RectTransform rt = m_tokenMenu.GetComponent <RectTransform>(); Vector2 rtSize = rt.sizeDelta; Vector2 cellSize = cell.GetComponent <RectTransform>().sizeDelta; rt.position = new Vector3( Screen.width / 2, cell.transform.position.y + rtSize.y / 2f + cellSize.y / 2f, 0); // buttons; assign self as TMM m_tokenButtons = m_tokenMenu.GetComponentsInChildren <TokenButton>(); foreach (var tb in m_tokenButtons) { tb.tokenMenuManager = gameObject.GetComponent <TokenMenuManager>(); } m_tmcb = m_tokenMenu.GetComponentInChildren <TokenMenuCloseButton>(); m_tmcb.tokenMenuManager = gameObject.GetComponent <TokenMenuManager>(); // colors IndicateConflictingTokens(); m_tokenMenu.SetActive(true); }
public FormCreate(CellController controller, Size clientSize, Point loc) { InitializeComponent(); //Рандомизация значений трекбаров для цвета this.trackBar1.Value = r.Next(0, this.trackBar1.Maximum); this.trackBar2.Value = r.Next(0, this.trackBar2.Maximum); this.trackBar3.Value = r.Next(0, this.trackBar3.Maximum); //Определение максимальных значений длины и ширины this.numericUpDown1.Maximum = clientSize.Width / 2; this.label10.Text = this.numericUpDown1.Maximum.ToString(); this.numericUpDown2.Maximum = clientSize.Height / 2; this.label11.Text = this.numericUpDown2.Maximum.ToString(); //Таймер для изменения цвета кнопки (косметика) buttonTimer.Interval = 1; buttonTimer.Tick += ButtonTimer_Tick; buttonTimer.Start(); this.controller = controller; this.location = loc; //Трекбары плохо работают с цветами. Ужасно выглядит. //if (DateTime.Now.Hour >= 18 || DateTime.Now.Hour <= 6) //{ // this.BackColor = Color.Black; // this.numericUpDown1.BackColor = this.numericUpDown2.BackColor = this.numericUpDown3.ForeColor = Color.Black; //} }
public Cell(int X, int Y) { Coordinate coord = new Coordinate(X, Y); if (CellController.FindCell(coord) != null) { Cell alreadyCell = CellController.FindCell(coord); if (alreadyCell.empty == -1) { alreadyCell.del(); empty = -1; Coordinate = coord; Position = new Vector2(coord.x * CellController.CellSize + CellController.CellSize / 2, coord.y * CellController.CellSize + CellController.CellSize / 2); cell = PoolScript.instance.GetObjectFromPool("Cell", Position, Quaternion.Euler(0, 0, 0)); cell.transform.parent = CellController.instance.transform; CellController.cells.Add(this); } } else { empty = -1; Coordinate = coord; Position = new Vector2(coord.x * CellController.CellSize + CellController.CellSize / 2, coord.y * CellController.CellSize + CellController.CellSize / 2); cell = PoolScript.instance.GetObjectFromPool("Cell", Position, Quaternion.Euler(0, 0, 0)); cell.transform.parent = CellController.instance.transform; CellController.cells.Add(this); } }
private void CheckLine(int y) { CellController cellController = null; for (int x = 0; x < boardWidth; x++) { cellController = GetCellController(x, y); if (cellController.TilesCount == 0) { if (y == 0) { cellController.CreateTile(); CellController lowerCellController = GetLowerCellController(cellController); if (lowerCellController != null) { StartMoveFromUpperCellCoroutine(lowerCellController); } } else { StartMoveFromUpperCellCoroutine(cellController); } } if (isSecondLeft && previousTime % helpTimer == 0) { Help(cellController); } } }
public override bool Grow() { bool hasGrown = false; foreach (ActionPattern actionPattern in actionPatterns) { if (MatchesPattern(actionPattern.GetPattern())) { if (actionPattern.action == Action.Die) { this.Kill(); return(hasGrown); } } } foreach (ActionPattern actionPattern in actionPatterns) { if (MatchesPattern(actionPattern.GetPattern())) { if (actionPattern.action == Action.Expand) { CellController cell = this.Grid.GetCellInDirection(this.X, this.Y, actionPattern.expandDirection); if (CanClaim(cell)) { cell.Claim(this); hasGrown = true; } } } } return(hasGrown); }
// Each combatant lose 1% in defend after each combat // Organ can reflect the attack (1/2 defense - attack on the pathogen public bool defend(CellController pathogen) { float combat = pathogen.power() - defense(); bool successful; if (combat <= 0) // successful defense against the pathogen { pathogen.updateHealthStats(-combat / 2); // pathogen is damaged pathogen.updateDefenseStats(-1f); updateDefenseStats(-1.0f); // organ loses a bit of defense successful = true; } else // Lost { updateHealthStats(-combat); updateDefenseStats(-1.0f); pathogen.updateDefenseStats(-1f); // pathogen loses a bit of defense damageBody(); if (stats_health <= 0) { Destroy(gameObject); // Die! } else { inContact [pathogen.GetInstanceID()] = new Damage(combat, Time.time + 1); } successful = false; // Keeps track of the damage if contact continues; } //Debug.Log(gameObject.name+"."+defense()+" defends against "+ pathogen.name // +"."+pathogen.power()+ " "+ showStats()+ (successful?" success":"failed")); return(successful); }
CellController _clickedCellController; // выделеная яечкйка void Start() { _puzzle = PuzzleGame.Instance.GetNewGame(1); for (int x = 0; x < 9; x++) { for (int y = 0; y < 9; y++) { PuzzleCell cell = _puzzle.GetCell(x, y); cell.OnCellOpen += OnCellOpened; var cellButton = GameObject.Find($"{x}_{y}"); CellController controller = cellButton.GetComponent <CellController>(); controller.Cell = cell; controller.X = x; //колонка controller.Y = y; //строка controller.CellName = cellButton.name; controller.CellClicked += OnCellClicked; _cells[x, y] = controller; controller.DrawCell(); } } //Find keypad buttons for (int i = 1; i < 10; i++) { var keyPadButton = GameObject.Find($"Num{i}").GetComponent <Button>(); int number = i; keyPadButton.onClick.AddListener(() => OnKeyPadButtonClicked(number)); } }
void Depoint() { lineRenderer.enabled = false; leftBarbRenderer.enabled = false; rightBarbRenderer.enabled = false; targetCell = null; }
public void FillArray() //das wird für die Methode GetAdjacentCells in der Cellcontrollerklasse verwendet { // lokales Hilfs-Array CellController[] arrayOfObjects = GameObject.FindObjectsOfType <CellController>(); Debug.Log("objekt: " + arrayOfObjects[0]); Debug.Log("Hilfsarray arrayOfObjects.Length: " + arrayOfObjects.Length); int nummer = 0; for (var i = 0; i < GridSize; i++) { for (var j = 0; j < GridSize; j++) { for (int k = 0; k < 64; k++) { if (arrayOfObjects[k].cellNum == nummer) { ArrayOfCells[i, j] = arrayOfObjects[k].GetComponent <CellController>();;//checkNumber(nummer, arrayOfObjects[k], i, j); ListOfCells.Add(ArrayOfCells[i, j]); cellController = ArrayOfCells[i, j]; cellController.xCoord = i; cellController.yCoord = j; break; } } nummer++; } } }
//private float animSpeed = 1f; private void Update() { if (Input.GetMouseButtonDown(0) && Input.mousePosition.x >= g.camera.pixelRect.x) { targetCell = g.map.GetCellFromCamera(Input.mousePosition); if (targetCell != cell) { moveToCell(targetCell); // g.c.Trigger(Channel.Camera.SetTarget, targetCell); // ListenTo(g.c, Channel.Camera.SetTarget, SetTarget); } } if (Input.GetKeyDown(KeyCode.Space) && g.map.obtacles[cell].GetType() != typeof(BombController)) { SetPlayerBomb(); } /* * if (Input.GetKeyDown(KeyCode.A)) { * animatorFactor -= 0.01f; * console.log(animatorFactor); * } * if (Input.GetKeyDown(KeyCode.D)) { * animatorFactor += 0.01f; * console.log(animatorFactor); * } */ }
public void LoadMap(string str) { gameController.ships.Clear(); string[] ships = str.Split(';'); foreach (string ship in ships) { string[] ship_datas = ship.Split('|'); Ship newShip = new Ship(0); List <CellController> cellList = new List <CellController>(); foreach (string ship_data in ship_datas) { string[] keypair = ship_data.Split('='); switch (keypair[0]) { case "amount": newShip.PieceAmount = int.Parse(keypair[1]); break; case "pieces": string[] pieces = keypair[1].Split(','); foreach (string piece in pieces) { string[] p = piece.Split(':'); CellController c = playerController.Cells[int.Parse(p[1])][int.Parse(p[0])]; c.EnemyCell = true; cellList.Add(c); } newShip.Cells = cellList.ToArray(); break; } } gameController.ships.Add(newShip); } }
private void ConnectCells(CellController cell1, CellController cell2) { if (cell1 != null && cell2 != null) { if (!cell1.Empty && !cell2.Empty) { if (cell1.ZoneID != cell2.ZoneID) { var zone1 = _zones.Find(x => x.ZoneID == cell1.ZoneID); var zone2 = _zones.Find(x => x.ZoneID == cell2.ZoneID); if (zone1 == null || zone2 == null) { return; } if (zone1.Neighbors.Contains(zone2)) { return; } zone1.Neighbors.Add(zone2); zone2.Neighbors.Add(zone1); } } } }
public CellController ReplaceCell(MapPoint point, CellController prefab) { if (point.X < 0 || point.Y < 0 || point.X > 0xffff || point.Y > 0xffff) { return(null); } CellController newCell = CellController.InstantiateMe(prefab, transform, point); MapRect rect = prefab.GetCellIndexes(point, selectedRotation); rect.Foreach((MapPoint p) => { int key = p.toInt(); if (cells.ContainsKey(key)) { GameObject.Destroy(cells[key].gameObject); cells.Remove(key); cells[key] = newCell; } }); newCell.SetRotation(selectedRotation); return(newCell); }
private void InitCellController(CellController cellController, int hor, int vert) { cellController.SetFieldManager(fieldManager); cellController.SetSceneManager(sceneManager); cellController.SetPosition(new CellPosition(hor, vert)); cellController.CellChange += fieldManager.GetWinnerCheckerCellChangeHandler(); }
private CellController SpawnCell(int x, int y, CellController prefab) { if (x > TilesWide - 1 || y > TilesHigh - 1 || x < 0 || y < 0) { return(prefab); } if (foregroundArray[x, y] != null) { int indexToRemove = cellsToUpdate.IndexOf(foregroundArray[x, y]); if (indexToRemove > 0) { cellsToUpdate.RemoveAt(indexToRemove); } Destroy(foregroundArray[x, y].gameObject); } Vector3 scale = this.transform.localScale; Vector3 position = new Vector3((bottomLeft.x / scale.x) + x, (bottomLeft.y / scale.x) + y, 0.1f); CellController cell = Instantiate(prefab, position, new Quaternion()); cell.X = x; cell.Y = y; AddForegroundCellToGrid(cell); return(cell); }
void GetAdjacentCells() { adjacentCells = new List <CellController> (); CellController northCell = null, westCell = null, eastCell = null, southCell = null; if (xCoord - 1 >= 0) { northCell = GMInstance.ArrayOfCells [xCoord - 1, yCoord]; adjacentCells.Add(northCell); } if (yCoord - 1 >= 0) { Debug.Log("cellNumber of this clicked box: " + GMInstance.ArrayOfCells[xCoord, yCoord - 1].cellNum); westCell = GMInstance.ArrayOfCells[xCoord, yCoord - 1]; adjacentCells.Add(westCell); } if (yCoord + 1 <= GMInstance.GridSize - 1) { eastCell = GMInstance.ArrayOfCells [xCoord, yCoord + 1]; adjacentCells.Add(eastCell); } if (xCoord + 1 <= GMInstance.GridSize - 1) { southCell = GMInstance.ArrayOfCells [xCoord + 1, yCoord]; adjacentCells.Add(southCell); } }
void GenerateMap() { for (int i = 0; i < GRID_SIZE + 1; i++) { Cells.Add(new List <CellController>()); for (int j = 0; j < GRID_SIZE + 1; j++) { if (!(i == 0 && j == 0)) { CellPrefab.GetComponent <RectTransform>().sizeDelta = new Vector2(CELL_SIZE, CELL_SIZE); GameObject o = Instantiate(CellPrefab, new Vector2((j - (GRID_SIZE + 1) / 2) * CELL_SIZE, (-i + (GRID_SIZE + 1) / 2) * CELL_SIZE) + MAP_OFFSET, Quaternion.identity) as GameObject; o.transform.SetParent(canvas.transform, false); if (i > 0 && j > 0) { CellController c = o.AddComponent <CellController>(); c.ID_i = i - 1; c.ID_j = j - 1; o.name = c.ID_i + ":" + c.ID_j; Cells[c.ID_i].Add(c); Destroy(o.transform.Find("Text").gameObject); } else { //HEADER Text t = o.transform.Find("Text").GetComponent <Text>(); t.text = i == 0 ? LETTERS[j - 1] : i.ToString(); t.color = Color.white; o.name = "Header-" + t.text; Destroy(o.GetComponent <Image>()); Destroy(o.GetComponent <Button>()); } } } } }
public void Clicked(CellController cell) { if (!Attack) { switch (this.state) { case CellState.None: if (SelectedCells.Count < ShipAmount.TotalCellAmount) { this.state = CellState.Selected; SelectedCells.Add(this); } break; case CellState.Selected: this.state = CellState.None; SelectedCells.Remove(this); break; } this.Invalidate(); } else { if (!Locked) { if (EnemyCell) { state = CellState.Selected; Invalidate(); ShipAmount.TotalCellAmount--; } MainController.DoAttack(); } } }
private void MoveToClosest() { if (!isDragging) { float minDistance = 0f; bool firstPass = true; currentCell.SetIsFree(true); Transform currentTf = gameObject.transform; foreach (var cell in cells) { if (cell.GetIsFree()) { float currentDistance = CalculateDistance(currentTf, cell.transform); if (firstPass || currentDistance < minDistance) { minDistance = currentDistance; currentCell = cell; } firstPass = false; } } currentCell.SetIsFree(false); gameObject.transform.position = new Vector3(currentCell.transform.position.x, yHeight, currentCell.transform.position.z); } }
public void handleCellClicked(CellController cell) { var pos = getPos(cell.x, cell.y); if (currentPlayer == Player.Wheel) { cell.addWheel(); choices[pos] = Player.Wheel; } else { cell.addTurbo(); choices[pos] = Player.Turbo; } var winner = getWinner(); if (winner != null) { GameOverController.setText(winner.ToString() + " won!"); SceneManager.LoadScene("gameOverScene"); } else if (isAllCellsFilled()) { GameOverController.setText("tie :("); SceneManager.LoadScene("gameOverScene"); } togglePlayer(); }
static void Main(string[] args) { var time = DateTime.Now; Console.Write("Enter height: "); int.TryParse(Console.ReadLine(), out int height); Console.Write("Enter width: "); int.TryParse(Console.ReadLine(), out int width); Console.Write("Enter the shape of your living cells (dead cells will be just empty spaces): "); string shape = Console.ReadLine(); Console.Clear(); var life = new CellController(shape); life.GenerateCells(height, width); life.DrawCells(); while (life.GameIsNotOver) { var newTime = DateTime.Now; if (newTime.Second != time.Second) { time = newTime; life.UpdateGrid(); life.DrawCells(); } } Console.WriteLine("Game is over. No conditions for the cells to reproduce."); }
// This cell defend against another public bool defendAgainst(CellController other) { //Debug.Log (name + " defends against " + other.name); float combat = other.power() - defense(); bool win; if (combat <= 0) // successful defense against the others { other.updateHealthStats(combat); other.updateDefenseStats(-1.0f); updateDefenseStats(-1.0f); win = true; } else // Lost { updateHealthStats(-combat); updateDefenseStats(-1.0f); other.updateDefenseStats(-1.0f); if (stats_health <= 0) { Destroy(gameObject); //Debug.Log (name + " dies "); } else { inContact [other.GetInstanceID()] = new Damage(combat, Time.time + 1); } win = false; // Keeps track of the damage if contact continues; } //Debug.Log(gameObject.name+"."+gameObject.tag+" defends against "+ other.name+"."+other.tag + " "+ // showStats()+ (win?"succeeded":"failed") ); return(win); }
private void expand(CellController cell) { if (gameEnd) { return; } if (!cell.tile.activeInHierarchy) { return; } cell.tile.SetActive(false); if (checkGameEnd(cell)) { endGame(); cell.mine3.SetActive(true); return; } CellController[] neighbours = getNeighbours(cell); int bombsCount = countBombs(neighbours); if (bombsCount > 0) { cell.text.SetActive(true); cell.text.GetComponent <Text>().text = "" + bombsCount; return; } expandNeighbours(neighbours); }
void OnMouseDown() { // start the game once a cell is clicked if (selectedCell == null) // nothing selected yet // if nothing on this cell, ignore { if (spriteRenderer.sprite != null && !IsHighlighted() && spriteRenderer.sprite != highlightSprite) { selectedCell = this; Select(); SoundManager.Instance.PlaySound(SoundType.TypeSelect); } return; } if (selectedCell == this) // deselect { selectedCell = null; Clear(); } else // try moving from selectedCell to this { bool hasMoved = GameManager.Instance.TryMoveCell(selectedCell.indices, indices); if (hasMoved) // deselect { selectedCell = null; } // else retains selection } }
Vector2[] GetCellsInShip(ShipController shipController) { CellController rootCell = shipController.root.GetComponent <CellController>(); Vector2 rootPos = new Vector2(rootCell.row, rootCell.col); Vector2 tailPos = rootPos + new Vector2( shipController.direction.deltaVertical * (shipController.length - 1), shipController.direction.deltaHorizontal * (shipController.length - 1) ); Vector2[] shipCells = new Vector2[shipController.length]; int i = 0; int maxRow = Math.Max((int)rootPos.x, (int)tailPos.x); int minRow = Math.Min((int)rootPos.x, (int)tailPos.x); int maxCol = Math.Max((int)rootPos.y, (int)tailPos.y); int minCol = Math.Min((int)rootPos.y, (int)tailPos.y); for (int row = minRow; row <= maxRow; row++) { for (int col = minCol; col <= maxCol; col++) { shipCells[i] = new Vector2(row, col); i++; } } return(shipCells); }
public void FindPath(CellController start, CellController finish, Action <List <BlockController> > callback, bool checkObtacles = false) { Observable.Start(() => FindPathThread(start, finish, checkObtacles)) //.TakeUntilDestroy(g.c) .ObserveOnMainThread() .Subscribe(callback); }
// Start is called before the first frame update void Awake() { if (Instance == null) { Instance = this; } }
private void SetZone(int zoneID, CellController cell, ZoneController zone, int currentSize) { cell.ZoneID = zoneID; zone.Cells.Add(cell); currentSize++; if (currentSize > _maxZoneSize) { return; } if (cell.LeftCell != null && cell.LeftCell.ZoneID < 0 && !cell.LeftCell.Empty) { SetZone(zoneID, cell.LeftCell, zone, currentSize); } if (cell.RightCell != null && cell.RightCell.ZoneID < 0 && !cell.RightCell.Empty) { SetZone(zoneID, cell.RightCell, zone, currentSize); } if (cell.TopCell != null && cell.TopCell.ZoneID < 0 && !cell.TopCell.Empty) { SetZone(zoneID, cell.TopCell, zone, currentSize); } if (cell.BottomCell != null && cell.BottomCell.ZoneID < 0 && !cell.BottomCell.Empty) { SetZone(zoneID, cell.BottomCell, zone, currentSize); } }
public Entity ReplaceCellView(CellController newTile) { var componentPool = GetComponentPool(CellsComponentIds.CellView); var component = (CellViewComponent)(componentPool.Count > 0 ? componentPool.Pop() : new CellViewComponent()); component.Tile = newTile; ReplaceComponent(CellsComponentIds.CellView, component); return this; }
// Update is called once per frame void Update() { ray = Camera.main.ScreenPointToRay(Input.mousePosition); if (Input.GetButtonDown("Fire")) { if (Physics.Raycast(ray, out hit, 1000f, FighterVision - 5)) //-1 to invert mask, -4 to ignore raycast { SelectActiveCell(false); if (hit.collider.gameObject.GetComponent <CellManager>() != null) { selectedCell = hit.collider.gameObject.GetComponent <CellManager>(); cellController = selectedCell.controller; UIManager.Instance.BuildUI(cellController); selectedCell.Selected(true); //TODO controller calls build UI } else if (hit.collider.gameObject.GetComponent <WhereIs>() != null) { whereIsBuffer = hit.collider.gameObject.GetComponent <WhereIs>(); fighterBuffer = whereIsBuffer.GetFighter(); if (fighterInFocus != null) { fighterInFocus.ToggleInFocus(false); } fighterInFocus = fighterBuffer; fighterInFocus.ToggleInFocus(true); UIManager.Instance.TrackFighter(fighterInFocus, whereIsBuffer, fighterBuffer.GetFighterType() == typeof(Tower)); } } } }
public void TargetCell(CellController cell) { if (selectedCell) { selectedCell.Target(cell); EnableTarget(cell.transform.position); AudioSource.PlayClipAtPoint(selectSource.clip, GameObject.FindWithTag("MainCamera").GetComponent<Camera>().ScreenToWorldPoint(new Vector3(0, 0, 0))); } }
/// <summary> /// Перенести дополнительные параметры ячейки и предмета в ячейке. /// </summary> /// <param name="cell">Ячейка.</param> public void MoveMoreParams(CellController cell) { var item = cell.Item; if (item != null) { item.Modification = Modification; item.RarityItem = (Rarity)RarityItem; } }
/// <summary> /// Уничтожить объект в ячейке. /// </summary> /// <param name="cell">Ячейка с предметом.</param> public static void RecycleItem(CellController cell) { if (cell.Item != null) { Destroy(cell.Item.gameObject); LogController.Instance.AddString(String.Format("Предмет \"{0}\" удалён.", cell.Item.BaseItem.Name)); } cell.Item = null; }
/// <summary> /// Создать клона указанного предмета в указанной ячейки. /// </summary> /// <param name="cell">Ячейка в которой будет создан клон.</param> /// <param name="item">Предмет для клонирования.</param> public static ItemController CreateCloneItem(CellController cell, ItemController item) { ItemController clone = null; if (cell.CheckPutItem(item)) { clone = Instantiate(item); clone.BaseItem = item.BaseItem; // TODO: Случайно задаём редкость предмета. clone.RarityItem = (Rarity)UnityEngine.Random.Range(0, 4); cell.PutItem(clone); } return clone; }
/// <summary> /// Получить CellInfo на основе CellController. /// </summary> /// <param name="cell">Ячейка.</param> public static CellInfo ToCellInfo(CellController cell) { var res = new CellInfo(); res.IndexCell = cell.Index; var item = cell.Item; if (item != null) { res.IndexItem = item.BaseItem.Index; res.Modification = item.Modification; res.RarityItem = (int)item.RarityItem; } return res; }
/// <summary> /// Создать новое поле. /// </summary> public void CreateField() { ClearField(); _cells = new CellController[Width, Height]; for (int x = 0; x < Width; x++) { for (int y = 0; y < Height; y++) { var obj = CreateCell(x, y); _cells[x, y] = obj; } } }
public void Init(CellController cellController, int newDefenseRating = 1) { var position = transform.position; _spot = Pools.cells.CreateEntity() .AddPosition(position.x, position.y, position.z) .AddDefenseRating(newDefenseRating) .AddView(gameObject); if (cellController != null) { _spot.ReplaceSpot(cellController.Entity, 0); } else { _spot.RemoveSpot(); } Cell = cellController; }
void FixedUpdate() { float actualSpeed, randX, randY; if (target && target.owner != "body") { target = null; state = "untargeted"; } if (target && state == "targeted") { actualSpeed = ((Mathf.Cos((Time.time + instanceID) * 12) + 1) / 2) * topSpeed; Vector3 directionVector = target.transform.position - transform.position; Vector2 directionVector2D; directionVector.Normalize(); directionVector *= actualSpeed; directionVector2D = new Vector2(directionVector.x, directionVector.y); physicsBody.AddForce(directionVector2D); } else if (state == "untargeted") { timeToNewRoamHeading -= Time.deltaTime; if (timeToNewRoamHeading <= 0) { timeToNewRoamHeading = newRoamHeadingInterval; randX = Random.Range(-1f, 1f); randY = Random.Range(-1f, 1f); roamHeading = new Vector3(randX, randY, 0); roamHeading.Normalize(); } actualSpeed = ((Mathf.Cos((Time.time + instanceID) * 12) + 1) / 2) * topSpeed; physicsBody.AddForce(roamHeading * actualSpeed); } }
/// <summary> /// Изменить размер поля. /// </summary> /// <param name="clear">Очистить поле.</param> public void ResizeField(bool clear) { if (clear) ClearField(); // Уничтожаем лишние объекты. if (Width < _cells.GetLength(0)) { for (int x = Width; x < _cells.GetLength(0); x++) for (int y = 0; y < _cells.GetLength(1); y++) if (_cells[x, y] != null) DestroyImmediate(_cells[x, y].gameObject); } if (Height < _cells.GetLength(1)) { for (int y = Height; y < _cells.GetLength(1); y++) for (int x = 0; x < _cells.GetLength(0); x++) if (_cells[x, y] != null) DestroyImmediate(_cells[x, y].gameObject); } // Формируем новое поле. var newCells = new CellController[Width, Height]; // Создаём новые ячейки, если новый размер поля больше старого. if (Width > _cells.GetLength(0)) { for (int x = _cells.GetLength(0); x < Width; x++) for (int y = 0; y < Height; y++) if (newCells[x, y] == null) newCells[x, y] = CreateCell(x, y); } if (Height > _cells.GetLength(1)) { for (int y = _cells.GetLength(1); y < Height; y++) for (int x = 0; x < Width; x++) if (newCells[x, y] == null) newCells[x, y] = CreateCell(x, y); } // Переносим данные в новое поле. var minWidht = Width; if (_cells.GetLength(0) < Width) minWidht = _cells.GetLength(0); var minHeight = Height; if (_cells.GetLength(1) < Height) minHeight = _cells.GetLength(1); for (int x = 0; x < minWidht; x++) for (int y = 0; y < minHeight; y++) newCells[x, y] = _cells[x, y]; _cells = newCells; }
/// <summary> /// Запустить анимацию смены местами элементов в ячейках. /// </summary> /// <param name="cell1">Ячейка.</param> /// <param name="cell2">Ячейка.</param> private IEnumerator PlaySwapAnimation(CellController cell1, CellController cell2) { _fixedField++; if (cell1.Y == cell2.Y) { if (cell1.X > cell2.X) { cell1.Element.AnimationLeft(); cell2.Element.AnimationRight(); } else { cell1.Element.AnimationRight(); cell2.Element.AnimationLeft(); } } else { if (cell1.Y > cell2.Y) { cell1.Element.AnimationDown(); cell2.Element.AnimationUp(); } else { cell1.Element.AnimationUp(); cell2.Element.AnimationDown(); } } // Ждём окончания анимаций. while (cell1.Element.AnimationIsPlay() && cell2.Element.AnimationIsPlay()) yield return null; cell1.Element.transform.localPosition = new Vector3(0, 0, -1); cell2.Element.transform.localPosition = new Vector3(0, 0, -1); _fixedField--; }
/// <summary> /// Положить предмет в ячейку. /// </summary> /// <param name="item">Предмет.</param> /// <param name="cell">Ячейка.</param> public static bool SetItemInCell(ItemController item, CellController cell) { if (cell == null) throw new NullReferenceException("Ячейка не может быть NULL."); return cell.PutItem(item); }
/// <summary> /// Поменять местами предметы в ячейках. /// </summary> public static void SwapItemsInCell(CellController from, CellController to) { if (from == null || to == null) return; // Проверяем возможно ли перемещение предмета из ячейке назначения в ячейку "от куда". if (!from.CheckPutItem(to.Item)) return; var tempItem = to.Item; var swap = SetItemInCell(from.Item, to); if (swap) SetItemInCell(tempItem, from); }
/// <summary> /// Опустить элемент если под ним пустая ячейка. /// </summary> /// <param name="cell">Ячейка с элементом.</param> private void LowerElement(CellController cell) { var x = cell.X; for (int y = cell.Y - 1; y >= 0; y--) { var cellY = _cells[x, y]; if (cellY == null) continue; if (cellY.Element == null) StartCoroutine(LowerColumn(cell, cellY)); break; } }
public CellController EditorSetCell(MapPoint point, CellController prefab) { if(point.X<0 || point.Y<0 || point.X>0xffff || point.Y>0xffff) return null; CellController newCell = null; int key = point.toInt(); if(!cells.ContainsKey(key)) { newCell = CellController.InstantiateMe(prefab,transform,point); cells.Add(key,newCell); } else newCell = cells[key]; return newCell; }
public void Detarget() { targetCell = null; }
public void TargetCell(CellController cell) { target = cell; }
/// <summary> /// Уничтожить элементы с пометкой "Должен быть уничтожен". /// </summary> /// <param name="cell">Ячейка для проверки.</param> private void DestroyElementMustByDestroyed(CellController cell) { if (cell != null && cell.Element.MustByDestroyed) DestroyElement(cell); #region Горизонталь. // Вправо. for (int x = cell.X + 1; x < _cells.GetLength(0); x++) { var c = _cells[x, cell.Y]; if (c != null && c.Element.MustByDestroyed) DestroyElement(c); else break; } // Влево. for (int x = cell.X - 1; x >= 0; x--) { var c = _cells[x, cell.Y]; if (c != null && c.Element.MustByDestroyed) DestroyElement(c); else break; } #endregion #region Вертикаль. // Вверх. for (int y = cell.Y + 1; y < _cells.GetLength(1); y++) { var c = _cells[cell.X, y]; if (c != null && c.Element.MustByDestroyed) DestroyElement(c); else break; } // Вниз. for (int y = cell.Y - 1; y >= 0; y--) { var c = _cells[cell.X, y]; if (c != null && c.Element.MustByDestroyed) DestroyElement(c); else break; } #endregion }
/// <summary> /// Опустить элементы в столбце включая текущий и выше. /// </summary> /// <param name="cell">Ячейка содержащая элемент для опускания.</param> /// <param name="toCell">Куда опускать.</param> private IEnumerator LowerColumn(CellController cell, CellController toCell) { var x = cell.X; _fixedField++; while (_fixedColumn[x] > 0) yield return null; var prevCell = toCell; for (int y = cell.Y; y < _cells.GetLength(1); y++) { var cellY = _cells[x, y]; if (cellY == null) continue; if (cellY.Element == null) break; StartCoroutine(LowerColumnElement(cellY, prevCell)); prevCell = cellY; } _fixedField--; }
/// <summary> /// Опустить элемент до дна. /// </summary> /// <param name="cell">Элемент.</param> /// <param name="toCell">Свободная ячейка под элементом.</param> private IEnumerator LowerColumnElement(CellController cell, CellController toCell) { _fixedField++; _fixedColumn[cell.X]++; cell.Element.AnimationLower(); while (cell.Element.AnimationIsPlay()) yield return null; _fixedField--; _fixedColumn[cell.X]--; cell.Element.transform.localPosition = new Vector3(0, 0, -1); SwapElements(toCell, cell); LowerElement(toCell); }
// Update is called once per frame void Update() { GameObject newVirion; VirionController newVirionController; float integrityScale, infectionScale, indicatorScale; if (!dead) { if (owner == "body") { if (generatesBodies) { indicatorScale = (Mathf.Cos(Time.time * 16) * 0.1f) + 2; generationIndicator.transform.localScale = new Vector3(indicatorScale, indicatorScale, 1); } } else { timeToSpawn -= Time.deltaTime; timeToFire -= Time.deltaTime; if (timeToSpawn <= 0) { timeToSpawn = spawnInterval; virusCount++; virusCountText.text = virusCount + ""; } if (targetCell) { if (targetCell.owner != "body") { targetCell = null; } } if (targetCell && virusCount > 1 && timeToFire <= 0) { newVirion = Instantiate(VirionPrefab, transform.position, Quaternion.identity) as GameObject; newVirionController = newVirion.GetComponent<VirionController>(); newVirionController.TargetCell(targetCell); virusCount--; virusCountText.text = virusCount + ""; timeToFire = fireInterval; } } integrityScale = Mathf.Lerp(0, 1, integrity / maxIntegrity); infectionScale = Mathf.Lerp(0, 1, infection / integrity); integrityBar.localScale = new Vector3(integrityScale, 1, 1); infectionBar.localScale = new Vector3(infectionScale, 1, 1); } else { Destroy(gameObject); } }
public CellController ReplaceCell(MapPoint point, CellController prefab) { if(point.X<0 || point.Y<0 || point.X>0xffff || point.Y>0xffff) return null; CellController newCell = CellController.InstantiateMe(prefab,transform,point); MapRect rect = prefab.GetCellIndexes(point,selectedRotation); rect.Foreach((MapPoint p) => { int key = p.toInt(); if(cells.ContainsKey(key)) { GameObject.Destroy(cells[key].gameObject); cells.Remove(key); cells[key] = newCell; } }); newCell.SetRotation(selectedRotation); return newCell; }
/// <summary> /// Поменять местами элементы в ячейках. /// </summary> /// <param name="cell1">Ячейка.</param> /// <param name="cell2">Ячейка.</param> private void SwapElements(CellController cell1, CellController cell2) { if (cell1.Element != null) cell1.Element.transform.SetParent(cell2.transform, false); if (cell2.Element != null) cell2.Element.transform.SetParent(cell1.transform, false); var element = cell1.Element; cell1.Element = cell2.Element; cell2.Element = element; }
/// <summary> /// Уничтожить элемент в ячейке. /// </summary> /// <param name="cell">Ячейка.</param> private void DestroyElement(CellController cell) { var trans = cell.transform; Instantiate(Parameters.Instance.PrefabExplosion, trans.position, trans.rotation); Destroy(cell.Element.gameObject); cell.Element = null; DestroyElementsCount++; }
public static CellController InstantiateMe(CellController prefab, Transform parent, MapPoint point) { CellController newCell = Instantiate<CellController>(prefab); newCell.PrefabName = prefab.name; newCell.transform.parent = parent; newCell.Position = point; return newCell; }
// Use this for initialization void Start() { healthyCellController = healthyCell.GetComponent<CellController>(); winText = winText.GetComponent<Text>(); }
/// <summary> /// Создать случайный элемент в ячейке. /// </summary> /// <param name="cell">Ячейка в которой будет элемент.</param> /// <returns>Созданный элемент.</returns> private ElementController CreateElement(CellController cell) { var rnd = UnityEngine.Random.Range(0, PrefabElements.Length); var element = PrefabElements[rnd]; var res = Instantiate(element); cell.Element = res; var pos = Vector3.zero; pos.z = -1; res.transform.position = pos; res.transform.SetParent(cell.transform, false); return res; }
/// <summary> /// Выбрать элемент. /// </summary> /// <param name="cell">Ячейка.</param> private IEnumerator SelectionElement(CellController selected) { if (_fixedField > 0) yield break; if (_firstSelected == selected || selected == null) { _firstSelected.Element.StopAnimations(); _firstSelected = null; yield break; } if (_firstSelected == null) { _firstSelected = selected; _firstSelected.Element.AnimationSelected(); } else { _firstSelected.Element.StopAnimations(); selected.Element.StopAnimations(); var swap = false; if (selected.X <= _firstSelected.X + 1 && selected.X >= _firstSelected.X - 1 && selected.Y == _firstSelected.Y || selected.Y <= _firstSelected.Y + 1 && selected.Y >= _firstSelected.Y - 1 && selected.X == _firstSelected.X) swap = true; if (swap) { yield return StartCoroutine(PlaySwapAnimation(selected, _firstSelected)); SwapElements(selected, _firstSelected); var dest = (CheckElementDestroyed(selected).Count > 0); if (!dest) dest = (CheckElementDestroyed(_firstSelected).Count > 0); if (dest) { StartCoroutine(FullCheckField()); } else { yield return StartCoroutine(PlaySwapAnimation(selected, _firstSelected)); SwapElements(_firstSelected, selected); } } _firstSelected = null; } }
/// <summary> /// Проверить элемент на уничтожение. /// </summary> /// <param name="cell">Ячейка для проверки.</param> /// <returns>Список ячеек для уничтожения.</returns> private List<CellController> CheckElementDestroyed(CellController cell) { var res = new List<CellController>(); var element = cell.Element; #region Горизонталь. var destroy = false; if (cell.X - 1 >= 0 && cell.X + 1 < _cells.GetLength(0) && _cells[cell.X - 1, cell.Y] != null && _cells[cell.X + 1, cell.Y] != null && _cells[cell.X - 1, cell.Y].Element.Type == element.Type && _cells[cell.X + 1, cell.Y].Element.Type == element.Type) { destroy = true; } else if (cell.X - 2 >= 0 && _cells[cell.X - 1, cell.Y] != null && _cells[cell.X - 2, cell.Y] != null && _cells[cell.X - 1, cell.Y].Element.Type == element.Type && _cells[cell.X - 2, cell.Y].Element.Type == element.Type) { destroy = true; } else if (cell.X + 2 < _cells.GetLength(0) && _cells[cell.X + 1, cell.Y] != null && _cells[cell.X + 2, cell.Y] != null && _cells[cell.X + 1, cell.Y].Element.Type == element.Type && _cells[cell.X + 2, cell.Y].Element.Type == element.Type) { destroy = true; } if (destroy) { // Вправо. for (int x = cell.X + 1; x < _cells.GetLength(0); x++) { var c = _cells[x, cell.Y]; if (c != null && c.Element.Type == element.Type) res.Add(c); else break; } // Влево. for (int x = cell.X - 1; x >= 0; x--) { var c = _cells[x, cell.Y]; if (c != null && c.Element.Type == element.Type) res.Add(c); else break; } } #endregion #region Вертикаль. destroy = false; if (cell.Y - 1 >= 0 && cell.Y + 1 < _cells.GetLength(1) && _cells[cell.X, cell.Y - 1] != null && _cells[cell.X, cell.Y + 1] != null && _cells[cell.X, cell.Y - 1].Element.Type == element.Type && _cells[cell.X, cell.Y + 1].Element.Type == element.Type) { destroy = true; } else if (cell.Y - 2 >= 0 && _cells[cell.X, cell.Y - 1] != null && _cells[cell.X, cell.Y - 2] != null && _cells[cell.X, cell.Y - 1].Element.Type == element.Type && _cells[cell.X, cell.Y - 2].Element.Type == element.Type) { destroy = true; } else if (cell.Y + 2 < _cells.GetLength(1) && _cells[cell.X, cell.Y + 1] != null && _cells[cell.X, cell.Y + 2] != null && _cells[cell.X, cell.Y + 1].Element.Type == element.Type && _cells[cell.X, cell.Y + 2].Element.Type == element.Type) { destroy = true; } if (destroy) { // Вверх. for (int y = cell.Y + 1; y < _cells.GetLength(1); y++) { var c = _cells[cell.X, y]; if (c != null && c.Element.Type == element.Type) res.Add(c); else break; } // Вниз. for (int y = cell.Y - 1; y >= 0; y--) { var c = _cells[cell.X, y]; if (c != null && c.Element.Type == element.Type) res.Add(c); else break; } } #endregion if (res.Count > 0) res.Add(cell); return res; }