public List <Node> GetFullStackConnectionsFromDir(Direction dir)
{
List <Node> ns = new List <Node>();
ConnectionSet[] conns = connectionStack.ToArray();
foreach (ConnectionSet set in conns)
{
if (set[dir] != null)
{
Node n = GameManager.instance.map[(int)set[dir]];
if (ns.Contains(n) == false)
{
ns.Add(n);
}
}
}
return(ns);
}
void RunCheck(GameManager.Direction aDirection)
{
// log the direction
m_CurrentDirection = aDirection;
// make sure the ai doesn't hit walls or falls off the map
if ((UseSensor(aDirection) & (GameManager.SensorData.Wall | GameManager.SensorData.OffGrid)) != 0)
{
// TODO: maybe store these to build an actual x,y grid idk yet
return;
}
// check to see if the space we are checking is clear
if ((UseSensor(aDirection) & GameManager.SensorData.Clear) != 0)
{
Node node = new Node();
// check for bombs
if ((UseSensor(aDirection) & GameManager.SensorData.Bomb) != 0)
{
node.transform.data.isBomb = true;
node.transform.data.turnsSinceEnemyBomb++;
}
// check for enemy ai
if ((UseSensor(aDirection) & GameManager.SensorData.Enemy) != 0)
{
node.transform.data.isEnemy = true;
}
// check for a beautiful diamond
if ((UseSensor(aDirection) & GameManager.SensorData.Diamond) != 0)
{
node.transform.data.isDiamond = true;
}
// check for goal
if ((UseSensor(aDirection) & GameManager.SensorData.Goal) != 0)
{
node.transform.data.isGoal = true;
}
node.transform.data.foundFrom = m_CurrentDirection;
m_Map.AddNode(node);
m_NumOfSquaresScanned++;
}
}
/// <summary>
/// return true if the node and the one it is connected to in that direction have mis-matching string, that would indicate that a one-way connection would cut the string if traveled over.
/// </summary>
/// <param name="node"></param>
/// <param name="dir"></param>
/// <returns></returns>
public bool disjoint(Node node, GameManager.Direction dir)
{
Node other = this[node[(int)dir]];
GameManager.Direction opposite = dir.inverse();
if ( // if one node has an enter/exit for the string on the connection, and the other does not have the corresponding exit/enter
((node.hasEnter && (node.enter == dir)) && ((other.leave != opposite) || !other.hasLeave)) ||
((node.hasLeave && (node.leave == dir)) && ((other.enter != opposite) || !other.hasEnter)) ||
((other.hasEnter && (other.enter == opposite)) && ((node.leave != dir) || !node.hasLeave)) ||
((other.hasLeave && (other.leave == opposite)) && ((node.enter != dir) || !node.hasEnter))
)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Set the visiblity of this corner mask. True = visible, false = not visible.
/// For corner masks on the diagonal, has two parts of the mask, one for each half
/// of the mask that might be needed if the tiles shown on each side do not have
/// the same lack/presence of a corner.
/// </summary>
/// <param name="set"></param>
/// <param name="dir"></param>
public void setCornerFromDir(bool set, Direction dir)
{
if ((dir == Direction.North) || (dir == Direction.South)) // if accessed from vertical direction, set vertical part of mask
{
foreach (SpriteMask mask in maskVertical)
{
if (mask != null)
{
mask.gameObject.SetActive(!set);
}
}
vertActive = !set;
}
else // if accessed from horizontal direction, set horizontal part of mask
{
foreach (SpriteMask mask in maskHorizontal)
{
if (mask != null)
{
mask.gameObject.SetActive(!set);
}
}
horiActive = !set;
}
// The "line of sight" mask needs to be set visible if either the verical/horizontal corner is set visible, or visa-versa
// If the sets of masks for horizontal/vertical was deleted because it was not needed, it does not need to be considered.
if (((maskVertical.Length == 0) || vertActive) && ((maskHorizontal.Length == 0) || horiActive))
{
if (maskLineOfSight != null)
{
maskLineOfSight.gameObject.SetActive(false);
}
}
else
{
if (maskLineOfSight != null)
{
maskLineOfSight.gameObject.SetActive(true);
}
}
}
public void SetLineFromDir(Direction dir, bool b)
{
switch (dir)
{
case Direction.North:
northLine.gameObject.SetActive(b);
break;
case Direction.South:
southLine.gameObject.SetActive(b);
break;
case Direction.East:
eastLine.gameObject.SetActive(b);
break;
case Direction.West:
westLine.gameObject.SetActive(b);
break;
}
}
// Use this for initialization
public void initialize()
{
center = new Vector2Int(renderMap.dim / 2, renderMap.dim / 2);
// drawPathInstructions does need to be hardcoded, but this algorithm makes it so only 1/4 of it needs to be written, since it is the same pattern in each of the 4 directions
if (drawPathInstructions.Length < 4)
{
drawPathInstructions = new DrawPathInstruction[4];
for (int i = 0; i < 4; i++)
{
Direction dir = (Direction)i;
Direction left = dir.counterclockwise();
Direction right = dir.clockwise();
drawPathInstructions[i] = new DrawPathInstruction(dir, new DrawPathInstruction[] {
new DrawPathInstruction(dir, new DrawPathInstruction[] { new DrawPathInstruction(left, new DrawPathInstruction[] { }), new DrawPathInstruction(right, new DrawPathInstruction[] { }) }),
new DrawPathInstruction(left, new DrawPathInstruction[] { new DrawPathInstruction(dir, new DrawPathInstruction[] { new DrawPathInstruction(left, new DrawPathInstruction[] { }) }) }),
new DrawPathInstruction(right, new DrawPathInstruction[] { new DrawPathInstruction(dir, new DrawPathInstruction[] { new DrawPathInstruction(right, new DrawPathInstruction[] { }) }) }),
});
}
}
}
private bool checkDir(GameManager.Direction dir)
{
Vector3 temp = genTemp(dir);
RaycastHit hit;
if (Physics.Raycast(transform.position, temp, out hit, CHECK_DIST))
{
if (hit.collider.tag == "Level")
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
//public int? this[Direction dir] {
public int this[Direction dir] {
get {
switch (dir)
{
case Direction.North:
return(north);
case Direction.South:
return(south);
case Direction.West:
return(west);
case Direction.East:
return(east);
}
return(east);
}
set {
switch (dir)
{
case Direction.North:
north = value;
break;
case Direction.South:
south = value;
break;
case Direction.West:
west = value;
break;
case Direction.East:
east = value;
break;
}
}
}
public static bool CheckForBomb(AIBaseEnt m_AI, Direction m_Direction)
{
m_AI.DebugMsg("Checking movement in " + m_Direction + " direction...");
bool isBomb = false;
Dictionary <Direction, TileInfo> moveData = SearchImmediate(m_AI);
if (moveData.ContainsKey(m_Direction) && (moveData[m_Direction].GetTileData() & SensorData.Bomb) != 0)
{
isBomb = true;
}
else
{
isBomb = false;
}
if (isBomb)
{
m_AI.DebugMsg("MovementScript.CheckMovement() " + m_Direction + " is not safe; SensorData = " + moveData[m_Direction].GetTileData());
}
return(isBomb);
}
private Vector3 genTemp(GameManager.Direction dir)
{
Vector3 temp = transform.position;
if (dir == GameManager.Direction.North)
{
temp.z = temp.z + LEVEL_SIZE;
}
else if (dir == GameManager.Direction.South)
{
temp.z = temp.z - LEVEL_SIZE;
}
else if (dir == GameManager.Direction.East)
{
temp.x = temp.x + LEVEL_SIZE;
}
else if (dir == GameManager.Direction.West)
{
temp.x = temp.x - LEVEL_SIZE;
}
return(temp);
}
public void Rotate(GameManager.Direction direction)
{
switch (direction)
{
case GameManager.Direction.North:
this.gameObject.transform.eulerAngles = new Vector3(0, 0, 0);
break;
case GameManager.Direction.South:
this.gameObject.transform.eulerAngles = new Vector3(0, 180, 0);
break;
case GameManager.Direction.East:
this.gameObject.transform.eulerAngles = new Vector3(0, 90, 0);
break;
case GameManager.Direction.West:
this.gameObject.transform.eulerAngles = new Vector3(0, 270, 0);
break;
default:
break;
}
}
public void Move(GameManager.Direction direction)
{
switch (direction)
{
case GameManager.Direction.North:
this.gameObject.transform.position += new Vector3(unitDistance, 0, 0);
break;
case GameManager.Direction.South:
this.gameObject.transform.position += new Vector3(-unitDistance, 0, 0);
break;
case GameManager.Direction.East:
this.gameObject.transform.position += new Vector3(0, 0, -unitDistance);
break;
case GameManager.Direction.West:
this.gameObject.transform.position += new Vector3(0, 0, unitDistance);
break;
default:
break;
}
}
//USE THIS TO GET A MOVE DIReCTION TO ADD TO aMOVES!!! IT UPDATES OUR CURRENT POSITION WHICH WE NEED FOR THE GRAPH
GameManager.Direction Move(GameManager.Direction direction)
{
//Change the current position based on the direction we're moving
switch (direction)
{
case GameManager.Direction.Up:
currentPosition += Vector2.up;
break;
case GameManager.Direction.Left:
currentPosition += Vector2.left;
break;
case GameManager.Direction.Down:
currentPosition += Vector2.up;
break;
case GameManager.Direction.Right:
currentPosition += Vector2.right;
break;
}
return(direction);
}
private void checkDirectionPossible(ArrayList posDir, Vector3 leftOffset, Vector3 rightOffset, Vector3 temp, GameManager.Direction currentDir, GameManager.Direction oppositeDir)
{
Debug.DrawRay(leftOffset, temp * 1.0f, Color.white);
if (genHit(leftOffset, temp, levelLayer) && (myDirection != currentDir && myDirection != oppositeDir))
{
Debug.DrawRay(rightOffset, temp * 1.0f, Color.white);
if (genHit(rightOffset, temp, levelLayer) && (myDirection != currentDir && myDirection != oppositeDir))
{
posDir.Add(currentDir);
}
}
}
private void checkIntersection()
{
ArrayList posDir = new ArrayList();
GameManager.Direction tempDir = myDirection;
GameManager.Direction revTempDir;
Vector3 temp;
Vector3 leftOffset;
Vector3 rightOffset;
float OFFSET_VALUE = 0.95f;
if (tempDir == GameManager.Direction.North)
{
revTempDir = GameManager.Direction.South;
}
else if (tempDir == GameManager.Direction.South)
{
revTempDir = GameManager.Direction.North;
}
else if (tempDir == GameManager.Direction.East)
{
revTempDir = GameManager.Direction.West;
}
else if (tempDir == GameManager.Direction.West)
{
revTempDir = GameManager.Direction.East;
}
else
{
revTempDir = GameManager.Direction.North;
}
for (int i = 0; i < 4; i++)
{
temp = transform.position;
leftOffset = transform.position;
rightOffset = transform.position;
if (i == 0)
{
temp.z = temp.z + LEVEL_SIZE;
leftOffset.x -= OFFSET_VALUE;
rightOffset.x += OFFSET_VALUE;
checkDirectionPossible(posDir, leftOffset, rightOffset, temp, GameManager.Direction.North, GameManager.Direction.South);
}
else if (i == 1)
{
temp.z = temp.z - LEVEL_SIZE;
leftOffset.x += OFFSET_VALUE;
rightOffset.x -= OFFSET_VALUE;
checkDirectionPossible(posDir, leftOffset, rightOffset, temp, GameManager.Direction.South, GameManager.Direction.North);
}
else if (i == 2)
{
temp.x = temp.x + LEVEL_SIZE;
leftOffset.z -= OFFSET_VALUE;
rightOffset.z += OFFSET_VALUE;
checkDirectionPossible(posDir, leftOffset, rightOffset, temp, GameManager.Direction.East, GameManager.Direction.West);
}
else if (i == 3)
{
temp.x = temp.x - LEVEL_SIZE;
leftOffset.z += OFFSET_VALUE;
rightOffset.z -= OFFSET_VALUE;
checkDirectionPossible(posDir, leftOffset, rightOffset, temp, GameManager.Direction.West, GameManager.Direction.East);
}
}
int newDirection = Random.Range(0, posDir.Count);
if (posDir.Count > 0)
{
if (checkDir(tempDir))
{
setNewDir(posDir, newDirection);
}
else
{
int directionChangeChance = Random.Range(1, 11);
if (directionChangeChance == 1)
{
if (!(checkDir(revTempDir)))
{
myDirection = revTempDir;
intersected = true;
}
}
else if (directionChangeChance >= 2 && directionChangeChance <= 5)
{
if (!(checkDir(tempDir)))
{
intersected = true;
}
else
{
setNewDir(posDir, newDirection);
}
}
else
{
setNewDir(posDir, newDirection);
}
}
}
else
{
intersected = false;
}
}
void FixedUpdate()
{
pacManListener(transform.position);
if (superMode)
{
if (Input.GetButton("Fire1"))
{
Rigidbody instance = Instantiate(bullet, transform.position, transform.rotation) as Rigidbody;
Vector3 fwd = transform.TransformDirection(Vector3.back);
instance.AddForce(fwd * power);
Destroy(instance.gameObject, DESTROY_BULLET_TIME);
}
if (followCam.InPosition)
{
float tiltAroundY = followCam.TiltAroundY;
float moveForward = Input.GetAxis("Vertical");
if (myDirection == GameManager.Direction.North)
{
if (tiltAroundY < 280 && tiltAroundY > 260)
{
myDirection = GameManager.Direction.West;
}
else if (tiltAroundY > 80 && tiltAroundY < 170)
{
myDirection = GameManager.Direction.East;
}
moveNorth(moveForward);
}
else if (myDirection == GameManager.Direction.East)
{
if (tiltAroundY > 170)
{
myDirection = GameManager.Direction.South;
}
else if (tiltAroundY < 10)
{
myDirection = GameManager.Direction.North;
}
moveEast(moveForward);
}
else if (myDirection == GameManager.Direction.South)
{
if (tiltAroundY > 260)
{
myDirection = GameManager.Direction.West;
}
else if (tiltAroundY < 100)
{
myDirection = GameManager.Direction.East;
}
moveSouth(moveForward);
}
else if (myDirection == GameManager.Direction.West)
{
if (tiltAroundY > 350)
{
myDirection = GameManager.Direction.North;
}
else if (tiltAroundY < 190)
{
myDirection = GameManager.Direction.South;
}
moveWest(moveForward);
}
}
}
else
{
if (Input.GetAxis("Right") > 0)
{
myDirection = GameManager.Direction.East;
moveEast(Input.GetAxis("Right"));
}
else if (Input.GetAxis("Left") > 0)
{
myDirection = GameManager.Direction.West;
moveWest(Input.GetAxis("Left"));
}
else if (Input.GetAxis("Up") > 0)
{
myDirection = GameManager.Direction.North;
moveNorth(Input.GetAxis("Up"));
}
else if (Input.GetAxis("Down") > 0)
{
myDirection = GameManager.Direction.South;
moveSouth(Input.GetAxis("Down"));
}
}
if (curPos.x >= level.renderer.bounds.max.x)
{
curPos.x = level.renderer.bounds.min.x;
}
else if (curPos.x <= level.renderer.bounds.min.x)
{
curPos.x = level.renderer.bounds.max.x;
}
transform.position = curPos;
setRotation();
}
public override void _Update()
{
//Player interaction objects
//if (InputManager.instance.OnInputDown(InputManager.Action.action)) {
if (Input.GetButtonDown("Action"))
{
//if (currentPosition.hasSign/* && curdir == 0*/) {
if (currentPosition.type == Node.TileType.sign /* && curdir == 0*/)
{
//Player reads a sign
///////// make sign visible/not visible
signText.text = currentPosition.signMessage;
signImage.gameObject.SetActive(!signImage.gameObject.activeInHierarchy);
//Debug.Log(currentPosition.signMessage);
}
else
{
if (hasBall)
{
//Player drops the ball
hasBall = false;
//} else if ((currentPosition.data.hasEnter && !currentPosition.data.hasLeave) || stringLeft == map.stringleft && currentPosition.type == Node.TileType.source) {
}
else if (
(currentPosition.hasEnter && !currentPosition.hasLeave) ||
stringLeft >= map.stringleft && currentPosition.type == Node.TileType.source)
{
//Player pick up the ball
hasBall = true;
}
}
}
//Shows pause menu
//if (InputManager.instance.OnInputDown(InputManager.Action.back)) {
if (Input.GetButtonDown("Back"))
{
GameManager.changeState(pauseMenu, this);
}
//Dont do anything past here if we are doing an animation
if (animLockout)
{
return;
}
else if (winTrigger)
{
youWinScreenTimeout -= Time.deltaTime;
if (youWinScreenTimeout < 0.0f)
{
winTrigger = false;
// load the next level if it exists, else return to level selector
if (GameManager.saveGame.levelNumber >= 0 && GameManager.saveGame.levelNumber < levelSelector.levelButtons.Length)
{
LevelSelector.changeLevelHelper(GameManager.saveGame.levelNumber);
}
else
{
GameManager.changeState(levelSelector, this);
}
}
return;
}
//This for loop deals with inputs and moves the player around.
//for (int i = 0; i < 4; i++) {
//Direction lines up with input manager so we can directly convert to an action from a direction.
//GameManager.Direction dir = (GameManager.Direction)i;
bool directionInput = false;
GameManager.Direction dir = GameManager.Direction.North;
float ver = Input.GetAxisRaw("Vertical");
float hor = Input.GetAxisRaw("Horizontal");
if (!Mathf.Approximately(ver, 0.0f) && ver > 0) // if multiple axis are active, choose only one, with priority N > E > S > W
{
directionInput = true;
}
else if (!Mathf.Approximately(hor, 0.0f) && hor > 0)
{
dir = GameManager.Direction.East;
directionInput = true;
}
else if (!Mathf.Approximately(ver, 0.0f) && ver < 0)
{
dir = GameManager.Direction.South;
directionInput = true;
}
else if (!Mathf.Approximately(hor, 0.0f) && hor < 0)
{
dir = GameManager.Direction.West;
directionInput = true;
}
//if (InputManager.instance.OnInput((InputManager.Action)i)) {
if (directionInput) // only go into if a direction input occured
{
bool canMove = false;
Node otherNode = null;
if (signImage.gameObject.activeInHierarchy)
{
signImage.gameObject.SetActive(false);
}
//curdir = i;
//curdir = (int)dir;
if (hasBall && (currentPosition.hasLeave || (currentPosition.type != Node.TileType.source && !currentPosition.hasLeave && !currentPosition.hasEnter)))
{
hasBall = false;
}
if (currentPosition[(int)dir] >= 0)
{
otherNode = map[currentPosition[(int)dir]];
//See if the other node has a leave
canMove = (
(
(!otherNode.hasLeave && !otherNode.hasEnter && stringLeft > 0) || ( // can't carry string onto tiles if it already has string on it
otherNode.hasLeave && otherNode.leave.inverse() == dir && // unless you are rolling up the string
currentPosition.hasEnter && currentPosition.enter == dir) ||
!hasBall) && // this stuff about string doesn't matter if you are not carrying string
!map.disjoint(currentPosition, dir) && // can't walk through one-ways if it would sever the string
(otherNode.type != Node.TileType.unwalkable || pitWalk) // can't walk over pits, unless leveleditor "walk over pits" setting is set
);
}
if (cinimaticMode && Input.GetKey(KeyCode.Space))
{
canMove = false;
}
animLockout = true;
StartCoroutine(CharacterAnimator.instance.AnimateMovement(
(bool flag) => { onArrive(canMove, otherNode, dir); },
dir, moveAnimSpeed, canMove
));
//break;
}
//}
}
public void onArrive(bool canMove, Node otherNode, GameManager.Direction dir)
{
if (!canMove)
{
animLockout = false;
return;
}
//Handle fake connection stacking
{
//If the connection from this node to the other is one-way
if (otherNode[(int)dir.inverse()] != currentPosition.index)
{
// temp override connection to that node
otherNode[(int)dir.inverse()] = currentPosition.index;
}
}
if (hasBall)
{
//Tag the current square with line exit dir
if (!otherNode.hasLeave)
{
currentPosition.leave = dir;
currentPosition.hasLeave = true;
otherNode.enter = dir.inverse();
otherNode.hasEnter = true;
stringLeft--;
}
else
{
//Do a backup
currentPosition.hasEnter = false;
otherNode.hasLeave = false;
stringLeft++;
}
}
currentPosition = otherNode;
#if UNITY_EDITOR // if this is in the editor, call getCurrentNode() every time movement happens,
// and apply copied colors and sprites to the new tile is currently drawing.
if (editLevel != null)
{
editLevel.getCurrentNode();
editLevel.drawTiles(); // only changes stuff if currently drawing
//Debug.Log("calling getCurrentNode()...")
}
else
{
Debug.Log("Cannot call getCurrentNode(), there is no reference to editLevel script/object");
}
#endif
nonEuclidRenderer.HandleRender(dir, currentPosition);
animLockout = false;
setUItext(); // apply changes to UI text: string left, checkpoints.
if (map.winConditions())
{
winTrigger = true;
wintext.SetActive(true); // make win text visible
winSound.SetActive(true); // play sound
// play win sound here
levelSelector.unlockLevel(); // unlocks next level
GameManager.saveGame.levelNumber++; // advance last level visited, so will auto-load next level
SaveObj.SaveGame(GameManager.settings.saveNum, GameManager.saveGame); // save changes to levels accessible and last-level-visited
//Debug.Log("You win!");
}
//if (currentPosition.hasSign && !signsVisited.Contains(currentPosition.index)) {
if (currentPosition.type == Node.TileType.sign && !signsVisited.Contains(currentPosition.index))
{
signsVisited.Add(currentPosition.index);
signText.text = currentPosition.signMessage;
signImage.gameObject.SetActive(true);
}
}
public void SetWallFromDir(Direction dir, bool b)
{
walls[(int)dir].gameObject.SetActive(b);
}
void QueueAction(ref List <GameManager.Direction> aMoves, ref int aBombTime)
{
// grab the last nodes we checked out
List <Node> nodes = new List <Node>();
LinkedListNode <Node> currentLNode = m_Map.nodes.Last;
int count = m_NumOfSquaresScanned;
while (count > 1)
{
nodes.Add(currentLNode.Value);
currentLNode = currentLNode.Previous;
count--;
}
// are any of these nodes the diamond?
foreach (Node node in nodes)
{
if (node.transform.data.isDiamond)
{
aMoves.Add(node.transform.data.foundFrom);
m_CurrentDirection = node.transform.data.foundFrom;
m_IsMoving = true;
m_IsHoldingDiamond = true; // log that we grabbed the diamond
return;
}
if (node.transform.data.isGoal && m_IsHoldingDiamond)
{
aMoves.Add(node.transform.data.foundFrom);
m_CurrentDirection = node.transform.data.foundFrom;
m_IsMoving = true;
m_IsGoingToGoal = true; // log that we grabbed the diamond
return;
}
}
foreach (Node node in nodes)
{
// if there is an enemy or a bomb move away if it is safe to
if (node.transform.data.isEnemy || node.transform.data.isBomb)
{
// tell the ai we are moving
m_IsMoving = true;
// dodge stuff
switch (RandomMove())
{
case GameManager.Direction.Up:
if ((UseSensor(GameManager.Direction.Down) & GameManager.SensorData.Clear) != 0 &&
((UseSensor(GameManager.Direction.Down) & GameManager.SensorData.Enemy) == 0) &&
((UseSensor(GameManager.Direction.Down) & GameManager.SensorData.Bomb) == 0))
{
aMoves.Add(GameManager.Direction.Down);
m_CurrentDirection = GameManager.Direction.Down;
return;
}
break;
case GameManager.Direction.Down:
if ((UseSensor(GameManager.Direction.Up) & GameManager.SensorData.Clear) != 0 &&
((UseSensor(GameManager.Direction.Down) & GameManager.SensorData.Enemy) == 0) &&
((UseSensor(GameManager.Direction.Down) & GameManager.SensorData.Bomb) == 0))
{
aMoves.Add(GameManager.Direction.Up);
m_CurrentDirection = GameManager.Direction.Up;
return;
}
break;
case GameManager.Direction.Left:
if ((UseSensor(GameManager.Direction.Right) & GameManager.SensorData.Clear) != 0 &&
((UseSensor(GameManager.Direction.Down) & GameManager.SensorData.Enemy) == 0) &&
((UseSensor(GameManager.Direction.Down) & GameManager.SensorData.Bomb) == 0))
{
aMoves.Add(GameManager.Direction.Right);
m_CurrentDirection = GameManager.Direction.Right;
return;
}
break;
case GameManager.Direction.Right:
if ((UseSensor(GameManager.Direction.Left) & GameManager.SensorData.Clear) != 0 &&
((UseSensor(GameManager.Direction.Down) & GameManager.SensorData.Enemy) == 0) &&
((UseSensor(GameManager.Direction.Down) & GameManager.SensorData.Bomb) == 0))
{
aMoves.Add(GameManager.Direction.Left);
m_CurrentDirection = GameManager.Direction.Left;
return;
}
break;
case GameManager.Direction.Current:
if ((UseSensor(GameManager.Direction.Down) & GameManager.SensorData.Clear) != 0 &&
((UseSensor(GameManager.Direction.Down) & GameManager.SensorData.Enemy) == 0) &&
((UseSensor(GameManager.Direction.Down) & GameManager.SensorData.Bomb) == 0))
{
aMoves.Add(GameManager.Direction.Down);
m_CurrentDirection = GameManager.Direction.Down;
return;
}
break;
}
}
}
// if there wasn't any enemy ai or bombs near us continue on our wonderfully straight path
if ((UseSensor(m_LastDirection) & GameManager.SensorData.Clear) != 0)
{
aMoves.Add(m_LastDirection);
}
else
{
aMoves.Add(RandomMove());
}
// tell the ai to move this turn
m_IsMoving = true;
}
public override CombatantAction GetAction(ref List <GameManager.Direction> aMoves, ref int aBombTime)
{
test++;
m_NumOfSquaresScanned = 0;
m_LastDirection = m_CurrentDirection;
RunCheck(GameManager.Direction.Current);
RunCheck(GameManager.Direction.Down);
RunCheck(GameManager.Direction.Left);
RunCheck(GameManager.Direction.Right);
RunCheck(GameManager.Direction.Up);
// get the first node we found this turn
LinkedListNode <Node> currentLNode = m_Map.nodes.Last;
int count = m_NumOfSquaresScanned;
while (count > 1)
{
// two way connections
//if (currentLNode.Previous.Value != null)
// currentLNode.Value.transform.data.connectedNodes.Add(currentLNode.Previous.Value);
currentLNode = currentLNode.Previous;
//if (currentLNode.Next.Value != null)
// currentLNode.Value.transform.data.connectedNodes.Add(currentLNode.Next.Value);
count--;
}
Node currentNode = currentLNode.Value;
// add nodes to the list of connected nodes
currentLNode = currentLNode.Next;
while (currentLNode != null)
{
currentNode.transform.data.connectedNodes.Add(currentLNode.Value);
currentLNode = currentLNode.Next;
}
QueueAction(ref aMoves, ref aBombTime);
// if we have the diamond
if (m_IsHoldingDiamond)
{
// go through our list of nodes and see if the goal is in there
LinkedListNode <Node> node = m_Map.nodes.First;
while (node != null)
{
// if it is
if (node.Value.transform.data.isGoal)
{
// go to it
//MoveToPriorPosition(ref aMoves);
m_IsMoving = true;
m_IsGoingToGoal = true;
break;
}
node = node.Next;
}
}
// do turn
if (m_IsMoving)
{
Resets();
//if (!m_IsGoingToGoal)
//{
// m_PriorMoves.Add(m_LastDirection);
//}
//else
//{
// m_IsGoingToGoal = false;
//}
//if (test > 14)
//{
// m_IsGoingToGoal = true;
// aMoves = new List<GameManager.Direction>();
// MoveToPriorPosition(ref aMoves);
// QueueAction(ref aMoves, ref aBombTime);
// test = 0;
//}
//else
//{
// if ((UseSensor(m_CurrentDirection) & GameManager.SensorData.Clear) != 0)
// m_PriorMoves.Add(m_CurrentDirection);
//}
return(CombatantAction.Move);
}
else if (m_IsBombing)
{
Resets();
return(CombatantAction.DropBomb);
}
else
{
Resets();
return(CombatantAction.Pass);
}
}
public DoorEventArgs(GameManager.Direction dir)
{
direction = dir;
}
public override CombatantAction GetAction(ref List <Direction> aMoves, ref int aBombTime)
{
// Check all directions
m_RightTile = UseSensor(Direction.Right);
m_LeftTile = UseSensor(Direction.Left);
m_UpTile = UseSensor(Direction.Up);
m_DownTile = UseSensor(Direction.Down);
m_CurrentTile = UseSensor(Direction.Current);
// Update the surrounding tiles
UpdateSurroundingTiles();
aBombTime = Random.Range(m_BombTime.min, m_BombTime.max + 1);
// Managing Movement
// For each node, check to make sure that the node was not yet visited and is not dangerous, or
// check if the diamond is there
// If so, then try to move to that position
if (m_CurrentNode.left.visited == false && m_CurrentNode.left.tile.Contains(m_DangerousAreas) == false ||
m_CurrentNode.left.tile.Contains(SensorData.Diamond))
{
// If an enemy is there, drop a bomb
if (m_CurrentNode.left.tile.Contains(SensorData.Enemy))
{
return(CombatantAction.DropBomb);
}
aMoves.Add(Direction.Left);
}
// Same logic as the first part, but for different nodes
else if (m_CurrentNode.right.visited == false && m_CurrentNode.right.tile.Contains(m_DangerousAreas) == false ||
m_CurrentNode.right.tile.Contains(SensorData.Diamond))
{
if (m_CurrentNode.right.tile.Contains(SensorData.Enemy))
{
return(CombatantAction.DropBomb);
}
aMoves.Add(Direction.Right);
}
else if (m_CurrentNode.up.visited == false && m_CurrentNode.up.tile.Contains(m_DangerousAreas) == false ||
m_CurrentNode.up.tile.Contains(SensorData.Diamond))
{
if (m_CurrentNode.up.tile.Contains(SensorData.Enemy))
{
return(CombatantAction.DropBomb);
}
aMoves.Add(Direction.Up);
}
else if (m_CurrentNode.down.visited == false && m_CurrentNode.down.tile.Contains(m_DangerousAreas) == false ||
m_CurrentNode.down.tile.Contains(SensorData.Diamond))
{
if (m_CurrentNode.down.tile.Contains(SensorData.Enemy))
{
return(CombatantAction.DropBomb);
}
aMoves.Add(Direction.Down);
}
else
{
// Go into a random direction if all tiles are already visited
// keep re-rolling until we get a proper direction, or until we've tried 10 more times
Direction dir = (Direction)Random.Range(0, 4);
SensorData targetTile = UseSensor(dir);
for (int i = 0; i < 10; i++)
{
if (targetTile.Contains(m_DangerousAreas))
{
dir = (Direction)Random.Range(0, 4);
targetTile = UseSensor(dir);
}
else
{
break;
}
}
// just pass if for some reason, our AI wants to walk into a wall
if (targetTile.Contains(SensorData.OffGrid, SensorData.Wall))
{
return(CombatantAction.Pass);
}
else if (targetTile.Contains(SensorData.Enemy))
{
return(CombatantAction.DropBomb);
}
// Just move to the position
aMoves.Add(dir);
}
// This will update the coordinates and return a movement action
CombatantAction action = MoveAndUpdateCoords(ref aMoves);
Debug.LogFormat("[{0}][{1}]", m_Horizontal, m_Vertical);
return(action);
}
/// <summary>
/// �]�w�B�B���ݩ�
/// </summary>
/// <param name="speed">�B�B���ʳt��</param>
/// <param name="direction">�B�B���ʪ���V</param>
public void SetIceAttributes(float speed, GameManager.Direction direction)
{
this.iceSpeed = speed;
this.iceMoveDirection = direction;
}
/// <summary>
/// Updates information in the direction of an adjacent tile
/// </summary>
/// <param name="m_Direction">Direction of the tile to update (Up, Down, Left, Right)</param>
/// <param name="m_AdjacentTileData">SensorData of the adjacent tile</param>
public void UpdateAdjacentTileData(Direction m_Direction, SensorData m_AdjacentTileData)
{
adjacentTiles[m_Direction].SetTileData(m_AdjacentTileData);
}
public DrawPathInstruction(Direction dir, DrawPathInstruction[] nextInstructions)
{
this.dir = dir;
//this.renderLayer = renderLayer;
this.nextInstructions = nextInstructions;
}
public TileInfo GetAdjacentTileInfo(Direction m_TileDirection)
{
return(adjacentTiles[m_TileDirection]);
}
GameManager.Direction RandomMove()
{
m_CurrentDirection = (GameManager.Direction)UnityEngine.Random.Range(0, 4);
if (m_CurrentDirection == m_LastDirection)
{
RandomMove();
}
// make sure it isn't a wall
switch (m_CurrentDirection)
{
case GameManager.Direction.Up:
if ((UseSensor(GameManager.Direction.Up) & GameManager.SensorData.Clear) != 0)
{
return(m_CurrentDirection);
}
else
{
RandomMove();
}
break;
case GameManager.Direction.Down:
if ((UseSensor(GameManager.Direction.Down) & GameManager.SensorData.Clear) != 0)
{
return(m_CurrentDirection);
}
else
{
RandomMove();
}
break;
case GameManager.Direction.Left:
if ((UseSensor(GameManager.Direction.Left) & GameManager.SensorData.Clear) != 0)
{
return(m_CurrentDirection);
}
else
{
RandomMove();
}
break;
case GameManager.Direction.Right:
if ((UseSensor(GameManager.Direction.Right) & GameManager.SensorData.Clear) != 0)
{
return(m_CurrentDirection);
}
else
{
RandomMove();
}
break;
default:
RandomMove();
break;
}
// to be safe if recursion fails or switch gets broken out for some reason
return(GameManager.Direction.Current);
}
void FixedUpdate () {
pacManListener(transform.position);
if (superMode) {
if (Input.GetButton("Fire1")) {
Rigidbody instance = Instantiate(bullet, transform.position, transform.rotation) as Rigidbody;
Vector3 fwd = transform.TransformDirection(Vector3.back);
instance.AddForce(fwd * power);
Destroy(instance.gameObject, DESTROY_BULLET_TIME);
}
if (followCam.InPosition) {
float tiltAroundY = followCam.TiltAroundY;
float moveForward = Input.GetAxis("Vertical");
if (myDirection == GameManager.Direction.North) {
if (tiltAroundY < 280 && tiltAroundY > 260) {
myDirection = GameManager.Direction.West;
} else if (tiltAroundY > 80 && tiltAroundY < 170) {
myDirection = GameManager.Direction.East;
}
moveNorth(moveForward);
} else if (myDirection == GameManager.Direction.East) {
if (tiltAroundY > 170) {
myDirection = GameManager.Direction.South;
} else if (tiltAroundY < 10) {
myDirection = GameManager.Direction.North;
}
moveEast(moveForward);
} else if (myDirection == GameManager.Direction.South) {
if (tiltAroundY > 260) {
myDirection = GameManager.Direction.West;
} else if (tiltAroundY < 100) {
myDirection = GameManager.Direction.East;
}
moveSouth(moveForward);
} else if (myDirection == GameManager.Direction.West) {
if (tiltAroundY > 350) {
myDirection = GameManager.Direction.North;
} else if (tiltAroundY < 190) {
myDirection = GameManager.Direction.South;
}
moveWest(moveForward);
}
}
} else {
if (Input.GetAxis ("Right") > 0) {
myDirection = GameManager.Direction.East;
moveEast(Input.GetAxis("Right"));
} else if (Input.GetAxis ("Left") > 0) {
myDirection = GameManager.Direction.West;
moveWest(Input.GetAxis("Left"));
} else if (Input.GetAxis ("Up") > 0) {
myDirection = GameManager.Direction.North;
moveNorth(Input.GetAxis("Up"));
} else if (Input.GetAxis ("Down") > 0) {
myDirection = GameManager.Direction.South;
moveSouth(Input.GetAxis("Down"));
}
}
if (curPos.x >= level.renderer.bounds.max.x) {
curPos.x = level.renderer.bounds.min.x;
} else if (curPos.x <= level.renderer.bounds.min.x) {
curPos.x = level.renderer.bounds.max.x;
}
transform.position = curPos;
setRotation();
}
public IEnumerator <object> AnimateMovement(AnimationCallback callback, GameManager.Direction dir, float time, bool canMove)
{
float progress = 0.0f;
//Vector3 startPos = this.gameObject.transform.position;
// for some reason, changing the camera size messes this up if you use global position, so use local position instead.
//Vector3 startPos = this.gameObject.transform.localPosition;
Vector3 goalPos = startPos + (new Vector3(moveDir[(int)dir].x, moveDir[(int)dir].y, 0));
//changes the direction of the player sprite
spriteR = gameObject.GetComponent <SpriteRenderer>();
if ((int)dir == 0)
{
spriteR.sprite = sprites[characterSelect[characterInput][10]];
}
else if ((int)dir == 1)
{
spriteR.sprite = sprites[characterSelect[characterInput][7]];
}
else if ((int)dir == 2)
{
spriteR.sprite = sprites[characterSelect[characterInput][1]];
}
else if ((int)dir == 3)
{
spriteR.sprite = sprites[characterSelect[characterInput][4]];
}
foot = !foot;
if (canMove)
{
//Slide forward
while (progress <= time)
{
if (GameManager.getCurrentState()._stateType != GameManager.IStateType.gameplay)
{
yield return(null);
continue;
}
if ((int)dir == 0)
{
if (foot)
{
spriteR.sprite = sprites[characterSelect[characterInput][9]];
}
else
{
spriteR.sprite = sprites[characterSelect[characterInput][11]];
}
}
else if ((int)dir == 1)
{
if (foot)
{
spriteR.sprite = sprites[characterSelect[characterInput][6]];
}
else
{
spriteR.sprite = sprites[characterSelect[characterInput][8]];
}
}
else if ((int)dir == 2)
{
if (foot)
{
spriteR.sprite = sprites[characterSelect[characterInput][0]];
}
else
{
spriteR.sprite = sprites[characterSelect[characterInput][2]];
}
}
else if ((int)dir == 3)
{
if (foot)
{
spriteR.sprite = sprites[characterSelect[characterInput][3]];
}
else
{
spriteR.sprite = sprites[characterSelect[characterInput][5]];
}
}
progress += Time.deltaTime;
//this.gameObject.transform.position = Vector3.Lerp(startPos, goalPos, progress / time);
// for some reason, changing the camera size messes this up if you use global position, so use local position instead.
this.gameObject.transform.localPosition = Vector3.Lerp(startPos, goalPos, progress / time);
yield return(null);
}
//Snap back
resetPos();
//this.gameObject.transform.position = startPos;
// for some reason, changing the camera size messes this up if you use global position, so use local position instead.
if ((int)dir == 0)
{
spriteR.sprite = sprites[characterSelect[characterInput][10]];
}
else if ((int)dir == 1)
{
spriteR.sprite = sprites[characterSelect[characterInput][7]];
}
else if ((int)dir == 2)
{
spriteR.sprite = sprites[characterSelect[characterInput][1]];
}
else if ((int)dir == 3)
{
spriteR.sprite = sprites[characterSelect[characterInput][4]];
}
}
callback(true);
}
public SensorData GetSensorData(Direction m_Direction)
{
// Used for MovementScript
return(UseSensor(m_Direction));
}
public void DrawFullNode(Node node, GameManager.Direction?dir, Vector2Int?position, bool grayout = false)
{
if ((node == null) || (dir == null) || (position == null)) // set everything invisible if any of these are null
{
this.gameObject.SetActive(false);
}
else
{
// otherwise, draw the stuff as appropriate
int i;
for (i = 0; i < 4; i++)
{
SetLineFromDir((Direction)i, false);
}
if (node.hasEnter) // set line/string visible as appropriate
{
SetLineFromDir(node.enter, true);
}
if (node.hasLeave)
{
SetLineFromDir(node.leave, true);
}
// set line/string center visible as appropriate
/*if (node.hasEnter && node.hasLeave && node.enter.inverse() == node.leave)
* lineCenter.gameObject.SetActive(true);
* else
* lineCenter.gameObject.SetActive(false);*/
// should evaluate to an array of size 2 for tiles on the cardinal directions, 4 for the middle tile, or 1 otherwise
// add the directions that need to be checked to the array
// Directions to be check are based on tile location in relation to the center tile
// North correspondes to upper-right, east to lower-right, south to lower-left, and west to upper-left.
// Center tile is checked in upper-right, lower-right, lower-left, upper-right directions,
// Tile on the cardinal directions are checked in the two directions pointeed away from the center tile,
// and all other tile are checked in the main direction that points away from the center tile
Direction[] checkDirection = new Direction[((position.Value.x == 2) ? 2 : 1) * ((position.Value.y == 2) ? 2 : 1)];
i = 0;
if (position.Value.x <= 2)
{
if (position.Value.y <= 2)
{
checkDirection[i] = Direction.South;
i++;
}
if (position.Value.y >= 2)
{
checkDirection[i] = Direction.West;
i++;
}
}
if (position.Value.x >= 2)
{
if (position.Value.y >= 2)
{
checkDirection[i] = Direction.North;
i++;
}
if (position.Value.y <= 2)
{
checkDirection[i] = Direction.East;
}
}
// now in each of the given directions, it checks the nodes that can be reached clockwise and counter cockwise in each direction.
// If nodes reached clockwise/counter-clockwise do not match or are null, the corner in that direction is set visible, otherwise that corner is set non-visible.
foreach (Direction d in checkDirection)
{
if (node.drawCorner[(int)d])
{
GameManager.gameplay.nonEuclidRenderer.cornerMaskMap[
position.Value.x + (((int)d < 2) ? 1 : 0),
position.Value.y + ((((int)d % 3) == 0) ? 1 : 0)
].setCornerFromDir(true, dir.Value);
}
}
//Update the floor sprite if this node has one.
//load errorsprite if floor sprite is invalid.
if (node.floorSprite != null)
{
//Sprite fSprite = Resources.Load<Sprite>("Floor_" + node.floorSprite);
Sprite fSprite = GameManager.getSprite("Floor_" + node.floorSprite);
if (fSprite != null)
{
floor.sprite = fSprite;
}
else
{
Debug.Log("Error: sprite \"Floor_<" + node.floorSprite + ">\" not found");
//floor.sprite = Resources.Load<Sprite>("ErrorSprite");
floor.sprite = GameManager.errorSprite;
}
}
//Update the wall sprites if this node has one.
//load errorsprite if wall sprite is invalid.
if (node.wallSprite != null)
{
//Sprite wSprite = Resources.Load<Sprite>("Wall_" + node.wallSprite + "_N");
Sprite wSprite = GameManager.getSprite("Wall_" + node.wallSprite + "_N");
if (wSprite != null)
{
//northWall.sprite = wSprite;
walls[0].sprite = wSprite;
}
else
{
Debug.Log("Error: sprite \"Wall_<" + node.wallSprite + ">_N\" not found");
//walls[0].sprite = Resources.Load<Sprite>("ErrorSprite");
walls[0].sprite = GameManager.errorSprite;
}
//wSprite = Resources.Load<Sprite>("Wall_" + node.wallSprite + "_E");
wSprite = GameManager.getSprite("Wall_" + node.wallSprite + "_E");
if (wSprite != null)
{
walls[1].sprite = wSprite;
}
else
{
Debug.Log("Error: sprite \"Wall_<" + node.wallSprite + ">_E\" not found");
//walls[1].sprite = Resources.Load<Sprite>("ErrorSprite");
walls[1].sprite = GameManager.errorSprite;
}
//wSprite = Resources.Load<Sprite>("Wall_" + node.wallSprite + "_S");
wSprite = GameManager.getSprite("Wall_" + node.wallSprite + "_S");
if (wSprite != null)
{
walls[2].sprite = wSprite;
}
else
{
Debug.Log("Error: sprite \"Wall_<" + node.wallSprite + ">_S\" not found");
//walls[2].sprite = Resources.Load<Sprite>("ErrorSprite");
walls[2].sprite = GameManager.errorSprite;
}
//wSprite = Resources.Load<Sprite>("Wall_" + node.wallSprite + "_W");
wSprite = GameManager.getSprite("Wall_" + node.wallSprite + "_W");
if (wSprite != null)
{
walls[3].sprite = wSprite;
}
else
{
Debug.Log("Error: sprite \"Wall_<" + node.wallSprite + ">_W\" not found");
//walls[3].sprite = Resources.Load<Sprite>("ErrorSprite");
walls[3].sprite = GameManager.errorSprite;
}
//wSprite = Resources.Load<Sprite>("Corner_" + node.wallSprite);
wSprite = GameManager.getSprite("Corner_" + node.wallSprite);
if (wSprite != null)
{
corners.sprite = wSprite;
}
else
{
Debug.Log("Error: sprite \"Corner_<" + node.wallSprite + ">\" not found");
//corners.sprite = Resources.Load<Sprite>("ErrorSprite");
corners.sprite = GameManager.errorSprite;
}
}
if (grayout) // if grayed-out, set all colors as grayed versions
{
floor.color = Color.Lerp(node.colorF, Color.gray, 0.9f);
for (int j = 0; j < walls.Length; j++)
{
walls[j].color = Color.Lerp(node.colorW, Color.gray, 0.9f);
}
corners.color = Color.Lerp(node.colorW, Color.gray, 0.9f);
Color grayish = new Color(0.55f, 0.55f, 0.55f);
for (int j = 0; j < debris.Length; j++)
{
debris[j].color = grayish;
}
for (int j = 0; j < lines.Length; j++)
{
lines[j].color = grayish;
}
//lineCenter.color = grayish;
}
else // if not grayed-out, set all colors as normal
{
floor.color = node.colorF;
for (int j = 0; j < walls.Length; j++)
{
walls[j].color = node.colorW;
}
corners.color = node.colorW;
for (int j = 0; j < debris.Length; j++)
{
debris[j].color = Color.white;
}
for (int j = 0; j < lines.Length; j++)
{
lines[j].color = Color.white;
}
//lineCenter.color = Color.white;
}
//set debris visible is it exists
SetDebrisFromNode(node);
//set this tile visible
this.gameObject.SetActive(true);
//set walls visible as appropriate
SetWallsFromNode(node, dir, position);
}
}
