/// <inheritdoc /> public bool TrySpawnEntityAt(string EntityType, Vector2 position, int argMap, out IEntity entity) { var mapmanager = IoCManager.Resolve <IMapManager>(); var coordinates = new LocalCoordinates(position, mapmanager.GetMap(argMap).FindGridAt(position)); return(TrySpawnEntityAt(EntityType, coordinates, out entity)); }
public override void AlignPlacementMode(ScreenCoordinates mouseScreen) { MouseCoords = ScreenToPlayerGrid(mouseScreen); CurrentTile = MouseCoords.Grid.GetTile(MouseCoords); if (pManager.CurrentPermission.IsTile) { return; } var nodes = new List <Vector2>(); if (pManager.CurrentPrototype.MountingPoints != null) { nodes.AddRange( pManager.CurrentPrototype.MountingPoints.Select( current => new Vector2(MouseCoords.X, CurrentTile.Y + current))); } else { nodes.Add(new Vector2(MouseCoords.X, CurrentTile.Y + 0.5f)); nodes.Add(new Vector2(MouseCoords.X, CurrentTile.Y + 1.0f)); nodes.Add(new Vector2(MouseCoords.X, CurrentTile.Y + 1.5f)); } Vector2 closestNode = (from Vector2 node in nodes orderby(node - MouseCoords.Position).LengthSquared ascending select node).First(); MouseCoords = new LocalCoordinates(closestNode + new Vector2(pManager.CurrentPrototype.PlacementOffset.X, pManager.CurrentPrototype.PlacementOffset.Y), MouseCoords.Grid); }
public override bool FrameUpdate(RenderFrameEventArgs e, ScreenCoordinates mouseS) { if (mouseS.MapID == MapId.Nullspace) { onGrid = false; return(false); } MouseScreen = mouseS; MouseCoords = pManager.eyeManager.ScreenToWorld(MouseScreen); snapSize = MouseCoords.Grid.SnapSize; //Find snap size. onGrid = true; var mouselocal = new Vector2( //Round local coordinates onto the snap grid (float)Math.Round(MouseCoords.X / (double)snapSize, MidpointRounding.AwayFromZero) * snapSize, (float)Math.Round(MouseCoords.Y / (double)snapSize, MidpointRounding.AwayFromZero) * snapSize); //Convert back to original world and screen coordinates after applying offset MouseCoords = new LocalCoordinates(mouselocal + new Vector2(pManager.CurrentPrototype.PlacementOffset.X, pManager.CurrentPrototype.PlacementOffset.Y), MouseCoords.Grid); MouseScreen = pManager.eyeManager.WorldToScreen(MouseCoords); if (!RangeCheck()) { return(false); } return(true); }
/// <inheritdoc /> public IEntity ForceSpawnEntityAt(string EntityType, Vector2 position, int argMap) { var mapmanager = IoCManager.Resolve <IMapManager>(); var coordinates = new LocalCoordinates(position, mapmanager.GetMap(argMap).FindGridAt(position)); return(ForceSpawnEntityAt(EntityType, coordinates)); }
public override void AlignPlacementMode(ScreenCoordinates mouseScreen) { if (mouseScreen.MapID == MapId.Nullspace) { return; } MouseCoords = ScreenToPlayerGrid(mouseScreen); CurrentTile = MouseCoords.Grid.GetTile(MouseCoords); float tileSize = MouseCoords.Grid.TileSize; //convert from ushort to float GridDistancing = tileSize; if (pManager.CurrentPermission.IsTile) { MouseCoords = new LocalCoordinates(CurrentTile.X + tileSize / 2, CurrentTile.Y + tileSize / 2, MouseCoords.Grid); } else { MouseCoords = new LocalCoordinates(CurrentTile.X + tileSize / 2 + pManager.CurrentPrototype.PlacementOffset.X, CurrentTile.Y + tileSize / 2 + pManager.CurrentPrototype.PlacementOffset.Y, MouseCoords.Grid); } }
public bool CheckClick(LocalCoordinates worldPos, out int drawdepth) { var component = Owner.GetComponent <IClickTargetComponent>(); drawdepth = (int)component.DrawDepth; return(true); }
public IEntity GetEntityUnderPosition(LocalCoordinates coordinates) { // Find all the entities intersecting our click var entities = _entityManager.GetEntitiesIntersecting(coordinates.MapID, coordinates.Position); // Check the entities against whether or not we can click them var foundEntities = new List <(IEntity clicked, int drawDepth)>(); foreach (IEntity entity in entities) { if (entity.TryGetComponent <IClientClickableComponent>(out var component) && entity.GetComponent <ITransformComponent>().IsMapTransform && component.CheckClick(coordinates, out int drawdepthofclicked)) { foundEntities.Add((entity, drawdepthofclicked)); } } if (foundEntities.Count != 0) { foundEntities.Sort(new ClickableEntityComparer()); return(foundEntities[foundEntities.Count - 1].clicked); } return(null); }
public override bool FrameUpdate(RenderFrameEventArgs e, ScreenCoordinates mouseS) { if (mouseS.MapID == MapId.Nullspace) { return(false); } MouseScreen = mouseS; MouseCoords = pManager.eyeManager.ScreenToWorld(MouseScreen); CurrentTile = MouseCoords.Grid.GetTile(MouseCoords); var tileSize = MouseCoords.Grid.TileSize; if (!RangeCheck()) { return(false); } if (pManager.CurrentPermission.IsTile) { MouseCoords = new LocalCoordinates(CurrentTile.X + tileSize / 2, CurrentTile.Y + tileSize / 2, MouseCoords.Grid); } else { MouseCoords = new LocalCoordinates(CurrentTile.X + tileSize / 2 + pManager.CurrentPrototype.PlacementOffset.X, CurrentTile.Y + tileSize / 2 + pManager.CurrentPrototype.PlacementOffset.Y, MouseCoords.Grid); } MouseScreen = pManager.eyeManager.WorldToScreen(MouseCoords); return(true); }
public override bool Update(ScreenCoordinates mouseS) { if (mouseS.MapID == MapManager.NULLSPACE) { return(false); } mouseScreen = mouseS; mouseCoords = CluwneLib.ScreenToCoordinates(mouseScreen); var snapsize = mouseCoords.Grid.SnapSize; //Find snap size. var mouselocal = new Vector2( //Round local coordinates onto the snap grid (float)(Math.Round((mouseCoords.Position.X / (double)snapsize - 0.5), MidpointRounding.AwayFromZero) + 0.5) * snapsize, (float)(Math.Round((mouseCoords.Position.Y / (double)snapsize - 0.5), MidpointRounding.AwayFromZero) + 0.5) * snapsize); //Adjust mouseCoords to new calculated position mouseCoords = new LocalCoordinates(mouselocal + new Vector2(pManager.CurrentPrototype.PlacementOffset.X, pManager.CurrentPrototype.PlacementOffset.Y), mouseCoords.Grid); mouseScreen = CluwneLib.WorldToScreen(mouseCoords); if (!RangeCheck()) { return(false); } return(true); }
void IAfterAttack.Afterattack(IEntity user, LocalCoordinates clicklocation, IEntity attacked) { if (UserCanFire(user) && WeaponCanFire()) { Fire(user, clicklocation); } }
public override bool Update(ScreenCoordinates mouseS) { if (mouseS.MapID == MapManager.NULLSPACE) { return(false); } mouseScreen = mouseS; mouseCoords = CluwneLib.ScreenToCoordinates(mouseScreen); currentTile = mouseCoords.Grid.GetTile(mouseCoords); var tilesize = mouseCoords.Grid.TileSize; if (!RangeCheck()) { return(false); } if (pManager.CurrentPermission.IsTile) { mouseCoords = new LocalCoordinates(currentTile.X + tilesize / 2, currentTile.Y + tilesize / 2, mouseCoords.Grid); mouseScreen = CluwneLib.WorldToScreen(mouseCoords); } else { mouseCoords = new LocalCoordinates(currentTile.X + tilesize / 2 + pManager.CurrentPrototype.PlacementOffset.X, currentTile.Y + tilesize / 2 + pManager.CurrentPrototype.PlacementOffset.Y, mouseCoords.Grid); mouseScreen = CluwneLib.WorldToScreen(mouseCoords); } return(true); }
public override bool Update(ScreenCoordinates mouseS) { if (mouseS.MapID == MapManager.NULLSPACE) { return(false); } mouseScreen = mouseS; mouseCoords = CluwneLib.ScreenToCoordinates(mouseScreen); var snapsize = mouseCoords.Grid.SnapSize; //Find snap size. var mouselocal = new Vector2( //Round local coordinates onto the snap grid (float)Math.Round((mouseCoords.X / (double)snapsize), MidpointRounding.AwayFromZero) * snapsize, (float)Math.Round((mouseCoords.Y / (double)snapsize), MidpointRounding.AwayFromZero) * snapsize); //Convert back to original world and screen coordinates after applying offset mouseCoords = new LocalCoordinates(mouselocal + new Vector2(pManager.CurrentPrototype.PlacementOffset.X, pManager.CurrentPrototype.PlacementOffset.Y), mouseCoords.Grid); mouseScreen = CluwneLib.WorldToScreen(mouseCoords); if (!RangeCheck()) { return(false); } return(true); }
public override bool FrameUpdate(RenderFrameEventArgs e, ScreenCoordinates mouseS) { if (mouseS.MapID == MapId.Nullspace) { onGrid = false; return(false); } MouseScreen = mouseS; MouseCoords = pManager.eyeManager.ScreenToWorld(MouseScreen); snapSize = MouseCoords.Grid.SnapSize; //Find snap size. onGrid = true; var mouseLocal = new Vector2( //Round local coordinates onto the snap grid (float)(Math.Round((MouseCoords.Position.X / (double)snapSize - 0.5f), MidpointRounding.AwayFromZero) + 0.5) * snapSize, (float)(Math.Round((MouseCoords.Position.Y / (double)snapSize - 0.5f), MidpointRounding.AwayFromZero) + 0.5) * snapSize); //Adjust mouseCoords to new calculated position MouseCoords = new LocalCoordinates(mouseLocal + new Vector2(pManager.CurrentPrototype.PlacementOffset.X, pManager.CurrentPrototype.PlacementOffset.Y), MouseCoords.Grid); MouseScreen = pManager.eyeManager.WorldToScreen(MouseCoords); if (!RangeCheck()) { return(false); } return(true); }
/// <inheritdoc /> public IEntity ForceSpawnEntityAt(string EntityType, LocalCoordinates coordinates) { IEntity entity = SpawnEntity(EntityType); entity.GetComponent <TransformComponent>().LocalPosition = coordinates; entity.Initialize(); return(entity); }
public override bool IsValidPosition(LocalCoordinates position) { if (!RangeCheck(position)) { return(false); } return(true); }
/// <summary> /// Constructs a new state snapshot of a TransformComponent. /// </summary> /// <param name="position">Current position offset of the entity.</param> /// <param name="rotation">Current direction offset of the entity.</param> /// <param name="parent">Current parent transform of this entity.</param> public TransformComponentState(LocalCoordinates position, Angle rotation, int?parentID) : base(NetIDs.TRANSFORM) { Position = position.Position; MapID = position.MapID; GridID = position.GridID; Rotation = rotation; ParentID = parentID; }
/// <summary> /// We didn't click on any entity, try doing an afterattack on the click location /// </summary> /// <param name="user"></param> /// <param name="weapon"></param> /// <param name="clicklocation"></param> private void InteractAfterattack(IEntity user, IEntity weapon, LocalCoordinates clicklocation) { List <IAfterAttack> afterattacks = weapon.GetComponents <IAfterAttack>().ToList(); for (var i = 0; i < afterattacks.Count; i++) { afterattacks[i].Afterattack(user, clicklocation); } }
/// <summary> /// Gets all players inside of a circle. /// </summary> /// <param name="position">Position of the circle in world-space.</param> /// <param name="range">Radius of the circle in world units.</param> /// <returns></returns> public List <IPlayerSession> GetPlayersInRange(LocalCoordinates position, int range) { //TODO: This needs to be moved to the PVS system. return (_sessions.Values.Where(x => x.attachedEntity != null && position.InRange(x.attachedEntity.GetComponent <ITransformComponent>().LocalPosition, range)) .Cast <IPlayerSession>() .ToList()); }
/// <summary> /// Play an audio file at a static position. /// </summary> /// <param name="filename">The resource path to the OGG Vorbis file to play.</param> /// <param name="coordinates">The coordinates at which to play the audio.</param> public void Play(string filename, LocalCoordinates coordinates, AudioParams?audioParams = null) { var msg = new PlayAudioPositionalMessage { FileName = filename, Coordinates = coordinates, AudioParams = audioParams ?? AudioParams.Default }; RaiseNetworkEvent(msg); }
/// <inheritdoc /> public IEntity ForceSpawnEntityAt(string entityType, LocalCoordinates coordinates) { Entity entity = SpawnEntity(entityType); entity.GetComponent <TransformComponent>().LocalPosition = coordinates; if (Started) { InitializeEntity(entity); } return(entity); }
protected override void Fire(IEntity user, LocalCoordinates clicklocation) { var userposition = user.GetComponent <TransformComponent>().WorldPosition; //Remember world positions are ephemeral and can only be used instantaneously var angle = new Angle(clicklocation.Position - userposition); var ray = new Ray(userposition, angle.ToVec()); var raycastresults = IoCManager.Resolve <ICollisionManager>().IntersectRay(ray, 20, Owner.GetComponent <TransformComponent>().GetMapTransform().Owner); Hit(raycastresults); AfterEffects(user, raycastresults, angle); }
public void AssignFunctions(RiverGenerator rg) { this.rg = rg; lc = rg.localCoordinates; //globalRiverC = rg.globalRiverC; lt = rg.lt; fmc = rg.fmc; ftm = rg.ftm; fd = rg.fd; }
public IEnumerable <IEntity> GetEntitiesInRange(IEntity entity, float range) { if (entity.TryGetComponent <BoundingBoxComponent>(out var component)) { return(GetEntitiesInRange(entity.GetComponent <ITransformComponent>().MapID, component.WorldAABB, range)); } else { LocalCoordinates coords = entity.GetComponent <ITransformComponent>().LocalPosition; return(GetEntitiesInRange(coords, range)); } }
public override bool IsValidPosition(LocalCoordinates position) { if (!RangeCheck(position)) { return(false); } var entitymanager = IoCManager.Resolve <IClientEntityManager>(); return(!(entitymanager.AnyEntitiesIntersecting(MouseCoords.MapID, new Box2(new Vector2(CurrentTile.X, CurrentTile.Y), new Vector2(CurrentTile.X + 0.99f, CurrentTile.Y + 0.99f))))); }
public RiverGenerator(LocalTerrain localTerrain) { lt = localTerrain; //globalRiverC = new GlobalCoordinates(100); localCoordinates = lt.localTerrainC; //currentRiver = new RiverInfo(this); rivers = new List<RiverInfo>(); //localRiverC = new LocalCoordinates(globalRiverC, new Vector3(0, 0, 0), 200, 200); }
/// <inheritdoc /> public IEnumerable <IEntity> GetEntitiesInArc(LocalCoordinates coordinates, float range, Angle direction, float arcwidth) { var entities = GetEntitiesInRange(coordinates, range); foreach (var entity in entities) { var angle = new Angle(entity.GetComponent <TransformComponent>().WorldPosition - coordinates.ToWorld().Position); if (angle.Degrees < direction.Degrees + arcwidth / 2 && angle.Degrees > direction.Degrees - arcwidth / 2) { yield return(entity); } } }
public override bool IsValidPosition(LocalCoordinates position) { if (pManager.CurrentPermission.IsTile) { return(false); } else if (!RangeCheck(position)) { return(false); } return(true); }
public override void AlignPlacementMode(ScreenCoordinates mouseScreen) { MouseCoords = ScreenToPlayerGrid(mouseScreen); CurrentTile = MouseCoords.Grid.GetTile(MouseCoords); if (pManager.CurrentPermission.IsTile) { return; } if (!RangeCheck(MouseCoords)) { return; } var manager = IoCManager.Resolve <IClientEntityManager>(); var snapToEntities = manager.GetEntitiesInRange(MouseCoords, SnapToRange) .Where(entity => entity.Prototype == pManager.CurrentPrototype && entity.GetComponent <ITransformComponent>().MapID == MouseCoords.MapID) .OrderBy(entity => (entity.GetComponent <ITransformComponent>().WorldPosition - MouseCoords.ToWorld().Position).LengthSquared) .ToList(); if (snapToEntities.Any()) { var closestEntity = snapToEntities.First(); if (closestEntity.TryGetComponent <ISpriteComponent>(out var component)) { var closestBounds = component.BaseRSI.Size; var closestRect = Box2.FromDimensions( closestEntity.GetComponent <ITransformComponent>().WorldPosition.X - closestBounds.X / 2f, closestEntity.GetComponent <ITransformComponent>().WorldPosition.Y - closestBounds.Y / 2f, closestBounds.X, closestBounds.Y); var sides = new[] { new Vector2(closestRect.Left + closestRect.Width / 2f, closestRect.Top - closestBounds.Y / 2f), new Vector2(closestRect.Left + closestRect.Width / 2f, closestRect.Bottom + closestBounds.Y / 2f), new Vector2(closestRect.Left - closestBounds.X / 2f, closestRect.Top + closestRect.Height / 2f), new Vector2(closestRect.Right + closestBounds.X / 2f, closestRect.Top + closestRect.Height / 2f) }; var closestSide = (from Vector2 side in sides orderby(side - MouseCoords.Position).LengthSquared select side).First(); MouseCoords = new LocalCoordinates(closestSide, MouseCoords.Grid); } } }
public IEnumerable <IEntity> GetEntitiesInRange(LocalCoordinates worldPos, float Range) { Range *= Range; // Square it here to avoid Sqrt foreach (var entity in GetEntities()) { var transform = entity.GetComponent <ITransformComponent>(); var relativePosition = worldPos.Position - transform.WorldPosition; if (relativePosition.LengthSquared <= Range) { yield return(entity); } } }
/// <summary> /// Checks if the player is spawning within a certain range of his character if range is required on this mode /// </summary> /// <returns></returns> public bool RangeCheck(LocalCoordinates coordinates) { if (!RangeRequired) { return(true); } var range = pManager.CurrentPermission.Range; if (range > 0 && !pManager.PlayerManager.LocalPlayer.ControlledEntity.GetComponent <ITransformComponent>().LocalPosition.InRange(coordinates, range)) { return(false); } return(true); }
public ReadResults Parse(out ICoordinates result) { result = default; ReadResults readResults = ReadDouble(out double left); if (!readResults.Successful) { return(readResults); } if (UseBedrock) { StringReader.SkipWhitespace(); } else { if (!StringReader.AtEndOfArgument()) { StringReader.SetCursor(Start); return(ReadResults.Failure(CommandError.Vec3CoordinatesIncomplete().WithContext(StringReader))); } StringReader.Skip(); } readResults = ReadDouble(out double up); if (!readResults.Successful) { return(readResults); } if (UseBedrock) { StringReader.SkipWhitespace(); } else { if (!StringReader.AtEndOfArgument()) { StringReader.SetCursor(Start); return(ReadResults.Failure(CommandError.Vec3CoordinatesIncomplete().WithContext(StringReader))); } StringReader.Skip(); } readResults = ReadDouble(out double forwards); if (readResults.Successful) { result = new LocalCoordinates(left, up, forwards); } return(readResults); }
public LocalTerrain(int terrainWidth, int terrainHeight, int stepSize, GlobalTerrain globalTerrain, LayerManager layerManager) { gt = globalTerrain; gt.lt = this; lm = layerManager; localTerrainC = new LocalCoordinates(new Vector3(0, 0, 0), terrainWidth, terrainHeight); //visibleTerrain = new float[terrainHeight, terrainWidth]; this.terrainHeight = terrainHeight; this.terrainWidth = terrainWidth; this.stepSize = stepSize; }
/// <inheritdoc /> public bool TrySpawnEntityAt(string EntityType, LocalCoordinates coordinates, out IEntity entity) { var prototype = _protoManager.Index <EntityPrototype>(EntityType); if (prototype.CanSpawnAt(coordinates.Grid, coordinates.Position)) { entity = SpawnEntity(EntityType); entity.GetComponent <TransformComponent>().LocalPosition = coordinates; entity.Initialize(); return(true); } entity = null; return(false); }
public FilterGenerator(int quadrantSize, LocalTerrain localTerrain) { globalFilterMountainC = new GlobalCoordinates(100); globalFilterAverageC = new GlobalCoordinates(100); globalFilterMedianC = new GlobalCoordinates(100); globalFilterSpikeC = new GlobalCoordinates(100); globalFilterGaussianC = new GlobalCoordinates(100); globalFilterMinThresholdC = new GlobalCoordinates(100); globalFilterMaxThresholdC = new GlobalCoordinates(100); lt = localTerrain; localCoordinates = lt.localTerrainC; mf = new MountainFilter(this); af = new AverageFilter(this); mdf = new MedianFilter(this); sf = new SpikeFilter(this); gf = new GaussianFilter(this); tf = new ThresholdFilter(this); }