//////////////////////////////////////////////////////////////////////////
// Private Methods //
//////////////////////////////////////////////////////////////////////////
void instanciateDog()
{
scr_Node node = dogSpawns[Random.Range(0, 2)];
GameObject myDog = Instantiate(dog,
node.POSITION,
Quaternion.identity) as GameObject;
scr_DogController dogCntrl = myDog.GetComponent <scr_DogController>();
if (dogCntrl == null)
{
return;
}
m_dogCntrl = dogCntrl;
dogCntrl.Init(node);
Camera mainCam = Camera.main;
if (mainCam != null)
{
scr_CameraFollow camFollow = mainCam.GetComponent <scr_CameraFollow>();
if (camFollow != null)
{
camFollow.SetTarget(myDog.transform);
}
}
return;
}
Init(scr_DogController _dog, scr_Node _startNode)
{
m_animator = GetComponent <Animator>();
m_rb = GetComponent <Rigidbody2D>();
m_direction = Vector3.zero;
// Setup Start Node.
transform.position = _startNode.POSITION;
m_start = _startNode;
// Setup Dog.
m_dog = _dog;
m_path = new Queue <scr_Node>();
m_fsm = new scr_fsm();
m_fsm.Init();
m_fsm.AddState(new Scr_miguel_calculatePath(this));
m_fsm.AddState(new Scr_miguel_followPath(this));
m_fsm.SetState((int)MIGUEL_STATE.CalculatePath);
return;
}
public src_aStarNode(scr_Node _node, scr_Node _pathVia, float _heuristic)
{
m_node = _node;
m_pathVia = _pathVia;
m_h = _heuristic;
return;
}
public src_aStarNode()
{
m_node = null;
m_pathVia = null;
m_h = 100000.0f;
return;
}
Init(scr_Node m_node)
{
m_target = m_node;
m_state = DOGPHASE.Idle;
m_directionIndex = DOGDIRECTION.None;
return;
}
Contains(scr_Node _node)
{
foreach (src_aStarNode starNode in m_starNodeList)
{
if (starNode.m_node == _node)
{
return(true);
}
}
return(false);
}
public scr_Node(Vector3 _position, NODE_TYPE _type)
{
m_position = _position;
m_up = null;
m_right = null;
m_down = null;
m_left = null;
m_type = _type;
m_explored = false;
return;
}
//////////////////////////////////////////////////////////////////////////
// Public Methods //
//////////////////////////////////////////////////////////////////////////
public scr_Node()
{
m_position = Vector3.zero;
m_up = null;
m_right = null;
m_down = null;
m_left = null;
m_type = NODE_TYPE.kNone;
m_explored = false;
return;
}
DebugNodeGrid()
{
for (int row = 0; row < m_nodeGrid.NUMROWS; ++row)
{
for (int col = 0; col < m_nodeGrid.NUMCOLS; ++col)
{
scr_Node node = m_nodeGrid.GetNode(row, col);
if (node.NODETYPE == NODE_TYPE.kStreet)
{
Instantiate(m_prefabNode, node.POSITION, Quaternion.identity);
}
}
}
}
Init(int _numCols, int _numRows)
{
numCols = _numCols;
numRows = _numRows;
m_nodeGrid = new scr_Node[numRows, numCols];
for (int row = 0; row < numRows; ++row)
{
for (int col = 0; col < numCols; ++col)
{
m_nodeGrid[row, col] = new scr_Node();
}
}
//////////////////////////////////////////////////////////////////////////
// Set Connections //
//////////////////////////////////////////////////////////////////////////
for (int row = 0; row < numRows; ++row)
{
for (int col = 0; col < numCols; ++col)
{
// Add Up Node.
if (row > 0)
{
m_nodeGrid[row, col].SetUp(m_nodeGrid[row - 1, col]);
}
// Add Right Node.
if (col < (numCols - 1))
{
m_nodeGrid[row, col].SetRight(m_nodeGrid[row, (col + 1)]);
}
// Add Down Node.
if (row < (numRows - 1))
{
m_nodeGrid[row, col].SetDown(m_nodeGrid[row + 1, col]);
}
// Add Left Node.
if (col > 0)
{
m_nodeGrid[row, col].SetLeft(m_nodeGrid[row, col - 1]);
}
}
}
}
void instanciateHouse()
{
int pos = Random.Range(0, houseSpawns.Count - 1);
scr_Node node = houseSpawns[pos];
float distancia = Vector3.Distance(dog.transform.position, node.POSITION);
if (distancia > distanciaMinimaSpawn)
{
GameObject myHouse = Instantiate(house,
houseSpawns[pos].POSITION,
Quaternion.identity) as GameObject;
myHouse.tag = "dogHouse";
node.NODETYPE = NODE_TYPE.kHouse;
return;
}
else
{
houseSpawns.RemoveAt(pos);
instanciateHouse();
}
}
LoadScene(string _fileName)
{
// Get File from Resoruces Folder.
TextAsset file;
file = Resources.Load(_fileName) as TextAsset;
// Check if file exists.
if (file == null)
{
return;
}
// Load file in the CSV Reader.
CSVFileReader fileReader = new CSVFileReader(file.text);
CSVRow row = new CSVRow();
m_nodeGrid.Init(fileReader.NUM_COL, fileReader.NUM_ROW);
int rowCount = -1;
int colCount = -1;
while (fileReader.ReadRow(row))
{
rowCount++;
colCount = -1;
foreach (string type in row)
{
colCount++;
Vector3 tPosition = new Vector3(m_tileInitPosition.x + (colCount * TILE_SIZE),
m_tileInitPosition.y - (rowCount * TILE_SIZE),
0.0F);
GameObject prefab = GameObject.Instantiate(m_tile, tPosition, Quaternion.identity);
prefab.AddComponent <BoxCollider>();
Color tmp = prefab.GetComponent <SpriteRenderer>().color;
tmp.a = 0;
prefab.GetComponent <SpriteRenderer>().color = tmp;
scr_Utilities.tileType x = scr_Utilities.GiveTileType(type);
int typeNumber = scr_Utilities.setType(x);
// Setup NODE.
scr_Node node = m_nodeGrid.GetNode(rowCount, colCount);
node.SetPosition(tPosition);
if (typeNumber == 8)//casa random
{
int randomHouse = Random.Range(0, houses.Length);
switch (randomHouse)
{
case 0:
{
prefab.tag = "house0";
break;
}
case 1:
{
prefab.tag = "house1";
break;
}
case 2:
{
prefab.tag = "house2";
break;
}
case 3:
{
prefab.tag = "house3";
break;
}
case 4:
{
prefab.tag = "house4";
break;
}
default:
break;
}
prefab.GetComponent <SpriteRenderer>().sprite = houses[randomHouse];
node.NODETYPE = NODE_TYPE.kBlock;
}
else if (typeNumber == 1) //calle horizontal
{
prefab.GetComponent <SpriteRenderer>().sprite = sprites[typeNumber];
prefab.transform.eulerAngles = new Vector3(0, 0, 90);
node.NODETYPE = NODE_TYPE.kStreet;
prefab.tag = "calle";
}
else if (typeNumber == 2) //calle vertical
{
prefab.GetComponent <SpriteRenderer>().sprite = sprites[typeNumber];
prefab.transform.eulerAngles = new Vector3(0, 0, 0);
node.NODETYPE = NODE_TYPE.kStreet;
prefab.tag = "calle";
}
else if (typeNumber == 3) //calle interseccion
{
prefab.GetComponent <SpriteRenderer>().sprite = sprites[typeNumber];
prefab.transform.eulerAngles = new Vector3(0, 0, 0);
node.NODETYPE = NODE_TYPE.kStreet;
prefab.tag = "interseccion";
}
else if (typeNumber == 4) //calle Tright
{
prefab.GetComponent <SpriteRenderer>().sprite = sprites[typeNumber];
prefab.transform.eulerAngles = new Vector3(0, 0, 0);
node.NODETYPE = NODE_TYPE.kStreet;
prefab.tag = "T";
}
else if (typeNumber == 5) //calle Tleft
{
prefab.GetComponent <SpriteRenderer>().sprite = sprites[typeNumber];
prefab.transform.eulerAngles = new Vector3(0, 0, -90);
node.NODETYPE = NODE_TYPE.kStreet;
prefab.tag = "T";
}
else if (typeNumber == 6) //calle Tup
{
prefab.GetComponent <SpriteRenderer>().sprite = sprites[typeNumber];
prefab.transform.eulerAngles = new Vector3(0, 0, 180);
node.NODETYPE = NODE_TYPE.kStreet;
prefab.tag = "T";
}
else if (typeNumber == 7) //calle Tdown
{
prefab.GetComponent <SpriteRenderer>().sprite = sprites[typeNumber];
prefab.transform.eulerAngles = new Vector3(0, 0, 90);
node.NODETYPE = NODE_TYPE.kStreet;
prefab.tag = "T";
}
else if (typeNumber == 9) //cesped
{
prefab.GetComponent <SpriteRenderer>().sprite = sprites[typeNumber];
prefab.transform.eulerAngles = new Vector3(0, 0, 90);
node.NODETYPE = NODE_TYPE.kStreet;
prefab.tag = "cesped";
}
else if (typeNumber == 10) //reloj
{
prefab.GetComponent <SpriteRenderer>().sprite = sprites[typeNumber];
prefab.transform.eulerAngles = new Vector3(0, 0, 0);
GameObject.Instantiate(manecillaReloj, new Vector3(prefab.transform.position.x, prefab.transform.position.y - 0.15f, prefab.transform.position.z - 0.1f), Quaternion.identity);
prefab.tag = "reloj";
}
else if (typeNumber == 14) //calle codo
{
prefab.GetComponent <SpriteRenderer>().sprite = sprites[typeNumber];
prefab.transform.eulerAngles = new Vector3(0, 0, 0);
node.NODETYPE = NODE_TYPE.kStreet;
prefab.tag = "codo";
}
else if (typeNumber == 16) //calle codo
{
prefab.GetComponent <SpriteRenderer>().sprite = sprites[typeNumber];
prefab.transform.eulerAngles = new Vector3(0, 0, -90);
node.NODETYPE = NODE_TYPE.kStreet;
prefab.tag = "codo";
}
else if (typeNumber == 17) //calle codo
{
prefab.GetComponent <SpriteRenderer>().sprite = sprites[typeNumber];
prefab.transform.eulerAngles = new Vector3(0, 0, -180);
node.NODETYPE = NODE_TYPE.kStreet;
prefab.tag = "codo";
}
else if (typeNumber == 18) //calle codo
{
prefab.GetComponent <SpriteRenderer>().sprite = sprites[typeNumber];
prefab.transform.eulerAngles = new Vector3(0, 0, 90);
node.NODETYPE = NODE_TYPE.kStreet;
prefab.tag = "codo";
}
else if (typeNumber == 12) // Dog Spawn Point.
{
prefab.GetComponent <SpriteRenderer>().sprite = sprites[9]; //poner cesped
tPosition.z = -0.1f;
node.NODETYPE = NODE_TYPE.kStreet;
dogSpawns.Add(node);
prefab.tag = "cesped";
}
else if (typeNumber == 13) // Enemy Spawn Point.
{
prefab.GetComponent <SpriteRenderer>().sprite = sprites[9]; //poner cesped
tPosition.z = -0.1f;
node.NODETYPE = NODE_TYPE.kStreet;
enemySpawns.Add(node);
prefab.tag = "cesped";
}
else if (typeNumber == 11) // Dog House Spawn Point.
{
prefab.GetComponent <SpriteRenderer>().sprite = sprites[9]; //poner cesped
tPosition.z = -0.1f;
node.NODETYPE = NODE_TYPE.kStreet;
houseSpawns.Add(node);
prefab.tag = "cesped";
}
else
{
prefab.GetComponent <SpriteRenderer>().sprite = sprites[typeNumber];
node.NODETYPE = NODE_TYPE.kBlock;
}
}
}
return;
}
SetRight(scr_Node _right)
{
m_right = _right;
return;
}
SetLeft(scr_Node _left)
{
m_left = _left;
return;
}
SetUp(scr_Node _up)
{
m_up = _up;
return;
}
SetDown(scr_Node _down)
{
m_down = _down;
return;
}
NodeCollision()
{
//revisar si el nodo esta explorado
if (m_target.m_explored == false)
{
Collider[] objects = Physics.OverlapSphere(m_target.POSITION, m_radio);
foreach (Collider collider in objects)
{
float distance = Vector3.Distance(collider.transform.position, transform.position);
Color tmp = collider.GetComponent <SpriteRenderer>().color;
if (distance < m_radio * 0.4f)
{
tmp.a = 1;
}
else if (distance < m_radio * 0.6f)
{
tmp.a += 0.6f;
}
else if (distance < m_radio * 0.9f)
{
tmp.a += 0.3f;
}
collider.GetComponent <SpriteRenderer>().color = tmp;
}
m_target.m_explored = true;
}
if (m_target.NODETYPE == NODE_TYPE.kHouse)
{
scr_gameMaster.GetSingleton().Win();
}
switch (m_directionIndex)
{
case DOGDIRECTION.Up:
if (m_target.UP == null)
{
m_state = DOGPHASE.Idle;
return;
}
if (m_target.UP.NODETYPE == NODE_TYPE.kStreet ||
m_target.UP.NODETYPE == NODE_TYPE.kHouse)
{
m_target = m_target.UP;
return;
}
else
{
m_state = DOGPHASE.Idle;
return;
}
case DOGDIRECTION.Right:
if (m_target.RIGHT == null)
{
m_state = DOGPHASE.Idle;
return;
}
if (m_target.RIGHT.NODETYPE == NODE_TYPE.kStreet ||
m_target.RIGHT.NODETYPE == NODE_TYPE.kHouse)
{
m_target = m_target.RIGHT;
return;
}
else
{
m_state = DOGPHASE.Idle;
return;
}
case DOGDIRECTION.Down:
if (m_target.DOWN == null)
{
m_state = DOGPHASE.Idle;
return;
}
if (m_target.DOWN.NODETYPE == NODE_TYPE.kStreet ||
m_target.DOWN.NODETYPE == NODE_TYPE.kHouse)
{
m_target = m_target.DOWN;
return;
}
else
{
m_state = DOGPHASE.Idle;
return;
}
case DOGDIRECTION.Left:
if (m_target.LEFT == null)
{
m_state = DOGPHASE.Idle;
return;
}
if (m_target.LEFT.NODETYPE == NODE_TYPE.kStreet ||
m_target.LEFT.NODETYPE == NODE_TYPE.kHouse)
{
m_target = m_target.LEFT;
return;
}
else
{
m_state = DOGPHASE.Idle;
return;
}
default:
m_state = DOGPHASE.Idle;
return;
}
}
