// TODO: fix movement, see card.
// May need new to create new method, GetDirectionsToPlayer(shouldDiag)
private void Move(Vector3 dir)
{
if (dir.x > 0)
{
currDir = Direction.right;
}
else if (dir.x < 0)
{
currDir = Direction.left;
}
else if (dir.y > 0)
{
currDir = Direction.up;
}
else
{
currDir = Direction.down;
}
if (CanMoveForEnemy(transform.position, currDir))
{
MoveDir(dir);
}
else
{
Direction randomDir = (Direction)Random.Range(0, 4);
if (CanMoveForEnemy(transform.position, randomDir))
{
MoveDir(DirectionUtil.Convert(randomDir));
}
}
}
private bool ComplexHallwayCheckSpot(Vector3Int pos, Direction dir)
{
// Check these positions
// . . .
// . v .
// # # #
pos += new Vector3Int(MID, MID, 0);
Vector3Int posA = pos + DirectionUtil.Convert(dir);
Vector3Int posB = posA + DirectionUtil.Convert(DirectionUtil.NextDir(dir));
Vector3Int posC = posA + DirectionUtil.Convert(DirectionUtil.PrevDir(dir));
// hacky code
if (pos.x < 1 || MAX_SIZE - 2 < pos.x || pos.y < 1 || MAX_SIZE - 2 < pos.y)
{
return(false);
}
if (grid[posA.x, posA.y] || grid[posB.x, posB.y] || grid[posC.x, posC.y])
{
return(false);
}
return(true);
}
private bool IsConnectionBlocked(Vector3Int pos, Direction dir)
{
// check 3x3 outside
// #.......#
// ###-P-###
// ???
// ???
// ???
pos += new Vector3Int(MID, MID, 0);
Vector3Int posP = pos + DirectionUtil.Convert(DirectionUtil.PrevDir(dir));
Vector3Int posN = pos + DirectionUtil.Convert(DirectionUtil.NextDir(dir));
Vector3Int dirVec = DirectionUtil.Convert(dir);
for (int i = 0; i < 3; i++)
{
pos += dirVec;
posP += dirVec;
posN += dirVec;
if (grid[pos.x, pos.y] || grid[posP.x, posP.y] || grid[posN.x, posN.y])
{
return(true);
}
}
return(false);
}
public void SetSnakeSpawn(Vector3 pos, Direction dir)
{
Player.body[0].transform.position = pos;
for (int i = 1; i < Player.body.Length; i++)
{
Player.body[i].transform.position = pos - DirectionUtil.Convert(dir);
}
currDir = dir;
directionQueue.Clear();
}
protected virtual void Shoot()
{
Vector3 dir = DirectionUtil.Convert(direction);
GameObject go = ProjectileManager.CreateProjectile(projectile);
BasicProjectile bp = go.GetComponent <BasicProjectile>();
go.transform.position = transform.position; // + dir
go.transform.rotation = Quaternion.Euler(0, 0, Mathf.Atan2(dir.y, dir.x) * Mathf.Rad2Deg);
bp.direction = dir;
bp.IgnoreCollision(GetComponent <Collider2D>());
}
protected override void Shoot()
{
Vector3 dir = DirectionUtil.Convert(direction);
GameObject go = ProjectileManager.CreateProjectile(projectile);
RayCastProj rc = go.GetComponent <RayCastProj>();
go.transform.position = bulletSpawn.position; // + dir
rc.startPos = bulletSpawn.position;
rc.direction = dir;
rc.Cast();
}
private void Prefire()
{
Vector3 dir = DirectionUtil.Convert(direction);
GameObject go = ProjectileManager.CreateProjectile(prefireLaser);
RayCastProj rc = go.GetComponent <RayCastProj>();
go.transform.position = bulletSpawn.position; // + dir
rc.startPos = bulletSpawn.position;
rc.direction = dir;
rc.IgnoreCollision(GetComponent <Collider2D>());
rc.Cast();
}
// assumes origRoom is already in rooms
public bool Add(RCObj origRoom, int origConnectionIndex, RCObj newRoom, int newConnectionIndex)
{
if (!rooms.Contains(origRoom) || !origRoom.connections[origConnectionIndex].isAvailable ||
!newRoom.connections[newConnectionIndex].isAvailable)
{
Debug.LogWarning("Something went wrong when adding a room to composite!");
}
Direction dirOut = origRoom.connections[origConnectionIndex].side;
Vector3Int nearestPos = origRoom.pos + origRoom.connections[origConnectionIndex].pos -
newRoom.connections[newConnectionIndex].pos + MIN_HALLWAY * DirectionUtil.Convert(dirOut);
HallwayObj hallway = new HallwayObj(origRoom, newRoom,
origRoom.connections[origConnectionIndex], newRoom.connections[newConnectionIndex], true);
for (int i = 0; i < MAX_HALLWAY; i++)
{
if (Constants.doRandom)
{
if (Random.Range(0, 1f) < 0.3f)
{
continue;
}
}
newRoom.pos = nearestPos + (i * DirectionUtil.Convert(dirOut));
if (CanAddRoom(newRoom))
{
if (TryGenerateSimpleHallway(hallway))
{
hallway.roomA.connectedObjects.Add(hallway.roomB);
hallway.roomB.connectedObjects.Add(hallway.roomA);
rooms.Add(newRoom);
origRoom.connections[origConnectionIndex].isAvailable = false;
newRoom.connections[newConnectionIndex].isAvailable = false;
AddRoomToGrid(newRoom);
AddHalwayToGrid(hallway);
UpdateDoorAvailability();
return(true);
}
}
}
return(false);
}
// returns if found end
private bool ComplexHallwayHelperHelper(Vector3Int pos, Direction dir, Vector3Int end,
Dictionary <Vector3Int, Vector3Int> child2parent, Queue <System.Tuple <Vector3Int, Direction> > frontier)
{
Vector3Int nextPos = pos + DirectionUtil.Convert(dir);
if (nextPos == end)
{
child2parent[nextPos] = pos;
return(true);
}
if (!child2parent.ContainsKey(nextPos) && ComplexHallwayCheckSpot(nextPos, dir))
{
frontier.Enqueue(new System.Tuple <Vector3Int, Direction>(nextPos, dir));
child2parent[nextPos] = pos;
}
return(false);
}
private bool TryGenerateSimpleHallway(HallwayObj hallway)
{
Vector3Int start = basePos + hallway.roomA.pos + hallway.connectionA.pos;
Vector3Int end = basePos + hallway.roomB.pos + hallway.connectionB.pos;
if (start.x != end.x && start.y != end.y)
{
Debug.LogWarning("Simple hallway couldn't be made because points aren't in a line!");
return(false);
}
List <Vector3Int> path = new List <Vector3Int>();
Vector3Int dir = DirectionUtil.Convert(hallway.connectionA.side);
Vector3Int pos = start + dir;
Vector3Int posP = pos + DirectionUtil.Convert(DirectionUtil.PrevDir(hallway.connectionA.side));
Vector3Int posN = pos + DirectionUtil.Convert(DirectionUtil.NextDir(hallway.connectionA.side));
int lim = 0;
while (pos != end && lim < SIMPLE_HALLWAY_LIMIT)
{
if (grid[MID + pos.x, MID + pos.y] || grid[MID + posP.x, MID + posP.y] || grid[MID + posN.x, MID + posN.y])
{
return(false);
}
path.Add(pos - basePos);
pos += dir;
posP += dir;
posN += dir;
lim += 1;
}
if (lim >= SIMPLE_HALLWAY_LIMIT)
{
Debug.LogWarning("Exceeded limit on simple path gen!");
return(false);
}
hallway.path = path;
return(true);
}
void Update()
{
if (CheckCanInput())
{
if (Input.GetKeyDown(KeyCode.D) || Input.GetKeyDown(KeyCode.RightArrow))
{
ChangeDirection(Direction.right);
}
else if (Input.GetKeyDown(KeyCode.S) || Input.GetKeyDown(KeyCode.DownArrow))
{
ChangeDirection(Direction.down);
}
else if (Input.GetKeyDown(KeyCode.A) || Input.GetKeyDown(KeyCode.LeftArrow))
{
ChangeDirection(Direction.left);
}
else if (Input.GetKeyDown(KeyCode.W) || Input.GetKeyDown(KeyCode.UpArrow))
{
ChangeDirection(Direction.up);
}
// Legacy Movement
//if (Input.GetKeyDown(KeyCode.R))
//{
// ChangeDirection(Direction.right);
//}
//else if (Input.GetKeyDown(KeyCode.D))
//{
// ChangeDirection(Direction.down);
//}
//else if (Input.GetKeyDown(KeyCode.L))
//{
// ChangeDirection(Direction.left);
//}
//else if (Input.GetKeyDown(KeyCode.U))
//{
// ChangeDirection(Direction.up);
//}
isSprinting = canSpecialMove && !isReversing && Input.GetKey(KeyCode.LeftShift);
bool wasReversing = isReversing;
isReversing = canSpecialMove && !isSprinting && Input.GetKey(KeyCode.LeftControl);
if (isReversing != wasReversing)
{
if (isReversing) // start reversing
{
currDir = DirectionUtil.Convert(tip.transform.position - Player.body[3].transform.position);
}
else // stop reversing
{
currDir = DirectionUtil.Convert(transform.position - Player.body[1].transform.position);
}
}
isSpecialMovement = isSprinting || isReversing;
Player.playerWeaponManager.isSprinting = isSpecialMovement;
//if (Input.GetKeyDown(KeyCode.R))
//{
// RestartSnake();
//}
}
}
public void ReverseBody()
{
//AudioManager.Play("player_reversing");
canOpenChest = true;
//Vector3 headDir = DirectionUtil.Convert(currDir);
Vector3 tipDir = DirectionUtil.Convert(currDir);
//if (Player.playerEffects.GetExitingIndex() > 0)
// headDir = Vector3.zero;
//Vector3 body2Dir = Player.body[1].transform.position - Player.body[0].transform.position;
Vector3 body2TailDir = Player.body[2].transform.position - Player.body[3].transform.position;
//tipSprite.transform.position = Player.body[3].transform.position;
//Player.body[3].transform.position = Player.body[2].transform.position;
//Player.body[2].transform.position = Player.body[1].transform.position;
//Player.body[1].transform.position = Player.body[0].transform.position;
//transform.position += headDir;
Player.body[0].transform.position = Player.body[1].transform.position;
Player.body[1].transform.position = Player.body[2].transform.position;
Player.body[2].transform.position = Player.body[3].transform.position;
Player.body[3].transform.position = tipSprite.transform.position;
tipSprite.transform.position += tipDir;
// setting sprites
//float headRot = Mathf.Atan2(headDir.y, headDir.x) * Mathf.Rad2Deg;
//float tailRot = Mathf.Atan2(tipDir.y, tipDir.x) * Mathf.Rad2Deg;
// head
//Vector3 tipDir = Player.body[3].transform.position - tip.transform.position;
//float tipRot = Mathf.Atan2(tipDir.y, tipDir.x) * Mathf.Rad2Deg;
Vector3 headDir = transform.position - Player.body[1].transform.position;
float headRot = Mathf.Atan2(headDir.y, headDir.x) * Mathf.Rad2Deg;
//Player.body[0].transform.rotation = Quaternion.Euler(0, 0, tipRot);
segSprites[0].SetSprite(snakeHead, false, headRot, Vector3.zero, -headDir);
// body
//bool body1ShouldBend = Vector3.Dot(headDir, body2Dir) == 0;
//float body1Rot = 0;
//segSprites[2].SetSprite(segSprites[1]);
//if (body1ShouldBend)
//{
// Vector3 bendDir = headDir + body2Dir;
// body1Rot = Mathf.Atan2(bendDir.y, bendDir.x) * Mathf.Rad2Deg - 45;
// // float forwardAngle = (headRot - body1Rot - 45) * 2 + body1Rot + 45
// segSprites[1].SetSprite(snakeBent, true, body1Rot, headDir, body2Dir);
//}
//else
//{
// body1Rot = Mathf.Atan2(headDir.y, headDir.x) * Mathf.Rad2Deg;
// segSprites[1].SetSprite(snakeStraight, false, body1Rot, headDir, body2Dir);
//}
segSprites[1].SetSprite(segSprites[2]);
Sprite s = segSprites[3].isBent ? snakeBodyBent : snakeBodyStraight;
segSprites[2].SetSprite(segSprites[3], s);
// tail
Vector3 tailBodyDir = Player.body[2].transform.position - Player.body[3].transform.position;
Vector3 tailTipDir = tip.transform.position - Player.body[3].transform.position;
bool tailShouldBend = Vector3.Dot(tailTipDir, tailBodyDir) == 0;
float tailRot;
if (tailShouldBend)
{
Vector3 bendDir = tailTipDir + tailBodyDir;
tailRot = Mathf.Atan2(bendDir.y, bendDir.x) * Mathf.Rad2Deg - 45;
segSprites[3].SetSprite(snakeTailBent, true, tailRot, tailTipDir, tailBodyDir);
}
else
{
tailRot = Mathf.Atan2(-tipDir.y, -tipDir.x) * Mathf.Rad2Deg;
segSprites[3].SetSprite(snakeTailStraight, false, tailRot, tailTipDir, tailBodyDir);
}
//segSprites[3].SetSprite(snakeTail, segSprites[2].isBent, tailRot, tailBodyDir, -tipDir);
// tip
float tipRot = 180 + Mathf.Atan2(tipDir.y, tipDir.x) * Mathf.Rad2Deg;
tipSprite.transform.rotation = Quaternion.Euler(0, 0, tipRot);
}
public void MoveBody()
{
canOpenChest = true;
Vector3 headDir = DirectionUtil.Convert(currDir);
if (Player.playerEffects.GetExitingIndex() > 0)
{
headDir = Vector3.zero;
}
Vector3 body2Dir = Player.body[1].transform.position - Player.body[0].transform.position;
tipSprite.transform.position = Player.body[3].transform.position;
Player.body[3].transform.position = Player.body[2].transform.position;
Player.body[2].transform.position = Player.body[1].transform.position;
Player.body[1].transform.position = Player.body[0].transform.position;
transform.position += headDir;
// setting sprites
float headRot = Mathf.Atan2(headDir.y, headDir.x) * Mathf.Rad2Deg;
// tip
Vector3 tipDir = Player.body[3].transform.position - tip.transform.position;
float tipRot = Mathf.Atan2(tipDir.y, tipDir.x) * Mathf.Rad2Deg;
tipSprite.transform.rotation = Quaternion.Euler(0, 0, tipRot);
// tail
Vector3 tailBodyDir = Player.body[2].transform.position - Player.body[3].transform.position;
float tailRot = Mathf.Atan2(tailBodyDir.y, tailBodyDir.x) * Mathf.Rad2Deg;
if (segSprites[2].isBent)
{
segSprites[3].SetSprite(segSprites[2], snakeTailBent);
}
else
{
segSprites[3].SetSprite(segSprites[2], snakeTailStraight);
}
// body
bool body1ShouldBend = Vector3.Dot(headDir, body2Dir) == 0;
float body1Rot = 0;
segSprites[2].SetSprite(segSprites[1]);
if (body1ShouldBend)
{
Vector3 bendDir = headDir + body2Dir;
body1Rot = Mathf.Atan2(bendDir.y, bendDir.x) * Mathf.Rad2Deg - 45;
// float forwardAngle = (headRot - body1Rot - 45) * 2 + body1Rot + 45
segSprites[1].SetSprite(snakeBodyBent, true, body1Rot, headDir, body2Dir);
}
else
{
body1Rot = Mathf.Atan2(headDir.y, headDir.x) * Mathf.Rad2Deg;
segSprites[1].SetSprite(snakeBodyStraight, false, body1Rot, headDir, body2Dir);
}
// head
segSprites[0].SetSprite(snakeHead, false, headRot, Vector3.zero, -headDir);
}
private bool TryGenerateComplexHallwayHelper(HallwayObj hallway)
{
Vector3Int rawStart = basePos + hallway.roomA.pos + hallway.connectionA.pos;
Vector3Int rawEnd = basePos + hallway.roomB.pos + hallway.connectionB.pos;
Direction startDir = hallway.connectionA.side;
Direction endDir = hallway.connectionB.side;
Vector3Int start = rawStart + DirectionUtil.Convert(startDir);
Vector3Int end = rawEnd + DirectionUtil.Convert(endDir);
List <Vector3Int> path = new List <Vector3Int>();
int lim = 0; // nodes expanded
// pos, dir
Queue <System.Tuple <Vector3Int, Direction> > frontier = new Queue <System.Tuple <Vector3Int, Direction> >();
Dictionary <Vector3Int, Vector3Int> child2parent = new Dictionary <Vector3Int, Vector3Int>();
frontier.Enqueue(new System.Tuple <Vector3Int, Direction>(start, startDir));
child2parent[start] = start;
bool foundPath = false;
// BFS -- add direction first
// note: this should be an A* search but i don't want to implement a priority queue
while (frontier.Count > 0 && lim < COMPLEX_HALLWAY_LIMIT)
{
System.Tuple <Vector3Int, Direction> node = frontier.Dequeue();
Vector3Int pos = node.Item1;
Direction dir = node.Item2;
lim += 1;
// go through neighbors in order of: dir => dir + 1 => dir - 1
// check
// not in dictionary
// is legal spot (check new tiles on grid)
// if (grid[MID + pos.x, MID + pos.y])
Direction nextDir = dir;
if (ComplexHallwayHelperHelper(pos, nextDir, end, child2parent, frontier))
{
foundPath = true;
break;
}
nextDir = DirectionUtil.NextDir(dir);
if (ComplexHallwayHelperHelper(pos, nextDir, end, child2parent, frontier))
{
foundPath = true;
break;
}
nextDir = DirectionUtil.PrevDir(dir);
if (ComplexHallwayHelperHelper(pos, nextDir, end, child2parent, frontier))
{
foundPath = true;
break;
}
}
//if (lim >= COMPLEX_HALLWAY_LIMIT)
// Debug.LogWarning("Exceeded limit on complex path gen!");
if (!foundPath)
{
return(false);
}
//Debug.Log("Succeeded in generating complex hallway!");
Vector3Int p = end;
path.Add(p - basePos);
while (p != start)
{
p = child2parent[p];
path.Add(p - basePos);
}
hallway.path = path;
return(true);
}
