public static void setChunk(Chunk chunk)
{
Vector2I corner = _world.loadedPosition;
Vector2I position = chunk.position;
// Determine the Local Array based position of the chunk
Vector2I localPos = position - corner;
Vector2I blockPos = new Vector2I(localPos.x * Chunk.tileDimension, localPos.y * Chunk.tileDimension);
Tile[,,] data = chunk.tiles;
//try
//{
for (int i = 0; i < data.GetLength(0); i++)
{
for (int j = 0; j < data.GetLength(1); j++)
{
// Set foreground tile
TileAsset asset = TileStore.getTile(data[i, j, 0].id);
_map[i + blockPos.x, j + blockPos.y] = asset.solid;
}
}
rebuildMap();
//}
//catch
//{
// Debug.Log(string.Format("OOR: {0},{1},{2},{3}", corner, position, localPos, blockPos));
//}
}
/// <summary>
/// Sets the parameters to the PreviewRenderUtility and calls the rendering
/// </summary>
/// <param name="tile">The Tile to preview</param>
/// <param name="angle">The camera angle</param>
/// <param name="distance">The distance of the camera to the preview cube</param>
/// <param name="samplingIterations">The amount of slices used to raymarch in the Texture3D</param>
/// <param name="density">A linear factor to multiply the Texture3D with</param>
private static void RenderInPreviewRenderUtility(TileAsset tile, Vector2 angle, float distance)
{
PreviewRenderUtilityHelpers.Instance.DrawMesh(tile, Matrix4x4.identity, PreviewMaterial, 0);
PreviewRenderUtilityHelpers.Instance.camera.transform.rotation = Quaternion.Euler(new Vector3(-angle.y, -angle.x, 0));
PreviewRenderUtilityHelpers.Instance.camera.transform.position = Vector3.up * 1.5f + PreviewRenderUtilityHelpers.Instance.camera.transform.forward * -distance;
PreviewRenderUtilityHelpers.Instance.camera.Render();
}
public void loadData(StreamReader reader)
{
// TODO:
// Chunk cache for metadata blocks
_tiles = new Tile[tileDimension, tileDimension, 2];
int x = int.Parse(reader.ReadLine());
int y = int.Parse(reader.ReadLine());
_position = new Vector2I(x, y);
for (int i = 0; i < dimension; i++)
{
for (int j = 0; j < dimension; j++)
{
for (int k = 0; k < tileDepth; k++)
{
// Read in the ID value
int id = int.Parse(reader.ReadLine());
// Load the specified tile from the store
TileAsset asset = TileStore.getTile(id);
// Create the new instance and load any extra custom data
Tile tile = asset.getTile();
tile.loadData(reader);
_tiles[i, j, k] = tile;
}
}
}
}
public override IEnumerator Start()
{
Caching.ClearCache();
Global.Initialize();
MVersion versions = new MVersion();
SUser sUser = Global.SUser;
List <IEnumerator> list = new List <IEnumerator>();
list.Add(sUser.Download(TileAsset.Url, versions.tile, (AssetBundle assetbundle) => {
TileAsset.assetbundle = assetbundle;
TileCacher.Instance.Reset(TileAsset.Data.tiles);
TileAsset.Clear();
}));
list.Add(sUser.Download(ImageAssetBundleManager.mapUrl, versions.map, (AssetBundle assetbundle) => {
ImageAssetBundleManager.map = assetbundle;
}, false));
/*list.Add(sUser.Download(ConstantAsset.Url, versions.constant, (AssetBundle assetbundle) => {
* ConstantAsset.assetbundle = assetbundle;
* Global.Constant = ConstantAsset.Data.constant;
* }));*/
Debug.Log("Start");
for (int i = 0; i < list.Count; i++)
{
Debug.Log(i + "/" + list.Count);
yield return(this.StartCoroutine(list[i]));
}
Debug.Log("Start Over");
loadComplete = true;
}
public void ParseLocal(string filename)
{
IniFile ini = new IniFile(filename);
string[] section_names = ini.GetSectionNames();
List <string> ignored_assets = new List <string>();
foreach (string sec in section_names)
{
string entry_type = sec.Split(':')[0];
string name = sec.Split(':')[1];
Asset asset = null;
if (entry_type == Asset.AssetType.biome.ToString())
{
BiomeAsset biomeAsset = new BiomeAsset(name);
biomeAsset.LoadFrom(ini);
asset = biomeAsset;
}
if (entry_type == Asset.AssetType.tile.ToString())
{
TileAsset tileAsset = new TileAsset(name);
tileAsset.LoadFrom(ini);
asset = tileAsset;
}
if (entry_type == Asset.AssetType.item.ToString())
{
ItemAsset itemAsset = new ItemAsset(name);
itemAsset.LoadFrom(ini);
asset = itemAsset;
}
if (asset != null)
{
this.AddNew(asset);
}
else
{
ignored_assets.Add(sec);
}
}
if (ignored_assets.Count > 0)
{
FileInfo file = new FileInfo(filename);
string errormsg = file.Name + ": " + "Following assets could not be loaded, because parser for their type is either not present or not working:\n\n";
foreach (string s in ignored_assets)
{
errormsg += s + ", ";
}
errormsg = errormsg.Substring(0, errormsg.Length - 2);
ui.MessageBox.Show(errormsg + "\n", ui.MessageBox.Buttons.OK);
}
}
/// <summary>
/// Renders a thumbnail of the Texture3D
/// </summary>
/// <param name="tile">The Texture3D to preview</param>
/// <param name="rect">The area where the preview is located</param>
/// <param name="angle">The camera angle</param>
/// <param name="distance">The distance of the camera to the preview cube</param>
/// <param name="samplingIterations">The amount of slices used to raymarch in the Texture3D</param>
/// <param name="density">A linear factor to multiply the Texture3D with</param>
/// <returns>A Texture2D with the thumbnail</returns>
public static Texture2D RenderTexture3DStaticPreview(this TileAsset tile, Rect rect, Vector2 angle, float distance)
{
PreviewRenderUtilityHelpers.Instance.BeginStaticPreview(rect);
RenderInPreviewRenderUtility(tile, angle, distance);
return(PreviewRenderUtilityHelpers.Instance.EndStaticPreview());
}
public virtual void onDestroyed(Vector2 position)
{
TileAsset tile = TileStore.getTile(id);
if (tile.dropItem)
{
Debug.Log(tile);
EntityItem item = (EntityItem)EntityStore.createEntity(0);
Debug.Log(item);
item.itemID = tile.droppedItem.id;
item.transform.position = new Vector3(position.x - 0.5f, position.y - 0.5f, 1.0f);
}
}
public void buildMesh(Chunk chunk)
{
reset();
_chunk = chunk;
_dimension = chunk.dimension;
Tile[,,] tiles = _chunk.tiles;
for (int i = 0; i < _dimension; i++)
{
for (int j = 0; j < _dimension; j++)
{
Vector2I pos = new Vector2I(i, j);
TileAsset tile = _tileStoreCache[tiles[i, j, 0].id];
TileAsset background = _tileStoreCache[tiles[i, j, 1].id];
// is the tile visible?
if (tile.visible)
{
setTile(tiles[i, j, 0], pos);
if (!tile.opaque && background.visible) // can you see through it?
{
setBackground(background, pos);
}
}
else if (background.visible) // is the background tile visible?
{
setBackground(background, pos);
}
}
}
Mesh mesh = chunk.container.mesh;
mesh.Clear();
mesh.vertices = _vertices.ToArray();
mesh.SetIndices(_triangles.ToArray(), MeshTopology.Triangles, 0);
mesh.uv = _uvs.ToArray();
mesh.RecalculateNormals();
;
}
private void setBackground(TileAsset tile, Vector2I pos)
{
_vertices.Add(new Vector3(-0.5f + pos.x, -0.5f + pos.y, 1));
_vertices.Add(new Vector3(0.5f + pos.x, -0.5f + pos.y, 1));
_vertices.Add(new Vector3(0.5f + pos.x, 0.5f + pos.y, 1));
_vertices.Add(new Vector3(-0.5f + pos.x, 0.5f + pos.y, 1));
Rect rect = Atlas.getTexture(tile.texture.name);
_uvs.Add(new Vector2(rect.xMin, rect.yMin));
_uvs.Add(new Vector2(rect.xMax, rect.yMin));
_uvs.Add(new Vector2(rect.xMax, rect.yMax));
_uvs.Add(new Vector2(rect.xMin, rect.yMax));
_triangles.Add(_index + 0);
_triangles.Add(_index + 3);
_triangles.Add(_index + 2);
_triangles.Add(_index + 2);
_triangles.Add(_index + 1);
_triangles.Add(_index + 0);
_index += 4;
}
public Tile(int id, int health)
{
this._id = id;
this._health = health;
this._asset = TileStore.getTile(id);
}
public void Init(int[] mapPos, List <Board.DoorPos> doors, int floor, TileAsset doorTiles, List <GameObject> enemiesList, Room roomCreator, int bossDoor)
{
gandulf = roomCreator.Shopper;
roomType = roomCreator.GetRoomType();
totalWeight = 7 * floor;
nextLevel = roomCreator.GetNextLevel();
chest = roomCreator.Chest;
this.bossDoor = bossDoor;
this.mapPos = mapPos;
this.floor = floor;
this.doors = doors;
this.doorTiles = doorTiles;
this.roomCreator = roomCreator;
allEnemiesList = enemiesList;
grid = gameObject.GetComponent <TileGrid>();
roomPosition = transform.position;
if (roomCreator.GetRoomType() == Board.Type.Chest)
{
GameObject chestOnScene = Instantiate(chest, transform.position + new Vector3(0.5f, 0.5f, 0), Quaternion.identity) as GameObject;
chestOnScene.transform.parent = gameObject.transform;
}
else if (roomCreator.GetRoomType() == Board.Type.Shop)
{
GameObject shopOnScene = Instantiate(gandulf, transform.position + new Vector3(-4.5f, 3f, 0), Quaternion.identity) as GameObject;
shopOnScene.transform.parent = gameObject.transform;
}
else if (roomCreator.GetRoomType() == Board.Type.Boss)
{
isBossRoom = true;
testForBoss = true;
enemies.Add(enemiesList[0]);
}
else if (enemiesList.Count > 0)
{
CreateEnemies();
}
LayerBehind layerB = GetComponent <LayerBehind>(); //to make the boss room be opened
LayerFront layerF = GetComponent <LayerFront>();
if (bossDoor == -1)
{
layerB.ClearTiles(doors, doorTiles, floor);
layerF.ClearTiles(doors, doorTiles, floor);
}
if (bossDoor == 0)
{
layerB.ClearTiles(new List <Board.DoorPos> {
Board.DoorPos.Left
}, doorTiles, floor);
layerF.ClearTiles(new List <Board.DoorPos> {
Board.DoorPos.Left
}, doorTiles, floor);
}
else if (bossDoor == 1)
{
layerB.ClearTiles(new List <Board.DoorPos> {
Board.DoorPos.Up
}, doorTiles, floor);
layerF.ClearTiles(new List <Board.DoorPos> {
Board.DoorPos.Up
}, doorTiles, floor);
}
else if (bossDoor == 2)
{
layerB.ClearTiles(new List <Board.DoorPos> {
Board.DoorPos.Right
}, doorTiles, floor);
layerF.ClearTiles(new List <Board.DoorPos> {
Board.DoorPos.Right
}, doorTiles, floor);
}
else if (bossDoor == 3)
{
layerB.ClearTiles(new List <Board.DoorPos> {
Board.DoorPos.Down
}, doorTiles, floor);
layerF.ClearTiles(new List <Board.DoorPos> {
Board.DoorPos.Down
}, doorTiles, floor);
}
roomCreator.Open();
}
public ItemTile(int id, TileAsset tileAsset) : base(id)
{
_tileAsset = tileAsset;
}
public TileDoor(int id, int health, TileAsset asset) : base(id, health, asset)
{
_state = 1;
_assetN = (TileAssetDoor)asset;
}
/// <summary>
/// Renders a preview of the Texture3D
/// </summary>
/// <param name="texture3D">The Texture3D to preview</param>
/// <param name="rect">The area where the preview is located</param>
/// <param name="angle">The camera angle</param>
/// <param name="distance">The distance of the camera to the preview cube</param>
/// <param name="samplingIterations">The amount of slices used to raymarch in the Texture3D</param>
/// <param name="density">A linear factor to multiply the Texture3D with</param>
/// <returns>A Texture with the preview</returns>
public static Texture RenderPreview(this TileAsset asset, Rect rect, Vector2 angle, float distance)
{
PreviewRenderUtilityHelpers.Instance.BeginPreview(rect, BackgroundGuiStyle);
RenderInPreviewRenderUtility(asset, angle, distance);
return(PreviewRenderUtilityHelpers.Instance.EndPreview());
}
public static IEnumerator LoadAssetbundle(MVersion versions)
{
SUser sUser = Global.SUser;
List <IEnumerator> list = new List <IEnumerator>();
list.Add(sUser.Download(ImageAssetBundleManager.horseUrl, versions.horse_img, (AssetBundle assetbundle) => {
AvatarSpriteAsset.assetbundle = assetbundle;
ImageAssetBundleManager.horse = AvatarSpriteAsset.Data.meshs;
}));
list.Add(sUser.Download(ImageAssetBundleManager.headUrl, versions.head_img, (AssetBundle assetbundle) => {
AvatarSpriteAsset.assetbundle = assetbundle;
ImageAssetBundleManager.head = AvatarSpriteAsset.Data.meshs;
}));
list.Add(sUser.Download(ImageAssetBundleManager.clothesUrl, versions.clothes_img, (AssetBundle assetbundle) => {
AvatarSpriteAsset.assetbundle = assetbundle;
ImageAssetBundleManager.clothes = AvatarSpriteAsset.Data.meshs;
}));
list.Add(sUser.Download(ImageAssetBundleManager.weaponUrl, versions.weapon_img, (AssetBundle assetbundle) => {
AvatarSpriteAsset.assetbundle = assetbundle;
ImageAssetBundleManager.weapon = AvatarSpriteAsset.Data.meshs;
}));
list.Add(sUser.Download(ImageAssetBundleManager.equipmentIconUrl, versions.equipmenticon_icon, (AssetBundle assetbundle) => {
ImageAssetBundleManager.equipmentIcon = assetbundle;
}, false));
list.Add(sUser.Download(CharacterAsset.Url, versions.character, (AssetBundle assetbundle) => {
CharacterAsset.assetbundle = assetbundle;
CharacterCacher.Instance.Reset(CharacterAsset.Data.characters);
CharacterAsset.Clear();
}));
list.Add(sUser.Download(BattlefieldAsset.Url, versions.battlefield, (AssetBundle assetbundle) => {
BattlefieldAsset.assetbundle = assetbundle;
BattlefieldCacher.Instance.Reset(BattlefieldAsset.Data.battlefields);
BattlefieldAsset.Clear();
}));
list.Add(sUser.Download(SkillAsset.Url, versions.skill, (AssetBundle assetbundle) => {
SkillAsset.assetbundle = assetbundle;
SkillCacher.Instance.Reset(SkillAsset.Data.skills);
SkillAsset.Clear();
}));
list.Add(sUser.Download(NpcAsset.Url, versions.npc, (AssetBundle assetbundle) => {
NpcAsset.assetbundle = assetbundle;
NpcCacher.Instance.Reset(NpcAsset.Data.npcs);
NpcAsset.Clear();
}));
list.Add(sUser.Download(TileAsset.Url, versions.tile, (AssetBundle assetbundle) => {
TileAsset.assetbundle = assetbundle;
TileCacher.Instance.Reset(TileAsset.Data.tiles);
TileAsset.Clear();
}));
list.Add(sUser.Download(HorseAsset.Url, versions.horse, (AssetBundle assetbundle) => {
HorseAsset.assetbundle = assetbundle;
EquipmentCacher.Instance.ResetHorse(HorseAsset.Data.equipments);
HorseAsset.Clear();
}));
list.Add(sUser.Download(WeaponAsset.Url, versions.weapon, (AssetBundle assetbundle) => {
WeaponAsset.assetbundle = assetbundle;
EquipmentCacher.Instance.ResetWeapon(WeaponAsset.Data.equipments);
WeaponAsset.Clear();
}));
list.Add(sUser.Download(ClothesAsset.Url, versions.clothes, (AssetBundle assetbundle) => {
ClothesAsset.assetbundle = assetbundle;
EquipmentCacher.Instance.ResetClothes(ClothesAsset.Data.equipments);
ClothesAsset.Clear();
}));
list.Add(sUser.Download(ConstantAsset.Url, versions.constant, (AssetBundle assetbundle) => {
ConstantAsset.assetbundle = assetbundle;
Global.Constant = ConstantAsset.Data.constant;
}));
float step = 100f / list.Count;
for (int i = 0; i < list.Count; i++)
{
//CLoadingDialog.SetNextProgress((i + 1) * step);
yield return(AppManager.CurrentScene.StartCoroutine(list[i]));
}
yield return(0);
}
public Tile(int id, int health, TileAsset asset)
{
this._id = id;
this._health = health;
this._asset = asset;
}
private void ImportTileAssets(string ModPath)
{
//Find files in the dir
DirectoryInfo dir = new DirectoryInfo(ModPath + "/TileAssets");
FileInfo[] files = dir.GetFiles("*.asset.json", SearchOption.AllDirectories);
//for every file in that dir parse json :D
foreach (FileInfo file in files)
{
//JSON
string json = File.ReadAllText(file.FullName);
JToken jObject = JToken.Parse(json);
//Name
string name = "New TileAsset"; ///DEFAULT VALUE
if (jObject["Name"] != null)
{
name = jObject["Name"].ToObject <string>(); ///IF JSON CONTAINS CHANGE VALUE
}
//Model
GameObject model = null;
string modelName = "UNDEFINED";
if (jObject["Model"] != null)
{
modelName = jObject["Model"].ToObject <string>();
}
if (modelName != "UNDEFINED")
{
Models.TryGetValue(modelName, out model);
}
if (model == null)
{
model = defaultModel;
}
//Create 'prefab'
///Create TileAsset with model copy as child
GameObject TileAsset = new GameObject(name);
TileAsset.transform.SetParent(PrefabHolder);
GameObject assetModel = Instantiate(model, TileAsset.transform);
assetModel.name = "Model";
assetModel.transform.position = new Vector3(0f, 0f, .3f);
//Chance
int chance = 0;
if (jObject["SpawnChance"] != null)
{
chance = jObject["SpawnChance"].ToObject <int>();
}
//SizeRange
float[] ranges = new float[] { 1, 1 };
if (jObject["SizeRange"] != null)
{
ranges = jObject["SizeRange"].ToObject <float[]>();
}
Vector2 sizeRange = new Vector2(ranges[0], ranges[1]);
//AssetInteractions
List <string> interactions = new List <string>();
if (jObject["Interactions"] != null)
{
interactions = jObject["Interactions"].ToObject <List <string> >();
}
List <AssetInteraction> assetInteractions = new List <AssetInteraction>();
foreach (string interaction in interactions)
{
AssetInteraction _Interaction;
if (AssetInteractions.TryGetValue(interaction, out _Interaction))
{
assetInteractions.Add(_Interaction);
}
}
//Create TileAsset
TileAsset ta = TileAsset.AddComponent <TileAsset>();
ta.Setup(name, TileAsset, chance, sizeRange, assetInteractions);
TileAssets.Add(name, ta);
}
}
public IEnumerator Init(MVersion versions)
{
CScene scene = SceneManager.CurrentScene;
SUser sUser = Global.SUser;
List <IEnumerator> list = new List <IEnumerator>();
list.Add(sUser.Download(PromptMessageAsset.Url, versions.prompt_message, (AssetBundle assetbundle) => {
Debug.Log("CLogo assetbundle=" + assetbundle);
PromptMessageAsset.assetbundle = assetbundle;
}));
list.Add(sUser.Download(LanguageAsset.WORD_URL, versions.word, (AssetBundle assetbundle) => {
LanguageAsset.assetbundle = assetbundle;
Language.Reset(LanguageAsset.Data.words);
LanguageAsset.Clear();
}));
list.Add(sUser.Download(ImageAssetBundleManager.horseUrl, versions.horse_img, (AssetBundle assetbundle) => {
AvatarSpriteAsset.assetbundle = assetbundle;
ImageAssetBundleManager.horse = AvatarSpriteAsset.Data.meshs;
}));
list.Add(sUser.Download(ImageAssetBundleManager.headUrl, versions.head_img, (AssetBundle assetbundle) => {
AvatarSpriteAsset.assetbundle = assetbundle;
ImageAssetBundleManager.head = AvatarSpriteAsset.Data.meshs;
}));
list.Add(sUser.Download(ImageAssetBundleManager.clothesUrl, versions.clothes_img, (AssetBundle assetbundle) => {
AvatarSpriteAsset.assetbundle = assetbundle;
ImageAssetBundleManager.clothes = AvatarSpriteAsset.Data.meshs;
}));
list.Add(sUser.Download(ImageAssetBundleManager.weaponUrl, versions.weapon_img, (AssetBundle assetbundle) => {
AvatarSpriteAsset.assetbundle = assetbundle;
ImageAssetBundleManager.weapon = AvatarSpriteAsset.Data.meshs;
}));
list.Add(sUser.Download(WorldAsset.Url, versions.world, (AssetBundle assetbundle) => {
WorldAsset.assetbundle = assetbundle;
Global.worlds = WorldAsset.Data.worlds;
}));
list.Add(sUser.Download(ConstantAsset.Url, versions.constant, (AssetBundle assetbundle) => {
ConstantAsset.assetbundle = assetbundle;
Global.Constant = ConstantAsset.Data.constant;
}));
list.Add(sUser.Download(NpcAsset.Url, versions.npc, (AssetBundle assetbundle) => {
NpcAsset.assetbundle = assetbundle;
NpcCacher.Instance.Reset(NpcAsset.Data.npcs);
NpcAsset.Clear();
}));
list.Add(sUser.Download(NpcEquipmentAsset.Url, versions.npc_equipment, (AssetBundle assetbundle) => {
NpcEquipmentAsset.assetbundle = assetbundle;
NpcEquipmentCacher.Instance.Reset(NpcEquipmentAsset.Data.npc_equipments);
NpcEquipmentAsset.Clear();
}));
list.Add(sUser.Download(CharacterStarAsset.Url, versions.characterstar, (AssetBundle assetbundle) => {
CharacterStarAsset.assetbundle = assetbundle;
CharacterStarCacher.Instance.Reset(CharacterStarAsset.Data.characterStars);
CharacterStarAsset.Clear();
}));
/*list.Add(sUser.Download(AreaAsset.Url, versions.area, (AssetBundle assetbundle)=>{
* AreaAsset.assetbundle = assetbundle;
* AreaCacher.Instance.Reset(AreaAsset.Data.areas);
* AreaAsset.Clear();
* }));*/
list.Add(sUser.Download(ItemAsset.Url, versions.item, (AssetBundle assetbundle) => {
ItemAsset.assetbundle = assetbundle;
ItemCacher.Instance.Reset(ItemAsset.Data.items);
ItemAsset.Clear();
}));
/*list.Add(sUser.Download(MissionAsset.Url, versions.mission, (AssetBundle assetbundle)=>{
* MissionAsset.assetbundle = assetbundle;
* MissionCacher.Instance.Reset(MissionAsset.Data.missions);
* MissionAsset.Clear();
* }));*/
list.Add(sUser.Download(SkillAsset.Url, versions.skill, (AssetBundle assetbundle) => {
SkillAsset.assetbundle = assetbundle;
SkillCacher.Instance.Reset(SkillAsset.Data.skills);
SkillAsset.Clear();
}));
list.Add(sUser.Download(StrategyAsset.Url, versions.strategy, (AssetBundle assetbundle) => {
StrategyAsset.assetbundle = assetbundle;
StrategyCacher.Instance.Reset(StrategyAsset.Data.strategys);
StrategyAsset.Clear();
}));
list.Add(sUser.Download(ExpAsset.Url, versions.exp, (AssetBundle assetbundle) => {
ExpAsset.assetbundle = assetbundle;
ExpCacher.Instance.Reset(ExpAsset.Data.exps);
ExpAsset.Clear();
}));
list.Add(sUser.Download(BattlefieldAsset.Url, versions.battlefield, (AssetBundle assetbundle) => {
BattlefieldAsset.assetbundle = assetbundle;
BattlefieldCacher.Instance.Reset(BattlefieldAsset.Data.battlefields);
BattlefieldAsset.Clear();
}));
list.Add(sUser.Download(BuildingAsset.Url, versions.building, (AssetBundle assetbundle) => {
BuildingAsset.assetbundle = assetbundle;
BuildingCacher.Instance.Reset(BuildingAsset.Data.buildings);
BuildingAsset.Clear();
}));
list.Add(sUser.Download(BaseMapAsset.Url, versions.top_map, (AssetBundle assetbundle) => {
BaseMapAsset.assetbundle = assetbundle;
BaseMapCacher.Instance.Reset(BaseMapAsset.Data.baseMaps);
BaseMapAsset.Clear();
}));
list.Add(sUser.Download(CharacterAsset.Url, versions.character, (AssetBundle assetbundle) => {
CharacterAsset.assetbundle = assetbundle;
CharacterCacher.Instance.Reset(CharacterAsset.Data.characters);
CharacterAsset.Clear();
}));
list.Add(sUser.Download(TileAsset.Url, versions.tile, (AssetBundle assetbundle) => {
TileAsset.assetbundle = assetbundle;
TileCacher.Instance.Reset(TileAsset.Data.tiles);
TileAsset.Clear();
}));
list.Add(sUser.Download(LoginBonusAsset.Url, versions.loginbonus, (AssetBundle assetbundle) => {
LoginBonusAsset.assetbundle = assetbundle;
LoginBonusCacher.Instance.Reset(LoginBonusAsset.Data.loginbonuses);
LoginBonusAsset.Clear();
}));
list.Add(sUser.Download(ImageAssetBundleManager.mapUrl, versions.map, (AssetBundle assetbundle) => {
ImageAssetBundleManager.map = assetbundle;
}, false));
list.Add(sUser.Download(ImageAssetBundleManager.equipmentIconUrl, versions.equipmenticon_icon, (AssetBundle assetbundle) => {
ImageAssetBundleManager.equipmentIcon = assetbundle;
}, false));
list.Add(sUser.Download(ImageAssetBundleManager.itemIconUrl, versions.item_icon, (AssetBundle assetbundle) => {
ImageAssetBundleManager.itemIcon = assetbundle;
}, false));
list.Add(sUser.Download(ImageAssetBundleManager.skillIconUrl, versions.skill_icon, (AssetBundle assetbundle) => {
ImageAssetBundleManager.skillIcon = assetbundle;
}, false));
list.Add(sUser.Download(HorseAsset.Url, versions.horse, (AssetBundle assetbundle) => {
HorseAsset.assetbundle = assetbundle;
EquipmentCacher.Instance.ResetHorse(HorseAsset.Data.equipments);
HorseAsset.Clear();
}));
list.Add(sUser.Download(WeaponAsset.Url, versions.weapon, (AssetBundle assetbundle) => {
WeaponAsset.assetbundle = assetbundle;
EquipmentCacher.Instance.ResetWeapon(WeaponAsset.Data.equipments);
WeaponAsset.Clear();
}));
list.Add(sUser.Download(ClothesAsset.Url, versions.clothes, (AssetBundle assetbundle) => {
ClothesAsset.assetbundle = assetbundle;
EquipmentCacher.Instance.ResetClothes(ClothesAsset.Data.equipments);
ClothesAsset.Clear();
}));
list.Add(sUser.Download(StoryProgressAsset.Url, versions.character, (AssetBundle assetbundle) => {
StoryProgressAsset.assetbundle = assetbundle;
foreach (string key in StoryProgressAsset.Data.keys)
{
App.Util.LSharp.LSharpVarlable.SetVarlable(key, "0");
}
StoryProgressAsset.Clear();
}));
if (App.Util.Global.SUser.self != null)
{
list.Add(sUser.RequestGet());
}
float step = 100f / list.Count;
for (int i = 0; i < list.Count; i++)
{
CLoadingDialog.SetNextProgress((i + 1) * step);
yield return(scene.StartCoroutine(list[i]));
}
yield return(0);
}
public void Generate()
{
//Debug.Log("Generate");
tileDEBUG.AddRange(tiles.Values);
tileCoordsDEBUG.AddRange(tiles.Keys);
HexData hexData = new HexData(Game.instance.gameConfig.hexSize);
for (int r = -Game.instance.gameConfig.chunkSize / 2; r <= Game.instance.gameConfig.chunkSize / 2; r++)
{
for (int q = -Game.instance.gameConfig.chunkSize / 2; q <= Game.instance.gameConfig.chunkSize / 2; q++)
{
GameObject tileGO = tiles[new Vector3(r, q, -r - q)].gameObject;
int xr = (int)(r + Game.instance.gameConfig.chunkSize * coords.x);
int yq = (int)(q + Game.instance.gameConfig.chunkSize * coords.y);
Tile tile = tileGO.GetComponent <Tile>();
tile.coords = new Vector3(xr, yq, -xr - yq);
tile.chunk = this;
tile.biome = "randomBiome";
tile.tileType = "randomTileType";
Vector3 pos = new Vector3(
tileGO.transform.localPosition.x,
World.instance.HeightMap2(tile),
tileGO.transform.localPosition.z
);
tileGO.transform.localPosition = pos;
tileGO.name = "Tile (" + xr + ", " + yq + ")";
if (pos.y < World.instance.waterThreshold)
{
tile.SetColor(World.instance.water);
}
else if (pos.y < World.instance.grassThreshold)
{
tile.SetColor(World.instance.grass);
if (Random.Range(0, World.instance.generalTileAssetChance) == 0)
{
List <TileAsset> tileAssets = World.instance.tileAssets;
List <int> usedRots = new List <int>();
usedRots.Add(-1);
for (int i = 0; i < Random.Range(0, tileAssets.Count) || i < World.instance.maxAssetsPerTile; i++)
{
TileAsset asset = tileAssets[Random.Range(0, tileAssets.Count)];
if (Random.Range(0, asset.chance) == 0)
{
GameObject assetGO = Instantiate(asset.gameObject, tile.transform);
assetGO.name.Replace("(Clone)", "");
float scale = Random.Range(asset.sizeRange.x, asset.sizeRange.y);
assetGO.transform.localScale = new Vector3(scale, scale, scale);
int rotation = -1;
while (usedRots.Contains(rotation))
{
rotation = Random.Range(0, 5);
}
usedRots.Add(rotation);
assetGO.transform.Rotate(new Vector3(0f, rotation * 60f, 0f));
}
}
}
}
else
{
tile.SetColor(World.instance.stone);
}
}
}
}
