public void LoadSummon(CChar c, CTile t) { var builder = new CharViewBuilder(); c.SetView(builder.Build(c.Proxy)); this.RenderChar(c, t); }
private void RenderChar(CChar character, CTile tile) { var sprite = character.View.Sprites[character.View.Torso]; var render = character.GameHandle.AddComponent <SpriteRenderer>(); character.GameHandle.transform.position = tile.Handle.transform.position; character.GameHandle.transform.SetParent(this._container); character.GameHandle.name = character.View.Type.ToString() + " " + character.View.Race.ToString(); render.sprite = sprite; render.sortingLayerName = SortingLayers.CHAR_TORSO; this.TryAttachHead(character, SortingLayers.CHAR_HEAD, character.View.Head, tile); this.TryAttachDeco(character, tile); this.TryAttachEquipment(character, tile); this.TryAttachMount(character, tile); character.SubComponents.Add(SortingLayers.CHAR_TORSO, character.GameHandle); character.SubComponents.Add(SortingLayers.CHAR_MAIN, character.GameHandle); if (!character.Proxy.LParty) { character.GameHandle.transform.localRotation = Quaternion.Euler(0, 180, 0); } // TODO: This really should be elsewhere, but it works for now. tile.SetCurrent(character); character.SetTile(tile); character.ProcessEnterNewTile(tile); }
private void TryAttachEquipmentHelper(CChar c, VEquipment e, string sort, CTile tile, float xOffset = 0, float yOffset = 0) { if (e != null) { var spriteHandler = new GameObject(); if (e.SpriteIndex > e.Sprites.Length) { throw new System.Exception(); } var sprite = e.Sprites[e.SpriteIndex]; var render = spriteHandler.AddComponent <SpriteRenderer>(); var position = c.GameHandle.transform.position; position.x += xOffset; position.y += yOffset; spriteHandler.transform.position = position; if (sort == SortingLayers.CHAR_HELM) { spriteHandler.transform.SetParent(c.SubComponents[SortingLayers.CHAR_HEAD].transform); } else { spriteHandler.transform.SetParent(c.GameHandle.transform); } spriteHandler.name = e.Name; render.sprite = sprite; render.sortingLayerName = sort; c.SubComponents.Add(sort, spriteHandler); } }
private void TryHandleAoEHover(CTile t) { foreach (var tile in this._aoeTiles) { GameObject.Destroy(tile); } this._aoeTiles.Clear(); var eAbility = CombatManager.Instance.GetCurrentAbility(); if (eAbility != EAbility.None) { var active = AbilityTable.Instance.Table[eAbility]; if (active.Data.AoE >= 1) { this.HandleAoEHover(t, active); } else if (active.Data.CastType == ECastType.Raycast || active.Data.CastType == ECastType.Melee_Raycast) { this.HandleRaycastHover(t, active); } else if (active.Data.CastType == ECastType.Arc) { this.HandleArcHover(t, active); } } }
private void TryProcessFirstTile() { if (this._data.Source != null) { var ap = this._data.Char.Proxy.GetPoints(ESecondaryStat.AP); var stamina = this._data.Char.Proxy.GetPoints(ESecondaryStat.Stamina); var tile = this._data.TargetPath.GetFirstTile() as MTile; this._next = tile.Controller; var apCost = this._next.Model.GetCost(); var stamCost = this._next.Model.GetStaminaCost(); if (apCost <= ap && stamCost <= stamina) { var data = new EvTileMoveData(); data.Cost = apCost; data.Char = this._data.Char; data.ParentMove = this; data.Source = this._data.Source; data.Target = this._next; var e = new EvTileMove(data); e.AddCallback(this.TileMoveDone); this.AddChildAction(e); e.TryProcess(); } else { this.TryDone(null); } } }
private CTile[,] LoadTilesFromFile(string file) { var fs = File.Open(file, FileMode.Open); BinaryReader br = new BinaryReader(fs); int maxX = br.ReadInt32(); int maxY = br.ReadInt32(); var tiles = new CTile[maxX, maxY]; for (int x = 0; x < tiles.GetLength(0); x++) { for (int y = 0; y < tiles.GetLength(1); y++) { tiles[x, y] = new CTile() { Type = br.ReadUInt16(), Wall = br.ReadByte(), Liquid = br.ReadByte(), BTileHeader = br.ReadByte(), BTileHeader2 = br.ReadByte(), BTileHeader3 = br.ReadByte(), FrameX = br.ReadInt16(), FrameY = br.ReadInt16(), STileHeader = br.ReadInt16() }; } } fs.Close(); return(tiles); }
private void TryAttachDecoHelper(CChar c, string sort, int spriteIndex, CTile tile) { if (c.Proxy.Type == ECharType.Humanoid && spriteIndex >= 0) { var spriteHandler = new GameObject(); var sprite = c.View.Sprites[spriteIndex]; var render = spriteHandler.AddComponent <SpriteRenderer>(); spriteHandler.transform.position = c.GameHandle.transform.position; if (sort == SortingLayers.CHAR_FACE || sort == SortingLayers.CHAR_HEAD_DECO_1 || sort == SortingLayers.CHAR_HEAD_DECO_2) { spriteHandler.transform.SetParent(c.SubComponents[SortingLayers.CHAR_HEAD].transform); } else { spriteHandler.transform.SetParent(c.GameHandle.transform); } spriteHandler.name = sort; render.sprite = sprite; render.sortingLayerName = sort; c.SubComponents.Add(sort, spriteHandler); } }
public void AttachDeco(CTile tile, EDeco deco) { var decoParam = DecoTable.Instance.Table[deco]; var data = this.GetDecoData(decoParam); var sprite = this._sprites[ListUtil <int> .GetRandomElement(decoParam.Sprites)]; FTile.SetEnvironmentFlagTrue(tile.GetFlags()); var handle = new GameObject(); var model = new MDeco(deco); model.SetData(data); var view = new VDeco(deco); var controller = new CDeco(); controller.SetGameHandle(handle); controller.SetModel(model); controller.SetView(view); var renderer = handle.AddComponent <SpriteRenderer>(); tile.SetCurrent(controller); renderer.sprite = sprite; renderer.transform.SetParent(tile.Handle.transform); renderer.transform.position = tile.Handle.transform.position; var tileRenderer = tile.Handle.GetComponent <SpriteRenderer>(); renderer.sortingLayerName = tileRenderer.sortingLayerName; renderer.sortingOrder = tileRenderer.sortingOrder + 1; }
// ----------------------------------------------------------------------------------------------------------------- public CTile.EDirection SetPlayerDestination(CTile cur_tile, CTile.EDirection dir) { CTile.EDirection dir_next = CTile.DIR_EX[(int)dir].m_next; CTile.EDirection dir_next_next = CTile.DIR_EX[(int)dir_next].m_next; CTile.EDirection dir_prev = CTile.DIR_EX[(int)dir].m_prev; CTile.EDirection dir_prev_prev = CTile.DIR_EX[(int)dir_prev].m_prev; CTile.EDirection dir_back = CTile.DIR_EX[(int)dir].m_opposite; CTile.EDirection[] dir_selection_order = { dir, dir_next, dir_prev, dir_next_next, dir_prev_prev, dir_back }; CTile.EDirection final_dir = dir; foreach (CTile.EDirection d in dir_selection_order) { m_dest_tile = cur_tile.GetNeighbor(d); if (m_dest_tile != null && !m_level_tags.IsTagSet(m_dest_tile, (int)CTile.ETag.T_BORDER)) { final_dir = d; break; } } utils.Assert(m_dest_tile != null, "Destination tile is null"); m_direction = dir; m_player.SetDestination(m_dest_tile.GetPosition()); // utils.Log("Set player destination :: cur={0}:{1} dest={2}:{3} dir={4}", // cur_tile.m_x, cur_tile.m_z, m_dest_tile.m_x, m_dest_tile.m_z, dir); return(final_dir); }
public object MarshalNativeToManaged(IntPtr pNativeData) { CGameData data = (CGameData)Marshal.PtrToStructure(pNativeData, typeof(CGameData)); GameData resData = new GameData(); resData.playerPosition = data.playerPosition; resData.calendar = new Calendar(); resData.calendar.season = ((SeasonType)data.calendar.season).ToString(); resData.calendar.time = Marshal.PtrToStringAnsi(data.calendar.time); resData.calendar.isNight = data.calendar.isNight; resData.weather = new Weather(); resData.weather.type = data.weather.type; resData.weather.temprature = data.weather.temperature; resData.weather.humidity = data.weather.humidity; resData.weather.wind = data.weather.wind; resData.weather.pressure = data.weather.pressure; resData.weather.acidic = data.weather.acidic; int width = data.map.width; int height = data.map.height; int size = width * height; Tile[] tiles = new Tile[width * height]; resData.map = new Map(width, height, tiles); for (int i = 0; i < size; i++) { IntPtr p = new IntPtr(data.map.tiles.ToInt64() + i * Marshal.SizeOf(typeof(CTile))); CTile tile = (CTile)Marshal.PtrToStructure(p, typeof(CTile)); resData.map.tiles[i] = new Tile(tile.ter, tile.loc, tile.furn, tile.seen != 0); } return(resData); }
public void ProcessEnterNewTile(CTile tile) { AZone spearWallProto = null; if (FActionStatus.HasFlag(this._proxy.GetActionFlags().CurFlags, FActionStatus.Flags.Spearwalling)) { spearWallProto = this._proxy.GetZones().Find(x => x.Type == EZone.Spear_Wall_Zone); } var deleteZones = new List <AZone>(); foreach (var zone in this.Proxy.GetZones()) { if (zone.GetData().DependsOnSourceChar&& zone.GetData().Source.Equals(this)) { deleteZones.Add(zone); } } foreach (var zone in deleteZones) { zone.RemoveFromParentAndSource(); } foreach (var neighbor in tile.GetAdjacent()) { if (spearWallProto != null) { this.ProcessSpearwallZone(neighbor, spearWallProto); } this.ProcessAttackOfOpportunityZone(neighbor); } this.SetTile(tile); }
public void LoadMapFromTexture() { if (null == m_tMapData) { return; } Clear(); Transform tmpBoard = this.transform.GetChild(0); Vector2 v2Size = new Vector2(m_tMapData.width, m_tMapData.height); Color32[] aPixelData = m_tMapData.GetPixels32(); for (int wLoop = 0; m_tMapData.width > wLoop; wLoop++) { for (int hLoop = 0; m_tMapData.height > hLoop; hLoop++) { Color32 color = aPixelData[(hLoop * m_tMapData.width) + wLoop]; foreach (SColorToPrefab cToPF in m_aColorToPrefabs) { if (cToPF.color.Equals(color)) { GameObject tileObject = (GameObject)GameObject.Instantiate(cToPF.prefab); CTile tile = tileObject.GetComponent <CTile>(); tile.Coordinates = new SPoint(wLoop, hLoop); tileObject.transform.parent = tmpBoard; tileObject.transform.localPosition = (Vector3)tile.Coordinates; } } } } }
// Carga el mapa en el array ya creado. No crea el array. public void loadLevel(int aLevel) { mCurrentLevel = aLevel; int[][] m; if (aLevel == 1) { m = LEVEL_001; } else { m = LEVEL_002; } // Para cada fila.. for (int y = 0; y < MAP_HEIGHT; y++) { // Llenar la fila. for (int x = 0; x < MAP_WIDTH; x++) { // Obtener que indice de tile es. 0, 1, .... int index = m [y] [x]; // Cambiar el tile. CTile tile = getTile(x, y); tile.setTileIndex(index); tile.setImage(mTiles[index]); // RUNNER //tile.setVelX(-100); } } loadItems(aLevel); }
public GameObject GetRaycast(MAction action, CTile tgt, Callback callback, float speed) { var sprite = this.GetBulletSprite(action); var bullet = new GameObject(); bullet.transform.position = action.Data.Source.GameHandle.transform.position; var renderer = bullet.AddComponent <SpriteRenderer>(); renderer.sprite = sprite; renderer.sortingLayerName = SortingLayers.PARTICLES; var tgtPosition = tgt.Handle.transform.position; var angle = Vector3.Angle(tgtPosition, bullet.transform.position); if (tgtPosition.y < bullet.transform.position.y) { angle = -angle; } if (action.Data.Source.Proxy.LParty) { bullet.transform.Rotate(0, 0, angle); } else { bullet.transform.localRotation = Quaternion.Euler(0, 180, angle); } return(this.GetDeleteRay(action, tgtPosition, callback, bullet, speed)); }
//Es como un manager de tiles public void update() { //Si la iteracion no pasa el maximo se repite for (int y = 0; y < MAP_HEIGHT; y++) { //Si la iteracion no pasa el maximo se repite for (int x = 0; x < MAP_WIDTH; x++) { //se update los tiles a medida que cambie mMap[y][x].update(); } } int col = (int)(CMouse.getX() / TILE_WIDTH); int row = (int)(CMouse.getY() / TILE_HEIGHT); CTile tile = getTile(col, row); if (tile != null) { if (CMouse.firstPress()) { int index = tile.getTileIndex(); if (index == 0) { tile.setTileIndex(1); tile.setImage(mTiles[1]); } else if (index == 1) { tile.setTileIndex(0); tile.setImage(mTiles[0]); } } } }
// Construye el mapa. Crear el array y carga el mapa aLevel. public void buildLevel(int aLevel) { mCurrentLevel = aLevel; int[][] m; if (aLevel == 1) { m = LEVEL_001; } else { m = LEVEL_002; } mMap = new List <List <CTile> > (); // Para cada fila.. for (int y = 0; y < MAP_HEIGHT; y++) { // Crea un array para la fila vacio. mMap.Add(new List <CTile> ()); // Llenar la fila. for (int x = 0; x < MAP_WIDTH; x++) { // Obtener que indice de tile es. 0, 1, .... int index = m [y] [x]; // Crear el tile. CTile tile = new CTile(x * TILE_WIDTH, y * TILE_HEIGHT, index, mTiles[index]); // Agregar el tile a la fila. mMap [y].Add(tile); } } loadItems(aLevel); }
//mMap es una lista de listas de elementos de CTiles public void loadLevel(int aLevel) { mCurrentLevel = aLevel; int[] m; m = LEVEL_001; //Mientras que y sea menor que el maximo de altura del mapa se agregan tiles. //Aca se crean las filas vacias. for (int y = 0; y < MAP_HEIGHT; y++) { //Se le agrega una fila, para eso es el add, se le agrega vacia. //Se van agregando de a 1 los tiles con arrays vacios. //mMap.Add(new List<CTile>()); //Mientras que la columna sea menor que el maximo se repite la iteracion. //Aca se llenan los arrays vacios de columnas con los tipos de tiles for (int x = 0; x < MAP_WIDTH; x++) { //Nos trae el indice de tiles (0, 1, 2...etc) int index = m[y * MAP_WIDTH + x]; //CTile tile = new CTile(x * TILE_WIDTH, y * TILE_HEIGHT, index, mTiles[index]); CTile tile = getTile(x, y); tile.setName("Tile - " + y + "," + x); //tile.setParentObject(mMapObject.transform); //Agrega el tile creado al array //mMap[y].Add(tile); tile.setTileIndex(index); tile.setImage(mTiles[index]); } } }
public void RemoveFromWorld() { _placedInWorld = false; int colWidth = mWidth * 2; int colLength = mLength * 2; for (int iX = 0; iX < colWidth; ++iX) { for (int iY = 0; iY < colLength; ++iY) { IntVec2 worldTile = GetWorldCollisionTile(iX, iY, mPosition, mItemRot); CCollisionTile tile = mWorld.mMap.mGlobalCollisionTiles[worldTile.X, worldTile.Y]; tile.mOccupied = 0; tile.mSolid = false; } } for (int iX = 0; iX < mWidth; ++iX) { for (int iY = 0; iY < mLength; ++iY) { Vector2 worldPoint = RotationAxisTable[mItemRot].Transform(new Vector2(iX, iY)); int worldX = (int)worldPoint.x + mX; int worldY = (int)worldPoint.y + mY; CTile worldTile = mWorld.mMap.mTiles[worldX, worldY]; worldTile.mItem = -1; } } mWorld.RebuildInfluenceMap(); }
public virtual void PlaceInWorld() { mBluerprint = false; _placedInWorld = true; mBounds = CalculateBounds(mPosition, mItemRot, mWidth, mLength); int colWidth = mWidth * 2; int colLength = mLength * 2; for (int iX = 0; iX < colWidth; ++iX) { for (int iY = 0; iY < colLength; ++iY) { IntVec2 worldTile = GetWorldCollisionTile(iX, iY, mPosition, mItemRot); CCollisionTile tile = mWorld.mMap.mGlobalCollisionTiles[worldTile.X, worldTile.Y]; tile.mOccupied = -1; tile.mSolid = mAsset.mTiles[iX, iY].mSolid; } } for (int iX = 0; iX < mWidth; ++iX) { for (int iY = 0; iY < mLength; ++iY) { Vector2 worldPoint = RotationAxisTable[mItemRot].Transform(new Vector2(iX, iY)); int worldX = (int)worldPoint.x + mX; int worldY = (int)worldPoint.y + mY; CTile worldTile = mWorld.mMap.mTiles[worldX, worldY]; worldTile.mItem = mID; } } mWorld.RebuildInfluenceMap(); }
// ----------------------------------------------------------------------------------------------------------------- public CTile GetTileByOffset(CTile t, CTile.EDirection dir, int offset) { int x = 0, z = 0; t.GetTilePosXZByOffset(dir, offset, ref x, ref z); return(GetTileByPosXZ(x, z)); }
private bool TryProcessTileWithChar(CTile t) { if (t.Current != null && t.Current.GetType().Equals(typeof(CChar)) && this._currActingData.Ability != EAbility.None) { var ability = AbilityTable.Instance.Table[this._currActingData.Ability]; var target = t.Current as CChar; var tile = this._combatData.PotentialTgtTiles.Find(x => x.Equals(t)); if (tile != null) { if (this._currActingData.CurrentlyActing.Proxy.LParty == target.Proxy.LParty) { if (!ability.Data.Hostile) { return(true); } } else { if (ability.Data.Hostile) { return(true); } } } } return(false); }
private void Awake() { m_dBoardTiles = new Dictionary <SPoint, CTile>(); m_v2Size = new Vector2(10f, 10f); //DEBUG - TODO: Do proper logic with SOLevelData if (m_LevelData) { foreach (STileData tile in m_LevelData.m_lTiles) { bool bFound = false; foreach (STileTypeToPrefab mapping in m_PrefabToTileType) { if (mapping.type == tile.eType) { GameObject tileObject = GameObject.Instantiate(mapping.prefab, (Vector3)tile.position, Quaternion.identity); CTile tileComponent = tileObject.GetComponent <CTile>(); tileComponent.Coordinates = tile.position; AddTile(tileComponent); bFound = true; } } if (!bFound) { Debug.LogWarning("Tile type not mapped found"); } } } }
private void TryProcessNextTile(CTile tile) { var ap = this._data.Char.Proxy.GetPoints(ESecondaryStat.AP); var stamina = this._data.Char.Proxy.GetPoints(ESecondaryStat.Stamina); var model = (MTile)this._data.TargetPath.GetNextTile(tile.Model); if (model != null) { this._next = model.Controller; var apCost = this._next.Model.GetCost(); var stamCost = this._next.Model.GetStaminaCost(); if (apCost <= ap && stamCost <= stamina) { var data = new EvTileMoveData(); data.Cost = apCost; data.Char = this._data.Char; data.ParentMove = this; data.Source = this._current; data.StamCost = this._data.Target.Model.GetStaminaCost(); data.Target = this._next; var e = new EvTileMove(data); e.AddCallback(this.TileMoveDone); e.TryProcess(); } else { this.TryDone(null); } } else { this.TryDone(null); } }
public void DoScatter(object o) { var hit = o as MHit; var tgt = hit.Data.Target.Current as CChar; if (tgt != null && FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Push) && !FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Dodge) && !FHit.HasFlag(hit.Data.Flags.CurFlags, FHit.Flags.Parry)) { CTile randomController = null; var tgtTile = hit.Data.Source.Tile.Model.GetPushTile(tgt.Tile.Model); if (tgtTile == null) { randomController = hit.Data.Source.Tile.GetNearestEmptyTile(); } if (randomController != null) { tgtTile = randomController.Model; } if (tgtTile != null) { var data = new EvTileMoveData(); data.Char = tgt; data.Cost = 0; data.DoAttackOfOpportunity = false; data.StamCost = 0; data.Source = tgt.Tile; data.Target = tgtTile.Controller; var e = new EvTileMove(data); e.AddCallback(hit.CallbackHandler); e.TryProcess(); } } }
private void InitTileType(CTile tile, MapInitInfo info) { if (tile.Model.Type == ETile.None) { var mapParams = BiomeTable.Instance.Table[info.Biome]; double roll = RNG.Instance.NextDouble(); double tally = 1.0; foreach (var kvp in mapParams.TileDict) { tally -= kvp.Value; if (roll >= tally) { tile.Model.SetType(kvp.Key); tile.Model.SetAPCost(TileTable.Instance.Table[kvp.Key].Cost); tile.Model.SetStaminaCost(TileTable.Instance.Table[kvp.Key].StaminaCost); tile.Model.SetThreatMod(TileTable.Instance.Table[kvp.Key].ThreatMod); tile.Model.SetVulnMod(TileTable.Instance.Table[kvp.Key].VulnMod); if (TileTable.Instance.Table[kvp.Key].Liquid) { tile.Model.SetLiquid(true); } break; } } } }
public void SaveToScriptableObject(string mapName) { SOLevelData soLevelData = ScriptableObject.CreateInstance <SOLevelData>(); List <STileData> lLevelData = new List <STileData>(); Transform tFakeBoard = this.transform.GetChild(0); int iTileCount = tFakeBoard.childCount; for (int iLoop = 0; iLoop < iTileCount; iLoop++) { STileData tileData = new STileData(); CTile tile = tFakeBoard.GetChild(iLoop).GetComponent <CTile>(); if (tile) { tileData.position = tile.Coordinates; tileData.eType = tile.Type; lLevelData.Add(tileData); } } soLevelData.m_lTiles = lLevelData; string sPath = Application.dataPath + "/Resources/LevelsData"; if (!Directory.Exists(sPath)) { AssetDatabase.CreateFolder("Assets/Resources", "LevelsData"); } AssetDatabase.CreateAsset(soLevelData, String.Format("Assets/Resources/LevelsData/{0}.asset", mapName)); }
private void InitLiquidTile(CTile tile, Transform tileHolder) { var script = tile.Handle.AddComponent <STile>(); script.InitTile(tile); var sprites = this._spriteDict[tile.Model.Type]; var roll = RNG.Instance.Next(0, sprites.Count - 1); var sprite = sprites[roll]; var render = tile.Handle.AddComponent <SpriteRenderer>(); render.sprite = sprite; render.sortingLayerName = SortingLayers.TILE_LAYER; tile.Handle.transform.SetParent(tileHolder); tile.Handle.name = SortingLayers.TILE + "( " + tile.Model.GetCol() + " / " + tile.Model.GetRow() + " )"; tile.InitLiquidTile(); tile.LiquidHandle.transform.position = tile.Model.Center; var liquidRenderer = tile.LiquidHandle.AddComponent <SpriteRenderer>(); var liquidSprites = MapBridge.Instance.GetTileSprites(ETile.Water); liquidRenderer.sprite = liquidSprites[roll + 8]; liquidRenderer.sortingLayerName = SortingLayers.TILE_LAYER; tile.LiquidHandle.transform.SetParent(tileHolder); tile.LiquidHandle.name = SortingLayers.TILE + "( " + tile.Model.GetCol() + " / " + tile.Model.GetRow() + " )"; }
// Use this for initialization void Start() { //m_akTile = new CTile[8]; //m_akTile = new StTile[8]; m_fDist = Vector3.Distance(m_vTileEndPos, m_vTileStartPos); // 타일별 이동 정보 세팅 Vector3 vCreateStartPos = m_vTileEndPos; vCreateStartPos.x += 1.0f; for (int i = 0; i < m_nCount; ++i) { CTile kTime = new CTile(); kTime.kTile = GameObject.Instantiate(g_Tile); kTime.kTile.transform.position = vCreateStartPos; //m_akTile[i].kTile = Instantiate(g_Tile); //m_akTile[i].kTile.transform.position = vCreateStartPos; kTime.vStartPos = vCreateStartPos; kTime.fContinueTime = m_fTime * Vector3.Distance(m_vTileEndPos, vCreateStartPos) / m_fDist; vCreateStartPos.x += 1.0f; kTime.fStartTime = Time.fixedTime; m_tmTile.Add(i, kTime); } for (int i = 0; i < 8; ++i) { ////m_akTile[i].fStartTime = Time.fixedTime; } }
// Carga el mapa en el array ya creado. No crea el array. public void loadLevel(int aLevel) { mCurrentLevel = aLevel; int[] m; if (aLevel == 1) { m = LEVEL_ANDY_001; } else { m = LEVEL_ANDY_002; } // Para cada fila.. for (int y = 0; y < mMapHeight; y++) { // Llenar la fila. for (int x = 0; x < mMapWidth; x++) { // Obtener que indice de tile es. 0, 1, .... int index = m [y * mMapWidth + x]; // Cambiar el tile. CTile tile = getTile(x, y); tile.setTileIndex(index); tile.setImage(mTiles[index]); } } loadEnemies(aLevel); }
public List <CTile> FindPatha(CTile start, CTile goal) { AStar a = new AStar(); a.FindPath(start, goal, _board); return(a.Path()); }
private void TryAttachDeco(CChar c, CTile t) { this.TryAttachDecoHelper(c, SortingLayers.CHAR_FACE, c.View.Face, t); this.TryAttachDecoHelper(c, SortingLayers.CHAR_HEAD_DECO_1, c.View.HeadDeco1, t); this.TryAttachDecoHelper(c, SortingLayers.CHAR_HEAD_DECO_2, c.View.HeadDeco2, t); this.TryAttachDecoHelper(c, SortingLayers.CHAR_TORSO_DECO_1, c.View.TorsoDeco1, t); this.TryAttachDecoHelper(c, SortingLayers.CHAR_TORSO_DECO_2, c.View.TorsoDeco2, t); }