void GotMove(NetworkMessage netMsg)
{
var msg = netMsg.ReadMessage <MoveMessage>();
/*
* BasePlayer player = players[msg.id];
* VRAR_Tile tile = GameStateManager.getInstance().getCurrentLevel().getAdjacentTile(player.tileLocation.x, player.tileLocation.y, VRAR_Level.getCounterTile(msg.direction));
* player.tileLocation = new Vector2Int(tile.tileIndex_X, tile.tileIndex_Y);
*/
BasePlayer player = players[msg.id];
VRAR_Tile tile = GameStateManager.getInstance().getCurrentLevel().getAdjacentTile(player.GetCurrentVec().x, player.GetCurrentVec().y, VRAR_Level.getCounterTile(msg.direction));
player.Move(msg.direction);
// local player
if (IsMyId(msg.id))
{
// move the world.
TileRenderer.instance.walkLocalPlayer(player.GetCurrentVec().x, player.GetCurrentVec().y, msg.direction);
}
else
{
//TileRenderer.instance.walkExternalPlayer(player.GetCurrentVec().x, player.GetCurrentVec().y, player, msg.direction);
TileRenderer.instance.walkExternalPlayer(GamePlayManagerAR.instance.localPlayer.GetCurrentVec().x, GamePlayManagerAR.instance.localPlayer.GetCurrentVec().y, player, msg.direction, true);
// move the other player.
//otherplayer.tilePosition =
}
}
/// <summary>
/// Add a player to the list
/// </summary>
/// <param name="player"></param>
public void AddPlayer(BasePlayer player)
{
/*
* //Set the dungeon master if the given player is a dungeon master
* if (player.role == Roles.RoleEnum.DungeonMaster)
* {
* Debug.Log("Adding a dungeon master");
* currentDungeonMaster = player;
* }
* //Create a panel if the player is not a dungeon master
* else
* {
* Debug.Log("Adding " + player.GetRoleId());
* players.Add(player);
* InstantiatePanel(player);
* GameObject g = Instantiate(role.GetRoleModel(player.role));
* g.transform.position = FindObjectOfType<LevelManager>().getWorldPosFromTilePos(player.spawnLocation.x, player.spawnLocation.y, 1);
* player.player = g;
* }
*/
//spawn the players
player.SpawnPlayer(player.spawnLocation);
InstantiatePanel(player);
//player.GetObject().transform.position = FindObjectOfType<LevelManager>().getWorldPosFromTilePos(player.spawnLocation.x, player.spawnLocation.y, 1);
//player.GetObject().transform.position = TileInteractor.instance.lvlManager.getWorldPosFromTilePos(player.spawnLocation.x, player.spawnLocation.y);
VRAR_Tile tile = GameStateManager.instance.getCurrentLevel().getTileFromIndexPos(player.spawnLocation.x, player.spawnLocation.y);
player.GetObject().transform.position = TileInteractor.instance.lvlManager.getWorldPosFromTilePos(tile.tileIndex_X, tile.tileIndex_Y, tile.height_ + 1);
}
public void walkExternalPlayer(int currentX, int currentY, BasePlayer player, int dir, bool animated)
{
if (animated)
{
player.GetObject().transform.localEulerAngles = new Vector3(0, directionToRotation(dir), 0);
//player.GetObject().transform.position = new Vector3(player.GetObject().transform.position.x, GameStateManager.getInstance().getCurrentLevel().getTileFromIndexPos(currentX, currentY).height_ * 0.1339f, player.GetObject().transform.position.z);
player.GetObject().transform.position = new Vector3(player.GetObject().transform.position.x, GameStateManager.getInstance().getCurrentLevel().getTileFromIndexPos(player.GetCurrentVec().x, player.GetCurrentVec().y).height_ *LevelManager.TILE_SCALE * 0.447f, player.GetObject().transform.position.z);
}
//print("walk external :" + player.GetName() + " local x :" + currentX + " local y :" + currentY);
//List<VRAR_Tile> list = GameStateManager.getInstance().getCurrentLevel().selectRadius(localPlayer.GetCurrentVec().x, localPlayer.GetCurrentVec().y, localPlayer.GetSight());
List <VRAR_Tile> list = GameStateManager.getInstance().getCurrentLevel().selectRadius(currentX, currentY, localPlayer.GetSight());
VRAR_Tile tileFromIndexPos = GameStateManager.getInstance().getCurrentLevel().getTileFromIndexPos(player.GetCurrentVec().x, player.GetCurrentVec().y);
if (list.Contains(tileFromIndexPos))
{
//Debug.Log("EXTERNAL we can see the other player");
player.GetObject().GetComponentInChildren <SkinnedMeshRenderer>().enabled = true;
//float y = tileFromIndexPos.hexObject.lossyScale.y * 0.447f - player.GetObject().transform.position.y;
//float y = player.GetObject().transform.position.y - GameStateManager.getInstance().getCurrentLevel().getTileFromIndexPos(currentX, currentY).height_ * 0.1339f;
//this.SlowTranslatePlayer(player, VRAR_Level.getNeighborDistance(dir) + new Vector3(0f, y, 0f), speed * LevelManager.TILE_SCALE);
this.SlowTranslatePlayer(player, VRAR_Level.getNeighborDistance(dir), speed * LevelManager.TILE_SCALE, animated);
}
else
{
//Debug.Log("EXTERNAL we CANNOT see the other player");
player.GetObject().GetComponentInChildren <SkinnedMeshRenderer>().enabled = false;
this.SlowTranslatePlayer(player, VRAR_Level.getNeighborDistance(dir), speed * LevelManager.TILE_SCALE, false);
}
}
//Create a hexagon shaped map with random terrain
public void createHexagonMap(int radius)
{
for (int x = -radius; x <= radius; x++)
{
int r1 = Mathf.Max(-radius, -x - radius);
int r2 = Mathf.Min(radius, -x + radius);
for (int y = r1; y <= r2; y++)
{
string terrain = "Mountain";
VRAR_Tile tile;
switch (Random.Range(0, 6))
{
case 0:
terrain = "Mountain";
tile = new VRAR_Tile(x, y, 1, terrain, false);
break;
default:
terrain = "Grass";
tile = new VRAR_Tile(x, y, 1, terrain, true);
break;
}
vrarTileDict.Add(new Vector2Int(x, y), tile);
vrarTiles.Add(tile);
}
}
}
public void unloadLevelOnClick()
{
previousSelectedTile = null;
clearScene();
spawnLevelsOverview();
GameStateManager.instance.setGlobalStateIndex(GameStateManager.STATE_CAMPAIGN_EDITOR);
}
public TileMessage(VRAR_Tile tile, bool removingTile)
{
tileIndex_X = tile.tileIndex_X;
tileIndex_Y = tile.tileIndex_Y;
height_ = tile.height_;
//isPhantom = tile.isPhantom;
removing = removingTile;
interactableObjectId = tile.getInteractableObject().getObjectID();
int dumbObjectIdsSize = tile.getDumbObjectsList().Count;
dumbObjectIds = new int[dumbObjectIdsSize];
for (int i = 0; i < dumbObjectIdsSize; i++)
{
dumbObjectIds[i] = tile.getDumbObjectsList()[i].getObjectID();
}
locationKeys = tile.getLocationsList().Keys.ToArray();
locationValues = tile.getLocationsList().Values.ToArray();
scaleKeys = tile.getscaleList().Keys.ToArray();
scaleValues = tile.getscaleList().Values.ToArray();
rotationKeys = tile.getRotationList().Keys.ToArray();
rotationValues = tile.getRotationList().Values.ToArray();
terrain = tile.GetTerrain();
walkable = tile.walkable;
}
public IEnumerator DropIn(VRAR_Tile tile, float dropTime, UnityAction callback)
{
if (tile.tileGameObject != null)
{
tile.tileGameObject.Translate(new Vector3(0, fallHeight * LevelManager.TILE_SCALE));
int stepCount = (int)(dropTime / Time.fixedDeltaTime);
int stepIndex = 0;
//float step = Time.fixedDeltaTime / scaleTime;
float step = fallHeight / stepCount;
//print("step is :" + step + " scaleTime :" + scaleTime + "wh :" + scaleTime / Time.fixedDeltaTime + " fiDelta :" + Time.fixedDeltaTime);
Vector3 alphaStep = new Vector3(0, -step * LevelManager.TILE_SCALE, 0);
//if (scaleIn)
{
//transform.localScale = new Vector3();
}
//else
{
//transform.localScale = size;
//alphaStep = -alphaStep;
}
//while (timer <= scaleTime)
while (stepIndex <= stepCount)
{
stepIndex++;
//timer += Time.fixedDeltaTime;
if (tile.tileGameObject != null)
{
tile.tileGameObject.Translate(alphaStep);
}
else
{
break;
}
yield return(new WaitForFixedUpdate());
}
//if (transform != null)
{
//if (scaleIn)
{
//transform.localScale = size;
}
//else
{
//transform.localScale = new Vector3();
}
}
tile.tileGameObject.position = new Vector3(tile.tileGameObject.position.x, 0, tile.tileGameObject.position.z);
if (callback != null)
{
callback();
}
yield break;
}
}
//Not sure if this works atm needs fixing sort of
public List <VRAR_Tile> selectCircleEdge(int xI, int yI, int radius, int dir)
{
List <VRAR_Tile> result = new List <VRAR_Tile>();
//We iterate through all the tile positions, if there is a tile at that position we add it to the list
Vector2Int tilePos = new Vector2Int(xI + radius * axialDirections[dir].x, yI + radius * axialDirections[dir].y);
int lineDir = dir + 2;
if (lineDir > 5)
{
lineDir = -2;
}
for (int tiles = 0; tiles < radius; tiles++)
{
//Get the tile at the tileposition we are currently iterating, and add it to the list, unless its null
VRAR_Tile tile = getTileFromIndexPos(tilePos.x, tilePos.y);
if (tile != null)
{
result.Add(tile);
}
//Go to the next tile position (neighbour in the diection we are doing right now
tilePos += axialDirections[lineDir];
}
return(result);
}
/**********************************************
* Gui functions
**********************************************/
public void loadLevelOnclick()
{
previousSelectedTile = null;
clearScene();
spawnLevel();
GameStateManager.instance.setGlobalStateIndex(GameStateManager.STATE_LEVEL_EDITOR);
//GameStateManager.instance.setCurrentLevel(lvl);
}
public VRAR_Level(int iX, int iY)
{
levelTile = new VRAR_Tile(iX, iY);
//createHexagonMap(40);
//createLVLFile();////////(use this when you need to generate VRAR_Levels on the spot)
loadLevel();
}
// Update is called once per frame
void Update()
{
cursorMove();
switch (stateIndex)
{
case 0:
lvl = lvlManager.getLevelObjectFromTilePos(lvlManager.getTilePosFromWorldPos(ingameCursor.position));
if (lvl != null)
{
//Reset the previous tile back to normal
if (previousSelectedTile != null)
{
previousSelectedTile.GetComponent <Renderer>().material = previousSelectedTileMaterial;
previousSelectedTileMaterial = lvl.levelTile.hexObject.gameObject.GetComponent <Renderer>().material;
}
//Set material of selected tile
lvl.levelTile.hexObject.gameObject.GetComponent <Renderer>().material = selectedTileMaterial;
//Add update list of selected tiles
selectedTiles.Clear();
selectedTiles.Add(lvl.levelTile);
//update debug text of current selected tile
selectedLevelText.text = "lvl :" + lvl.levelTile.tileIndex_X + " " + lvl.levelTile.tileIndex_Y;
previousSelectedTile = lvl.levelTile.hexObject.gameObject;
}
break;
default:
VRAR_Tile selTile = lvl.getTileFromIndexPos(lvlManager.getTilePosFromWorldPos(ingameCursor.position).x, lvlManager.getTilePosFromWorldPos(ingameCursor.position).y);
if (selTile != null)
{
//Reset the previous tile back to normal
if (previousSelectedTile != null)
{
previousSelectedTile.GetComponent <Renderer>().material = previousSelectedTileMaterial;
previousSelectedTileMaterial = selTile.hexObject.gameObject.GetComponent <Renderer>().material;
}
//Set material of selected tile
selTile.hexObject.gameObject.GetComponent <Renderer>().material = selectedTileMaterial;
//Add update list of selected tiles
selectedTiles.Clear();
selectedTiles.Add(selTile);
//update debug text of current selected tile
selectedLevelText.text = "lvl :" + selTile.tileIndex_X + " " + selTile.tileIndex_Y;
previousSelectedTile = selTile.hexObject.gameObject;
lvl.tileUpdate(0, 0);
}
break;
}
}
public void updateTileProperties(VRAR_Tile tile, TileObjectEditor a)
{
a.LoadInObjects(tile.getDumbObjectsList());
a.SetElevationCaption(tile.height_);
a.SetTerrainCaption(tile.terrain);
a.SetWalkable(tile.walkable);
a.SetSelectedObject(tile);
a.SetTileInteractor(this);
}
//Moves the character and return true if succesful, return false if there is no tile or its not walkable
public bool Move(int direction)
{
VRAR_Tile targetTile = GameStateManager.getInstance().getCurrentLevel().getAdjacentTile(_currentTilePos.x, _currentTilePos.y, VRAR_Level.getCounterTile(direction));
//if (targetTile == null || !targetTile.walkable)
// return false;
_currentTilePos = new Vector2Int(targetTile.tileIndex_X, targetTile.tileIndex_Y);
return(true);
}
/*
* public void SetSelectedTile(VRAR_Tile tile)
* {
* ClearButtons();
* BaseTileObject baseTileObject = tile.getInteractableObject();
* if (tile.GetWalkable())
* {
* if (baseTileObject.getInteractable())
* {
* LoadInteractableButtons(baseTileObject);
* }
* else
* {
* EnableButton(walkButtonPrefab);
* }
* }
* }*/
//Wtf does a tile being walkable have to do with the player? this is very bad and confusing
private bool IsWalkable(VRAR_Tile tile)
{
if (localPlayer == null)
{
return(false);
}
VRAR_Tile playerTile = GameStateManager.getInstance().getCurrentLevel().getTileFromIndexPos(localPlayer.GetCurrentTile().tileIndex_X, localPlayer.GetCurrentTile().tileIndex_Y);
return(GameStateManager.getInstance().getCurrentLevel().CheckWalkable(playerTile, tile, maxTileRadius));
}
//Moves the character and return true if succesful, return false if there is no tile or its not walkable
public bool Move(int direction)
{
VRAR_Tile targetTile = GameStateManager.instance.getCurrentLevel().getAdjacentTile(_currentTilePos.x, _currentTilePos.y, VRAR_Level.getCounterTile(direction));
//if (targetTile == null || !targetTile.walkable)
// return false;
_currentTilePos = new Vector2Int(targetTile.tileIndex_X, targetTile.tileIndex_Y);
_object.transform.position = targetTile.tileGameObject.position + new Vector3(0, targetTile.height_, 0);
return(true);
}
public void WalkButtonPressed()
{
//Clear buttons and hide tilehighlighter
clearButtons();
TileRenderer.instance.updateTileHighlighter(this.transform, false);
VRAR_Tile start = GamePlayManagerAR.instance.localPlayer.GetCurrentTile();
VRAR_Tile end = currentTile;
if (start == end)
{
return;
}
List <VRAR_Tile> tilePath = GameStateManager.getInstance().getCurrentLevel().findPath(start, end);
//tilePath.Reverse();
List <int> dirPath = GameStateManager.getInstance().getCurrentLevel().TilesToDirections(tilePath);
//foreach (VRAR_Tile tile in tilePath)
//{
//tile.hexObject.GetComponent<MeshRenderer>().material = null;
//Debug.Log(tile.tileIndex_X + " " + tile.tileIndex_Y);
//}
//Debug.Log("TILES " + tilePath.Count + " DIRS " + dirPath.Count);
//This is a veryvery bad solution, but now it doesnt look like people walk through objects
if (dirPath != null)
{
StartCoroutine("tempMove", dirPath);
}
/*
* Vector2Int pos = new Vector2Int(currentTile.tileIndex_X, currentTile.tileIndex_Y);
* foreach (int dir in dirPath)
* {
*
* pos += VRAR_Level.axialDirections[dir];
* GameStateManager.getInstance().getCurrentLevel().getTileFromIndexPos(pos.x, pos.y).hexObject.GetComponent<MeshRenderer>().material = null;
*
* if (client != null)
* {
* client.QueueMove(dir);
* }
* else
* {
* GamePlayManagerAR.instance.localPlayer.Move(dir);
* TileRenderer.instance.walkLocalPlayer(dir);
* }
* }*/
}
/**********************************************
* Gui functions
**********************************************/
public void loadLevelOnclick()
{
if (GameStateManager.instance.getGlobalStateIndex() == GameStateManager.STATE_CAMPAIGN_EDITOR && GameStateManager.instance.getCurrentLevel() != null)
{
previousSelectedTile = null;
clearScene();
GameStateManager.instance.setGlobalStateIndex(GameStateManager.STATE_LEVEL_EDITOR);
StartCoroutine(slowSpawnLVL());
//GameStateManager.instance.setCurrentLevel(lvl);
}
}
private void OpenTileProperties(VRAR_Tile tile)
{
/*
* Debug.Log("Object pressed");
* TileProperties a = Instantiate(tilePropertiesPrefab);
* a.LoadInObjects(tile.getDumbObjectsList());
* a.SetElevationCaption(tile.height_);
* a.SetTerrainCaption(tile.terrain);
* a.SetWalkable(tile.walkable);
* a.SetSelectedObject(tile);
* a.SetTileInteractor(this);*/
}
private void updateButtons(VRAR_Tile tile)
{
//We can only attack neighbours
foreach (VRAR_Tile circleTile in GameStateManager.getInstance().getCurrentLevel().selectCircle(GamePlayManagerAR.instance.localPlayer.GetCurrentVec().x, GamePlayManagerAR.instance.localPlayer.GetCurrentVec().y, 1))
{
if (circleTile == currentTile)
{
//if there is an npc show attack button
NonPlayer npc = tile.getNPC();
if (npc != null)
{
attackButtonPrefab.SetActive(true);
}
//if there is another player also show attack button
if (client != null)
{
List <BasePlayer> players = client.getPlayerList();
foreach (BasePlayer player in players)
{
if (player.GetCurrentTile() == tile)
{
attackButtonPrefab.SetActive(true);
}
}
}
}
}
if (tile.GetWalkable())
{
walkButtonPrefab.SetActive(true);
//if an object is walkable that means there is no object there so we can ignore te rest in this function
return;
}
BaseTileObject baseTileObject = tile.getInteractableObject();
//show hand if interactable
if (baseTileObject.getInteractable() || tile.getInterior() != null)
{
handButtonPrefab.SetActive(true);
inspectButtonPrefab.SetActive(true);
currentTileText.text = baseTileObject.getName();
}
//if its not interactable we want to allow the player to inspec the object, but not if ther is object (id == 0)
else
{
inspectButtonPrefab.SetActive(true);
currentTileText.text = baseTileObject.getName();
}
}
private void addTileObject(VRAR_Tile tile, BaseTileObject tileObject)
{
//tile.AddPosition(tileObject.getObjectID(), tile.tileGameObject.position+new Vector3(UnityEngine.Random.Range(0.0f, 1f), 0, UnityEngine.Random.Range(0.0f, 1f)));
Vector3 position = tile.tileGameObject.position + new Vector3(UnityEngine.Random.Range(0.0f, 1f), 0, UnityEngine.Random.Range(0.0f, 1f));
float scale = UnityEngine.Random.Range(0.5f, 1f);
//tile.AddScale(tileObject.getObjectID(), new Vector3(scale, scale, scale));
Vector3 scaleVector = new Vector3(scale, scale, scale);
//tile.AddRotation(tileObject.getObjectID(), Quaternion.Euler(new Vector3(UnityEngine.Random.Range(0, 2), UnityEngine.Random.Range(0, 360), 0)));
Quaternion rotation = Quaternion.Euler(new Vector3(UnityEngine.Random.Range(0, 2), UnityEngine.Random.Range(0, 360), 0));
tile.addDumbObject(tileObject, position, rotation, scaleVector);
//TileRenderer.instance.updateTile(tile);
}
public void updateTile(VRAR_Tile newTile)
{
if (GameStateManager.instance.getGlobalStateIndex() == 4)
{
newTile.hexObject.gameObject.GetComponent <Renderer>().material = TileObjectManger.getMaterial(newTile.terrain);
newTile.hexObject.gameObject.GetComponent <Renderer>().material = TileObjectManger.getMaterial(newTile.terrain);
newTile.hexObject.localScale = new Vector3(1, newTile.height_, 1);
}
else
{
Debug.LogError("TileRenderer.updateTile() called while game is in invalid state. State should be 4 while the game is in :" + GameStateManager.instance.getGlobalStateIndex());
}
}
public VRAR_Tile getTileFromIndexPos(int iX, int iY)
{
VRAR_Tile res = null;
//res = vrarTileArray[iX+negOffsetX,iY+negOffsetY];
Vector2Int key = new Vector2Int(iX, iY);
if (vrarTileDict.ContainsKey(key))
{
res = vrarTileDict[key];
}
return(res);
}
public bool CheckWalkable(VRAR_Tile origin, VRAR_Tile destination, int radius)
{
List <VRAR_Tile> reachable = selectRadius(origin.tileIndex_X, origin.tileIndex_Y, radius);
foreach (VRAR_Tile tile in reachable)
{
if (tile == destination)
{
return(true);
}
}
return(false);
}
//Get the direction of endtile in relaton to starttile, return intmax if the tles are not neighbours
private int getDirection(VRAR_Tile startTile, VRAR_Tile endTile)
{
Vector2Int difference = new Vector2Int(startTile.tileIndex_X - endTile.tileIndex_X, startTile.tileIndex_Y - endTile.tileIndex_Y);
for (int i = 0; i < axialDirections.Length; i++)
{
if (difference == axialDirections[i])
{
return(i);
}
}
Debug.LogError("These tiles are not neighbours");
return(int.MaxValue);
}
public List <VRAR_Tile> getWalkableNeighbours(int xI, int yI)
{
List <VRAR_Tile> result = new List <VRAR_Tile>();
for (int dir = 0; dir < 6; dir++)
{
VRAR_Tile tile = getAdjacentTile(xI, yI, dir);
if (tile != null && tile.walkable)
{
result.Add(tile);
}
}
return(result);
}
void FixedUpdate()
{
//Debug.Log(brushTicking);
if (brushTicking && (GameStateManager.instance.getGlobalStateIndex() == GameStateManager.STATE_LEVEL_EDITOR || GameStateManager.instance.getGlobalStateIndex() != GameStateManager.STATE_PLAYING) && !Valve.VR.InteractionSystem.VRInputHandler.isInTileObjectEditMenu)
{
//EditTile(brushActionDropdown.value);
EditTile(currentBrush);
}
else if (brushTicking && GameStateManager.instance.getGlobalStateIndex() == GameStateManager.STATE_PLAYING)
{
EditTile(currentBrush);
}
else if (TileToolEditTick && GameStateManager.instance.getGlobalStateIndex() == GameStateManager.STATE_LEVEL_EDITOR)
{
TileToolEditTick = false;
/*
* VRAR_Level lvl = GameStateManager.instance.getCurrentLevel();//TileRenderer.getCurrLVL();
*
*
* VRAR_Tile tile = lvl.getTileFromIndexPos(lvlManager.getTilePosFromWorldPos(ingameCursor.position).x, lvlManager.getTilePosFromWorldPos(ingameCursor.position).y);
* if (tile != null)
* {
* //currentlySelected = tile;
*
* if (!menuOpen)
* {
* menuOpen = true;
* OpenTileProperties(tile);
* }
* }*/
}
else if (GameStateManager.instance.getGlobalStateIndex() == GameStateManager.STATE_PLAYING || GameStateManager.instance.getGlobalStateIndex() == GameStateManager.STATE_LEVEL_EDITOR)
{
VRAR_Level lvl = GameStateManager.instance.getCurrentLevel();
VRAR_Tile tile = lvl.getTileFromIndexPos(lvlManager.getTilePosFromWorldPos(ingameCursor.position).x, lvlManager.getTilePosFromWorldPos(ingameCursor.position).y);
if (tile != null)
{
if (tile != lastSelectedTile)
{
OpenTileProperties(tile);
}
lastSelectedTile = tile;
}
}
}
private void SelectCrosshair()
{
Ray ray = Camera.main.ScreenPointToRay(new Vector3(Screen.width / 2, Screen.height / 2));
if (Application.platform != RuntimePlatform.Android)
{
//use mouse position if not on the phone
ray = Camera.main.ScreenPointToRay(Input.mousePosition);
MouseInput();
}
RaycastHit hit;
//Vector3 forward = transform.TransformDirection(Vector3.forward * int.MaxValue);
Debug.DrawRay(ray.origin, ray.direction, Color.red);
if (Physics.Raycast(ray, out hit, int.MaxValue))
{
//Debug.Log(hit.collider.gameObject.name);
//Because we are in an update method. We don't wanna repeat the code over and over. That's why we have a checker.
if (GiveNextHit(hit.collider.gameObject))
{
myGamePlayManager.objectHit = hit.collider.gameObject;
//Debug.Log("hitTile :" + myGamePlayManager.objectHit.name);
Vector2Int tilePos = LevelManager.Instance.getTilePosFromWorldPos(hit.transform.position);
VRAR_Tile tile = GameStateManager.getInstance().getCurrentLevel().getTileFromIndexPos(tilePos.x, tilePos.y);
if (tile != null)
{
clearButtons();
currentTileText.text = tile.GetTerrain();
currentTile = tile;
updateButtons(tile);
TileRenderer.instance.updateTileHighlighter(hit.transform, true);
}
lastHit = hit.collider.gameObject;
}
}
else
{
clearButtons();
//we just want to turn it off, so we pass a random transform
TileRenderer.instance.updateTileHighlighter(this.transform, false);
}
}
public void QueueMove(int direction)
{
BasePlayer player = GamePlayManagerAR.instance.localPlayer;
VRAR_Tile tile = GameStateManager.getInstance().getCurrentLevel().getAdjacentTile(player.GetCurrentVec().x, player.GetCurrentVec().y, VRAR_Level.getCounterTile(direction));
if (tile == null || !tile.walkable)
{
return;
}
var moveMessage = new MoveRequestMessage();
moveMessage.direction = direction;
client.Send(CustomNetMsg.MoveRequest, moveMessage);
}
public VRAR_Tile removeTile(int x, int y)
{
VRAR_Tile res = null;
Vector2Int key = new Vector2Int(x, y);
if (vrarTileDict.ContainsKey(key))
{
//vrarTileDict[key].isPhantom = true;
res = vrarTileDict[key];
vrarTiles.Remove(res);
vrarTileDict.Remove(key);
}
return(res);
}
public VRAR_Tile addNewTile(VRAR_Tile tile)
{
Vector2Int key = new Vector2Int(tile.tileIndex_X, tile.tileIndex_Y);
if (!vrarTileDict.ContainsKey(key))
{
vrarTiles.Add(tile);
vrarTileDict.Add(key, tile);
}
else
{
Debug.LogWarning("Someone tried to add a new empty tile to level :" + this);
}
return(vrarTileDict[key]);
}
