public TileMapCreatingSystem(Contexts contexts, Map map)
{
Assert.IsNotNull(map);
_context = contexts.tile;
_map = map;
}
public void SetMbTilesAsBackground(string mbtilesFileName)
{
// Remove previous TileOverlay if created
if (TileOverlay != null)
{
//TileOverlay.Remove();
return;
}
// Make Db Context Options Builder to create sqlite db builder
DbContextOptionsBuilder <TileContext> myContextBuilder = new DbContextOptionsBuilder <TileContext>();
myContextBuilder.UseSqlite($"Filename={mbtilesFileName}");
// Initialize TileContext with this builder
TileContext tileContext = new TileContext(myContextBuilder.Options);
// Create TileService with this TileConext
ReadOnlyTileService readOnlyTileService = new ReadOnlyTileService(tileContext);
// Create CustomTileProvider with this TileService
CustomTileProvider customTileProvider = new CustomTileProvider(readOnlyTileService);
// And finally, create the TileOverlayOptions
TileOverlayOptions options = new TileOverlayOptions().InvokeZIndex(0f)
.InvokeTileProvider(customTileProvider);
// And TileOverlay
GoogleMap map = (GoogleMap)LayerService.CurrentMap;
TileOverlay = map.AddTileOverlay(options);
}
private void CreateGround(TileContext context)
{
if (context.Tile.Gid <= 0)
{
return;
}
var floor = Instantiate(Floor);
floor.transform.position = context.TilePosition;
floor.GetComponentInChildren <Renderer>().material.SetTexture("_MainTex", _spriteLibrary.GetTexture(context.Tile.Gid));
}
public string Move(ResultModel model)
{
try
{
string direction = model.parameters.direction.ToString();
int directionToSend = -1;
switch (direction.ToLower())
{
case "left":
//handle left
directionToSend = 2;
break;
case "right":
//handle right
directionToSend = 3;
break;
case "up":
//handle up
directionToSend = 0;
break;
case "down":
//handle down
directionToSend = 1;
break;
default:
return("I didn't understand that");
}
directionToSend++;
int fortranResult = _fortranProxy.SendToFortran(directionToSend);
if (fortranResult == 6)
{
return(@"There is a large pillar blocking your way, you'll have to go around");
}
var t = TileFactory.GetTile(fortranResult);
_currentTile = t;
return(t.Description);
}
catch (Exception e)
{
return($"Error occured, {e.ToString()}");
}
}
public TileSet GetTileSet(TileContext context)
{
TileSet tileSheet = null;
foreach (var sheet in _tileSets)
{
if (sheet.FirstGid > context.Tile.Gid)
{
break;
}
tileSheet = sheet;
}
return(tileSheet ?? _tileSets.Last());
}
private void BuildLevel(string levelName)
{
var map = XmlManager <Map> .Load("Assets/Resources/Levels/" + levelName + ".tmx");
_spriteLibrary.Generate(map.TileSets);
var width = map.Width;
var height = map.Height;
foreach (var layer in map.Layer)
{
for (var z = 0; z < height; z++)
{
for (var x = 0; x < width; x++)
{
var tileContext = new TileContext
{
Tile = layer.Data[z * height + x],
TilePosition = new Vector3(x, 0, -z)
};
if (BuilderDefinitions.ContainsKey(layer.Name))
{
BuilderDefinitions[layer.Name](tileContext);
}
}
}
}
for (var i = 0; i < map.ObjectGroup.Length; i++)
{
var objectGroup = map.ObjectGroup[i];
if (objectGroup.Name == "BloodLayer")
{
LevelContext.BloodLayer = i;
}
else
{
BuildObjectGroup(objectGroup, i);
}
}
AddWallCaps(map);
}
public static float previewSize(TileContext context)
{
switch (context)
{
case TileContext.None:
return(16);
case TileContext.PartialContext:
return(48);
case TileContext.FullContext:
return(80);
case TileContext.Slope:
return(48);
}
return(0);
}
public Contexts()
{
buff = new BuffContext();
card = new CardContext();
game = new GameContext();
gameEvent = new GameEventContext();
tile = new TileContext();
unit = new UnitContext();
var postConstructors = System.Linq.Enumerable.Where(
GetType().GetMethods(),
method => System.Attribute.IsDefined(method, typeof(Entitas.CodeGeneration.Attributes.PostConstructorAttribute))
);
foreach (var postConstructor in postConstructors)
{
postConstructor.Invoke(this, null);
}
}
private void CreateWalls(TileContext context)
{
if (context.Tile.Gid == 0)
{
return;
}
var wallSheet = _spriteLibrary.GetTileSet(context);
var correctedGid = context.Tile.Gid - wallSheet.FirstGid;
var correctedWall = wallSheet.Tile.FirstOrDefault(x => x.Id == correctedGid);
if (correctedWall != null)
{
var direction = correctedWall.Properties.FirstOrDefault(x => x.Name == "WallDirection");
if (direction != null)
{
GameObject wall = null;
switch (direction.Value)
{
case WallDirection.Left:
wall = Instantiate(LeftWall);
break;
case WallDirection.Top:
wall = Instantiate(TopWall);
break;
case WallDirection.Corner:
wall = Instantiate(CornerWall);
break;
}
if (wall != null)
{
wall.transform.position = context.TilePosition;
}
}
}
}
private void CreateSpawns(TileContext context)
{
if (context.Tile.Gid == 0)
{
return;
}
var spawnSheet = _spriteLibrary.GetTileSet(context);
var actualId = context.Tile.Gid - spawnSheet.FirstGid;
switch (actualId)
{
case 0:
var enemy = Instantiate(Enemy);
enemy.transform.position = context.TilePosition;
break;
case 1:
Player.transform.position = context.TilePosition;
break;
}
}
public static float previewSize(TileContext context){
switch (context) {
case TileContext.None:
return 16;
case TileContext.PartialContext:
return 48;
case TileContext.FullContext:
return 80;
case TileContext.Slope:
return 48;
}
return 0;
}
public MissionBossSetupSystem(Contexts contexts) : base(contexts)
{
_unitContext = contexts.unit;
_tileContext = contexts.tile;
}
public ToolKitsButtonSetupSystem(Contexts contexts, MapEditorToolkits toolKits)
{
_toolKits = toolKits;
_context = contexts.tile;
}
public static System.Collections.Generic.HashSet <TileEntity> GetEntitiesWithSpawnpoint(this TileContext context, int index)
{
return(((Entitas.EntityIndex <TileEntity, int>)context.GetEntityIndex(Contexts.Spawnpoint)).GetEntities(index));
}
public static System.Collections.Generic.HashSet <TileEntity> GetEntitiesWithId(this TileContext context, int Id)
{
return(((Entitas.EntityIndex <TileEntity, int>)context.GetEntityIndex(Contexts.Id)).GetEntities(Id));
}
public TileReactiveSystem(Contexts contexts) : base(contexts.tile)
{
_context = contexts.tile;
}
public PlayerCharacterCreatingSystem(Contexts contexts)
{
_gameContext = contexts.game;
_tileContext = contexts.tile;
_unitContext = contexts.unit;
}
public TileGraphCreatingSystem(Contexts contexts)
{
_context = contexts.tile;
}
public TileBrushSystem(Contexts contexts)
{
_context = contexts.tile;
}
public static System.Collections.Generic.HashSet <TileEntity> GetEntitiesWithMapPosition(this TileContext context, Position Value)
{
return(((Entitas.EntityIndex <TileEntity, Position>)context.GetEntityIndex(Contexts.MapPosition)).GetEntities(Value));
}
public TileDetailSystem(Contexts contexts, MapEditorToolkits toolKit)
{
_context = contexts.tile;
_toolKit = toolKit;
}
