// Update is called once per frame
void Update()
{
alpha -= 0.05f;
GameObject player = GameObject.FindGameObjectWithTag("Player");
if (PlayerProfile.Instance().ControlScheme == 2)
{
Destroy(this.gameObject);
}
if (player)
{
SnakeState playerSnake = player.GetComponent <SnakeState>();
this.transform.localScale = playerSnake.GetSnakeThickness() * Vector3.one * 2.0f;
this.transform.parent = player.transform;
this.distance = Mathf.Log(1 + inputManager.TargetDirection().magnitude * 0.007f);
this.transform.localPosition = new Vector3(0.0f, heightOffPlane, distance);
//playerSnake.SnakeFogDistance()
/*
* if (VRSettings.enabled)
* {
* this.gameObject.SetActive(true);
* }
* else
* {
* this.gameObject.SetActive(Input.touchCount > 0);
* }*/
if (Input.anyKey)
{
alpha = 1.0f;
}
}
this.GetComponent <MeshRenderer>().material.color = new Color(1, 1, 1, alpha);
}
public void EnableCloseObjects()
{
GameObject player = GameObject.FindGameObjectWithTag("Player");
if (!player)
{
return;
}
SnakeState playerSnake = player.GetComponent <SnakeState>();
List <GameObject> objectsToRemove = new List <GameObject>();
foreach (GameObject obj in this.inactiveObjectsToCheck)
{
if (Vector2.Distance(obj.transform.position, playerSnake.transform.position) < playerSnake.SnakeFogDistance() * radiusFactor)
{
obj.SetActive(true);
objectsToRemove.Add(obj);
}
}
foreach (GameObject obj in objectsToRemove)
{
inactiveObjectsToCheck.Remove(obj);
}
}
private void GenerateLocalSnake()
{
SnakeState playerSnake = Instantiate <SnakeState> (this.localSnakePrefab);
playerSnake.transform.position = this.gameWorld.GenerateRandomWorldPoint(0, this.gameWorld.worldRadius / 5.0f);
playerSnake.name = PlayerProfile.Instance().Nickname;
}
private void ExitState(SnakeState state)
{
switch (state)
{
case SnakeState.Idle:
IdleExitState();
break;
case SnakeState.Move:
MoveExitState();
break;
case SnakeState.OnRail:
OnRailExitState();
break;
case SnakeState.Shrink:
ShrinkExitState();
break;
case SnakeState.Die:
DieExitState();
break;
}
}
private void ShrinkState()
{
DebugExecute("Shrink");
// Move head along skeleton (from head to tail)
float disToTarget = Mathf.Abs(targetCell.relPos - body.head.relPos);
body.UpdateBodyShrink(-(disToTarget / 5f));
// Destroy cells along skeleton
if (body.head.next != null && body.head.distanceToNext < 0.1f)
{
body.DestroyCell(body.head.next);
}
// If arrived at target position,
if (disToTarget < 0.1f)
{
// Trim skeleton
body.skeleton.ShaveStart(body.correction + targetCell.relPos);
// Reset correction to heads position
body.correction = -body.head.relPos;
// Switch state
currentState = dying ? SnakeState.Die : SnakeState.Move;
}
}
public override void Destroy()
{
// Find closest snake
// This is a hack
GameObject[] snakes = GameObject.FindGameObjectsWithTag("Snake");
GameObject closestSnake = GameObject.FindGameObjectWithTag("Player");
float minDistance = Vector2.Distance(this.food.transform.position, closestSnake.transform.position);
foreach (GameObject snake in snakes)
{
if (snake.activeInHierarchy)
{
float dist = Vector2.Distance(this.food.transform.position, snake.transform.position);
if (dist < minDistance)
{
dist = minDistance;
closestSnake = snake;
}
}
}
SnakeState closestSnakeState = closestSnake.GetComponent <SnakeState>();
if (minDistance < closestSnakeState.GetSnakeThickness() * GameConfig.EAT_DISTANCE_RATIO * 2.0f)
{
food.CollectFood(closestSnakeState);
}
else
{
Destroy(this.gameObject);
}
}
private void EnterState(SnakeState state)
{
// print("EnterState: " + state);
switch (state)
{
case SnakeState.Idle:
IdleEnterState();
break;
case SnakeState.Move:
MoveEnterState();
break;
case SnakeState.OnRail:
OnRailEnterState();
break;
case SnakeState.Shrink:
ShrinkEnterState();
break;
case SnakeState.Die:
DieEnterState();
break;
}
}
private void GenerateAISnakes()
{
for (int i = 0; i < maxSnakes - 1; i++)
{
SnakeState snake = Instantiate <SnakeState> (this.localAISnakePrefab);
snake.SetRandomStartBackbone(this.gameWorld.GenerateRandomWorldPoint(this.gameWorld.worldRadius / 4.0f, this.gameWorld.worldRadius));
snake.snakeSkinID = Random.Range(0, GameConfig.NUM_SNAKE_SKINS);
}
}
void GetReferences()
{
if (!GameObject.FindGameObjectWithTag("Player"))
{
return;
}
this.playerSnake = GameObject.FindGameObjectWithTag("Player").GetComponent <SnakeState>();
this.gameWorld = GameObject.FindGameObjectWithTag("World").GetComponent <GameWorld>();
}
private void CreateSnakeBodyCollider()
{
this.snakeBody = new GameObject();
this.snakeBody.tag = "SnakeBody";
this.snakeBody.transform.position = this.snakeState.GetHeadPosition();
this.snakeBody.AddComponent <SnakeStateReference>().snakeState = this.snakeState;
this.snakeBodyCollider = this.snakeBody.AddComponent <BoxCollider2D>();
this.snakeBodyCollider.isTrigger = true;
}
void AtrociousRotateFunctionToKeepToDeadline()
{
GameObject player = GameObject.FindGameObjectWithTag("Player");
if (player)
{
SnakeState playerSnake = player.GetComponent <SnakeState>();
playerSnake.TurnTowards(inputManager.TargetDirection(), Time.deltaTime * 8);
}
}
public bool IsRunInto(SnakeState other)
{
if (other == this)
{
return(false);
}
float distanceToOther = other.DistanceFrom(this.GetHeadPosition());
return(distanceToOther < other.GetSnakeThickness() / 2.0f);
}
// Update is called once per frame
void Update()
{
GameObject snake = GameObject.FindGameObjectWithTag("Player");
if (snake)
{
this.playerSnake = snake.GetComponent <SnakeState>();
this.transform.localScale = Vector3.one * 0.2f * this.playerSnake.SnakeFogDistance();
this.gameObject.transform.position = this.playerSnake.transform.position + Vector3.back * 0.5f;
}
}
// Use this for initialization
void Start()
{
MovementDirection = Vector2.right;
TailPieces = new List <GameObject>();
UnusedTailPieces = new Stack <GameObject>();
ResetSnake();
CurrentState = SnakeState.Dead;
}
public SnakeGameState(GameSize gameSize, int initialSnakeLength, bool canSnakeGrow) : base(gameSize)
{
SnakeState = new SnakeState(initialSnakeLength, canSnakeGrow);
Walls = new List <BitArray>(gameSize.Height);
for (int i = 0; i < gameSize.Height; i++)
{
Walls.Add(new BitArray(gameSize.Width));
}
Bonus = GenerateBonus();
}
void FollowSnake()
{
GameObject snake = GameObject.FindGameObjectWithTag("Player");
if (snake)
{
snakeToTrack = snake.GetComponent <SnakeState>();
transform.position = Vector3.Lerp(this.transform.position, snakeToTrack.transform.position, LerpAmount) + Vector3.back;
}
else
{
snakeToTrack = null;
}
}
// Update is called once per frame
void Update()
{
GameObject snake = GameObject.FindGameObjectWithTag("Player");
if (snake)
{
this.playerSnake = snake.GetComponent <SnakeState>();
Vector2 normalizedPos = playerSnake.transform.position / gameWorld.worldRadius;
RectTransform transform = this.GetComponent <RectTransform>();
RectTransform parentTransform = this.gameObject.transform.parent.GetComponent <RectTransform>();
transform.anchoredPosition = normalizedPos * (parentTransform.rect.width / 2.0f);
}
}
public void ResetSnake()
{
MovementDirection = Vector2.up;
transform.position = Vector3.zero;
OldHeadPosition = Vector2.zero;
RemoveTailFromSnake();
CurrentState = SnakeState.Alive;
TimeSinceMove = 0d;
FailurePoint = "";
}
public void SetSnakeData(SnakeState state)
{
this.head.transform.position = state.headPosition;
this.currentDirection = state.direction;
this.links = state.linkPositions.Select(x => Instantiate(snakeTailPrefab, x, Quaternion.identity, this.transform).GetComponent <SnakeTail>()).ToList();
if (state.isDead == false)
{
SnakeDieEvent.DoReverse(this);
}
else
{
SnakeDieEvent.DoExecute(this);
}
}
private void HandleSnakeState()
{
if (state == SnakeState.Overloaded)
{
overloadCooldownLeft -= Time.deltaTime;
if (overloadCooldownLeft <= 0)
{
state = SnakeState.Normal;
overloadCurrent = 0;
if (OnOverloadEnd != null)
{
OnOverloadEnd();
}
}
}
}
void FollowSnake()
{
GameObject snake = GameObject.FindGameObjectWithTag("Player");
if (snake)
{
snakeToTrack = snake.GetComponent <SnakeState>();
this.targetPosition = snakeToTrack.transform.position;
this.targetPosition += Vector3.back * SCALE_FACTOR * snakeToTrack.GetSnakeThickness();
transform.position = Vector3.Lerp(this.transform.position, targetPosition, LerpAmount);
}
else
{
snakeToTrack = null;
}
}
private void Head_OnCollectableCollision(int obj)
{
this.ChangeSpeed(snakeSpeedIncrease);
overloadCurrent++;
if (overloadCurrent == overloadTreshhold && state != SnakeState.Overloaded && state != SnakeState.Charged)
{
state = SnakeState.Charged;
overloadCooldownLeft = overloadCooldown;
if (OnChargingComplete != null)
{
OnChargingComplete();
}
}
}
// Update is called once per frame
void Update()
{
GameObject player = GameObject.FindGameObjectWithTag("Player");
GameObject[] enemies = GameObject.FindGameObjectsWithTag("Snake");
if (!player)
{
return;
}
SnakeState[] snakes = new SnakeState[enemies.Length + 1];
for (int i = 0; i < enemies.Length; i++)
{
snakes[i] = enemies[i].GetComponent <SnakeState>();
}
snakes[enemies.Length] = player.GetComponent <SnakeState>();
Array.Sort(snakes, this.snakeScoreComparer);
int playerRank = -1;
int j = 1;
foreach (SnakeState snake in snakes)
{
if (snake.gameObject == player)
{
playerRank = j;
}
j++;
}
for (int i = 0; i < this.scoreBoardState.maxScoreboardPlayers; i++)
{
if (i < snakes.Length)
{
this.scoreBoardState.SetEntry(i, snakes[i].name, snakes[i].score);
}
else
{
this.scoreBoardState.SetEntry(i, "-", 0);
}
}
this.scoreBoardState.SetPlayerRank(playerRank);
}
private void DieState()
{
DebugExecute("Die");
// // Switch state
// currentState = SnakeState.Move;
// If players' snake dies, it's game over
if (name == "Player Snake")
{
GameManager.INSTANCE.currentState = GameManager.GameState.GameOver;
currentState = SnakeState.Idle;
}
// If any other snake dies, remove it from game
else
{
Destroy(gameObject);
}
}
private void DisableDistantObjects()
{
GameObject player = GameObject.FindGameObjectWithTag("Player");
if (!player)
{
return;
}
SnakeState playerSnake = player.GetComponent <SnakeState>();
GameObject[] foodObjects = GameObject.FindGameObjectsWithTag("Food");
foreach (GameObject food in foodObjects)
{
if (Vector2.Distance(food.transform.position, playerSnake.transform.position) > playerSnake.SnakeFogDistance() * 0.01f)
{
food.SetActive(false);
inactiveObjectsToCheck.Add(food);
}
}
}
private void HandlePause()
{
if (gameState == GameState.Paused)
{
if (Input.GetKeyDown(KeyCode.DownArrow))
{
snakeBody[0].nextDirection = Direction.Down;
snakeBody[0].moveSpeed = currentSpeed;
gameState = GameState.Playing;
}
if (Input.GetKeyDown(KeyCode.UpArrow))
{
snakeBody[0].nextDirection = Direction.Up;
snakeBody[0].moveSpeed = currentSpeed;
gameState = GameState.Playing;
}
if (Input.GetKeyDown(KeyCode.RightArrow))
{
snakeBody[0].nextDirection = Direction.Right;
snakeBody[0].moveSpeed = currentSpeed;
gameState = GameState.Playing;
}
if (Input.GetKeyDown(KeyCode.LeftArrow))
{
snakeBody[0].nextDirection = Direction.Left;
snakeBody[0].moveSpeed = currentSpeed;
gameState = GameState.Playing;
}
if (overloadCooldownLeft > 0 && (state != SnakeState.Charged || state != SnakeState.Overloaded))
{
if (overloadCooldownLeft < overloadCooldown)
{
state = SnakeState.Overloaded;
}
}
}
}
private void SetState(SnakeState state)
{
this.state = state;
this.stateTime = 0;
}
void Awake()
{
this.snakeState = this.GetComponent <SnakeState>();
//this.snakeState.head.AddComponent<NetworkSnakeHeadController>().snakeState = this.snakeState;
}
public void StartMoving()
{
snakeState = new SnakeMooving();
}
public Player()
{
snakeState = new SnakeStopped();
}
public override bool Update()
{
if (Orbs.Count > 0)
{
if (tailCount > Orbs.Count)
{
tailCount = Orbs.Count;
Orbs.Last().Invulnerable = false;
Orbs.Last().nBuild.PolyColor = Color.Red;
this.speed *= 1.5f;
}
Orbs.Last().nBuild.PolyColor = Color.Red;
int toRemove = -1;
foreach (Enemy e in Orbs)
{
e.Update();
if (e.health <= 3)
toRemove = Orbs.IndexOf(e);
}
if (toRemove != -1)
Orbs.RemoveAt(toRemove);
}
else
this.Invulnerable = false;
int changetime = rand.Next(1,3);
stateTime += Time.Delta;
switch (state)
{
case SnakeState.Up :{
move = new Vector2(0,-1);
addTailV(move);
if (new WallCollider(new Vector2(0, -Screen.Y), WallDirection.Up).Contains(Position) || stateTime > changetime) {
lastState = state;
switch (rand.Next(0,2))
{
case 0:
SetState(SnakeState.Left);
break;
case 1:
SetState(SnakeState.Right);
break;
case 2:
SetState(SnakeState.Down);
break;
} }
}break;
case SnakeState.Down :{
move = new Vector2(0, 1);
addTailV(move);
if (new WallCollider(new Vector2(0, Screen.Y), WallDirection.Down).Contains(Position) || stateTime > changetime)
{
lastState = state;
switch (rand.Next(0, 3))
{
case 0:
SetState(SnakeState.Left);
break;
case 1:
SetState(SnakeState.Right);
break;
case 2:
SetState(SnakeState.Up);
break;
}
}
}break;
case SnakeState.Left:{
move = new Vector2( -1,0);
addTailV(move);
if (new WallCollider(new Vector2(-Screen.X, 0), WallDirection.Left).Contains(Position) || stateTime > changetime)
{
switch (rand.Next(0, 3))
{
case 0:
SetState(SnakeState.Up);
break;
case 1:
SetState(SnakeState.Down);
break;
case 2:
SetState(SnakeState.Right);
break;
}
}
}break;
case SnakeState.Right:{
move = new Vector2(1, 0);
addTailV(move);
if (new WallCollider(new Vector2(Screen.X, 0), WallDirection.Right).Contains(Position) || stateTime > changetime)
{
lastState = state;
switch (rand.Next(0, 3))
{
case 0:
SetState(SnakeState.Up);
break;
case 1:
SetState(SnakeState.Down);
break;
case 2:
SetState(SnakeState.Left);
break;
}
}
}break;
}
Position += move * Time.Delta * speed;
UpdateTail();
if (cooldown <= 0)
{
Vector2 distance = (p.Position - this.Position) * Screen.Scale;
float currVec = (float)Math.Atan2(distance.Y, distance.X);
float pi4 = (float)Math.PI / 4;
Vector2 left = new Vector2((float)Math.Cos(currVec + pi4), (float)Math.Sin(currVec + pi4));
Vector2 right = new Vector2((float)Math.Cos(currVec - pi4), (float)Math.Sin(currVec - pi4));
Tesseract.Engine.GameWorld.GameState.InstantiateCurrent(new EnemyBullet(this.Position, distance));
Tesseract.Engine.GameWorld.GameState.InstantiateCurrent(new EnemyBullet(this.Position, left));
Tesseract.Engine.GameWorld.GameState.InstantiateCurrent(new EnemyBullet(this.Position, right));
cooldown = (Orbs.Count+1);
}
else
{
cooldown = cooldown - 2 * Time.Delta;
}
return base.Update();
}
public int CollectFood(SnakeState collectingSnake)
{
this.collectingSnake = collectingSnake;
this.collected = true;
return(this.weight);
}
