/// <summary>
/// Reads a Vector Tile stream.
/// </summary>
/// <param name="stream">Vector tile stream.</param>
/// <param name="tileDefinition">Tile information.</param>
/// <param name="idAttributeName">Optional. Specifies the name of the attribute that the vector tile feature's ID should be stored in the NetTopologySuite Features AttributeTable.</param>
/// <returns></returns>
public VectorTile Read(Stream stream, Tiles.Tile tileDefinition, string idAttributeName)
{
// Deserialize the tile
var tile = ProtoBuf.Serializer.Deserialize <Mapbox.Tile>(stream);
var vectorTile = new VectorTile {
TileId = tileDefinition.Id
};
foreach (var mbTileLayer in tile.Layers)
{
Debug.Assert(mbTileLayer.Version == 2U);
var tgs = new TileGeometryTransform(tileDefinition, mbTileLayer.Extent);
var layer = new Layer {
Name = mbTileLayer.Name
};
foreach (var mbTileFeature in mbTileLayer.Features)
{
var feature = ReadFeature(tgs, mbTileLayer, mbTileFeature, idAttributeName);
layer.Features.Add(feature);
}
vectorTile.Layers.Add(layer);
}
return(vectorTile);
}
/// <summary>
/// Initializes this transformation utility
/// </summary>
/// <param name="tile">The tile's bounds</param>
/// <param name="extent">The tile's extent in pixel. Tiles are always square.</param>
public TileGeometryTransform(Tiles.Tile tile, uint extent) : this()
{
_tile = tile;
_extent = extent;
var meters = WebMercatorHandler.LatLonToMeters(_tile.Top, _tile.Left);
var pixels = WebMercatorHandler.MetersToPixels(meters, tile.Zoom, (int)extent);
_top = (long)pixels.y;
_left = (long)pixels.x;
}
public Snake(Tiles.Tile Tile)
{
_Texture = Tile._Texture;
//_EmptyTexture = TextureGen.CreateTexture(Width, Height, Color.Transparent);
segmentsDictionary = new Dictionary <string, SnakeSegment>();
segmentsDictionary.Add("Head", createSegment(Tile._Texture, Tile._Position, Tile._Color));
_segmentCount = segmentsDictionary.Keys.Count;
}
public override void Run(TimeSpan timeElapsed)
{
TargetPosition = Source.Position + PositionChange;
if (TargetPosition == Source.Position)
{
return;
}
bool moved = Source.MoveIn(PositionChange);
if (!moved)
{
Tiles.Tile tile = Source.CurrentMap.GetTerrain <Tiles.Tile>(TargetPosition);
if (!tile.IsWalkable)
{
BumpTile bump = new BumpTile(Source, tile);
BasicTutorial.GameState.Dungeon.ActionProcessor.PushAndRun(bump);
}
else
{
foreach (BasicEntity item in Source.CurrentMap.GetEntities <BasicEntity>(TargetPosition)) // Something blocked us
{
BumpGameObject bump = new BumpGameObject(Source, item);
BasicTutorial.GameState.Dungeon.ActionProcessor.PushAndRun(bump);
}
}
}
else if (Source == ((Tiles.TileMap)Source.CurrentMap).ControlledGameObject) // We are the player
{
if (PositionChange == Direction.LEFT)
{
BasicTutorial.GameState.Dungeon.Messages.Print("You move west.", BasicTutorial.MessageConsole.MessageTypes.Status);
}
else if (PositionChange == Direction.RIGHT)
{
BasicTutorial.GameState.Dungeon.Messages.Print("You move east.", BasicTutorial.MessageConsole.MessageTypes.Status);
}
else if (PositionChange == Direction.UP)
{
BasicTutorial.GameState.Dungeon.Messages.Print("You move north.", BasicTutorial.MessageConsole.MessageTypes.Status);
}
else if (PositionChange == Direction.DOWN)
{
BasicTutorial.GameState.Dungeon.Messages.Print("You move south.", BasicTutorial.MessageConsole.MessageTypes.Status);
}
}
Finish(ActionResult.Success);
}
/// <summary>
/// Writes the tiles in a /z/x/y.mvt folder structure.
/// </summary>
/// <param name="vectorTiles">The tiles.</param>
/// <param name="path">The path.</param>
/// <param name="extent">The extent.</param>
/// <remarks>Replaces the files if they are already present.</remarks>
public static void Write(this IEnumerable <VectorTile> vectorTiles, string path, uint extent = 4096)
{
foreach (var vectorTile in vectorTiles)
{
var tile = new Tiles.Tile(vectorTile.TileId);
var zFolder = Path.Combine(path, tile.Zoom.ToString());
if (!Directory.Exists(zFolder))
{
Directory.CreateDirectory(zFolder);
}
var xFolder = Path.Combine(zFolder, tile.X.ToString());
if (!Directory.Exists(xFolder))
{
Directory.CreateDirectory(xFolder);
}
var file = Path.Combine(xFolder, $"{tile.Y}.mvt");
using var stream = File.Open(file, FileMode.Create);
vectorTile.Write(stream, extent);
}
}
/// <summary>
/// Writes the tiles in a /z/x/y.mvt folder structure.
/// </summary>
/// <param name="tree">The tree.</param>
/// <param name="path">The path.</param>
/// <param name="extent">The extent.</param>
/// <remarks>Replaces the files if they are already present.</remarks>
public static void Write(this VectorTileTree tree, string path, uint extent = 4096)
{
foreach (var tileId in tree)
{
var tile = new Tiles.Tile(tileId);
var zFolder = Path.Combine(path, tile.Zoom.ToString());
if (!Directory.Exists(zFolder))
{
Directory.CreateDirectory(zFolder);
}
var xFolder = Path.Combine(zFolder, tile.X.ToString());
if (!Directory.Exists(xFolder))
{
Directory.CreateDirectory(xFolder);
}
var file = Path.Combine(xFolder, $"{tile.Y.ToString()}.mvt");
using (var stream = File.Open(file, FileMode.Create))
{
tree[tileId].Write(stream, extent);
}
}
}
/// <summary>
/// Writes the tiles provided in <c>IEnumerable<VectorTile></c> in a /z/x/y-{layer}.geojson folder structure.
/// </summary>
/// <param name="vectorTiles">The tiles.</param>
/// <param name="path">The path.</param>
/// <remarks>Replaces the files if they are already present.</remarks>
public static void Write(this IEnumerable <VectorTile> vectorTiles, string path)
{
foreach (var vectorTile in vectorTiles)
{
foreach (var layer in vectorTile.Layers)
{
var tile = new Tiles.Tile(vectorTile.TileId);
string zFolder = Path.Combine(path, tile.Zoom.ToString());
if (!Directory.Exists(zFolder))
{
Directory.CreateDirectory(zFolder);
}
string xFolder = Path.Combine(zFolder, tile.X.ToString());
if (!Directory.Exists(xFolder))
{
Directory.CreateDirectory(xFolder);
}
string file = Path.Combine(xFolder, $"{tile.Y}-{layer.Name}.geojson");
using var stream = File.Open(file, FileMode.Create);
layer.Write(stream);
}
}
}
/// <summary>
/// Writes the tiles provided in <c>VectorTileTree</c> in a /z/x/y-{layer}.geojson folder structure.
/// </summary>
/// <param name="tree">The tree.</param>
/// <param name="path">The path.</param>
/// <remarks>Replaces the files if they are already present.</remarks>
public static void Write(this VectorTileTree tree, string path)
{
foreach (ulong tileId in tree)
{
var tileData = tree[tileId];
foreach (var layer in tileData.Layers)
{
var tile = new Tiles.Tile(tileId);
string zFolder = Path.Combine(path, tile.Zoom.ToString());
if (!Directory.Exists(zFolder))
{
Directory.CreateDirectory(zFolder);
}
string xFolder = Path.Combine(zFolder, tile.X.ToString());
if (!Directory.Exists(xFolder))
{
Directory.CreateDirectory(xFolder);
}
string file = Path.Combine(xFolder, $"{tile.Y}-{layer.Name}.geojson");
using var stream = File.Open(file, FileMode.Create);
layer.Write(stream);
}
}
}
void CreateFood(Tiles.Tile Tile)
{
foodblock = new FoodBlock(Tile._Texture, Tile._Position, Tile._Color);
}
/// <summary>
/// Writes the tile to the given stream.
/// </summary>
public static void Write(this VectorTile vectorTile, Stream stream,
Func <IAttributeCollection, Itinero.VectorTiles.Layers.Layer, IAttributeCollection> mapAttributes = null, uint extent = 4096)
{
var tile = new Tiles.Tile(vectorTile.TileId);
double latitudeStep = (tile.Top - tile.Bottom) / extent;
double longitudeStep = (tile.Right - tile.Left) / extent;
double top = tile.Top;
double left = tile.Left;
var mapboxTile = new Mapbox.Tile();
foreach (var localLayer in vectorTile.Layers)
{
var layer = new Mapbox.Tile.Layer();
layer.Version = 2;
layer.Name = localLayer.Name;
layer.Extent = extent;
var keys = new Dictionary <string, uint>();
var values = new Dictionary <string, uint>();
if (localLayer is SegmentLayer)
{
var segmentLayer = localLayer as SegmentLayer;
var segments = segmentLayer.Segments;
var edgeProfile = segmentLayer.Profiles;
var edgeMeta = segmentLayer.Meta;
for (var i = 0; i < segments.Length; i++)
{
var feature = new Mapbox.Tile.Feature();
var shape = segments[i].Shape;
var posX = (int)((shape[0].Longitude - left) / longitudeStep);
var posY = (int)((top - shape[0].Latitude) / latitudeStep);
GenerateMoveTo(feature.Geometry, posX, posY);
// generate line to.
feature.Geometry.Add(GenerateCommandInteger(2, shape.Length - 1));
for (var j = 1; j < shape.Length; j++)
{
var localPosX = (int)((shape[j].Longitude - left) / longitudeStep);
var localPosY = (int)((top - shape[j].Latitude) / latitudeStep);
var dx = localPosX - posX;
var dy = localPosY - posY;
posX = localPosX;
posY = localPosY;
feature.Geometry.Add(GenerateParameterInteger(dx));
feature.Geometry.Add(GenerateParameterInteger(dy));
}
feature.Type = Tile.GeomType.LineString;
if (mapAttributes != null)
{
IAttributeCollection attributes = new AttributeCollection(edgeProfile.Get(segments[i].Profile));
var meta = edgeMeta.Get(segments[i].Meta);
foreach (var a in meta)
{
attributes.AddOrReplace(a);
}
attributes = mapAttributes(attributes, localLayer);
foreach (var attribute in attributes)
{
uint keyId;
if (!keys.TryGetValue(attribute.Key, out keyId))
{
keyId = (uint)keys.Count;
keys.Add(attribute.Key, keyId);
}
uint valueId;
if (!values.TryGetValue(attribute.Value, out valueId))
{
valueId = (uint)values.Count;
values.Add(attribute.Value, valueId);
}
feature.Tags.Add(keyId);
feature.Tags.Add(valueId);
}
}
else
{
var profile = edgeProfile.Get(segments[i].Profile);
if (profile != null)
{
foreach (var attribute in profile)
{
uint keyId;
if (!keys.TryGetValue(attribute.Key, out keyId))
{
keyId = (uint)keys.Count;
keys.Add(attribute.Key, keyId);
}
uint valueId;
if (!values.TryGetValue(attribute.Value, out valueId))
{
valueId = (uint)values.Count;
values.Add(attribute.Value, valueId);
}
feature.Tags.Add(keyId);
feature.Tags.Add(valueId);
}
}
var meta = edgeMeta.Get(segments[i].Meta);
if (meta != null)
{
foreach (var attribute in meta)
{
uint keyId;
if (!keys.TryGetValue(attribute.Key, out keyId))
{
keyId = (uint)keys.Count;
keys.Add(attribute.Key, keyId);
}
uint valueId;
if (!values.TryGetValue(attribute.Value, out valueId))
{
valueId = (uint)values.Count;
values.Add(attribute.Value, valueId);
}
feature.Tags.Add(keyId);
feature.Tags.Add(valueId);
}
}
}
layer.Features.Add(feature);
}
}
else if (localLayer is StopLayer)
{
var pointLayer = localLayer as StopLayer;
var points = pointLayer.Points;
var metaIndex = pointLayer.Meta;
for (var i = 0; i < points.Length; i++)
{
var point = points[i];
var feature = new Mapbox.Tile.Feature();
var posX = (int)((point.Longitude - left) / longitudeStep);
var posY = (int)((top - point.Latitude) / latitudeStep);
GenerateMoveTo(feature.Geometry, posX, posY);
feature.Type = Tile.GeomType.Point;
var attributes = metaIndex.Get(point.MetaId);
if (mapAttributes != null)
{
attributes = mapAttributes(attributes, localLayer);
}
if (attributes != null)
{
foreach (var attribute in attributes)
{
uint keyId;
if (!keys.TryGetValue(attribute.Key, out keyId))
{
keyId = (uint)keys.Count;
keys.Add(attribute.Key, keyId);
}
uint valueId;
if (!values.TryGetValue(attribute.Value, out valueId))
{
valueId = (uint)values.Count;
values.Add(attribute.Value, valueId);
}
feature.Tags.Add(keyId);
feature.Tags.Add(valueId);
}
}
layer.Features.Add(feature);
}
}
else
{ // unknown type of layer.
continue;
}
layer.Keys.AddRange(keys.Keys);
foreach (var value in values.Keys)
{
layer.Values.Add(new Tile.Value()
{
StringValue = value
});
}
mapboxTile.Layers.Add(layer);
}
ProtoBuf.Serializer.Serialize <Tile>(stream, mapboxTile);
}
/// <summary>
/// Writes the tile to the given stream.
/// </summary>
/// <param name="vectorTile">The vector tile.</param>
/// <param name="stream">The stream to write to.</param>
/// <param name="extent">The extent.</param>
/// <param name="idAttributeName">The name of an attribute property to use as the ID for the Feature. Vector tile feature ID's should be integer or ulong numbers.</param>
public static void Write(this VectorTile vectorTile, Stream stream, uint extent = 4096, string idAttributeName = "id")
{
var tile = new Tiles.Tile(vectorTile.TileId);
var tgt = new TileGeometryTransform(tile, extent);
var mapboxTile = new Mapbox.Tile();
foreach (var localLayer in vectorTile.Layers)
{
var layer = new Mapbox.Tile.Layer {
Version = 2, Name = localLayer.Name, Extent = extent
};
var keys = new Dictionary <string, uint>();
var values = new Dictionary <Tile.Value, uint>();
foreach (var localLayerFeature in localLayer.Features)
{
var feature = new Mapbox.Tile.Feature();
// Encode geometry
switch (localLayerFeature.Geometry)
{
case IPuntal puntal:
feature.Type = Tile.GeomType.Point;
feature.Geometry.AddRange(Encode(puntal, tgt));
break;
case ILineal lineal:
feature.Type = Tile.GeomType.LineString;
feature.Geometry.AddRange(Encode(lineal, tgt));
break;
case IPolygonal polygonal:
feature.Type = Tile.GeomType.Polygon;
feature.Geometry.AddRange(Encode(polygonal, tgt, tile.Zoom));
break;
default:
feature.Type = Tile.GeomType.Unknown;
break;
}
// If geometry collapsed during encoding, we don't add the feature at all
if (feature.Geometry.Count == 0)
{
continue;
}
// Translate attributes for feature
AddAttributes(feature.Tags, keys, values, localLayerFeature.Attributes);
//Try and retrieve an ID from the attributes.
var id = localLayerFeature.Attributes.GetOptionalValue(idAttributeName);
//Converting ID to string, then trying to parse. This will handle situations will ignore situations where the ID value is not actually an integer or ulong number.
if (id != null && ulong.TryParse(id.ToString(), out ulong idVal))
{
feature.Id = idVal;
}
// Add feature to layer
layer.Features.Add(feature);
}
layer.Keys.AddRange(keys.Keys);
layer.Values.AddRange(values.Keys);
mapboxTile.Layers.Add(layer);
}
ProtoBuf.Serializer.Serialize <Tile>(stream, mapboxTile);
}
public override Generated_World Generate_World(GameObject entity_parent, int width, int height)
{
// Generate height map
int[] height_map = new int[width * height];
int index = 0;
for (int j = 0; j < height; j++)
{
for (int i = 0; i < width; i++)
{
height_map[index] =
Mathf.FloorToInt(Mathf.PerlinNoise(i * roughness, j * roughness) *
scale + water_level - scale - water_level * 3 +
Mathf.PerlinNoise(
i * biome_delta + 100,
j * biome_delta + 100) *
water_level * 6);
height_map[index] = height_map[index] <= 0 ? 1 : height_map[index];
index++;
}
}
// Generate vertices
World.Vertex[] vertices = new World.Vertex[width * height];
int len = width * height;
for (index = 0; index < len; index++)
{
Stack <VertexType> vert_stack = new Stack <VertexType>();
while (vert_stack.Count <= height_map[index])
{
if (vert_stack.Count < water_level)
{
vert_stack.Push(VertexType.Dirt);
}
else if (vert_stack.Count < water_level + 2)
{
vert_stack.Push(VertexType.Sand);
}
else
{
vert_stack.Push(VertexType.Grass);
}
}
vertices[index] = new World.Vertex(vert_stack);
}
// Generate tiles
World.TileData[] tiles = new World.TileData[(width - 1) * (height - 1)];
index = 0;
int v_index = 0;
for (int j = 0; j < height - 1; j++)
{
for (int i = 0; i < width - 1; i++)
{
GenerationTile[] available = generationMap[(int)vertices[v_index].Type.Peek()];
if (available != null)
{
for (int e = 0; e < available.Length; e++)
{
if (UnityEngine.Random.value < available[e].probability)
{
GenerationTile genT = available[e];
if (genT.tile.Requirements.ValidateTerrain(vertices, width, height, i, j).Valid)
{
Tiles.Tile t = genT.tile.CreateInstance(
entity_parent,
new Vector3(i, height_map[v_index] + 1, j));
tiles[index] = new World.TileData(t);
break;
}
}
}
}
v_index++;
index++;
}
v_index++;
}
// Instantiate the world
Generated_World world = new Generated_World();
world.Vertices = vertices;
world.Tiles = tiles;
world.Entities = new QuadTree(0, 0, width, height);
return(world);
}
/// <summary>
/// Writes the tile to the given stream.
/// </summary>
/// <param name="vectorTile">The vector tile.</param>
/// <param name="stream">The stream to write to.</param>
/// <param name="extent">The extent.</param>
public static void Write(this VectorTile vectorTile, Stream stream, uint extent = 4096)
{
var tile = new Tiles.Tile(vectorTile.TileId);
double latitudeStep = (tile.Top - tile.Bottom) / extent;
double longitudeStep = (tile.Right - tile.Left) / extent;
double top = tile.Top;
double left = tile.Left;
var mapboxTile = new Mapbox.Tile();
foreach (var localLayer in vectorTile.Layers)
{
var layer = new Mapbox.Tile.Layer {
Version = 2, Name = localLayer.Name, Extent = extent
};
var keys = new Dictionary <string, uint>();
var values = new Dictionary <string, uint>();
foreach (var localLayerFeature in localLayer.Features)
{
if (localLayerFeature.Geometry is Point p)
{
var feature = new Mapbox.Tile.Feature();
var posX = (int)((p.X - left) / longitudeStep);
var posY = (int)((top - p.Y) / latitudeStep);
GenerateMoveTo(feature.Geometry, posX, posY);
feature.Type = Tile.GeomType.Point;
AddAttributes(feature.Tags, keys, values, localLayerFeature.Attributes);
layer.Features.Add(feature);
}
else if (localLayerFeature.Geometry is LineString ls)
{
var feature = new Mapbox.Tile.Feature();
var posX = (int)((ls.Coordinates[0].X - left) / longitudeStep);
var posY = (int)((top - ls.Coordinates[0].Y) / latitudeStep);
GenerateMoveTo(feature.Geometry, posX, posY);
// generate line to.
feature.Geometry.Add(GenerateCommandInteger(2, ls.Coordinates.Length - 1));
for (var j = 1; j < ls.Coordinates.Length; j++)
{
var localPosX = (int)((ls.Coordinates[j].X - left) / longitudeStep);
var localPosY = (int)((top - ls.Coordinates[j].Y) / latitudeStep);
var dx = localPosX - posX;
var dy = localPosY - posY;
posX = localPosX;
posY = localPosY;
feature.Geometry.Add(GenerateParameterInteger(dx));
feature.Geometry.Add(GenerateParameterInteger(dy));
}
feature.Type = Tile.GeomType.LineString;
AddAttributes(feature.Tags, keys, values, localLayerFeature.Attributes);
layer.Features.Add(feature);
}
}
layer.Keys.AddRange(keys.Keys);
foreach (var value in values.Keys)
{
if (int.TryParse(value, out var intValue))
{
layer.Values.Add(new Tile.Value()
{
IntValue = intValue
});
}
else if (float.TryParse(value, out var floatValue))
{
layer.Values.Add(new Tile.Value()
{
FloatValue = floatValue
});
}
else
{
layer.Values.Add(new Tile.Value()
{
StringValue = value
});
}
}
mapboxTile.Layers.Add(layer);
}
ProtoBuf.Serializer.Serialize <Tile>(stream, mapboxTile);
}
/// <summary>
/// Reads a Vector Tile stream.
/// </summary>
/// <param name="stream">Vector tile stream.</param>
/// <param name="tileDefinition">Tile information.</param>
/// <returns></returns>
public VectorTile Read(Stream stream, Tiles.Tile tileDefinition)
{
return(Read(stream, tileDefinition, null));
}
public Food(Tiles.Tile Tile)
{
CreateFood(Tile);
}
void FixedUpdate()
{
int currentStage = m_network.GetComponent <Network>().m_stage;
switch (currentStage)
{
case 0:
m_trade_button.gameObject.SetActive(true);
m_transmit_button.gameObject.SetActive(false);
break;
case 2:
m_trade_button.gameObject.SetActive(false);
m_transmit_button.gameObject.SetActive(true);
break;
case 1:
case 3:
default:
m_trade_button.gameObject.SetActive(false);
m_transmit_button.gameObject.SetActive(false);
break;
}
if (!m_game_running)
{
return;
}
for (int i = 0; i < m_players.Length; ++i)
{
Bot bot = m_players[i].bot.GetComponent <Bot>();
if (bot.GetStatus() == Bot.Status.Dead)
{
m_game_running = false;
Invoke("RestartGame", 3.0f);
m_network.GetComponent <Network>().leaveGame();
return;
}
}
if (m_action_sequence.Count > 0)
{
Bot bot = m_players[m_action_player].bot.GetComponent <Bot>();
if (bot.GetStatus() == Bot.Status.Idle)
{
Action action = m_actions.GetAction(m_action_sequence.Pop());
if (action.passive.actions != null)
{
for (int i = action.passive.actions.Length - 1; i >= 0; --i)
{
m_action_sequence.Push(action.passive.actions[i]);
}
}
if (action.passive.player_move != 0)
{
bot.Move(action.passive.player_move);
}
else if (action.passive.turn_body > 0)
{
bot.TurnRight();
}
else if (action.passive.turn_body < 0)
{
bot.TurnLeft();
}
else if (action.passive.turn_turret > 0)
{
bot.TurnTurretRight();
}
else if (action.passive.turn_turret < 0)
{
bot.TurnTurretLeft();
}
else if (action.passive.align_turret_to_body)
{
bot.AlignTurret();
}
else if (action.passive.target_modifier != 0)
{
m_target_bot.Modifier(action.passive.target_modifier);
}
else if (action.passive.player_modifier != 0)
{
bot.Modifier(action.passive.player_modifier);
}
else if (action.passive.target_move != 0)
{
m_target_bot.ForcedMove(m_target_dir);
}
else if (action.name == "fire" || action.name == "vampiric_shot")
{
Arena.HitInfo hitinfo = bot.Fire();
if (hitinfo.hit)
{
m_target_bot = hitinfo.bot;
if (action.on_hit.actions != null)
{
for (int i = action.on_hit.actions.Length - 1; i >= 0; --i)
{
m_action_sequence.Push(action.on_hit.actions[i]);
}
}
}
}
}
}
else if (!m_arena_acted)
{
Bot bot = m_players[m_action_player].bot.GetComponent <Bot>();
if (bot.GetStatus() == Bot.Status.Idle)
{
m_arena_acted = true;
Tiles.Tile tile = bot.GetTile();
if (tile.actions != null)
{
for (int i = tile.actions.Length - 1; i >= 0; --i)
{
m_action_sequence.Push(tile.actions[i]);
}
m_target_bot = bot;
m_target_dir = bot.GetTileDir();
}
}
}
else
{
Bot bot = m_players[m_action_player].bot.GetComponent <Bot>();
if (m_card_sequence.Count > 0 && bot.GetStatus() == Bot.Status.Idle)
{
Card card = m_cards.GetCard(m_card_sequence.Pop());
HandBehaviour player_hand = m_player_hand.GetComponent <HandBehaviour> ();
HandBehaviour opponent_hand = m_opponent_hand.GetComponent <HandBehaviour> ();
player_hand.SelectCard(card);
opponent_hand.SelectCard(card);
ActionSequence(m_player_sequence.Pop(), card.actions);
}
}
}
/// <summary>
/// Writes the tile to the given stream.
/// </summary>
public static void Write(this VectorTile vectorTile, Stream stream, uint extent = 4096)
{
var tile = new Tiles.Tile(vectorTile.TileId);
double latitudeStep = (tile.Top - tile.Bottom) / extent;
double longitudeStep = (tile.Right - tile.Left) / extent;
double top = tile.Top;
double left = tile.Left;
var mapboxTile = new Tile();
foreach (var localLayer in vectorTile.Layers)
{
var layer = new Tile.Layer {
Version = 2, Name = localLayer.Name, Extent = extent
};
var keys = new Dictionary <string, uint>();
var values = new Dictionary <string, uint>();
if (localLayer is EdgeLayer segmentLayer)
{
var edges = segmentLayer.Edges;
for (var i = 0; i < edges.Count; i++)
{
var postProcess = segmentLayer.Config.PostProcess ??
(attr => new List <IEnumerable <Attribute> > {
attr
});
var attributess =
postProcess(segmentLayer.Config.GetAttributesFunc(edges[i].EdgeId, tile.Zoom));
if (attributess == null)
{
continue;
}
foreach (var attributes in attributess)
{
var feature = new Tile.Feature();
var shape = edges[i].Shape;
var posX = (int)((shape[0].Longitude - left) / longitudeStep);
var posY = (int)((top - shape[0].Latitude) / latitudeStep);
GenerateMoveTo(feature.Geometry, posX, posY);
// generate line to.
feature.Geometry.Add(GenerateCommandInteger(2, shape.Length - 1));
for (var j = 1; j < shape.Length; j++)
{
var localPosX = (int)((shape[j].Longitude - left) / longitudeStep);
var localPosY = (int)((top - shape[j].Latitude) / latitudeStep);
var dx = localPosX - posX;
var dy = localPosY - posY;
posX = localPosX;
posY = localPosY;
feature.Geometry.Add(GenerateParameterInteger(dx));
feature.Geometry.Add(GenerateParameterInteger(dy));
}
feature.Type = Tile.GeomType.LineString;
AddAttributes(feature.Tags, keys, values, attributes);
layer.Features.Add(feature);
}
}
}
else if (localLayer is VertexLayer vertexLayer)
{
var vertices = vertexLayer.Vertices;
for (var i = 0; i < vertices.Count; i++)
{
var vertex = vertices[i];
var postProcess = vertexLayer.Config.PostProcess ??
(attr => new List <IEnumerable <Attribute> >()
{
attr
});
var vertexMetas = postProcess(vertexLayer.Config.GetAttributesFunc(vertex.Id, tile.Zoom));
if (vertexMetas == null)
{
continue;
}
foreach (var vertexMeta in vertexMetas)
{
var feature = new Tile.Feature();
var posX = (int)((vertex.Longitude - left) / longitudeStep);
var posY = (int)((top - vertex.Latitude) / latitudeStep);
GenerateMoveTo(feature.Geometry, posX, posY);
feature.Type = Tile.GeomType.Point;
AddAttributes(feature.Tags, keys, values, vertexMeta);
layer.Features.Add(feature);
}
}
}
else
{
// unknown type of layer.
continue;
}
layer.Keys.AddRange(keys.Keys);
foreach (var value in values.Keys)
{
if (int.TryParse(value, out var intValue))
{
layer.Values.Add(new Tile.Value()
{
IntValue = intValue
});
}
else if (float.TryParse(value, out var floatValue))
{
layer.Values.Add(new Tile.Value()
{
FloatValue = floatValue
});
}
else
{
layer.Values.Add(new Tile.Value()
{
StringValue = value
});
}
}
mapboxTile.Layers.Add(layer);
}
Serializer.Serialize <Tile>(stream, mapboxTile);
}
