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);
}
