public static TileDefinition SetTileItem(TileDefinition tileDefinition, TileBase item, int index)
{
TileDefinition def = tileDefinition;
if (index == 0)
{
def.plenum = (Plenum)item;
}
else if (index == 1)
{
def.turf = (Turf)item;
}
// We are a fixture
else if (index > 1 && index < (2 + TileDefinition.GetAllFixtureLayerSize()))
{
def.fixtures.SetFixtureAtIndex((Fixture)item, index - 2);
}
else
{
Debug.LogWarning("Out of range tile item was tried to be set");
}
return(def);
}
public TileModel(Guid tileIid, TileDefinition def)
{
id = tileIid;
title = def.Title;
wide = def.IsWide;
url = def.Url;
}
public TileDefinition[,] Load()
{
var doc = XDocument.Parse(_Xml);
var tiles = new List <(Position pos, TileDefinition definition)>();
foreach (var tile in doc.Root.Elements())
{
var objectElem = tile.Element("Object");
var objectType = objectElem == null ? MapObjectType.None : ParseEnum <MapObjectType>(objectElem.Value);
tiles.Add((ExtractPosition(tile), new TileDefinition(ParseEnum <GroundType>(tile.Element("Ground").Value), objectType)));
}
var mapWidth = tiles.Max(t => t.pos.X) + 1;
var mapHeight = tiles.Max(t => t.pos.Y) + 1;
var tilesArray = new TileDefinition[mapWidth, mapHeight];
foreach (var tile in tiles)
{
tilesArray[tile.pos.X, tile.pos.Y] = tile.definition;
}
return(tilesArray);
}
/**
* Adjusts the connections value based on the given new tile.
* Returns whether value changed.
*/
private bool UpdateSingleConnection(Direction direction, TileDefinition tile)
{
int index = LayerIndex;
if (index == 0)
{
index = 17; // Hardcoded to the Fixture layer until I got a better solution for this. Is needed to make Airlocks connect to walls
}
bool isGeneric = (tile.turf && (tile.turf.genericType == genericType || genericType == null));
if (tile.fixtures != null)
{
isGeneric = isGeneric || (tile.fixtures.GetFixtureAtLayerIndex(index) && (tile.fixtures.GetFixtureAtLayerIndex(index).genericType == genericType || genericType == null));
}
bool isSpecific = (tile.turf && (tile.turf.id == id || id == null));
if (tile.fixtures != null)
{
isSpecific = isSpecific || (tile.fixtures.GetFixtureAtLayerIndex(LayerIndex) && (tile.fixtures.GetFixtureAtLayerIndex(LayerIndex).id == id || id == null));
}
bool changed = generalAdjacents.UpdateDirection(direction, isGeneric, true);
changed |= specificAdjacents.UpdateDirection(direction, isSpecific, true);
return(changed);
}
private TileDefinition[] ParseTileDefinitions(XmlElement tilesDefinitionsXML)
{
List <TileDefinition> tiles = new List <TileDefinition>();
TileDefinition emptyTile = new TileDefinition();
emptyTile.tileType = TileDefinition.EMPTY_TILE_TYPE;
emptyTile.castShadow = false;
emptyTile.description = "Empty";
emptyTile.drawMode = TileDefinition.DrawMode.NONE;
emptyTile.energy = 0;
emptyTile.id = "empty";
//emptyTile.liquid = false;
emptyTile.materials = null;
emptyTile.solid = false;
tiles.Add(emptyTile);
byte tileId = 1;
foreach (XmlElement tileDefinitionXML in GetChildElements(tilesDefinitionsXML))
{
tiles.Add(ParseTileDefinition(tileId++, tileDefinitionXML));
}
return(tiles.ToArray());
}
/**
* When a single adjacent turf is updated
*/
public void UpdateSingle(Direction direction, TileDefinition tile)
{
if (UpdateSingleConnection(direction, tile))
{
UpdateMeshAndDirection();
}
}
private int Step()
{
s_StepPerfMarker.Begin();
int activeTiles = 0;
bool overPressureEvent = false;
// Step 1: Calculate flux
foreach (AtmosObject tile in atmosTiles)
{
if (tile.GetState() == AtmosStates.Active)
{
tile.CalculateFlux();
}
}
// Step 2: Simulate
foreach (TileObject tile in tileObjects)
{
AtmosStates state = tile.atmos.GetState();
switch (state)
{
case AtmosStates.Active:
tile.atmos.SimulateFlux();
activeTiles++;
break;
case AtmosStates.Semiactive:
tile.atmos.SimulateFlux();
break;
}
// Step 3: Move items according to the wind velocity
Vector2 velocity = tile.atmos.GetVelocity();
if (velocity != Vector2.zero)
{
MoveVelocity(tile);
}
// Step 4: Destroy tiles with to much pressure
if (tile.atmos.CheckOverPressure() && !overPressureEvent)
{
TileDefinition oldDefinition = tile.Tile;
if (oldDefinition.turf?.isWall == true)
{
oldDefinition.turf = floor;
tileManager.UpdateTile(tile.transform.position, oldDefinition);
tile.atmos.SetBlocked(false);
overPressureEvent = true;
}
}
}
// Step 5: Do pumps and pipes as well
StepDevices();
StepPipe();
s_StepPerfMarker.End();
return(activeTiles);
}
public void Clear(int biomeID)
{
this.Entities.Clear();
this.GetToken("biome").Value = biomeID;
this.GetToken("music").Text = BiomeData.Biomes[biomeID].Music;
var ground = TileDefinition.Find(BiomeData.Biomes[biomeID].GroundTile, true);
for (int row = 0; row < Height; row++)
{
for (int col = 0; col < Width; col++)
{
var def = ground;
if (Random.Flip() && def.Variants.Tokens.Count > 0)
{
var chance = Random.NextDouble();
var variants = def.Variants.Tokens.Where(v => v.Value < chance).ToArray();
if (variants.Length > 0)
{
def = TileDefinition.Find(variants.PickOne().Name);
}
}
SetTile(row, col, def);
}
}
}
/**
* When a single adjacent turf is updated
*/
public void UpdateSingle(Direction direction, TileDefinition tile)
{
if (UpdateSingleConnection(direction, tile))
{
UpdateWallCaps();
}
}
private void PaintTile()
{
Undo.RegisterFullObjectHierarchyUndo(Lvl, "Painted tile");
Vec2i tilePos = GameHelper.WorldToTilePos(GetMouseWorldPos() - (Vector2)Lvl.transform.position);
//Debug.Log("[Level] PaintTile - tilePos: " + tilePos +", GetMouseWorldPos(): "+ GetMouseWorldPos());
//if (Lvl.tileType != TileType.Empty) {
//TileDefinition tileDef = new TileDefinition { type = Lvl.tileType, goalColor = Lvl.tileGoalColor, color = (Lvl.tileType == TileType.Bucket ? Lvl.tileGoalColor : Lvl.tileColor), pos = tilePos };
TileDefinition tileDef = new TileDefinition {
type = TileType.Normal, goalColor = TileColor.None, color = TileColor.None, pos = tilePos
};
if (Lvl.Map.IsValidTile(tilePos))
{
Undo.RecordObject(Lvl.Map.GetTile(tilePos), "Painted tile");
Lvl.Map.SetTile(tilePos, tileDef);
}
else
{
Lvl.CreateTileAtPos(tilePos, tileDef);
Undo.RegisterCreatedObjectUndo(Lvl.Map.GetTile(tilePos).gameObject, "Painted tile");
}
//} else {
// Lvl.Map.DeleteTileAt(tilePos);
//}
current.Use();
}
public static void DeleteTileLayer(TileManager tileManager, int layerIndex, int x, int y)
{
if (tileManager.GetTile(x, y) == null)
{
return;
}
// Save old definition
TileDefinition oldDefinition = tileManager.GetTile(x, y).Tile;
// Copy object to avoid dupplication between editor and tilemap
if (oldDefinition.fixtures != null)
{
FixturesContainer f = (FixturesContainer)oldDefinition.fixtures.Clone();
oldDefinition.fixtures = f;
}
// Existing tile found. We try to update the non-null items in the tiledefinition
List <TileBase> tileBases = GetTileItems(oldDefinition);
for (int i = 0; i < tileBases.ToArray().Length; i++)
{
if (tileBases[i] != null && i == layerIndex)
{
oldDefinition = SetTileItem(oldDefinition, null, i);
}
}
Undo.RecordObject(tileManager.GetTile(x, y).gameObject, "Updated tile");
tileManager.EditorUpdateTile(x, y, oldDefinition);
}
private void MaybeSet(ref Tile[,] map, int x, int y, string tileName)
{
if (map[x, y].Definition.Wall && !map[x, y].Definition.CanBurn)
{
map[x, y].Index = TileDefinition.Find(tileName).Index;
}
}
public void Add(TileDefinition tile)
{
Argument.Assert.IsNotNull(tile, "tile");
if (Compare.IsNullOrEmpty(tile.LayoutId))
{
throw new PortalFatalException("Tiles require the 'LayoutId' property to be initialized before being added to a view.");
}
if (paneLookup == null)
{
paneLookup = new Dictionary <string, List <TileDefinition> >();
}
List <TileDefinition> tileList = null;
if (paneLookup.ContainsKey(tile.LayoutId))
{
tileList = paneLookup[tile.LayoutId];
}
if (tileList == null)
{
tileList = new List <TileDefinition>();
paneLookup.Add(tile.LayoutId, tileList);
}
tileList.Add(tile);
}
public virtual bool ProcessTileDamage(TilePosition pos, Tile tile, TileDefinition tileDefinition, int damage)
{
if (tileDefinition.energy != Tile.MAX_ENERGY)
{
if (tile.Energy > damage)
{
world.tileManager.SetTileEnergy(pos, (byte)(tile.Energy - damage));
world.tileManager.TileDamaged(pos);
return(false);
}
else
{
world.tileManager.DestroyTile(pos);
return(true);
}
}
else
{
//world.tileManager.DestroyTile(pos);
//return true;
return(false);
}
}
public override void Execute(TileManager tileManager, Tile tile, TilePosition pos)
{
TileDefinition tileDefinition = tileManager.GetTileDefinition(tile.tileType);
ItemDefinition itemDefinition = tileManager.world.itemManager.GetItemDefinitionById(tileDefinition.id);
tileManager.world.gameplay.CreateItem(itemDefinition, Graphics.TilePositionToVector3(pos));
}
public void SetupTile(TileDefinition tileDefinition)
{
_tileDefinition = tileDefinition;
SpriteRenderer.sprite = tileDefinition.TileSprite;
_board = transform.parent.GetComponent <Board>();
_particleSystem.startColor = _tileDefinition.EffectColor;
}
public void UpdateMapSolidity()
{
if (ParentBoard == null)
{
return;
}
ParentBoard.Tilemap[XPosition, YPosition].Definition = TileDefinition.Find(closed ? "doorwayClosed" : "doorwayOpened");
}
protected override void StartDelayed(InteractionEvent interactionEvent)
{
var tileObject = interactionEvent.Target.GetComponent <TileObject>();
TileDefinition tile = tileObject.Tile;
tile.turf = Turf;
Object.FindObjectOfType <TileManager>().UpdateTile(tileObject.transform.position, tile);
}
public void Set(TileDefinition def)
{
tileDef.color = def.color;
tileDef.goalColor = def.goalColor;
tileDef.type = def.type;
tileDef.pos = def.pos;
tileDef.paintedTurn = def.paintedTurn;
Refresh();
}
public static List <TileBase> GetTileItems(TileDefinition tileDefinition)
{
List <TileBase> items = new List <TileBase>();
items.Add(tileDefinition.plenum);
items.Add(tileDefinition.turf);
items.AddRange(tileDefinition.fixtures.GetAllFixtures());
return(items);
}
/**
* Adjusts the connections value based on the given new tile.
* Returns whether value changed.
*/
private bool UpdateSingleConnection(Direction direction, TileDefinition tile)
{
bool isConnected = (tile.turf && (tile.turf.genericType == type || type == null));
if (tile.fixtures != null)
{
isConnected = isConnected || (tile.fixtures.GetFixtureAtLayerIndex(LayerIndex) && (tile.fixtures.GetFixtureAtLayerIndex(LayerIndex).genericType == type || type == null));
}
return(adjacents.UpdateDirection(direction, isConnected, true));
}
public void Load(System.IO.BinaryReader br)
{
entries.Clear();
int n = br.ReadInt32();
for (int i = 0; i < n; i++)
{
string id = br.ReadString();
int position = br.ReadInt32();
int quantity = br.ReadInt32();
TileDefinition tileDefinition = owner.world.tileManager.GetTileDefinitionById(id);
CWObject cwobject = null;
if (tileDefinition != null)
{
//It's a tile
DynamicTile dynamicTile = new DynamicTile(owner.world, tileDefinition, -1);
cwobject = dynamicTile;
}
else
{
ItemDefinition itemDefinition = owner.world.itemManager.GetItemDefinitionById(id);
if (itemDefinition != null)
{
//It's an item
Item item;
if (itemDefinition.type == CubeWorld.World.Objects.CWDefinition.DefinitionType.ItemTile)
{
item = new ItemTile(owner.world, (ItemTileDefinition)itemDefinition, -1);
}
else
{
item = new Item(owner.world, itemDefinition, -1);
}
cwobject = item;
}
}
cwobject.Load(br);
InventoryEntry ie = new InventoryEntry();
ie.position = position;
ie.quantity = quantity;
ie.cwobject = cwobject;
entries.Add(ie);
}
}
/**
* Sets the tile at the given position
* to the currently selected tile type.
*
* Will create the tile if one does not exist
*/
public static void SetTile(TileManager tileManager, TileDefinition tileDefinition, int x, int y)
{
if (tileManager.GetTile(x, y) == null) {
tileManager.EditorCreateTile(x, y, tileDefinition);
Undo.RegisterCreatedObjectUndo(tileManager.GetTile(x, y).gameObject, "Created tile");
}
else {
Undo.RecordObject(tileManager.GetTile(x, y).gameObject, "Updated tile");
tileManager.EditorUpdateTile(x, y, tileDefinition);
}
}
/**
* Adjusts the connections value based on the given new tile.
* Returns whether value changed.
*/
private bool UpdateSingleConnection(Direction direction, TileDefinition tile)
{
bool isGeneric = (tile.turf && (tile.turf.genericType == genericType || genericType == null)) || (tile.fixture && (tile.fixture.genericType == genericType || genericType == null));
bool isSpecific = (tile.turf && (tile.turf.id == id || id == null)) || (tile.fixture && (tile.fixture.id == id || id == null));
bool changed = generalAdjacents.UpdateDirection(direction, isGeneric, true);
changed |= specificAdjacents.UpdateDirection(direction, isSpecific, true);
return(changed);
}
public void Setup(int distance, TileDefinition tileDefinition)
{
_tileDefinition = tileDefinition;
_text = GetComponentInChildren <Text>();
_text.text = ObjectiveCount.ToString();
if (ObjectiveCount > 0)
{
transform.gameObject.SetActive(true);
}
}
/**
* Adjusts the connections value based on the given new tile.
* Returns whether value changed.
*/
private bool UpdateSingleConnection(Direction direction, TileDefinition tile)
{
int index = (int)Layer;
bool isConnected = (tile.turf && (tile.turf.genericType == type || type == null));
if (tile.fixtures != null)
{
isConnected = isConnected || (tile.fixtures[index] && (tile.fixtures[index].genericType == type || type == null));
}
return(adjacents.UpdateDirection(direction, isConnected, true));
}
public TileDragHandler(TileManager tileManager, TileDefinition tileDefinition, Vector2Int mousePosition)
{
this.tileManager = tileManager;
this.tileDefinition = tileDefinition;
startPosition = mousePosition;
curPosition = mousePosition;
var tile = CreateGhostTile(tileManager, tileDefinition, " [" + mousePosition.x.ToString() + ", " + mousePosition.y.ToString() + "]");
tile.transform.position = tileManager.GetPosition(mousePosition.x, mousePosition.y);
dragTiles.Insert(0, tile);
}
public static BiomeData FromToken(Token t, int realmNum)
{
var n = new BiomeData();
n.Realm = (Realms)realmNum;
n.Name = t.Text;
var cvars = t.GetToken("rect").Text.Split(' ').Select(i => int.Parse(i)).ToArray();
n.Rect = new System.Drawing.Rectangle(cvars[0], cvars[1], cvars[2] - cvars[0], cvars[3] - cvars[1]);
n.GroundTile = (int)t.GetToken("ground").Value;
if (n.GroundTile == 0)
{
n.GroundTile = TileDefinition.Find(t.GetToken("ground").Text, true).Index;
}
var encounters = t.GetToken("encounters");
if (encounters == null)
{
n.Encounters = new string[0];
}
else
{
n.MaxEncounters = 10;
if (encounters.Value > 0)
{
n.MaxEncounters = (int)encounters.Value;
}
n.Encounters = encounters.Tokens.Select(x => x.Name).ToArray();
}
var cultures = t.GetToken("cultures");
if (cultures == null)
{
n.Cultures = new[] { "human" }
}
;
else
{
n.Cultures = cultures.Tokens.Select(x => x.Name).Where(e => Culture.Cultures.ContainsKey(e)).ToArray();
}
if (t.HasToken("music"))
{
n.Music = t.GetToken("music").Text;
}
return(n);
}
public void CreateTileAtPos(Vec2i pos, TileDefinition tileDef)
{
Tile tileInst = PrefabLibrary.I.GetTileInstance();
tileInst.Set(tileDef);
tileInst.gameObject.name = "Tile " + pos;
tileInst.transform.position = GameHelper.TileToWorldPos(pos) + (Vector2)transform.position;
tileInst.transform.SetParent(TileCont.transform);
tileInst.transform.localScale = Vector3.one;
tileMap.AddTile(tileInst);
}
/**
* Adjusts the connections value based on the given new tile.
* Returns whether value changed.
*/
private bool UpdateSingleConnection(Direction direction, TileDefinition tile)
{
bool isConnected = (tile.turf && (tile.turf.genericType == type || type == null));
if (tile.fixtures != null)
{
isConnected = isConnected || (tile.fixtures.GetFixtureAtLayerIndex(LayerIndex) && (tile.fixtures.GetFixtureAtLayerIndex(LayerIndex).genericType == type || type == null));
}
isConnected &= (AdjacencyBitmap.Adjacent(TileState.blockedDirection, direction) == 0);
return(adjacents.UpdateDirection(direction, isConnected, true));
}
/// <summary>
/// Initializes a new instance of the <see cref="Tile"/> class.
/// </summary>
/// <param name="type">The type.</param>
public Tile(TileDefinition type)
{
_definition = type;
}
public ScalableTileLayer(string name, Size mapSize, Size tileSize, TileDefinition defaultTileDefinition = null)
: base(name, mapSize, tileSize, defaultTileDefinition)
{
}
