public void Setup()
{
_componentFactory = IoCManager.Resolve <IComponentFactory>();
_componentFactory.Register <ThrowsInAddComponent>();
_componentFactory.Register <ThrowsInExposeDataComponent>();
_componentFactory.Register <ThrowsInInitializeComponent>();
_componentFactory.Register <ThrowsInStartupComponent>();
var compMan = IoCManager.Resolve <IComponentManager>();
compMan.Initialize();
EntityManager = IoCManager.Resolve <IServerEntityManager>();
MapManager = IoCManager.Resolve <IMapManager>();
MapManager.Initialize();
MapManager.Startup();
MapManager.CreateNewMapEntity(MapId.Nullspace);
var manager = IoCManager.Resolve <IPrototypeManager>();
manager.LoadFromStream(new StringReader(PROTOTYPES));
manager.Resync();
//NOTE: The grids have not moved, so we can assert worldpos == localpos for the test
}
public RegionManager(
IRegionFactory regionFactory,
IMapManager mapManager,
ITeamFactory teamFactory,
IMenuFactory menuFactory,
IDecisionManager decisionManager,
BattlefieldFactory battlefieldFactory,
IInput input,
IOutput output,
IChanceService chanceService)
{
_mapManager = mapManager;
_teamFactory = teamFactory;
_decisionManager = decisionManager;
_menuFactory = menuFactory;
_battlefieldFactory = battlefieldFactory;
_input = input;
_output = output;
_chanceService = chanceService;
IEnumerable <WorldRegion> allRegionEnums = EnumHelperMethods.GetAllValuesForEnum <WorldRegion>();
IEnumerable <Region> allRegions = regionFactory.GetRegions(allRegionEnums);
_regionalMap = mapManager.GetRegionalMap(allRegions.ToArray());
}
public BatchCloneNodesOperation(IMapManager mapManager, INode map, IEnumerable<Node> nodes, IEnumerable<Relationship> relationships)
: base(mapManager)
{
Map = map;
Nodes = nodes;
Relationships = relationships;
}
public MapPage()
{
InitializeComponent();
IMapManager mapManager = DependencyService.Get <IMapManager>();
mapManager.CoordinateType = CoordType.GCJ02;
Map.Loaded += MapLoaded;
//IOfflineMap offlineMap = DependencyService.Get<IOfflineMap>();
//offlineMap.HasUpdate += (_, e) => {
// Debug.WriteLine("OfflineMap has update: " + e.CityID);
//};
//offlineMap.Downloading += (_, e) => {
// Debug.WriteLine("OfflineMap downloading: " + e.CityID);
//};
//var list = offlineMap.HotList;
//list = offlineMap.AllList;
////offlineMap.Remove(131);
//var curr = offlineMap.Current;
////offlineMap.Start(27);
////offlineMap.Start(75);
//curr = offlineMap.Current;
//ICalculateUtils calc = DependencyService.Get<ICalculateUtils>();
//Debug.WriteLine(calc.CalculateDistance(
// new Coordinate(40, 116),
// new Coordinate(41, 117)
//));//139599.429229778 in iOS, 139689.085961837 in Android
}
public MapDownloadServerMessageHandler(NetworkContext context, IMapManager mapManager, string map)
{
_context = context;
_mapManager = mapManager;
ChangeMap(map);
}
public override bool Update(Vector2D mouseS, IMapManager currentMap)
{
if (currentMap == null) return false;
spriteToDraw = GetDirectionalSprite(pManager.CurrentBaseSprite);
mouseScreen = mouseS;
mouseWorld = new Vector2D(mouseScreen.X + ClientWindowData.Singleton.ScreenOrigin.X,
mouseScreen.Y + ClientWindowData.Singleton.ScreenOrigin.Y);
var spriteRectWorld = new RectangleF(mouseWorld.X - (spriteToDraw.Width/2f),
mouseWorld.Y - (spriteToDraw.Height/2f), spriteToDraw.Width,
spriteToDraw.Height);
if (pManager.CurrentPermission.IsTile)
return false;
if (pManager.CollisionManager.IsColliding(spriteRectWorld))
return false;
if (currentMap.IsSolidTile(mouseWorld)) return false;
if (pManager.CurrentPermission.Range > 0)
if (
(pManager.PlayerManager.ControlledEntity.GetComponent<TransformComponent>(ComponentFamily.Transform)
.Position - mouseWorld).Length > pManager.CurrentPermission.Range) return false;
currentTile = currentMap.GetFloorAt(mouseWorld);
return true;
}
/// <summary>
/// Creates a set of EntityCoordinates given some MapCoordinates.
/// </summary>
/// <param name="entityManager"></param>
/// <param name="mapManager"></param>
/// <param name="coordinates"></param>
/// <returns></returns>
public static EntityCoordinates FromMap(IEntityManager entityManager, IMapManager mapManager, MapCoordinates coordinates)
{
var mapId = coordinates.MapId;
var mapEntity = mapManager.GetMapEntity(mapId);
return(new EntityCoordinates(mapEntity.Uid, coordinates.Position));
}
public override bool Update(Vector2i mouseS, IMapManager currentMap)
{
if (currentMap == null)
{
return(false);
}
mouseScreen = mouseS;
mouseWorld = CluwneLib.ScreenToWorld(mouseScreen);
currentTile = currentMap.GetDefaultGrid().GetTile(mouseWorld);
if (!RangeCheck())
{
return(false);
}
var entitymanager = IoCManager.Resolve <IClientEntityManager>();
var failtoplace = entitymanager.AnyEntitiesIntersecting(new Box2(new Vector2(currentTile.X, currentTile.Y), new Vector2(currentTile.X + 0.99f, currentTile.Y + 0.99f)));
if (pManager.CurrentPermission.IsTile)
{
mouseWorld = new Vector2(currentTile.X + 0.5f,
currentTile.Y + 0.5f);
mouseScreen = (Vector2i)CluwneLib.WorldToScreen(mouseWorld);
}
else
{
mouseWorld = new Vector2(currentTile.X + 0.5f + pManager.CurrentPrototype.PlacementOffset.X,
currentTile.Y + 0.5f + pManager.CurrentPrototype.PlacementOffset.Y);
mouseScreen = (Vector2i)CluwneLib.WorldToScreen(mouseWorld);
}
return(failtoplace);
}
public RenderMap2D(Game game, Map map, IMapManager mapManager, IRenderView renderView,
uint initialScrollX = 0, uint initialScrollY = 0)
{
this.game = game;
this.mapManager = mapManager;
this.renderView = renderView;
var spriteFactory = renderView.SpriteFactory;
for (int row = 0; row < NUM_VISIBLE_TILES_Y; ++row)
{
for (int column = 0; column < NUM_VISIBLE_TILES_X; ++column)
{
var backgroundSprite = spriteFactory.CreateAnimated(TILE_WIDTH, TILE_HEIGHT, 0, 1);
var foregroundSprite = spriteFactory.CreateAnimated(TILE_WIDTH, TILE_HEIGHT, 0, 1);
backgroundSprite.Visible = true;
backgroundSprite.X = Global.Map2DViewX + column * TILE_WIDTH;
backgroundSprite.Y = Global.Map2DViewY + row * TILE_HEIGHT;
foregroundSprite.Visible = false;
foregroundSprite.X = Global.Map2DViewX + column * TILE_WIDTH;
foregroundSprite.Y = Global.Map2DViewY + row * TILE_HEIGHT;
backgroundTileSprites.Add(backgroundSprite);
foregroundTileSprites.Add(foregroundSprite);
}
}
SetMap(map, initialScrollX, initialScrollY);
}
public override bool Update(Vector2i mouseS, IMapManager currentMap)
{
if (currentMap == null) return false;
spriteToDraw = GetDirectionalSprite(pManager.CurrentBaseSpriteKey);
mouseScreen = mouseS;
mouseWorld = CluwneLib.ScreenToWorld(mouseScreen);
var bounds = spriteToDraw.GetLocalBounds();
var spriteSize = CluwneLib.PixelToTile(new Vector2f(bounds.Width, bounds.Height));
var spriteRectWorld = new FloatRect(mouseWorld.X - (spriteSize.X / 2f),
mouseWorld.Y - (spriteSize.Y / 2f),
spriteSize.X, spriteSize.Y);
if (pManager.CurrentPermission.IsTile)
return false;
if (pManager.CollisionManager.IsColliding(spriteRectWorld))
return false;
//if (currentMap.IsSolidTile(mouseWorld)) return false;
var rangeSquared = pManager.CurrentPermission.Range * pManager.CurrentPermission.Range;
if (rangeSquared > 0)
if (
(pManager.PlayerManager.ControlledEntity.GetComponent<TransformComponent>(ComponentFamily.Transform)
.Position - mouseWorld).LengthSquared() > rangeSquared) return false;
currentTile = currentMap.GetTileRef(mouseWorld);
return true;
}
private static void DeserializeChunk(IMapManager mapMan, IMapGrid grid, YamlMappingNode chunk)
{
var indNode = chunk["ind"];
var tileNode = chunk["tiles"];
var indices = indNode.AsVector2i() * grid.ChunkSize;
var tileBytes = Convert.FromBase64String(tileNode.ToString());
using (var stream = new MemoryStream(tileBytes))
{
using (var reader = new BinaryReader(stream))
{
mapMan.SuppressOnTileChanged = true;
for (var x = 0; x < grid.ChunkSize; x++)
{
for (var y = 0; y < grid.ChunkSize; y++)
{
var id = reader.ReadUInt16();
var data = reader.ReadUInt16();
var tile = new Tile(id, data);
grid.SetTile(new GridLocalCoordinates(x + indices.X, y + indices.Y, grid), tile);
}
}
mapMan.SuppressOnTileChanged = false;
}
}
}
public override bool Update(Vector2 mouseS, IMapManager currentMap)
{
if (currentMap == null) return false;
spriteToDraw = GetDirectionalSprite(pManager.CurrentBaseSprite);
mouseScreen = mouseS;
mouseWorld = MapUtil.worldToTileSize(mouseScreen);
var spriteSize = MapUtil.worldToTileSize(spriteToDraw.Size);
var spriteRectWorld = new RectangleF(mouseWorld.X - (spriteSize.X / 2f),
mouseWorld.Y - (spriteSize.Y / 2f),
spriteSize.X, spriteSize.Y);
if (pManager.CurrentPermission.IsTile)
return false;
if (pManager.CollisionManager.IsColliding(spriteRectWorld))
return false;
//if (currentMap.IsSolidTile(mouseWorld)) return false;
if (pManager.CurrentPermission.Range > 0)
if (
(pManager.PlayerManager.ControlledEntity.GetComponent<TransformComponent>(ComponentFamily.Transform)
.Position - mouseWorld).Length > pManager.CurrentPermission.Range) return false;
currentTile = currentMap.GetTileRef(mouseWorld);
return true;
}
public override bool Update(Vector2i mouseS, IMapManager currentMap)
{
if (currentMap == null)
{
return(false);
}
mouseScreen = mouseS;
mouseWorld = CluwneLib.ScreenToWorld(mouseScreen);
if (!(ongrid = currentMap.TryFindGridAt(mouseWorld, out IMapGrid currentgrid))) //Cant find a grid
{
return(false);
}
var mouselocal = currentgrid.WorldToLocal(mouseWorld); //Convert code to local grid coordinates
snapsize = currentgrid.SnapSize; //Find snap size.
mouselocal = new Vector2( //Round local coordinates onto the snap grid
(float)(Math.Round((mouselocal.X / (double)snapsize - 0.5), MidpointRounding.AwayFromZero) + 0.5) * snapsize,
(float)(Math.Round((mouselocal.Y / (double)snapsize - 0.5), MidpointRounding.AwayFromZero) + 0.5) * snapsize);
//Convert back to original world and screen coordinates after applying offset
mouseWorld = currentgrid.LocalToWorld(mouselocal) + new Vector2(pManager.CurrentPrototype.PlacementOffset.X, pManager.CurrentPrototype.PlacementOffset.Y);
mouseScreen = (Vector2i)CluwneLib.WorldToScreen(mouseWorld);
if (!RangeCheck())
{
return(false);
}
return(true);
}
public Wall(TileState state, RectangleF rect, Direction dir)
: base(state, rect)
{
ConnectSprite = true;
Opaque = true;
_dir = dir;
name = "Wall";
if (dir == Direction.East)
{
Sprite = _resourceManager.GetSprite("wall_EW");
topSprite = _resourceManager.GetSprite("wall_top_EW");
topSpriteNW = _resourceManager.GetSprite("wall_top_2");
topSpriteSE = _resourceManager.GetSprite("wall_top_8");
wallEndE = _resourceManager.GetSprite("wall_end_e");
wallEndW = _resourceManager.GetSprite("wall_end_w");
}
else
{
Sprite = _resourceManager.GetSprite("wall_NS");
topSprite = _resourceManager.GetSprite("wall_top_NS");
topSpriteNW = _resourceManager.GetSprite("wall_top_4");
topSpriteSE = _resourceManager.GetSprite("wall_top_1");
}
mapMgr = IoCManager.Resolve<IMapManager>();
}
public override bool Update(Vector2i mouseS, IMapManager currentMap)
{
if (currentMap == null)
{
return(false);
}
mouseScreen = mouseS;
mouseWorld = CluwneLib.ScreenToWorld(mouseScreen);
currentTile = currentMap.GetDefaultGrid().GetTile(mouseWorld);
if (!RangeCheck())
{
return(false);
}
if (pManager.CurrentPermission.IsTile)
{
mouseWorld = new Vector2(currentTile.X + 0.5f,
currentTile.Y + 0.5f);
mouseScreen = (Vector2i)CluwneLib.WorldToScreen(mouseWorld);
}
else
{
mouseWorld = new Vector2(currentTile.X + 0.5f + pManager.CurrentPrototype.PlacementOffset.X,
currentTile.Y + 0.5f + pManager.CurrentPrototype.PlacementOffset.Y);
mouseScreen = (Vector2i)CluwneLib.WorldToScreen(mouseWorld);
// if (CheckCollision())
// return false;
}
return(true);
}
/// <summary>
/// Try to join the lobby at the given IP end point as the given player.
/// </summary>
/// <param name="host">The IP address that the lobby server is running at.</param>
/// <param name="mapManager">The map manager that will be used to check to see if we have a
/// map and to save a downloaded map.</param>
/// <param name="player">This player that will be used to uniquely identify
/// ourselves.</param>
/// <param name="password">The password that the lobby host has set.</param>
public static Task<Maybe<LobbyMember>> JoinLobby(string host, Player player, IMapManager mapManager, string password) {
/*
return Task.Factory.StartNew(() => {
try {
Maybe<NetworkContext> context = NetworkContext.CreateClient(address, player, password);
if (context.Exists) {
LobbyMember lobbyMember = new LobbyMember(context.Value, mapManager);
return Maybe.Just(lobbyMember);
}
}
catch (Exception) {
}
return Maybe<LobbyMember>.Empty;
});
*/
Maybe<LobbyMember> result = Maybe<LobbyMember>.Empty;
Maybe<NetworkContext> context = NetworkContext.CreateClient(host, player, password);
if (context.Exists) {
LobbyMember lobbyMember = new LobbyMember(context.Value, mapManager);
result = Maybe.Just(lobbyMember);
}
return Task.Factory.StartNew(() => result);
}
public Wall(TileState state, RectangleF rect, Direction dir)
: base(state, rect)
{
ConnectSprite = true;
Opaque = true;
_dir = dir;
name = "Wall";
if (dir == Direction.East)
{
Sprite = _resourceManager.GetSprite("wall_EW");
topSprite = _resourceManager.GetSprite("wall_top_EW");
topSpriteNW = _resourceManager.GetSprite("wall_top_2");
topSpriteSE = _resourceManager.GetSprite("wall_top_8");
wallEndE = _resourceManager.GetSprite("wall_end_e");
wallEndW = _resourceManager.GetSprite("wall_end_w");
}
else
{
Sprite = _resourceManager.GetSprite("wall_NS");
topSprite = _resourceManager.GetSprite("wall_top_NS");
topSpriteNW = _resourceManager.GetSprite("wall_top_4");
topSpriteSE = _resourceManager.GetSprite("wall_top_1");
}
mapMgr = IoCManager.Resolve <IMapManager>();
}
public static void DeserializeGrid(IMapManager mapMan, IMap map, ref GridId?gridId, YamlMappingNode info, YamlSequenceNode chunks)
{
ushort csz = 0;
ushort tsz = 0;
float sgsz = 0.0f;
foreach (var kvInfo in info)
{
var key = kvInfo.Key.ToString();
var val = kvInfo.Value.ToString();
if (key == "csz")
{
csz = ushort.Parse(val);
}
else if (key == "tsz")
{
tsz = ushort.Parse(val);
}
else if (key == "sgsz")
{
sgsz = float.Parse(val);
}
}
var grid = map.CreateGrid(gridId, csz, sgsz);
gridId = grid.Index;
foreach (YamlMappingNode chunkNode in chunks.Cast <YamlMappingNode>())
{
DeserializeChunk(mapMan, grid, chunkNode);
}
}
public void Setup()
{
var compMan = IoCManager.Resolve <IComponentManager>();
compMan.Initialize();
EntityManager = IoCManager.Resolve <IServerEntityManagerInternal>();
MapManager = IoCManager.Resolve <IMapManager>();
MapManager.Initialize();
MapManager.Startup();
MapManager.CreateMap();
var manager = IoCManager.Resolve <IPrototypeManager>();
manager.LoadFromStream(new StringReader(PROTOTYPES));
manager.Resync();
// build the net dream
MapA = MapManager.CreateMap();
GridA = MapManager.CreateGrid(MapA);
MapB = MapManager.CreateMap();
GridB = MapManager.CreateGrid(MapB);
//NOTE: The grids have not moved, so we can assert worldpos == localpos for the test
}
public MoveToEntityOperator(IEntity owner, IEntity target, float desiredRange = 1.5f)
{
Setup(owner);
Target = target;
_mapManager = IoCManager.Resolve <IMapManager>();
DesiredRange = desiredRange;
}
/// <summary>
/// Creates a new AiEntityManager from the provided WorldEntity and IMapManager instances.
/// </summary>
/// <param name="entity">The WorldEntity the created AiEntityManager will control.</param>
/// <param name="mapManager">The MapManager for the map that the WorldEntity the AiEntityManager controls exists in.</param>
/// <param name="mapBattleManager">The MapBattleManager for the map that the WorldEntity the AiEntityManager controls
/// exists in.</param>
/// <param name="spawnEntityData">An object containing spawn data for the type of WorldEntity the created manager controls.</param>
/// <returns></returns>
public AiEntityManager Create(WorldEntity entity,
IMapManager mapManager,
IMapBattleManager mapBattleManager,
SpawnEntityData spawnEntityData)
{
return(new AiEntityManager(entity, mapManager, mapBattleManager, spawnEntityData));
}
private static void DeserializeChunk(IMapManager mapMan, IMapGridInternal grid, YamlMappingNode chunkData, IReadOnlyDictionary <ushort, string> tileDefMapping, ITileDefinitionManager tileDefinitionManager)
{
var indNode = chunkData["ind"];
var tileNode = chunkData["tiles"];
var(chunkOffsetX, chunkOffsetY) = indNode.AsVector2i();
var tileBytes = Convert.FromBase64String(tileNode.ToString());
using var stream = new MemoryStream(tileBytes);
using var reader = new BinaryReader(stream);
mapMan.SuppressOnTileChanged = true;
var chunk = grid.GetChunk(chunkOffsetX, chunkOffsetY);
chunk.SuppressCollisionRegeneration = true;
for (ushort y = 0; y < grid.ChunkSize; y++)
{
for (ushort x = 0; x < grid.ChunkSize; x++)
{
var id = reader.ReadUInt16();
var data = reader.ReadUInt16();
var defName = tileDefMapping[id];
id = tileDefinitionManager[defName].TileId;
var tile = new Tile(id, data);
chunk.SetTile(x, y, tile);
}
}
chunk.SuppressCollisionRegeneration = false;
mapMan.SuppressOnTileChanged = false;
}
private static void LoadGridNode(IMapManager mapMan, IMap map, ref GridId?newId, YamlMappingNode gridNode)
{
var info = (YamlMappingNode)gridNode["settings"];
var chunk = (YamlSequenceNode)gridNode["chunks"];
YamlGridSerializer.DeserializeGrid(mapMan, map, ref newId, info, chunk);
}
public EffectOverlay(EffectSystem owner, IPrototypeManager protoMan, IMapManager mapMan) : base(
"EffectSystem")
{
_owner = owner;
_unshadedShader = protoMan.Index <ShaderPrototype>("unshaded").Instance();
_mapManager = mapMan;
}
//TODO: This whole method should be removed once file loading/saving works, and replaced with a 'Demo' map.
/// <summary>
/// Generates 'Demo' grid and inserts it into the map manager.
/// </summary>
/// <param name="mapManager">The map manager to work with.</param>
/// <param name="defManager">The definition manager to work with.</param>
/// <param name="gridId">The ID of the grid to generate and insert into the map manager.</param>
private static void NewDefaultMap(IMapManager mapManager, ITileDefinitionManager defManager, int gridId)
{
mapManager.SuppressOnTileChanged = true;
try
{
Logger.Log("Cannot find map. Generating blank map.", LogLevel.Warning);
var floor = defManager["Floor"].TileId;
var wall = defManager["Wall"].TileId;
Debug.Assert(floor > 0);
Debug.Assert(wall > 0);
var grid = mapManager.GetGrid(gridId) ?? mapManager.CreateGrid(gridId);
for (var y = -32; y <= 32; ++y)
{
for (var x = -32; x <= 32; ++x)
{
if (Math.Abs(x) == 32 || Math.Abs(y) == 32 || Math.Abs(x) == 5 && Math.Abs(y) < 5 || Math.Abs(y) == 7 && Math.Abs(x) < 3)
{
grid.SetTile(x, y, new Tile(wall));
}
else
{
grid.SetTile(x, y, new Tile(floor));
}
}
}
}
finally
{
mapManager.SuppressOnTileChanged = false;
}
}
//TODO: Think about a factory for this
public DebugCoordsPanel(IPlayerManager playerMan,
IEyeManager eyeMan,
IInputManager inputMan,
IStateManager stateMan,
IClyde displayMan,
IMapManager mapMan)
{
playerManager = playerMan;
eyeManager = eyeMan;
inputManager = inputMan;
stateManager = stateMan;
_displayManager = displayMan;
_mapManager = mapMan;
SizeFlagsHorizontal = SizeFlags.None;
contents = new Label
{
FontColorShadowOverride = Color.Black,
};
AddChild(contents);
PanelOverride = new StyleBoxFlat
{
BackgroundColor = new Color(67, 105, 255, 138),
ContentMarginLeftOverride = 5,
ContentMarginTopOverride = 5
};
MouseFilter = contents.MouseFilter = MouseFilterMode.Ignore;
}
public void Setup()
{
var factory = IoCManager.Resolve <IComponentFactory>();
factory.Register <ClientTransformComponent>();
factory.RegisterReference <ClientTransformComponent, ITransformComponent>();
EntityManager = (EntityManager)IoCManager.Resolve <IClientEntityManager>();
MapManager = IoCManager.Resolve <IMapManager>();
var manager = IoCManager.Resolve <IPrototypeManager>();
manager.LoadFromStream(new StringReader(PROTOTYPES));
manager.Resync();
// build the net dream
var newMap = MapManager.CreateMap(new MapId(1));
newMap.CreateGrid(new GridId(4));
newMap = MapManager.CreateMap(new MapId(2));
newMap.CreateGrid(new GridId(5));
//NOTE: The grids have not moved, so we can assert worldpos == localpos for the tests
}
private static void DeserializeChunk(IMapManager mapMan, IMapGrid grid, YamlMappingNode chunk, IReadOnlyDictionary <ushort, string> tileDefMapping, ITileDefinitionManager tileDefinitionManager)
{
var indNode = chunk["ind"];
var tileNode = chunk["tiles"];
var(chunkOffsetX, chunkOffsetY) = indNode.AsVector2i() * grid.ChunkSize;
var tileBytes = Convert.FromBase64String(tileNode.ToString());
using (var stream = new MemoryStream(tileBytes))
using (var reader = new BinaryReader(stream))
{
mapMan.SuppressOnTileChanged = true;
for (var y = 0; y < grid.ChunkSize; y++)
{
for (var x = 0; x < grid.ChunkSize; x++)
{
var id = reader.ReadUInt16();
var data = reader.ReadUInt16();
var defName = tileDefMapping[id];
id = tileDefinitionManager[defName].TileId;
var tile = new Tile(id, data);
grid.SetTile(new MapIndices(chunkOffsetX + x, chunkOffsetY + y), tile);
}
}
mapMan.SuppressOnTileChanged = false;
}
}
public EntityCoordinates ToEntityCoordinates(IMapManager mapManager, GridId gridId)
{
var grid = mapManager.GetGrid(gridId);
var tile = grid.TileSize;
return(new EntityCoordinates(grid.GridEntityId, (X * tile, Y * tile)));
}
private void Init(SPWeb spWeb)
{
IMapManager mapManager = null;
if (spWeb != null && spWeb.Site != null)
{
var binding = new BasicHttpBinding();
binding.ReaderQuotas.MaxStringContentLength = 2147483647;
binding.Security.Mode = BasicHttpSecurityMode.TransportCredentialOnly;
binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Ntlm;
binding.MaxReceivedMessageSize = 2147483647;
//Note in the future it may be necessary to handle in a configuration file what zone to use if the Default zone doesn't support Windows NTLM authentication.
Uri siteUri = new Uri(spWeb.Site.Url + "/");
Uri combinedUri = new Uri(siteUri, "_vti_bin/sevensigma/transactionalmappingtoolservice.svc");
var address = new EndpointAddress(combinedUri);
CallingUrl.Url = spWeb.Url;
var client = new TransactionalMappingToolServiceClient(binding, address);
NetworkCredential credentials = CredentialCache.DefaultNetworkCredentials;
client.ClientCredentials.Windows.AllowedImpersonationLevel = TokenImpersonationLevel.Impersonation;
client.ClientCredentials.Windows.ClientCredential = credentials;
mapManager = new SoapMapManager(client, true);
mapManager.InitialiseMapManagerCompleted += mapManager_InitialiseMapManagerCompleted;
mapManager.InitialiseMapManagerAsync();
Completed.WaitOne(_mapManagerTimeout);
}
}
public bool IsVisible(bool checkWorld = true, [CanBeNull] IMapManager mapManager = null)
{
if (Icon?.DMI == null)
{
return(false);
}
if (Icon.Appearance.Invisibility > 0)
{
return(false); //TODO: mob.see_invisibility
}
if (checkWorld)
{
//Only render turfs (children of map entity) and their contents (secondary child of map entity)
//TODO: Use RobustToolbox's container system/components?
if (!_entityManager.TryGetComponent <TransformComponent>(Owner, out var transform))
{
return(false);
}
IoCManager.Resolve(ref mapManager);
EntityUid mapEntity = mapManager.GetMapEntityId(transform.MapID);
if (transform.ParentUid != mapEntity && transform.Parent?.ParentUid != mapEntity)
{
return(false);
}
}
return(true);
}
public BatchCloneNodesOperation(IMapManager mapManager, INode map, IEnumerable <Node> nodes, IEnumerable <Relationship> relationships)
: base(mapManager)
{
Map = map;
Nodes = nodes;
Relationships = relationships;
}
private void MakeFactionCores(IMapManager mapManager, IFactionManager factionManager)
{
var faction = factionManager.GetPlayerFaction();
faction.ModifyResource(new Dictionary <ResourceType, int>()
{
{ ResourceType.Gold, 10 },
{ ResourceType.Food, 10 },
{ ResourceType.Stone, 10 },
{ ResourceType.Wood, 10 },
});
var coreCell = mapManager.GetRandomCell((cell) => cell.Terrain.Type == TerrainType.Grass);
faction.StructureManager.AddStructure(StructureDefinition.StructureType.Core, coreCell.Coord);
var roadRect = coreCell.NonNullNeighbors;
foreach (var cell in roadRect)
{
faction.StructureManager.AddStructure(StructureDefinition.StructureType.Road, cell.Coord);
}
foreach (var roadStub in CellExtensions.GetCardinalsOutsideRectangle(roadRect))
{
faction.StructureManager.AddStructure(StructureDefinition.StructureType.Road, roadStub.Coord);
}
factionManager.MoveToNextTurn();
}
protected AddNodeOperationBase(IMapManager mapManager, INode map, Point location, Dictionary<string, string> defaultMetadata = null)
: base(mapManager)
{
X = location.X;
Y = location.Y;
Map = map;
DefaultMetadata = defaultMetadata;
}
/// <summary>
/// Converts this set of coordinates to map coordinates.
/// </summary>
public MapCoordinates ToMap(IMapManager mapManager)
{
//TODO: Assert GridID is not invalid
var grid = mapManager.GetGrid(GridID);
return(new MapCoordinates(grid.LocalToWorld(Position), grid.ParentMapId));
}
public MultipleNodeMetadata(string name, string value, MultipleNodesProperties nodeContainer,
IMapManager mapManager)
{
NodeContainer = nodeContainer;
MapManager = mapManager;
_name = name;
_value = value;
}
public TileRef(IMapManager map, int x, int y, Chunk chunk, int index)
{
this.map = map;
this.x = x;
this.y = y;
this.chunk = chunk;
this.index = index;
}
protected AddNodeOperationBase(IMapManager mapManager, INode map, Point location, Dictionary <string, string> defaultMetadata = null)
: base(mapManager)
{
X = location.X;
Y = location.Y;
Map = map;
DefaultMetadata = defaultMetadata;
}
public SuperFileProcessor(FileInfo[] files, IMapManager mapManager, INode map, Point location)
{
_files = files;
_mapManager = mapManager;
_map = map;
_location = location;
_fileCount = _files == null ? 0 : _files.Count();
_processedFile = 0;
}
private LobbyHost(NetworkContext context, IMapManager mapManager, string map)
: base(context) {
_mapHandler = new MapDownloadServerMessageHandler(context, mapManager, map);
_context.AddConnectionMonitor(_mapHandler);
_context.AddMessageHandler(_mapHandler);
_readinessHandler = new LobbyHostPlayerReadinessMessageHandler(context);
_context.AddConnectionMonitor(_readinessHandler);
_context.AddMessageHandler(_readinessHandler);
}
public override bool Update(Vector2D mouseS, IMapManager currentMap)
{
if (currentMap == null) return false;
spriteToDraw = GetDirectionalSprite(pManager.CurrentBaseSprite);
mouseScreen = mouseS;
mouseWorld = new Vector2D(mouseScreen.X + ClientWindowData.Singleton.ScreenOrigin.X,
mouseScreen.Y + ClientWindowData.Singleton.ScreenOrigin.Y);
var spriteRectWorld = new RectangleF(mouseWorld.X - (spriteToDraw.Width/2f),
mouseWorld.Y - (spriteToDraw.Height/2f), spriteToDraw.Width,
spriteToDraw.Height);
currentTile = currentMap.GetWallAt(mouseWorld);
if (!currentMap.IsSolidTile(mouseWorld))
return false;
if (pManager.CurrentPermission.Range > 0)
if (
(pManager.PlayerManager.ControlledEntity.GetComponent<TransformComponent>(ComponentFamily.Transform)
.Position - mouseWorld).Length > pManager.CurrentPermission.Range)
return false;
if (currentTile != null)
{
if (pManager.CurrentPermission.IsTile)
{
mouseWorld = (currentTile.Position +
new Vector2D(currentMap.GetTileSpacing()/2f, currentMap.GetTileSpacing()/2f));
mouseScreen = new Vector2D(mouseWorld.X - ClientWindowData.Singleton.ScreenOrigin.X,
mouseWorld.Y - ClientWindowData.Singleton.ScreenOrigin.Y);
}
else
{
mouseWorld = (currentTile.Position +
new Vector2D(currentMap.GetTileSpacing()/2f, currentMap.GetTileSpacing()/2f)) +
new Vector2D(pManager.CurrentTemplate.PlacementOffset.Key,
pManager.CurrentTemplate.PlacementOffset.Value);
mouseScreen = new Vector2D(mouseWorld.X - ClientWindowData.Singleton.ScreenOrigin.X,
mouseWorld.Y - ClientWindowData.Singleton.ScreenOrigin.Y);
spriteRectWorld = new RectangleF(mouseWorld.X - (spriteToDraw.Width/2f),
mouseWorld.Y - (spriteToDraw.Height/2f), spriteToDraw.Width,
spriteToDraw.Height);
if (pManager.CollisionManager.IsColliding(spriteRectWorld))
return false;
//Since walls also have collisions, this means we can't place objects on walls with this mode.
}
}
return true;
}
public override bool Update(Vector2D mouseS, IMapManager currentMap)
{
if (currentMap == null) return false;
spriteToDraw = GetDirectionalSprite(pManager.CurrentBaseSprite);
mouseScreen = mouseS;
mouseWorld = new Vector2D(mouseScreen.X + ClientWindowData.Singleton.ScreenOrigin.X,
mouseScreen.Y + ClientWindowData.Singleton.ScreenOrigin.Y);
var spriteRectWorld = new RectangleF(mouseWorld.X - (spriteToDraw.Width / 2f),
mouseWorld.Y - (spriteToDraw.Height / 2f), spriteToDraw.Width,
spriteToDraw.Height);
if (pManager.CurrentPermission.Range > 0)
if (
(pManager.PlayerManager.ControlledEntity.GetComponent<TransformComponent>(ComponentFamily.Transform)
.Position - mouseWorld).Length > pManager.CurrentPermission.Range) return false;
currentTile = currentMap.GetFloorAt(mouseWorld);
if (currentTile == null)
return false;
if (pManager.Direction == Direction.East || pManager.Direction == Direction.West)
{
pManager.Direction = Direction.East; // Don't ask
if (mouseWorld.Y > currentTile.Position.Y + (currentMap.GetTileSpacing() / 2f))
{
mouseWorld = currentTile.Position + new Vector2D(0f, currentMap.GetTileSpacing() - (currentMap.GetWallThickness() / 2f));
}
else
{
mouseWorld = currentTile.Position + new Vector2D(0f, -(currentMap.GetWallThickness() / 2f));
}
}
else
{
pManager.Direction = Direction.North;
if (mouseWorld.X > currentTile.Position.X + (currentMap.GetTileSpacing() / 2f))
{
mouseWorld = currentTile.Position + new Vector2D(currentMap.GetTileSpacing() - (currentMap.GetWallThickness() / 2f), 0f);
}
else // Westside, yo
{
mouseWorld = currentTile.Position + new Vector2D(-(currentMap.GetWallThickness() / 2f), 0f);
}
}
mouseScreen = new Vector2D(mouseWorld.X - ClientWindowData.Singleton.ScreenOrigin.X,
mouseWorld.Y - ClientWindowData.Singleton.ScreenOrigin.Y);
return true;
}
public override bool Update(Vector2 mouseS, IMapManager currentMap)
{
if (currentMap == null) return false;
spriteToDraw = GetDirectionalSprite(pManager.CurrentBaseSprite);
mouseScreen = mouseS;
mouseWorld = MapUtil.worldToTileSize(mouseScreen);
currentTile = currentMap.GetTileRef(mouseWorld);
return true;
}
private void mapManager_InitialiseMapManagerCompleted(object sender, InitialiseMapManagerEventArgs e)
{
if (e.IsInitialised)
{
_mapManager = sender as IMapManager;
}
else
{
ErrorMessage = e.ErrorMessage;
}
Completed.Set();
}
public override bool Update(Vector2i mouseS, IMapManager currentMap)
{
if (currentMap == null) return false;
spriteToDraw = GetDirectionalSprite(pManager.CurrentBaseSpriteKey);
mouseScreen = mouseS;
mouseWorld = CluwneLib.ScreenToWorld(mouseScreen);
currentTile = currentMap.GetTileRef(mouseWorld);
return true;
}
public override bool Update(Vector2 mouseS, IMapManager currentMap)
{
if (currentMap == null) return false;
spriteToDraw = GetDirectionalSprite(pManager.CurrentBaseSprite);
mouseScreen = mouseS;
mouseWorld = ClientWindowData.Singleton.ScreenToWorld(mouseScreen);
currentTile = currentMap.GetTileRef(mouseWorld);
return true;
}
protected State(IDictionary<Type, object> managers)
{
StateManager = (IStateManager) managers[typeof (IStateManager)];
NetworkManager = (INetworkManager) managers[typeof (INetworkManager)];
ResourceManager = (IResourceManager) managers[typeof (IResourceManager)];
UserInterfaceManager = (IUserInterfaceManager) managers[typeof (IUserInterfaceManager)];
MapManager = (IMapManager) managers[typeof (IMapManager)];
PlayerManager = (IPlayerManager) managers[typeof (IPlayerManager)];
ConfigurationManager = (IConfigurationManager) managers[typeof (IConfigurationManager)];
PlacementManager = (IPlacementManager) managers[typeof (IPlacementManager)];
KeyBindingManager = (IKeyBindingManager) managers[typeof (IKeyBindingManager)];
}
public override bool Update(Vector2D mouseS, IMapManager currentMap)
{
if (currentMap == null) return false;
spriteToDraw = GetDirectionalSprite(pManager.CurrentBaseSprite);
mouseScreen = mouseS;
mouseWorld = new Vector2D(mouseScreen.X + ClientWindowData.Singleton.ScreenOrigin.X,
mouseScreen.Y + ClientWindowData.Singleton.ScreenOrigin.Y);
currentTile = currentMap.GetFloorAt(mouseWorld);
return true;
}
public override bool Update(Vector2i mouseS, IMapManager currentMap)
{
if (currentMap == null) return false;
spriteToDraw = GetDirectionalSprite(pManager.CurrentBaseSpriteKey);
mouseScreen = mouseS;
mouseWorld = CluwneLib.ScreenToWorld(mouseScreen);
var bounds = spriteToDraw.GetLocalBounds();
var spriteSize = CluwneLib.PixelToTile(new Vector2f(bounds.Width, bounds.Height));
var spriteRectWorld = new FloatRect(mouseWorld.X - (spriteSize.X / 2f),
mouseWorld.Y - (spriteSize.Y / 2f),
spriteSize.X, spriteSize.Y);
currentTile = currentMap.GetTileRef(mouseWorld);
if (currentTile.Tile.TileDef.IsWall)
return false;
var rangeSquared = pManager.CurrentPermission.Range * pManager.CurrentPermission.Range;
if (rangeSquared > 0)
if (
(pManager.PlayerManager.ControlledEntity.GetComponent<TransformComponent>(ComponentFamily.Transform)
.Position - mouseWorld).LengthSquared() > rangeSquared)
return false;
if (pManager.CurrentPermission.IsTile)
{
mouseWorld = new Vector2f(currentTile.X + 0.5f,
currentTile.Y + 0.5f);
mouseScreen = CluwneLib.WorldToScreen(mouseWorld).Round();
}
else
{
mouseWorld = new Vector2f(currentTile.X + 0.5f + pManager.CurrentTemplate.PlacementOffset.Key,
currentTile.Y + 0.5f + pManager.CurrentTemplate.PlacementOffset.Value);
mouseScreen = CluwneLib.WorldToScreen(mouseWorld).Round();
spriteRectWorld = new FloatRect(mouseWorld.X - (bounds.Width/2f),
mouseWorld.Y - (bounds.Height/2f), bounds.Width,
bounds.Height);
if (pManager.CollisionManager.IsColliding(spriteRectWorld))
return false;
//Since walls also have collisions, this means we can't place objects on walls with this mode.
}
return true;
}
public SoapMetadataSet(IMapManager mapManager, ServerObjects.Metadata serviceMetadata, INode node, IRelationship relationship)
{
MapManager = mapManager;
ServiceMetadata = serviceMetadata;
Id = serviceMetadata.MetadataId;
DomainId = serviceMetadata.DomainUid;
RootMapId = serviceMetadata.RootMapUid;
Name = serviceMetadata.MetadataName;
Value = serviceMetadata.MetadataValue;
if (serviceMetadata.NodeUid.HasValue && serviceMetadata.NodeUid == node.Id)
{
Node = node;
}
else if (serviceMetadata.NodeUid.HasValue && serviceMetadata.NodeUid != node.Id)
{
throw new NotSupportedException("The node ID in the service metadata object differs to the provided node.");
}
else
{
Node = null;
}
if (serviceMetadata.RelationshipUid.HasValue && serviceMetadata.RelationshipUid == relationship.Id)
{
Relationship = relationship;
}
else if (serviceMetadata.RelationshipUid.HasValue && serviceMetadata.RelationshipUid != relationship.Id)
{
throw new NotSupportedException("The relationship ID in the service metadata object differs to the provided relationship.");
}
else
{
Relationship = null;
}
ConnectionType = null;
if (serviceMetadata.DescriptorTypeUid.HasValue && serviceMetadata.DescriptorTypeUid != Guid.Empty)
{
if (MapManager.ConnectionTypes.ContainsKey(serviceMetadata.DescriptorTypeUid.Value))
{
ConnectionType = MapManager.ConnectionTypes[serviceMetadata.DescriptorTypeUid.Value];
}
}
}
public override bool Update(Vector2 mouseS, IMapManager currentMap)
{
if (currentMap == null) return false;
spriteToDraw = GetDirectionalSprite(pManager.CurrentBaseSprite);
mouseScreen = mouseS;
mouseWorld = MapUtil.worldToTileSize(mouseScreen);
var spriteSize = MapUtil.worldToTileSize(spriteToDraw.Size);
var spriteRectWorld = new RectangleF(mouseWorld.X - (spriteSize.X / 2f),
mouseWorld.Y - (spriteSize.Y / 2f),
spriteSize.X, spriteSize.Y);
currentTile = currentMap.GetTileRef(mouseWorld);
if (currentTile.Tile.TileId != 0)
return false;
if (pManager.CurrentPermission.Range > 0)
if (
(pManager.PlayerManager.ControlledEntity.GetComponent<TransformComponent>(ComponentFamily.Transform)
.Position - mouseWorld).Length > pManager.CurrentPermission.Range)
return false;
if (pManager.CurrentPermission.IsTile)
{
mouseWorld = new Vector2(currentTile.X + 0.5f,
currentTile.Y + 0.5f);
mouseScreen = MapUtil.tileToWorldSize(mouseWorld);
}
else
{
mouseWorld = new Vector2(currentTile.X + 0.5f + pManager.CurrentTemplate.PlacementOffset.Key,
currentTile.Y + 0.5f + pManager.CurrentTemplate.PlacementOffset.Value);
mouseScreen = MapUtil.tileToWorldSize(mouseWorld);
spriteRectWorld = new RectangleF(mouseWorld.X - (spriteToDraw.Width/2f),
mouseWorld.Y - (spriteToDraw.Height/2f), spriteToDraw.Width,
spriteToDraw.Height);
if (pManager.CollisionManager.IsColliding(spriteRectWorld))
return false;
//Since walls also have collisions, this means we can't place objects on walls with this mode.
}
return true;
}
public static MetadataSetFactory GetInstance(IMapManager mapManager)
{
lock (padlock)
{
if (instances == null)
{
instances = new Dictionary<IMapManager, MetadataSetFactory>();
}
if (!instances.ContainsKey(mapManager))
{
instances[mapManager] = new MetadataSetFactory(mapManager);
}
return instances[mapManager];
}
}
public static List<INode> FindContainerMapsOfNode(this INode node, IMapManager mapManager)
{
var output = new List<INode>();
var relationships = node.Relationships.FindRelationships(mapManager.ConnectionTypes["From"], mapManager.RelationshipTypes["MapContainerRelationship"]);
foreach (var relationship in relationships)
{
var maps = relationship.Nodes.FindNodes(mapManager.ConnectionTypes["To"]);
if (maps != null)
{
var map = maps.FirstOrDefault();
if (map != null && map.NodeType == mapManager.NodeTypes["CompendiumMapNode"] && map.Id != node.Id)
{
output.Add(map);
}
}
}
return output;
}
public override bool Update(Vector2i mouseS, IMapManager currentMap)
{
if (currentMap == null) return false;
spriteToDraw = GetDirectionalSprite(pManager.CurrentBaseSpriteKey);
mouseScreen = mouseS;
mouseWorld = CluwneLib.ScreenToWorld(mouseScreen);
var bounds = spriteToDraw.GetLocalBounds();
var spriteSize = CluwneLib.PixelToTile(new Vector2f(bounds.Width, bounds.Height));
var spriteRectWorld = new FloatRect(mouseWorld.X - (spriteSize.X / 2f),
mouseWorld.Y - (spriteSize.Y / 2f),
spriteSize.X, spriteSize.Y);
if (pManager.CurrentPermission.IsTile)
return false;
//CollisionManager collisionMgr = (CollisionManager)ServiceManager.Singleton.GetService(ClientServiceType.CollisionManager);
//if (collisionMgr.IsColliding(spriteRectWorld, true)) validPosition = false;
currentTile = currentMap.GetTileRef(mouseWorld);
if (!currentTile.Tile.TileDef.IsWall)
return false;
var rangeSquared = pManager.CurrentPermission.Range * pManager.CurrentPermission.Range;
if (rangeSquared > 0)
if (
(pManager.PlayerManager.ControlledEntity.GetComponent<TransformComponent>(ComponentFamily.Transform)
.Position - mouseWorld).LengthSquared() > rangeSquared)
return false;
var nodes = new List<Vector2f>();
if (pManager.CurrentTemplate.MountingPoints != null)
{
nodes.AddRange(
pManager.CurrentTemplate.MountingPoints.Select(
current => new Vector2f(mouseWorld.X, currentTile.Y + current)));
}
else
{
nodes.Add(new Vector2f(mouseWorld.X, currentTile.Y + 0.5f));
nodes.Add(new Vector2f(mouseWorld.X, currentTile.Y + 1.0f));
nodes.Add(new Vector2f(mouseWorld.X, currentTile.Y + 1.5f));
}
Vector2f closestNode = (from Vector2f node in nodes
orderby (node - mouseWorld).LengthSquared() ascending
select node).First();
mouseWorld = closestNode + new Vector2f(pManager.CurrentTemplate.PlacementOffset.Key,
pManager.CurrentTemplate.PlacementOffset.Value);
mouseScreen = CluwneLib.WorldToScreen(mouseWorld).Round();
var range = pManager.CurrentPermission.Range;
if (range > 0)
if (
(pManager.PlayerManager.ControlledEntity.GetComponent<TransformComponent>(ComponentFamily.Transform)
.Position - mouseWorld).LengthSquared() > range * range)
return false;
return true;
}
public InProcessMetadata(IMapManager mapManager)
{
MapManager = mapManager;
}
public HtmlExportUtility(IMapManager mapmanager)
: base(mapmanager)
{
FileExtension = "html";
}
public TileRef(IMapManager map, int x, int y) : this(map, x, y, null, 0) { }
protected CommonSuperGraphBase(IMapManager mapManager)
{
MapManager = mapManager;
}
private MetadataSetFactory(IMapManager mapManager)
{
MapManager = mapManager;
}
