// ===============================================================================
// MAP RELATED
// ===============================================================================
// -------------------------------------------------------------------------------
// LoadDungeon
// -------------------------------------------------------------------------------
public DungeonMap LoadDungeon(TemplateMetaDungeon mapConfig)
{
DungeonMap map = null;
if (mapConfig == null)
{
throw new ArgumentException("No map configuration available!");
}
if (mapConfig.mapFile == null)
{
throw new ArgumentException("No map file available in map configuration: " + mapConfig);
}
map = new DungeonMap(mapConfig.mapFile.height, mapConfig.mapFile.width);
for (int x = 0; x < mapConfig.mapFile.width; x++)
{
for (int y = 0; y < mapConfig.mapFile.height; y++)
{
ScriptableTile tile = mapConfig.mapFile.map[x + y * mapConfig.mapFile.width];
map.SetTile(x, y, tile);
}
}
if (map == null)
{
throw new ArgumentException("Loaded map is empty!");
}
return(map);
}
private void InitBridge(Bridge bridge, Vector3Int cellPosition)
{
if (bridge)
{
ScriptableTile xm = tilemap.GetTile <ScriptableTile>(cellPosition + new Vector3Int(-1, 0, 0));
ScriptableTile xp = tilemap.GetTile <ScriptableTile>(cellPosition + new Vector3Int(1, 0, 0));
bool xmIsWater = xm && xm.ground && xm.ground.GetComponent <Water>() && !xm.ground.GetComponent <Bridge>();
bool xpIsWater = xp && xp.ground && xp.ground.GetComponent <Water>() && !xp.ground.GetComponent <Bridge>();
bridge.Initialize(!xmIsWater && !xpIsWater);
}
}
// -------------------------------------------------------------------------------
// LoadFloor
// -------------------------------------------------------------------------------
public void LoadFloor()
{
interactables.Clear();
if (currentDungeonConfig != null)
{
map = LoadDungeon(currentDungeonConfig);
}
if (map != null)
{
LoadMapConfig();
ClearMap();
for (int x = 0; x < map.Size.x; x++)
{
for (int y = 0; y < map.Size.y; y++)
{
ScriptableTile tile = map.GetTile(x, y);
if (tile is DungeonTileStart)
{
startPos = new Vector3(x, Finder.navi.baseHeightOffset, y);
startDir = Vector3Helper.CardinalDirection(((DungeonTileStart)tile).facingDirection);
CreateDungeonFloor(x, y, false, ((DungeonTileStart)tile).floorPrefab);
CreateDungeonCeiling(x, y, ((DungeonTileStart)tile).ceilingPrefab);
}
else if (tile is DungeonTileWall)
{
CreateDungeonFloor(x, y, true, ((DungeonTileWall)tile).floorPrefab);
CreateDungeonWall(x, y, ((DungeonTileWall)tile));
CreateDungeonCeiling(x, y, ((DungeonTileWall)tile).ceilingPrefab);
}
else if (tile is DungeonTileFloor)
{
CreateDungeonFloor(x, y, true, ((DungeonTileFloor)tile).floorPrefab, (DungeonTileFloor)tile);
CreateDungeonCeiling(x, y, ((DungeonTileFloor)tile).ceilingPrefab, (DungeonTileFloor)tile);
}
else if (tile is DungeonTileEvent)
{
CreateDungeonObject(x, y, (DungeonTileEvent)tile);
CreateDungeonFloor(x, y, false, ((DungeonTileEvent)tile).floorPrefab);
CreateDungeonCeiling(x, y, ((DungeonTileEvent)tile).ceilingPrefab);
}
}
}
}
else
{
throw new InvalidOperationException("tile map could not be loaded from map config!");
}
}
private void CommonRessourceCollectionResolve()
{
ResourceData resData = ResourceDictionary.instance.resourcesFromType[lastInteraction];
GameObject rootGameobject = MapModifier.instance.grid.GetRootOf(hoveredInteractor.transform.parent.gameObject);
MapModifier.instance.grid.MakeObjectInteractable(rootGameobject);
// play sound, and juice, and update inventory
AudioClip soundFx = resData.collectingSound[Random.Range(0, resData.collectingSound.Count)];
audiosource.clip = soundFx;
if (soundFx)
{
audiosource.Play();
}
int gain = Random.Range(1, 4);
interactionJuicer.LaunchGainAnim("+" + gain.ToString(), lastInteraction);
inventory.AddItem(ResourceDictionary.instance.GetResourceItem(resData.interactionType).Summarize(), gain);
playerController.RecomputeLoadFactor();
// decrement interactor ressource count
CollectData data = hoveredInteractor.GetComponent <CollectData>();
data.ressourceCount--;
if (data.ressourceCount <= 0)
{
ScriptableTile tile = (lastInteraction == InteractionType.Type.collectWheat) ? MapModifier.instance.tileDictionary["Dirt"] : MapModifier.instance.tileDictionary["Grass"];
Vector3Int cellPosition = MapModifier.instance.WorldToCell(hoveredInteractor.transform.parent.position);
MapModifier.instance.tilemap.SetTile(cellPosition, tile);
MapModifier.instance.tilemap.SetTransformMatrix(cellPosition, Matrix4x4.identity);
Destroy(hoveredInteractor.transform.parent.gameObject);
interactionTime = 0f;
interacting = false;
hoveredInteractor = null;
animator.SetBool("interaction", false);
}
// stop interaction loop if needed
if (!inventory.HasSpace())
{
ComputeInteractionConditions(lastInteraction);
UpdateHelp();
interactionTime = 0f;
interacting = false;
animator.SetBool("interaction", false);
}
}
public TileGameObject OverrideTile(ScriptableTile tile, Matrix4x4 matrix, Vector3Int cellPosition, bool forceUpdate)
{
RemoveTileAt(cellPosition, forceUpdate);
tilemap.SetTile(cellPosition, tile);
tilemap.SetTransformMatrix(cellPosition, matrix);
TileGameObject result = PlaceTile(tile, cellPosition, forceUpdate);
if (tile.neighbourUpdate)
{
NeighbourgRefresh(cellPosition, forceUpdate);
}
return(result);
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
ScriptableTile scriptableTile = (ScriptableTile)target;
GUILayout.BeginHorizontal();
if (GUILayout.Button("<<", GUILayout.ExpandWidth(false)))
{
scriptableTile.DecrMovCost();
}
EditorGUILayout.LabelField("Movement Cost: " + scriptableTile.moveCost, GUILayout.ExpandWidth(false));
if (GUILayout.Button(">>", GUILayout.ExpandWidth(false)))
{
scriptableTile.IncrMovCost();
}
GUILayout.EndHorizontal();
}
private void InitWater(Water water, Vector3Int cellPosition)
{
if (water)
{
ScriptableTile xm = tilemap.GetTile <ScriptableTile>(cellPosition + new Vector3Int(-1, 0, 0));
ScriptableTile xp = tilemap.GetTile <ScriptableTile>(cellPosition + new Vector3Int(1, 0, 0));
ScriptableTile zm = tilemap.GetTile <ScriptableTile>(cellPosition + new Vector3Int(0, -1, 0));
ScriptableTile zp = tilemap.GetTile <ScriptableTile>(cellPosition + new Vector3Int(0, 1, 0));
bool xmb = (xm && xm.ground && (xm.ground.name == "Water" || xm.ground.name == "Bridge"));
bool xpb = (xp && xp.ground && (xp.ground.name == "Water" || xp.ground.name == "Bridge"));
bool zmb = (zm && zm.ground && (zm.ground.name == "Water" || zm.ground.name == "Bridge"));
bool zpb = (zp && zp.ground && (zp.ground.name == "Water" || zp.ground.name == "Bridge"));
water.InitializeFromPool(xpb, xmb, zmb, zpb);
}
}
private void InitWall(Wall wall, Vector3Int cellPosition, string tileName)
{
if (wall)
{
ScriptableTile xm = tilemap.GetTile <ScriptableTile>(cellPosition + new Vector3Int(-1, 0, 0));
ScriptableTile xp = tilemap.GetTile <ScriptableTile>(cellPosition + new Vector3Int(1, 0, 0));
ScriptableTile zm = tilemap.GetTile <ScriptableTile>(cellPosition + new Vector3Int(0, -1, 0));
ScriptableTile zp = tilemap.GetTile <ScriptableTile>(cellPosition + new Vector3Int(0, 1, 0));
bool xmb = (xm && xm.building && xm.building.name.Contains("Wall"));
bool xpb = (xp && xp.building && xp.building.name.Contains("Wall"));
bool zmb = (zm && zm.building && zm.building.name.Contains("Wall"));
bool zpb = (zp && zp.building && zp.building.name.Contains("Wall"));
wall.Initialize(xpb, xmb, zmb, zpb, tileName);
}
}
// internal
private void InitDirt(Dirt dirt, Vector3Int cellPosition)
{
if (dirt)
{
ScriptableTile xm = tilemap.GetTile <ScriptableTile>(cellPosition + new Vector3Int(-1, 0, 0));
ScriptableTile xp = tilemap.GetTile <ScriptableTile>(cellPosition + new Vector3Int(1, 0, 0));
ScriptableTile zm = tilemap.GetTile <ScriptableTile>(cellPosition + new Vector3Int(0, -1, 0));
ScriptableTile zp = tilemap.GetTile <ScriptableTile>(cellPosition + new Vector3Int(0, 1, 0));
bool xmb = (xm && xm.ground && (xm.ground.GetComponent <Dirt>() != null || xm.ground.name == "Bridge"));
bool xpb = (xp && xp.ground && (xp.ground.GetComponent <Dirt>() != null || xp.ground.name == "Bridge"));
bool zmb = (zm && zm.ground && (zm.ground.GetComponent <Dirt>() != null || zm.ground.name == "Bridge"));
bool zpb = (zp && zp.ground && (zp.ground.GetComponent <Dirt>() != null || zp.ground.name == "Bridge"));
dirt.InitializeFromPool(xpb, xmb, zmb, zpb);
}
}
// [MenuItem ("Assets/Create/test", false)]
public static void CreateInstance()
{
GenericMenu menu = new GenericMenu();
AssetDatabase.Refresh();
string [] guids = AssetDatabase.FindAssets(string.Format("t:{0}", typeof(ScriptableTile)));
for (int i = 0; i < guids.Length; i++)
{
string assetPath = AssetDatabase.GUIDToAssetPath(guids [i]);
ScriptableTile asset = AssetDatabase.LoadAssetAtPath <ScriptableTile> (assetPath);
if (asset != null)
{
menu.AddItem(new GUIContent(asset.name), true, () => { CreateAsset(asset.GetType()); });
}
}
// menu.ShowAsContext ();
menu.DropDown(new Rect(100, 100, 100, 100));
}
private void InitStone(Stone stone, Vector3Int cellPosition)
{
if (stone)
{
BoundsInt area = new BoundsInt();
area.min = cellPosition + new Vector3Int(-1, -1, 0);
area.max = cellPosition + new Vector3Int(2, 2, 1);
TileBase[] neighbours = tilemap.GetTilesBlock(area);
int grassNeighbours = 0;
for (int i = 0; i < neighbours.Length; i++)
{
ScriptableTile n = (ScriptableTile)neighbours[i];
if (n && (n.name == "Grass" || n.name.Contains("Crop")))
{
grassNeighbours++;
}
}
stone.Initialize(2 - grassNeighbours / 3);
}
}
private void InitFences(Fences fence, Vector3Int cellPosition, string tileName)
{
if (fence)
{
ScriptableTile xm = tilemap.GetTile <ScriptableTile>(cellPosition + new Vector3Int(-1, 0, 0));
ScriptableTile xp = tilemap.GetTile <ScriptableTile>(cellPosition + new Vector3Int(1, 0, 0));
ScriptableTile zm = tilemap.GetTile <ScriptableTile>(cellPosition + new Vector3Int(0, -1, 0));
ScriptableTile zp = tilemap.GetTile <ScriptableTile>(cellPosition + new Vector3Int(0, 1, 0));
bool xmb = (xm && xm.building && xm.building.name.Contains("Fence"));
bool xpb = (xp && xp.building && xp.building.name.Contains("Fence"));
bool zmb = (zm && zm.building && zm.building.name.Contains("Fence"));
bool zpb = (zp && zp.building && zp.building.name.Contains("Fence"));
if (!xmb || !xpb || !zmb || !zpb)
{
fence.Initialize(xpb, xmb, zmb, zpb, tileName);
}
else
{
Destroy(fence.gameObject);
}
}
}
public void SetTile(int x, int y, ScriptableTile scriptableTile)
{
tiles[x, y] = scriptableTile;
}
public TileGameObject PlaceTile(ScriptableTile tile, Vector3Int cellPosition, bool forceUpdate)
{
TileGameObject tileGameObject = new TileGameObject();
Vector3 tileCenter = GetTileCenter(cellPosition);
// ground prefab
if (tile.ground)
{
GameObject terrain = InstantiateGameObject(tile.ground);
terrain.transform.localPosition = tileCenter;
terrain.transform.localEulerAngles = new Vector3(0, -tilemap.GetTransformMatrix(cellPosition).rotation.eulerAngles.z, 0);
terrain.SetActive(true);
InitDirt(terrain.GetComponent <Dirt>(), cellPosition);
InitWater(terrain.GetComponent <Water>(), cellPosition);
InitBridge(terrain.GetComponent <Bridge>(), cellPosition);
grid.AddGameObject(terrain, ConstructionLayer.LayerType.Terrain, true, forceUpdate);
tileGameObject.terrain = terrain;
}
// building prefab
if (tile.building)
{
GameObject building = InstantiateGameObject(tile.building);
building.transform.localPosition = tileCenter;
building.transform.localEulerAngles = new Vector3(0, 90 - tilemap.GetTransformMatrix(cellPosition).rotation.eulerAngles.z, 0);
building.SetActive(true);
InitWall(building.GetComponent <Wall>(), cellPosition, tile.name);
InitFences(building.GetComponent <Fences>(), cellPosition, tile.name);
if (tile.resourceContainer)
{
InitResourceContainer(building, cellPosition);
}
grid.AddGameObject(building, ConstructionLayer.LayerType.Building, true, forceUpdate);
tileGameObject.building = building;
}
// decoration prefab
if (tile.decoration)
{
GameObject decoration = InstantiateGameObject(tile.decoration);
decoration.transform.localPosition = tileCenter + new Vector3(Random.Range(tile.decorationNoisePosition.x, tile.decorationNoisePosition.y), 0, Random.Range(tile.decorationNoisePosition.x, tile.decorationNoisePosition.y));
decoration.transform.localEulerAngles = new Vector3(0, Random.Range(tile.decorationNoiseRotation.x, tile.decorationNoiseRotation.y), 0);
float scale = tile.decorationNoiseScale == Vector2.zero ? 1 : Random.Range(tile.decorationNoiseScale.x, tile.decorationNoiseScale.y);
decoration.transform.localScale = new Vector3(scale, scale, scale);
InitTree(decoration.GetComponent <TreeStandard>(), cellPosition);
InitStone(decoration.GetComponent <Stone>(), cellPosition);
InitMineral(decoration.GetComponent <MineralRessource>(), cellPosition, tile.optionalMaterial);
grid.AddGameObject(decoration, ConstructionLayer.LayerType.Decoration, true, forceUpdate);
tileGameObject.decoration = decoration;
}
if (!tileObjects.ContainsKey(cellPosition))
{
tileObjects.Add(cellPosition, tileGameObject);
}
else
{
Debug.LogWarning("already a tile Here !!");
}
return(tileGameObject);
}
/// <summary> Get scriptable tile script and load up all values to grid point object</summary>
public void RefreshScriptableTile()
{
scriptableTile = gridManager.ReferenceTiles[identity].GetComponent<ScriptableTile>();
}
