private void _graphicsService_GraphicsUpdated()
{
_graphicsAccessor.SetTopTable(_graphicsService.GetTileSection(_world.AnimationTileTableIndex));
_graphicsAccessor.SetBottomTable(_graphicsService.GetTileSection(_world.TileTableIndex));
TileSelector.Update();
Update();
}
void NewMap(int width, int height, float size, Material textureMaterial)
{
tiles = new List <List <GameObject> >();
rotations = new List <List <int> >();
tileTextureIndexes = new List <List <int> >();
tileFlips = new List <List <bool> >();
tileSize = size;
GameObject mapPlane = new GameObject("Map");
for (int i = 0; i < width; i++)
{
tiles.Add(new List <GameObject>());
rotations.Add(new List <int>());
tileTextureIndexes.Add(new List <int>());
tileFlips.Add(new List <bool>());
for (int j = 0; j < height; j++)
{
GameObject newTile = CreateTile(new Vector3((i - (width / 2)) * size, 0f, (j - (height / 2)) * size), size, textureMaterial, mapPlane.transform);
tiles[i].Add(newTile);
rotations[i].Add(0);
tileFlips[i].Add(false);
tileTextureIndexes[i].Add(0);
TileSelector sel = newTile.AddComponent <TileSelector>();
sel.id = (j * width) + i;
}
}
mapPlane.transform.Translate(width / 2, 0f, height / 2);
}
void Start()
{
Instance = this;
Spawns = new List <Vector3Int>();
changes = new Stack <TileChange>();
revertedChanges = new Stack <TileChange>();
Tile tileBase = ScriptableObject.CreateInstance <Tile>();
tileSelector = FindObjectOfType <TileSelector>();
Tiles = new TileType[MapController.maxX, MapController.maxY];
tileTypeToSprite = new Dictionary <TileType, Sprite>();
Tile tile = ScriptableObject.CreateInstance <Tile>();
tile.sprite = EmptyTileSprite;
foreach (TileTypeSprite tts in sprites)
{
tileTypeToSprite[tts.type] = tts.sprite;
}
for (int y = 0; y < MapController.maxY; y++)
{
for (int x = 0; x < MapController.maxX; x++)
{
GridMap.SetTile(new Vector3Int(x, y, 0), tile);
}
}
}
private void GraphicsSet_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
_world.TileTableIndex = int.Parse(GraphicsSet.SelectedValue.ToString());
_graphicsAccessor.SetBottomTable(_graphicsService.GetTileSection(_world.TileTableIndex));
TileSelector.Update();
Update();
}
static void AddSelectorMoveRequestListeners(TileSelector selector, Dictionary <int, Controller> controllers)
{
for (var playerIndex = 1; playerIndex <= playersCount; ++playerIndex)
{
UnityEventTools.AddIntPersistentListener(
controllers[playerIndex].DPadLeft.TurnOn,
new UnityAction <int>(selector.RequestMoveLeft),
playerIndex
);
UnityEventTools.AddIntPersistentListener(
controllers[playerIndex].DPadRight.TurnOn,
new UnityAction <int>(selector.RequestMoveRight),
playerIndex
);
UnityEventTools.AddIntPersistentListener(
controllers[playerIndex].DPadDown.TurnOn,
new UnityAction <int>(selector.RequestMoveDown),
playerIndex
);
UnityEventTools.AddIntPersistentListener(
controllers[playerIndex].DPadUp.TurnOn,
new UnityAction <int>(selector.RequestMoveUp),
playerIndex
);
}
}
void Init()
{
tileSelector = (TileSelector)target;
options = new string[tileSelector.tileListScriptableObject.tilesList.Count];
for (int i = 0; i < tileSelector.tileListScriptableObject.tilesList.Count; i++)
{
options[i] = tileSelector.tileListScriptableObject.tilesList[i].ToString();
}
}
private void Awake()
{
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(gameObject);
}
}
private void ExitState()
{
this.enabled = false;
tileHighlight.SetActive(false);
GameManager.instance.DeselectPiece(movingPiece);
movingPiece = null;
TileSelector selector = GetComponent <TileSelector>();
GameManager.instance.NextPlayer();
selector.EnterState();
}
public void OnBeginDrag(PointerEventData beginDrag)
{
if (TileManagerService.GetInstance().IsLocked)
{
return;
}
TileSelector selector = TileSelector.GetInstance();
selector.Unselect();
selector.Select(this);
}
private void ExitState()
{
this.enabled = false;
numOfAttackTiles = 0;
tileHighlight.SetActive(false);
GameManager.instance.DeselectPiece(movingPiece);
movingPiece = null;
availableMoves.Clear();
TileSelector selector = GetComponent <TileSelector>();
selector.EnterState();
}
private void PaletteIndex_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (PaletteIndex.SelectedItem != null)
{
_world.PaletteId = ((Palette)PaletteIndex.SelectedItem).Id;
Palette palette = _palettesService.GetPalette(_world.PaletteId);
_worldRenderer.Update(palette: palette);
TileSelector.Update(palette: palette);
Update();
}
}
public void Update()
{
if (ArtificialInteligenceMove.UpdateIsRunning)
{
// tileHighlight.SetActive (false);
//
if (Log)
{
Debug.Log("Ready to UpdateIsRunning base");
Log = false;
}
// if (RefrigtzChessPortable.AllDraw.CalIdle != 1&&RefrigtzChessPortable.AllDraw.CalIdle != 5) {
// if (RefrigtzChessPortable.AllDraw.CalIdle ==0)
// RefrigtzChessPortable.AllDraw.CalIdle = 2;
// }
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit))
{
Vector3 point = hit.point;
Vector2Int gridPoint = Geometry.GridFromPoint(point);
tileHighlight.SetActive(true);
tileHighlight.transform.position = Geometry.PointFromGrid(gridPoint);
if (Input.GetMouseButtonDown(0))
{
GameObject selectedPiece = GameManager.instance.PieceAtGrid(gridPoint);
if (GameManager.instance.DoesPieceBelongToCurrentPlayer(selectedPiece))
{
x = gridPoint.x;
y = gridPoint.y;
GameManager.instance.SelectPiece(selectedPiece);
// Reference Point 1: add ExitState call here later
ExitState(selectedPiece);
instance = this;
}
}
}
else
{
tileHighlight.SetActive(false);
}
}
else
{
Log = true;
}
}
private void CancelMove()
{
enabled = false;
foreach (GameObject highlight in locationHighlights)
{
Destroy(highlight);
}
TileSelector selector = GetComponent <TileSelector>();
selector.EnterState();
}
public override void Activate()
{
if (ts == null)
{
ts = GlobalData.gPlayer.GetComponent <TileSelector>();
}
ts.CheckGameObject();
if (ts.mSelectedGameObj == null)
{
ts.GetTileData();
ts.TillSoil();
}
ts.mSelectedGameObj = null;
}
private void _palettesService_PalettesChanged()
{
PaletteIndex.ItemsSource = _palettesService.GetPalettes();
if (PaletteIndex.SelectedItem == null)
{
PaletteIndex.SelectedIndex = 0;
}
else
{
_worldRenderer.Update(palette: (Palette)PaletteIndex.SelectedItem);
TileSelector.Update(palette: (Palette)PaletteIndex.SelectedItem);
Update();
}
}
void ResetSelection()
{
if (_selectedTile != null)
{
_selectedTile.tile.IsSelected = false;
_selectedTile = null;
}
if (_secondarySelectedTile != null)
{
_secondarySelectedTile.tile.IsSelected = false;
_secondarySelectedTile = null;
}
}
private void ResetTiles()
{
if (gridGameObject == null)
{
try
{
gridGameObject = FindObjectOfType <GridSystem>().gameObject;
}
catch (System.NullReferenceException)
{
Debug.Log("Could not find Grid System, created a new Grid System");
gridGameObject = new GameObject("Grid System");
gridGameObject.AddComponent <GridSystem>();
}
}
GridSystem gridSystem = gridGameObject.GetComponent <GridSystem>();
gridSystem.tileTransforms = new List <Transform>(tileSetSize * tileSetSize);
for (int i = 0; i < tileSetSize * tileSetSize; i++)
{
gridSystem.tileTransforms.Add(null);
}
gridSystem.tileSetSize = tileSetSize;
gridSystem.cellSize = cellSize;
while (gridGameObject.transform.childCount != 0)
{
DestroyImmediate(gridGameObject.transform.GetChild(0).gameObject);
}
for (int i = 0; i < tileSetSize; i++)
{
for (int j = 0; j < tileSetSize; j++)
{
GameObject tile = GameObject.CreatePrimitive(PrimitiveType.Cube);
tile.name = "Tile [" + i + "] [" + j + "]";
tile.transform.localScale = cellGameObjectSize;
tile.transform.parent = gridGameObject.transform;
tile.transform.localPosition = new Vector3(i * cellSize, 0, j * cellSize);
TileSelector tileSelector = tile.AddComponent <TileSelector>();
tileSelector.tileListScriptableObject = this.tileList;
tileSelector.positionOnGrid = new Vector2(i, j);
}
}
gridSystem.tileSetSize = tileSetSize;
gridSystem.cellSize = cellSize;
}
public IEnumerable <Tile> GetTilesInArea(RectangleF area, TileSelector selector = null)
{
for (var x = area.X.Floor(); x < area.Right.Ceil(); x++)
{
for (var y = area.Y.Floor(); y < area.Bottom.Ceil(); y++)
{
var tile = this[x, y];
if (tile != null && (selector == null || selector(tile)))
{
yield return(tile);
}
}
}
}
private void CancelMove()
{
this.enabled = false;
foreach (GameObject highlight in locationHighlights)
{
Destroy(highlight);
}
GameManager.instance.DeselectPiece(movingPiece);
TileSelector selector = GetComponent <TileSelector>();
selector.EnterState();
}
public void MoveUnit()
{
Unit unit = _selectedTile.tile.UnitInTile;
_secondarySelectedTile.tile.UnitInTile = unit;
unit.Position = _secondarySelectedTile.tile.Position;
unit.HasMoved = true;
_selectedTile.tile.UnitInTile = null;
_selectedTile.tile.IsSelected = false;
_selectedTile = _secondarySelectedTile;
_secondarySelectedTile = null;
ToggleUnitMoveState();
_selectedTile.wasPainted = false;
_selectedTile.tile.PaintTile(Color.green);
}
void ExitState()
{
this.enabled = false;
tileHighlight.SetActive(false);
GameManager.instance.DeselectPiece(movingPiece);
movingPiece = null;
TileSelector selector = GetComponent <TileSelector>();
GameManager.instance.NextPlayer();
selector.EnterState();
foreach (GameObject hightlight in localtionHighlights)
{
Destroy(hightlight);
}
}
public override void OnClick()
{
if (Mouse.LeftButton == MouseButtonState.Pressed)
{
this.CurrentType = TileSelector.GetSelectedTile();
}
else if (Mouse.RightButton == MouseButtonState.Pressed)
{
this.CurrentType = TileType.BlockConductorAir;
}
else if (Mouse.MiddleButton == MouseButtonState.Pressed)
{
TileSelector.SetSelectedTile(this.CurrentType);
}
}
public void FillReactorWithSelectedTile()
{
int interiorX = InternalWidth;
int interiorY = InternalLength;
TileType selected = TileSelector.GetSelectedTile();
for (int y = 1; y <= interiorY; y++)
{
for (int x = 1; x <= interiorX; x++)
{
Reactor.SetTile(selected, x, y);
}
}
}
public void OnPointerEnter(PointerEventData eventData)
{
if (TileManagerService.GetInstance().IsLocked)
{
return;
}
TileSelector selector = TileSelector.GetInstance();
if (selector.IsTileSelected() && selector.GetSelected() != this)
{
TileContainer tileB = selector.GetSelected();
TransitionToThenSwap(this, tileB);
selector.Unselect();
}
}
// cleans up current state
private void ExitState()
{
this.enabled = false;
attackHighlight.SetActive(false);
foreach (GameObject highlight in attackLocationHighlights)
{
Destroy(highlight);
}
TileSelector selector = GetComponent <TileSelector>();
// switch turns, then go back to selecting
GameManager.instance.NextPlayer();
selector.EnterState();
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
var infile = "b3dm.tileset.json";
var stream = File.OpenRead(infile);
var rootobject = TilesetJsonParser.ParseTilesetJson(stream);
var center = rootobject.Root.GetCenter();
var camera = rootobject.Root.GetCenter() + new Vector3(0, 0, 100);
var files = new List <Child>();
// select all tiles within 100m from camera
var todownload = TileSelector.GetTiles(center, camera, rootobject.Root.Children[0], files, 100);
Console.WriteLine("To download tiles: " + todownload.Count);
Console.ReadKey();
}
private void ExitState()
{
this.enabled = false;
tileHighlight.SetActive(false);
GameManager.instance.DeselectPiece(movingPiece);
movingPiece = null;
//below two lines are calling on the tile selector .cs file, getting the component and telling it to enter the 'select tile' state.
TileSelector selector = GetComponent <TileSelector>();
GameManager.instance.NextPlayer();
selector.EnterState();
foreach (GameObject highlight in locationHighlights)
{
Destroy(highlight);
}
}
void checkTile()
{
tooLongTimer = tooLong;
Ray r = new Ray(transform.position, Vector3.down);
RaycastHit rHit = new RaycastHit();
Physics.Raycast(r, out rHit);
TileSelector tS = rHit.transform.gameObject.GetComponent <TileSelector>();
if (tS != null && !tS.isSafe)
{
Die();
}
}
static void ConnectNearTileMovedSelection(
Dictionary <Vector2, GameObject> tiles,
Vector2 nearPosition,
TileSelector selector,
TileSelectionMoveEventNode.EventType moveEvent
)
{
if (tiles.ContainsKey(nearPosition))
{
var nearTile = tiles[nearPosition];
var nearSelector = nearTile.GetComponent <TileSelector>();
var action = new UnityAction <TileSelectionMoveEventNode.Data>(nearSelector.StealSelectionFrom);
UnityEventTools.AddPersistentListener(moveEvent, action);
}
}
void ClearRangeAndSecondaryTiles()
{
if (_secondarySelectedTile != null)
{
_secondarySelectedTile.tile.IsSelected = false;
_secondarySelectedTile = null;
}
if (_rangeTiles == null)
{
return;
}
for (int i = 0; i < _rangeTiles.Length; i++)
{
_rangeTiles[i].IsSelected = false;
}
}
// Use this for initialization
void Start()
{
if (levelConstructor == null)
{
GameObject levelConstructorObj = GameObject.Find("LevelConstructor");
if (levelConstructorObj == null)
{
// TODO: Some warning here.
}
if (levelConstructorObj != null)
{
levelConstructor = levelConstructorObj.GetComponent<LevelConstructor>();
}
}
if (tileSelector == null)
{
GameObject tileSelectorObj = GameObject.Find ("TileSelector");
if (tileSelectorObj != null)
{
tileSelector = tileSelectorObj.GetComponent<TileSelector>();
tileSelector.OnTileSelectionCallback += OnTileSelected;
}
}
}
