private void DeleteSnake(GameObject head)
{
SnakePart part = head.GetComponent <SnakePart>();
//si hay siguiente parte llamamos a esta función pero de esa parte
if (part.nextPart)
{
DeleteSnake(part.nextPart);
}
//finalmente borramos el objecto
Destroy(head);
}
protected virtual void QuarterTile() // TODO rename this
{
if (indexInSnake < World.currentEnergy && tail == null)
{
tail = Instantiate(another, transform.parent).GetComponent <SnakePart>();
tail.indexInSnake = indexInSnake + 1;
}
if (tail != null)
{
tail.Instruct(currentSection, Animation.clip);
}
}
private void MoveSnake()
{
while (snakeParts.Count >= snakeLength)
{
GameArea.Children.Remove(snakeParts[0].UiElement);
snakeParts.RemoveAt(0);
}
foreach (SnakePart snakePart in snakeParts)
{
(snakePart.UiElement as Rectangle).Fill = snakeBodyBrush;
snakePart.IsHead = false;
}
SnakePart snakeHead = snakeParts[^ 1];
bool eat()
{
bool flag = Foods.Instance.Eat(snake[0].targetPos);
if (flag)
{
GameObject body = Game.Instance.Clone(Config.Instance.PrefabBody, snake[0].trans.parent.gameObject);
SnakePart part = new SnakePart(body);
part.Copy(snake[snake.Count - 2]);
snake.Insert(snake.Count - 1, part);
}
return(flag);
}
public bool CanMove(Vector2Int _WantedTilePosition)
{
CustomTile wantedTile = GameData.Instance.m_TileManager.GetTile(_WantedTilePosition);
if (wantedTile == null)
{
return(false);
}
List <GameObject> entities = wantedTile.m_Entities;
if (wantedTile != null)
{
if (entities.Count > 0)
{
for (int i = 0; i < entities.Count; i++)
{
if (!wantedTile.m_Walkable)
{
return(false);
}
else
{
SnakePart snakePart = entities[i].GetComponent <SnakePart>();
if (snakePart != null && !snakePart.m_CanWalkOnItself)
{
Debug.Log("Hit my queue");
Hit();
}
else
{
Debug.Log("CHECK ITEM");
Item item;
bool doesItemExists = ItemManager.Instance.CheckItem(_WantedTilePosition, out item);
if (doesItemExists)
{
Debug.Log("ITEM EXISTS");
m_HasItem = true;
ItemManager.Instance.SetImageUIActive(true);
ItemManager.Instance.DestroyItem(_WantedTilePosition, item);
}
}
}
}
}
return(true);
}
return(false);
}
public void AddPart()
{
GameObject g = Instantiate(snakePart, ultimaParte.transform.position, ultimaParte.transform.rotation);
SnakePart ultimaParteP = ultimaParte.GetComponent <SnakePart>();
SnakePart part = g.GetComponent <SnakePart>();
g.name = "parte" + numParts;
ultimaParteP.SetNextPart(g);
ultimaParte = g;
g.transform.parent = snake.transform;
numParts++;
part.SetNextPosition(ultimaParteP.GetNextPosition());
}
public void ReverseOrder(SnakePart newTail)
{
if (tail)
{
tail.ReverseOrder(this);
}
if (newTail)
{
transform.position = newTail.transform.position;
}
tail = newTail;
moveCount = 0;
}
public void Attach(SnakePart part)
{
if (tail)
{
tail.Attach(part);
}
else
{
part.transform.position = transform.position;
tail = part;
tail.index = index + 1;
tail.gameObject.name = "Tail " + tail.index;
mid.parent = transform.parent;
part.moveDirection = moveDirection;
}
}
public SnakePart[] Move(SnakePart[] myOldSnake, Vector2 direction)
{
SnakePart[] myNewSnake = new SnakePart[myOldSnake.Length];
myNewSnake[0].setPosition(myOldSnake[0].getPosition() + direction);
for (int i = 0; i < myNewSnake.Length - 1; i++)
{
myNewSnake[i + 1] = myOldSnake[i];
}
return(myNewSnake);
}
private void CalculaNextPosition(SnakePart part)
{
Vector2 currentDirection = part.GetCurrentDirection(); //dirección actual
Vector2 currentPosition = part.GetPrevPosition(); //posición desde la que calculamos la siguiente
float desplazacimentoTotal = part.getWidth(); //cuanto desplazamiento entre prev y next ha de existir (es el ancho del sprite de la serpiente)
Vector2 nextPosition = new Vector2(currentPosition.x + (desplazacimentoTotal * currentDirection.x), currentPosition.y + (desplazacimentoTotal * currentDirection.y));
//asignamos la anterior dirección como siguiente dirección de la siguiente parte si tiene siguiente parte
if (part.GetNextPart())
{
part.GetNextPart().GetComponent <SnakePart>().AddDirection(part.GetCurrentDirection());
}
//asignamos la nueva siguiente posición calculada
part.SetNextPosition(nextPosition);
}
// get next position of snake depends the actual direction
private (int, int) calculateNextHeadPosition()
{
SnakePart head = snake.SnakeBodyParts[0];
var(iPos, jPos) = head;
// next i j snake positions in board.
// almost like a plain object in JavaScript.
Dictionary <int, (int, int)> places = new Dictionary <int, (int, int)>();
places.Add(37, (iPos, jPos - 1)); // left
places.Add(38, (iPos - 1, jPos)); // up
places.Add(39, (iPos, jPos + 1)); // right
places.Add(40, (iPos + 1, jPos)); // down
return(places[(int)direction]);
}
void CheckToCatchFood()
{
int tempPosSnakeX;
int tempPosSnakeY;
int tempPosFoodX;
int tempPosFoodY;
for (int i = 0; i < elements.Count(); i++)
{
if (elements[i].GetType() == typeof(SnakePart))
{
SnakePart sp = (SnakePart)elements[i];
if (sp.IsHead == true)
{
tempPosSnakeX = elements[i].Left / sizeRect;
tempPosSnakeY = elements[i].Top / sizeRect;
for (int j = 0; j < elements.Count(); j++)
{
if (elements[j].GetType() == typeof(Food))
{
Food fd = (Food)elements[j];
tempPosFoodX = elements[j].Left / sizeRect;
tempPosFoodY = elements[j].Top / sizeRect;
if (tempPosSnakeX == tempPosFoodX && tempPosSnakeY == tempPosFoodY)
{
//MessageBox.Show("Наехали на еду");
AddPartSnake();
// Удалим найденную еду.
elements.Remove(fd);
// Добавим новую еду.
AddFood();
// Увеличим скорость змейки.
IncreaseSpeedSnake();
}
}
}
}
}
}
}
public void Chop(int len)
{
if (tail)
{
tail.Chop(len);
}
if (len <= index)
{
tail = null;
}
if (len < index)
{
mid.parent = transform;
partPool.ReturnToPool(this);
}
}
private void CreateSnakeParts()
{
//add body
Vector3Int pos = Vector3Int.FloorToInt(transform.position);
pos.x -= startDirection.Value.x;
pos.y -= startDirection.Value.y;
snakeParts.Add(snakePool.Spawn <SnakePart> (pos, transform.rotation));
grid.RemoveAvaliableCell(pos);
//add tail
pos.x -= startDirection.Value.x;
pos.y -= startDirection.Value.y;
SnakePart tail = Instantiate(TailPrefab, pos, transform.rotation).GetComponent <SnakePart> ();
snakeParts.Add(tail);
grid.RemoveAvaliableCell(pos);
}
public static SnakePart[] Grow(SnakePart[] myOldSnake, Vector2 direction, Vector2 foodPosition, float myScale)
{
SnakePart[] myNewSnake = new SnakePart[myOldSnake.Length + 1];
SnakePart newSnakePart = new SnakePart();
newSnakePart.Spawn(lastTailPosition, myScale, Color.blue);
myNewSnake[myNewSnake.Length - 1] = newSnakePart;
for (int i = 0; i < myOldSnake.Length; i++)
{
myNewSnake[i] = myOldSnake[i];
}
snakeSize = myNewSnake.Length;
return(myNewSnake);
}
private SnakeDirection GetCoadaDirection(SnakePart prev, SnakePart sp)
{
if (prev.PositionOnY == sp.PositionOnY + 1)
{
return(SnakeDirection.Down);
}
if (prev.PositionOnY == sp.PositionOnY - 1)
{
return(SnakeDirection.Up);
}
if (prev.PositionOnX == sp.PositionOnX + 1)
{
return(SnakeDirection.Right);
}
if (prev.PositionOnX == sp.PositionOnX - 1)
{
return(SnakeDirection.Left);
}
return(SnakeDirection.Up);
}
void Start()
{
moveWatch = new Stopwatch();
moveWatch.Start();
direction = Direction.Left;
movementQueue = new Queue <Direction>();
player = ReInput.players.GetPlayer(playerId);
GameObject headGameObject = Instantiate(Prefabs.SnakePartHead, transform);
head = headGameObject.GetComponent <SnakePart>();
body = new List <SnakePart>();
for (int i = 0; i < startLength; i++)
{
GameObject bodyGameObject = Instantiate(Prefabs.SnakePartBody, new Vector3(-Constants.GridSize * (i + 1), 0, 0), Quaternion.identity, transform);
body.Add(bodyGameObject.GetComponent <SnakePart>());
}
}
/// <summary>
/// Vérification de collision pour le serpent.
/// </summary>
private void DoCollisionCheckWall()
{
// Récupération de la tête du serpent
SnakePart snakeHead = snakeParts[snakeParts.Count - 1];
// Vérification d'une collision avec les murs
if ((snakeHead.GetPosition().Y < 0) || (snakeHead.GetPosition().Y >= GameArea.ActualHeight) ||
(snakeHead.GetPosition().X < 0) || (snakeHead.GetPosition().X >= GameArea.ActualWidth))
{
EndGame();
}
// Vérification d'une collision avec une partie du serpent
foreach (SnakePart snakeBodyPart in snakeParts.Take(snakeParts.Count - 1))
{
if ((snakeHead.GetPosition().X == snakeBodyPart.GetPosition().X) && (snakeHead.GetPosition().Y == snakeBodyPart.GetPosition().Y))
{
EndGame();
}
}
}
void calcCrash()
{
foreach (Snake si in snakes.Values)
{
if (si.Dead)
{
continue;
}
SnakePart headi = si.snake[0];
foreach (Snake sj in snakes.Values)
{
if (si.id == sj.id)
{
continue;
}
if (checkCrash(headi, sj.snake[0]))
{
// 头和头相撞
si.Dead = true;
sj.Dead = true;
Debug.Log(string.Format("snake[{0}] crash snake[{1}] head to head", si.id, sj.id));
break;
}
else
{
for (int j = 1; j < sj.snake.Count; j++)
{
// 头和身子相撞
if (checkCrash(headi, sj.snake[j]))
{
Debug.Log(string.Format("snake[{0}] head crash snake[{1}] body", si.id, sj.id));
si.Dead = true;
break;
}
}
}
}
}
}
public void grow(int count)
{
SnakeTail snakeTail;
for (int i = 0; i < count; i++)
{
snakeTail = TileManager.instance.BuildSnakeTail();
snakeTail.AttachedSnakePart = LastSnakePart;
snakeTail.PartNumber = scoreHandler.Lenth;
snakeTail.onBite += OnTailEaten;
snakeTail.onLastSnakePart += OnNewLastSnakePart;
//Debug.Log("new soldier " + snakeTail.PartNumber);
snakeTail.transform.position = LastSnakePart.transform.position;
//
LastSnakePart.tile.AddObject(snakeTail);
//OnMoved += snakeTail.MoveToNext;
LastSnakePart = snakeTail;
}
}
private void ControlMovement(SnakePart part)
{
float moveHorizontal = Input.GetAxis("Horizontal");
float moveVertical = Input.GetAxis("Vertical");
//si hay algun tipo de movimiento añadimos la dirección a la pila de direcciones
if (moveHorizontal != 0 || moveVertical != 0)
{
//si pulsamos derecha
if (moveHorizontal > 0)
{
part.AddDirection(Vector2.right);
}
//si pulsamos izquierda
else if (moveHorizontal < 0)
{
part.AddDirection(Vector2.left);
}
//si pusamos arriba
else if (moveVertical > 0)
{
part.AddDirection(Vector2.up);
}
//si pulsamos abajo
else if (moveVertical < 0)
{
part.AddDirection(Vector2.down);
}
//si aun no nos movemos, cogemos directamente la siguiente dirección
if (part.GetCurrentDirection() == Vector2.zero)
{
part.NextDirection();
}
}
}
//fetches the correct snake texture based on the designated direction and part
public Texture2D getSnakeTexture(Direction direction, SnakePart part)
{
Texture2D result = null;
switch (part)
{
case SnakePart.head:
if (switchTongue)
{
if (direction == Direction.up)
{
return(tongueUp);
}
else if (direction == Direction.down)
{
return(tongueDown);
}
else if (direction == Direction.left)
{
return(tongueLeft);
}
else if (direction == Direction.right)
{
return(tongueRight);
}
}
else
{
if (direction == Direction.up)
{
return(headUp);
}
else if (direction == Direction.down)
{
return(headDown);
}
else if (direction == Direction.left)
{
return(headLeft);
}
else if (direction == Direction.right)
{
return(headRight);
}
}
break;
case SnakePart.body:
if (direction == Direction.up)
{
return(bodyUp);
}
else if (direction == Direction.down)
{
return(bodyDown);
}
else if (direction == Direction.left)
{
return(bodyLeft);
}
else if (direction == Direction.right)
{
return(bodyRight);
}
break;
case SnakePart.tail:
if (direction == Direction.up)
{
return(tailUp);
}
else if (direction == Direction.down)
{
return(tailDown);
}
else if (direction == Direction.left)
{
return(tailLeft);
}
else if (direction == Direction.right)
{
return(tailRight);
}
break;
}
return(null);
}
/// <summary>
/// Déplacement du serpent
/// </summary>
private void MoveSnake()
{
// Si la grandeur du serpent n'a pas changé, on supprimer la queue et la
// dernière partie du corp
if (snakeParts.Count == snakeLength)
{
GameArea.Children.Remove(snakeParts[0].GetUiElement());
GameArea.Children.Remove(snakeParts[1].GetUiElement());
snakeParts.RemoveAt(0);
}
// Pour chaque partie du serpent, on supprimer les éléments du canvas
foreach (SnakePart snakePart in snakeParts)
{
GameArea.Children.Remove(snakePart.GetUiElement());
}
// La dernière partie du corps devient la queue
snakeParts[0].SetTypeSnakePart(TypeSnakePart.TAIL);
// Récupération de la tête actuelle
SnakePart snakeHead = snakeParts[snakeParts.Count - 1];
// La tête devient le corps
snakeHead.SetTypeSnakePart(TypeSnakePart.BODY);
// Récupération des positions actuelle de la tête
double nextX = snakeHead.GetPosition().X;
double nextY = snakeHead.GetPosition().Y;
// Calcul des prochaines positions de la tête
switch (snakeDirection)
{
case Direction.LEFT:
nextX -= Configuration.SNAKE_SQUARE_SIZE;
break;
case Direction.RIGHT:
nextX += Configuration.SNAKE_SQUARE_SIZE;
break;
case Direction.UP:
nextY -= Configuration.SNAKE_SQUARE_SIZE;
break;
case Direction.DOWN:
nextY += Configuration.SNAKE_SQUARE_SIZE;
break;
}
// Création de la nouvelle tête
snakeParts.Add(new SnakePart(new Point(nextX, nextY), TypeSnakePart.HEAD, snakeDirection));
// Vérification d'une collision avec les murs ou le corps
DoCollisionCheckWall();
// Si le serpent est autorisé a se dessiner, le dessine
if (isAuthorizedToDrawSnake)
{
DrawSnake();
}
// Vérification d'une collision avec de la nourriture
DoCollisionCheckFood();
}
private void DrawSnakePart(SnakePart part)
{
Rectangle rectangle = converter.Convert(part.Coordinates, Canvas, MapSize);
DrawRectangle(rectangle, Brushes.BlueViolet);
}
//Start up code for creating the snake parts
private void StartUp()
{
_oldState = Keyboard.GetState();
_dead = false;
EndPause();
this.SnakeLength = this.StartLength;
for (int i = 0; i <= this.SnakeLength - 1; i++)
{
SnakePart part = new SnakePart(new Vector2(120 - (10 * i), 120), 3);
_Snake.Add(part);
}
_paused = false;
_pauseKeyDown = false;
_pausedForGuide = false;
}
/// <summary>
/// Makes the snake grow bigger!
/// </summary>
/// <returns></returns>
private bool GrowSnake()
{
SnakePart part = new SnakePart(_Snake[this.SnakeLength - 1].Position, _Snake[this.SnakeLength - 1].Facing);
_Snake.Add(part);
this.SnakeLength += 1;
return true;
}
void Update()
{
if (GetGameOverState() == false && Time.timeScale != 0)
{
//cojemos la cabeza primero y su controlador
GameObject obj = cabeza;
SnakePart part = obj.GetComponent <SnakePart>();
//control de movimiento (solo cabeza)
ControlMovement(part);
//actualizamos la posicion siguiente de cada parte de la serpiente
while (obj != null)
{
//calcula la siguiente posición
CalculaNextPosition(part);
//si la dirección actual es distinta de 0 (si hay movimiento) o si hay cambios de dirección pendientes
if (part.GetCurrentDirection() != Vector2.zero || part.GetNumDirections() > 0)
{
//Si la posición actual es >= que la siguiente (si ya se ha llegado a la siguiente posición)
if (DistanciaMaxima(obj.transform.position, part.GetNextPosition(), part.GetCurrentDirection()))
{
//actualizamos la actual a la siguiente (la nueva siguiente se actualiza en el update)
part.SetPrevPosition(part.GetNextPosition());
//por si nos pasamos actualizamos la posición del objeto
obj.transform.position = part.GetPrevPosition();
//si tiene que crecer, añadimos una nueva parte
if (crecer && obj == ultimaParte)
{
crecer = false;
AddPart();
}
//si hay direcciones pendientes, cambiamos de dirección
if (part.GetNumDirections() > 0)
{
Vector2 newDirection = part.NextDirection();
obj.transform.position = Vector3.Lerp(obj.transform.position, new Vector3(obj.transform.position.x + newDirection.x, obj.transform.position.y + newDirection.y), Time.deltaTime * speed);
}
//si no hay direccion pendiente mantenemos la actual
else
{
obj.transform.position = Vector3.Lerp(obj.transform.position, new Vector3(obj.transform.position.x + part.GetCurrentDirection().x, obj.transform.position.y + part.GetCurrentDirection().y), Time.deltaTime * speed);
}
//comprovamos si hay siguiente parte e iniciamos movimiento si no se mueve
GameObject nextGameObject = part.GetNextPart();
if (nextGameObject)
{
SnakePart partNextObject = nextGameObject.GetComponent <SnakePart>();
if (partNextObject.GetCurrentDirection() == Vector2.zero)
{
partNextObject.NextDirection();
}
}
}
//si aun no se ha llegado a la siguiente posición, continua con el actual movimiento
else
{
obj.transform.position = Vector3.Lerp(obj.transform.position, new Vector3(obj.transform.position.x + part.GetCurrentDirection().x, obj.transform.position.y + part.GetCurrentDirection().y), Time.deltaTime * speed);
}
}
//cambiamos a la parte siguiente si existe
obj = part.GetNextPart();
if (obj)
{
part = obj.GetComponent <SnakePart>();
}
}
text.text = numParts.ToString();
}
}
private void RenderSnakePart(Graphics graphics, SnakePart bodyPart)
{
var rect = new Rectangle(bodyPart.Position.X, bodyPart.Position.Y, bodyPart.Width, bodyPart.Height);
graphics.FillRectangle(bodyPartBrush, rect);
}
private void RenderSnakeHead(Graphics graphics, SnakePart head)
{
var rect = new Rectangle(head.Position.X, head.Position.Y, head.Width, head.Height);
graphics.FillEllipse(headBrush, rect);
}
bool checkCrash(SnakePart p1, SnakePart p2)
{
Vector3 offset = p1.trans.position - p2.trans.position;
return(Mathf.Approximately(offset.sqrMagnitude, 0));
}
public override void DieUntil(int PartNumber)
{
LastSnakePart = this;
}
public void OnNewLastSnakePart(SnakePart snakePart)
{
LastSnakePart = snakePart;
//Debug.Log("new last snake part " + snakePart);
}