protected void DettachNode(SnakeNode node)
{
if (fFirstNode == null)
{
return;
}
else if ((fFirstNode == fLastNode) &&
(fFirstNode == node))
{
fFirstNode = null;
fLastNode = null;
}
else if (fFirstNode == node)
{
fFirstNode = fFirstNode.NextSibling;
fFirstNode.PrevSibling = null;
}
else if (fLastNode == node)
{
fLastNode = fLastNode.PrevSibling;
fLastNode.NextSibling = null;
}
else
{
node.PrevSibling.NextSibling = node.NextSibling;
node.NextSibling.PrevSibling = node.PrevSibling;
}
node.PrevSibling = null;
node.NextSibling = null;
fLength--;
}
/// <summary>
/// Release this instance.
/// </summary>
public void Release()
{
//Release Component!
for (int i = 0; i < m_listCompoent.Count; ++i)
{
m_listCompoent[i].Release();
}
m_listCompoent.Clear();
//release the snake, head and tail included
SnakeNode node = m_head;
while (node != null)
{
SnakeNode next = node.Next;
EntityFactory.ReleaseEntity(node);
node = next;
}
m_head = null;
m_tail = null;
if (m_container != null)
{
GameObject.Destroy(m_container);
m_container = null;
}
m_context = null;
}
private void Move(Vector3 newPos)
{
var previousPosition = this.transform.position;
if (newPos.x > maxX)
{
newPos = new Vector3(minX, newPos.y, newPos.z);
}
else if (newPos.x < minX)
{
newPos = new Vector3(maxX, newPos.y, newPos.z);
}
else if (newPos.z > maxZ)
{
newPos = new Vector3(newPos.x, newPos.y, minZ);
}
else if (newPos.z < minZ)
{
newPos = new Vector3(newPos.x, newPos.y, maxZ);
}
this.transform.position = newPos;
if (_next != null)
{
_next.Move(previousPosition);
}
else if (shouldSpawn)
{
shouldSpawn = false;
//Soy el ultimo nodo y me toca spawnear otro nodo en la posición que acabo de abandonar
this._next = Instantiate(snakeNodePrefab, previousPosition, Quaternion.identity).GetComponent <SnakeNode>();
}
}
private void GenNewSnakeNode()
{
SnakeNode snakeNode = null;
switch (Direct)
{
case Direction.UP:
snakeNode = new SnakeNode(new Point(SnakeNodes[SnakeHead]._pos.X,
SnakeNodes[SnakeHead]._pos.Y - 1));
break;
case Direction.DOWN:
snakeNode = new SnakeNode(new Point(SnakeNodes[SnakeHead]._pos.X,
SnakeNodes[SnakeHead]._pos.Y + 1));
break;
case Direction.LEFT:
snakeNode = new SnakeNode(new Point(SnakeNodes[SnakeHead]._pos.X - 1,
SnakeNodes[SnakeHead]._pos.Y));
break;
case Direction.RIGHT:
snakeNode = new SnakeNode(new Point(SnakeNodes[SnakeHead]._pos.X + 1,
SnakeNodes[SnakeHead]._pos.Y));
break;
}
if (snakeNode != null)
{
SnakeNodes.Insert(0, snakeNode);
myCanvas.Children.Add(SnakeNodes[0]._rect);
}
}
protected override void Create(EntityObject entity)
{
m_entity = entity as SnakeNode;
m_context = GameManager.Instance.Context;
m_visible = true;
m_renderer = this.GetComponent <SpriteRenderer>();
if (m_renderer == null)
{
m_renderer = this.GetComponentInChildren <SpriteRenderer>();
}
if (m_renderer != null)
{
m_renderer.enabled = true;
m_renderer.color = m_context.GetUniqueColor(m_entity.TeamId);
if (m_entity.Index > 0)
{
m_renderer.sortingOrder = 10000 - m_entity.Index;
}
else
{
if (m_entity is SnakeTail)
{
m_renderer.sortingOrder = 0;
}
else if (m_entity is SnakeHead)
{
m_renderer.sortingOrder = 10000;
}
}
}
}
void Start()
{
restartsCount += 1;
mapManager = GameObject.FindObjectOfType <MapManager>();
spawnManager = GameObject.FindObjectOfType <SpawnManager>();
scoreManager = GameObject.FindObjectOfType <ScoreManager>();
scoreManager.OnScoreMilestoneReach += ScoreManager_OnScoreMilestoneReach;
snakeManager = GameObject.FindObjectOfType <SnakeManager>();
SnakeNode head = snakeManager.GetSnakeHead();
head.OnObstacleCollision += Head_OnObstacleCollision;
head.OnOutOfBoundsCollision += Head_OnOutOfBoundsCollision;
transitionBlack.gameObject.SetActive(false);
transitionWhite.gameObject.SetActive(false);
startNextLevelBtn.gameObject.SetActive(false);
buttons = new List <Button>();
buttons.Add(upBtn);
buttons.Add(rightBtn);
buttons.Add(downBtn);
buttons.Add(leftBtn);
if (restartsCount >= 2)
{
splashScreenBG.gameObject.SetActive(false);
splashScreenBtn.gameObject.SetActive(false);
snakeManager.gameState = GameState.Countdown;
}
}
private void CheckCollectableCollisions()
{
for (int i = 0; i < spawnManager.allActiveCollectables.Count; i++)
{
Collectable collectable = spawnManager.allActiveCollectables[i];
if (this.position == collectable.position)
{
// TODO: Extract spawning logic in the SpawnManager
// You may use event subscribe
SnakeNode lastNode = snakeManager.snakeBody[snakeManager.snakeBody.Count - 1];
Coord spawnPosition = new Coord(lastNode.previousPosition.x, lastNode.previousPosition.y);
Vector3 nodeSpawnPosition = mapManager.CoordToPosition(spawnPosition);
SnakeNode spawnedNode = Instantiate(snakeManager.nodePrefab, nodeSpawnPosition + Vector3.up * .65f, Quaternion.identity) as SnakeNode;
spawnedNode.transform.localScale = Vector3.one * (1 - mapManager.outlinePercent) * mapManager.tileSize;
spawnedNode.position = spawnPosition;
spawnedNode.moveSpeed = moveSpeed;
spawnedNode.prevNode = lastNode;
spawnedNode.index = lastNode.index + 1;
snakeManager.snakeBody.Add(spawnedNode);
spawnManager.DestroyCollectableAtPosition(collectable.position);
spawnManager.SpawnCollectable();
if (OnCollectableCollision != null)
{
OnCollectableCollision(collectable.LootValue);
}
}
}
}
protected void AttachNodeBefore(SnakeNode before, SnakeNode node)
{
node.PrevSibling = null;
node.NextSibling = before;
if (fFirstNode == null)
{
fFirstNode = node;
fLastNode = node;
}
else if ((before == fFirstNode) ||
(before == null))
{
fFirstNode.PrevSibling = node;
node.PrevSibling = null;
node.NextSibling = fFirstNode;
fFirstNode = node;
}
else
{
node.PrevSibling = before.PrevSibling;
node.NextSibling = before;
before.PrevSibling.NextSibling = node;
before.PrevSibling = node;
}
fLength++;
}
public static SnakeController CreateSnake()
{
if (!prefab_snakeHead)
{
prefab_snakeHead = Resources.Load <SnakeNode>(PrefabsName.snakeHead);
}
if (!prefab_snakeNode)
{
prefab_snakeNode = Resources.Load <SnakeNode>(PrefabsName.snakeNode);
}
var snakeCtrl = new GameObject("MySnake" + Random.Range(0, 10000)).AddComponent <SnakeController>();
if (snakeCtrl.NodeList == null)
{
snakeCtrl.NodeList = new List <SnakeNode>();
}
var head = Instantiate(prefab_snakeHead, snakeCtrl.transform);
float dir = Random.Range(-180, 180);
head.transform.localEulerAngles = new Vector3(0, 0, dir);
head.Init();
snakeCtrl.NodeList.Add(head);
for (int i = 0; i < 11; i++)
{
snakeCtrl.CreateNode();
}
return(snakeCtrl);
}
public void UpdateSnake(Node N, bool PutTail)
{
int HoldIndexX, HoldIndexY;
int DesIndexX = N.getIndexX(), DesIndexY = N.getIndexY();
foreach (SnakeNode SN in SnakeBody)
{
HoldIndexX = SN.getIndexX();
HoldIndexY = SN.getIndexY();
SN.setIndexX(DesIndexX);
SN.setIndexY(DesIndexY);
AC.changeNode(DesIndexX, DesIndexY, Enums.NodeState.Snake);
DesIndexX = HoldIndexX;
DesIndexY = HoldIndexY;
}
if (PutTail)
{
SnakeNode S = new SnakeNode();
S.SetSnakeNode(DesIndexX, DesIndexY);
SnakeBody.Add(S);
AC.changeNode(DesIndexX, DesIndexY, Enums.NodeState.Snake);
}
else
{
AC.changeNode(DesIndexX, DesIndexY, Enums.NodeState.None);
}
}
private void InstantiateSnake()
{
Map currentMap = mapManager.GetCurrentMap();
for (int i = 0; i < snakeLength; i++)
{
Coord spawnPosition = new Coord(currentMap.mapCenter.x - i, currentMap.mapCenter.y);
Vector3 nodeSpawnPosition = mapManager.CoordToPosition(spawnPosition);
SnakeNode spawnedNode = Instantiate(nodePrefab, nodeSpawnPosition + Vector3.up * .65f, Quaternion.identity) as SnakeNode;
spawnedNode.transform.localScale = Vector3.one * (1 - mapManager.outlinePercent) * mapManager.tileSize * (1 - mapManager.outlinePercent);
spawnedNode.position = spawnPosition;
spawnedNode.moveSpeed = snakeSpeed;
spawnedNode.index = i;
snakeBody.Add(spawnedNode);
if (i != 0)
{
spawnedNode.isHead = false;
spawnedNode.prevNode = snakeBody[i - 1];
}
if (i == 0)
{
spawnedNode.isHead = true;
Renderer rend = spawnedNode.GetComponent<Renderer>();
rend.sharedMaterial = headMaterial;
}
}
ChangeSpeed(currentSpeed);
}
private void GenerateNewNode()
{
GameObject node = GameObject.Instantiate(_snakeNodePrefab);
SnakeNode nodeComp = node.AddComponent <SnakeNode>();
SnakeNode last = _snake[_snake.Count - 1];
Vector3 pos = Vector3.zero;
switch (last.moveDir)
{
case MoveDir.UP:
pos = last.transform.position + (new Vector3(0f, -SnakeNode.nodeSize, 0));
break;
case MoveDir.DOWN:
pos = last.transform.position + (new Vector3(0f, SnakeNode.nodeSize, 0));
break;
case MoveDir.LEFT:
pos = last.transform.position + (new Vector3(SnakeNode.nodeSize, 0f, 0));
break;
case MoveDir.RIGHT:
pos = last.transform.position + (new Vector3(-SnakeNode.nodeSize, 0f, 0));
break;
}
node.transform.position = pos;
nodeComp.moveDir = last.moveDir;
_snake.Add(nodeComp);
}
public void OnTurnRightBtnPress()
{
SnakeNode head = GetSnakeHead();
Direction nextRightDirection = FindRightDirection(head);
head.nextDirection = nextRightDirection;
UnPauseSnake();
}
protected void AttachNodeAfter(SnakeNode after, SnakeNode node)
{
node.PrevSibling = after;
node.NextSibling = null;
if (fFirstNode == null)
{
fFirstNode = node;
fLastNode = node;
}
else if ((after == fLastNode) ||
(after == null))
{
fLastNode.NextSibling = node;
node.PrevSibling = fLastNode;
node.NextSibling = null;
fLastNode = node;
}
else
{
node.PrevSibling = after;
node.NextSibling = after.NextSibling;
after.NextSibling.PrevSibling = node;
after.NextSibling = node;
}
fLength++;
}
protected void AddNode()
{
SnakeNode new_node = fNodePool.TakeElement() as SnakeNode;
new_node.Owner = this;
AttachNodeBefore(null, new_node);
}
public void AddFirst(GameObject s)
{
SnakeNode toAdd = new SnakeNode();
toAdd.segment = s;
toAdd.next = headNode;
headNode = toAdd;
Debug.Log("hoi");
}
void OriginalSnake(Color[] colors)
{
snakeNode = new SnakeNode(snakePrefab, new Vector3(3, 0.5f, 0), colors[0], null);
for (int i = 1; i < colors.Length; i++)
{
snakeNode.eatFood(snakeNode, colors[i], null);
}
}
public override IDataPool_Element ElementConstructor()
{
SnakeNode node = new SnakeNode();
node.Initializer();
node.Name = "element" + fId;
fId++;
return(node);
}
void MoveNodeBefore(SnakeNode before, SnakeNode node)
{
if (fFirstNode == fLastNode)
{
return;
}
DettachNode(node);
AttachNodeBefore(before, node);
}
public void Move(SnakeNode node, Vector3 _pos)
{
if (node == null)
{
return;
}
Move(node.nextNode, node.snakeObj.transform.position);
node.snakeObj.transform.position = _pos;
}
public void Move(SnakeNode a, Vector3 _pos) //把 a 挪到 -pos的位置
{
if (a == null)
{
return;
}
Move(a.nextNode, a.snakeObj.transform.position);
a.snakeObj.transform.position = _pos;
}
void MoveNodeAfter(SnakeNode after, SnakeNode node)
{
if (fFirstNode == fLastNode)
{
return;
}
DettachNode(node);
AttachNodeAfter(after, node);
}
} //键盘输入上下左右
public void eatFood(SnakeNode node) //增加一节node 在最后一节的位置上增加一节
{
if (node.nextNode == null)
{
node.nextNode = new SnakeNode(snakeObj, snakeObj.transform.position);
}
else
{
eatFood(node.nextNode);
}
}
private void RetroSnakerStart()
{
GameObject node = GameObject.Instantiate(_snakeHeadPrefab);
_snakeHead = node.AddComponent <SnakeNode>();
_snakeHead.moveDir = MoveDir.UP;
_moveDir = _snakeHead.moveDir;
_snake.Add(_snakeHead);
for (int i = 1; i < _startNodeCount; i++)
{
GenerateNewNode();
}
}
/* * * * Lifecycle methods * * * */
void Awake()
{
// set up nodes' data
this.head = nodes[0];
this.head.setDirection(DIRECTION_POS_X);
this.head.setCoordinates(4, 2, 2);
nodes[1].setNodeBefore(nodes[0]);
nodes[1].setDirection(DIRECTION_POS_X);
nodes[1].setCoordinates(3, 2, 2);
this.tail = nodes[2];
this.tail.setNodeBefore(nodes[1]);
this.tail.setDirection(DIRECTION_POS_X);
this.tail.setCoordinates(2, 2, 2);
}
//Adding a Node to the snake
public void AddNode(Node N)
{
//Create new Snake node
SnakeNode S = new SnakeNode();
//set the node in the snake body
S.SetSnakeNode(N.getIndexX(), N.getIndexY());
//Add the Node
SnakeBody.Add(S);
//Change the ArrayNode Statue in the Main Array
AC.changeNode(N.getIndexX(), N.getIndexY(), Enums.NodeState.Snake);
}
///<summary>Adds a new node to the snake for one turn, with animation if necessary.</summary>
public void grow(float timeToMove, bool shouldMoveSmoothly)
{
// like the move function, but instantiates a new node as the head instead of moving the tail up
SnakeNode newHead = Instantiate(this.snakeNodePrefab, this.head.transform.position, this.head.transform.rotation, this.gameOrigin.transform) as SnakeNode;
newHead.setDirection(this.head.getDirection());
newHead.setCoordinates(this.head.getCoordinates());
this.nodes.Add(newHead);
newHead.StartCoroutine(newHead.moveToCoordinates(this.head.coordinatesOfNextNode(), timeToMove, shouldMoveSmoothly));
this.head.setNodeBefore(newHead);
this.head = newHead;
}
protected void Clear()
{
SnakeNode node = fFirstNode;
SnakeNode cache = null;
while (node != null)
{
cache = node;
node = node.NextSibling;
RemoveNode(cache);
}
fLength = 0;
}
//Check if the next move is good
Node CheckAviMove()
{
//get the Head of the snake
SnakeNode SN = snake.GetHead();
int x = 0, y = 0;
switch (MC.getMoveState())
{
case MoveState.up: x = -1; y = 0;
break;
case MoveState.down: x = 1; y = 0;
break;
case MoveState.left: x = 0; y = -1;
break;
case MoveState.right: x = 0; y = 1;
break;
}
Node N = new Node();
//make the move and trasfer it to the snake
N.SetNode(SN.getIndexX() + x, SN.getIndexY() + y);
if (N.getIndexX() < 0)
{
N.setIndexX(Height - 1);
}
if (N.getIndexY() < 0)
{
N.setIndexY(Width - 1);
}
if (N.getIndexX() == Height)
{
N.setIndexX(0);
}
if (N.getIndexY() == Width)
{
N.setIndexY(0);
}
return(N);
}
public void eatFood(SnakeNode node, Color color, Texture texture)
{
if (node.nextNode == null)
{
node.nextNode = new SnakeNode(snakeObj, snakeObj.transform.position, color, texture);
if (texture != null)
{
count += 1;
}
}
else
{
eatFood(node.nextNode, color, texture);
}
}
