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);
}
public override bool Update(ScreenCoordinates mouseS)
{
if (mouseS.MapID == MapId.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.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);
}
public virtual void Render(Vector2f topLeft, Vector2f bottomRight)
{
//Render slaves beneath
IEnumerable <SpriteComponent> renderablesBeneath = from SpriteComponent c in slaves
//FIXTHIS
orderby c.DrawDepth ascending
where c.DrawDepth < DrawDepth
select c;
foreach (SpriteComponent component in renderablesBeneath.ToList())
{
component.Render(topLeft, bottomRight);
}
//Render this sprite
if (!visible)
{
return;
}
if (currentBaseSprite == null)
{
return;
}
Sprite spriteToRender = GetActiveDirectionalSprite();
Vector2f renderPos = CluwneLib.WorldToScreen(Owner.GetComponent <TransformComponent>(ComponentFamily.Transform).Position);
var bounds = spriteToRender.GetLocalBounds();
SetSpriteCenter(spriteToRender, renderPos);
if (Owner.GetComponent <TransformComponent>(ComponentFamily.Transform).Position.X + bounds.Left + bounds.Width < topLeft.X ||
Owner.GetComponent <TransformComponent>(ComponentFamily.Transform).Position.X > bottomRight.X ||
Owner.GetComponent <TransformComponent>(ComponentFamily.Transform).Position.Y + bounds.Top + bounds.Height < topLeft.Y ||
Owner.GetComponent <TransformComponent>(ComponentFamily.Transform).Position.Y > bottomRight.Y)
{
return;
}
spriteToRender.Scale = new SFML.System.Vector2f(HorizontalFlip ? -1 : 1, 1);
spriteToRender.Draw();
//Render slaves above
IEnumerable <SpriteComponent> renderablesAbove = from SpriteComponent c in slaves
//FIXTHIS
orderby c.DrawDepth ascending
where c.DrawDepth >= DrawDepth
select c;
foreach (SpriteComponent component in renderablesAbove.ToList())
{
component.Render(topLeft, bottomRight);
}
//Draw AABB
var aabb = AABB;
CluwneLib.drawRectangle((int)(renderPos.X - aabb.Width / 2), (int)(renderPos.Y - aabb.Height / 2), aabb.Width, aabb.Height, new SFML.Graphics.Color(0, 255, 0));
}
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(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 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 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 void Render(Vector2 topLeft, Vector2 bottomRight)
{
if (!visible)
{
return;
}
var position = Owner.GetComponent <ITransformComponent>().Position;
if (position.X < topLeft.X ||
position.X > bottomRight.X ||
position.Y < topLeft.Y ||
position.Y > bottomRight.Y)
{
return;
}
base.Render(topLeft, bottomRight);
if (_speechBubble != null)
{
_speechBubble.Draw(CluwneLib.WorldToScreen(position),
new Vector2(), currentBaseSprite);
}
}
public override bool Update(Vector2i mouseS, IMapManager currentMap)
{
if (currentMap == null)
{
return(false);
}
spriteToDraw = GetSprite(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 (currentMap.IsSolidTile(mouseWorld)) validPosition = 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 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();
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 <ITransformComponent>()
.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.CurrentPrototype.PlacementOffset.X,
currentTile.Y + 0.5f + pManager.CurrentPrototype.PlacementOffset.Y);
mouseScreen = CluwneLib.WorldToScreen(mouseWorld).Round();
FloatRect 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 virtual void Render(Vector2 topLeft, Vector2 bottomRight)
{
ScreenCoordinates renderPos = CluwneLib.WorldToScreen(Owner.GetComponent <ITransformComponent>().LocalPosition);
foreach (KeyValuePair <string, ParticleSystem> particleSystem in _emitters)
{
particleSystem.Value.Move(renderPos.Position);
particleSystem.Value.Render();
}
}
public static void DrawTiles(IEnumerable <TileRef> tileRefs, SpriteBatch floorBatch, SpriteBatch gasBatch)
{
foreach (var tileReference in tileRefs)
{
var tileType = tileReference.TileDef;
var point = CluwneLib.WorldToScreen(new Vector2(tileReference.X, tileReference.Y));
RenderTile(tileType, point.X, point.Y, floorBatch);
RenderGas(tileType, point.X, point.Y, tileReference.TileSize, gasBatch);
}
}
public virtual void Render(Vector2f topLeft, Vector2f bottomRight)
{
Vector2f renderPos = CluwneLib.WorldToScreen(
Owner.GetComponent <TransformComponent>(ComponentFamily.Transform).Position);
foreach (KeyValuePair <string, ParticleSystem> particleSystem in _emitters)
{
particleSystem.Value.Move(renderPos);
particleSystem.Value.Render();
}
}
public override bool Update(ScreenCoordinates mouseS)
{
if (mouseS.MapID == MapManager.NULLSPACE)
{
return(false);
}
mouseScreen = mouseS;
mouseCoords = CluwneLib.ScreenToCoordinates(mouseScreen);
if (pManager.CurrentPermission.IsTile)
{
return(false);
}
currentTile = mouseCoords.Grid.GetTile(mouseCoords);
if (!RangeCheck())
{
return(false);
}
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);
mouseScreen = CluwneLib.WorldToScreen(mouseCoords);
return(true);
}
public override bool Update(Vector2i mouseS, IMapManager currentMap)
{
if (currentMap == null)
{
return(false);
}
mouseScreen = mouseS;
mouseWorld = CluwneLib.ScreenToWorld(mouseScreen);
if (pManager.CurrentPermission.IsTile)
{
return(false);
}
currentTile = currentMap.GetDefaultGrid().GetTile(mouseWorld);
if (!RangeCheck())
{
return(false);
}
var nodes = new List <Vector2>();
if (pManager.CurrentPrototype.MountingPoints != null)
{
nodes.AddRange(
pManager.CurrentPrototype.MountingPoints.Select(
current => new Vector2(mouseWorld.X, currentTile.Y + current)));
}
else
{
nodes.Add(new Vector2(mouseWorld.X, currentTile.Y + 0.5f));
nodes.Add(new Vector2(mouseWorld.X, currentTile.Y + 1.0f));
nodes.Add(new Vector2(mouseWorld.X, currentTile.Y + 1.5f));
}
Vector2 closestNode = (from Vector2 node in nodes
orderby(node - mouseWorld).LengthSquared ascending
select node).First();
mouseWorld = closestNode + new Vector2(pManager.CurrentPrototype.PlacementOffset.X,
pManager.CurrentPrototype.PlacementOffset.Y);
mouseScreen = (Vector2i)CluwneLib.WorldToScreen(mouseWorld);
return(true);
}
public void Render()
{
if (CurrentMode != null)
{
CurrentMode.Render();
if (CurrentPermission != null && CurrentPermission.Range > 0 && CurrentMode.rangerequired)
{
var pos = CluwneLib.WorldToScreen(PlayerManager.ControlledEntity.GetComponent <ITransformComponent>().Position);
CluwneLib.drawHollowCircle((int)Math.Floor(pos.X),
(int)Math.Floor(pos.Y),
CurrentPermission.Range * CluwneLib.TileSize,
3f,
Color4.White);
}
}
}
public void Render()
{
if (CurrentMode != null)
{
CurrentMode.Render();
}
if (CurrentPermission != null && CurrentPermission.Range > 0)
{
var pos = CluwneLib.WorldToScreen(PlayerManager.ControlledEntity.GetComponent <ITransformComponent>().Position);
CluwneLib.drawCircle(pos.X,
pos.Y,
CurrentPermission.Range,
Color.White,
new Vector2f(2, 2));
}
}
public override void Render()
{
base.Render();
if (ongrid)
{
var position = CluwneLib.ScreenToWorld(new Vector2i(0, 0)); //Find world coordinates closest to screen origin
var gridstart = CluwneLib.WorldToScreen(new Vector2( //Find snap grid closest to screen origin and convert back to screen coords
(float)Math.Round((position.X / snapsize), MidpointRounding.AwayFromZero) * snapsize,
(float)Math.Round((position.Y / snapsize), MidpointRounding.AwayFromZero) * snapsize));
for (float a = gridstart.X; a < CluwneLib.Window.Viewport.Size.X; a += snapsize * 32) //Iterate through screen creating gridlines
{
CluwneLib.drawLine(a, 0, CluwneLib.Window.Viewport.Size.Y, 90, 0.5f, Color4.Blue);
}
for (float a = gridstart.Y; a < CluwneLib.Window.Viewport.Size.Y; a += snapsize * 32)
{
CluwneLib.drawLine(0, a, CluwneLib.Window.Viewport.Size.X, 0, 0.5f, Color4.Blue);
}
}
}
public override void Render(Vector2f topLeft, Vector2f bottomRight)
{
if (!visible)
{
return;
}
if (Owner.GetComponent <TransformComponent>(ComponentFamily.Transform).Position.X < topLeft.X ||
Owner.GetComponent <TransformComponent>(ComponentFamily.Transform).Position.X > bottomRight.X ||
Owner.GetComponent <TransformComponent>(ComponentFamily.Transform).Position.Y < topLeft.Y ||
Owner.GetComponent <TransformComponent>(ComponentFamily.Transform).Position.Y > bottomRight.Y)
{
return;
}
base.Render(topLeft, bottomRight);
if (_speechBubble != null)
{
_speechBubble.Draw(CluwneLib.WorldToScreen(Owner.GetComponent <TransformComponent>(ComponentFamily.Transform).Position),
new Vector2f(), currentBaseSprite);
}
}
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);
}
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)
{
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(failtoplace);
}
public override bool Update(ScreenCoordinates mouseS)
{
if (mouseS.MapID == MapId.Nullspace)
{
return(false);
}
MouseScreen = mouseS;
MouseCoords = CluwneLib.ScreenToCoordinates(MouseScreen);
if (pManager.CurrentPermission.IsTile)
{
return(false);
}
CurrentTile = MouseCoords.Grid.GetTile(MouseCoords);
if (!RangeCheck())
{
return(false);
}
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 <ISpriteRenderableComponent>(out var component))
{
var closestSprite = component.GetCurrentSprite();
var closestBounds = closestSprite.LocalBounds;
var closestRect =
Box2.FromDimensions(
closestEntity.GetComponent <ITransformComponent>().WorldPosition.X - closestBounds.Width / 2f,
closestEntity.GetComponent <ITransformComponent>().WorldPosition.Y - closestBounds.Height / 2f,
closestBounds.Width, closestBounds.Height);
var sides = new[]
{
new Vector2(closestRect.Left + closestRect.Width / 2f, closestRect.Top - closestBounds.Height / 2f),
new Vector2(closestRect.Left + closestRect.Width / 2f, closestRect.Bottom + closestBounds.Height / 2f),
new Vector2(closestRect.Left - closestBounds.Width / 2f, closestRect.Top + closestRect.Height / 2f),
new Vector2(closestRect.Right + closestBounds.Width / 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);
MouseScreen = CluwneLib.WorldToScreen(MouseCoords);
}
}
if (CheckCollision())
{
return(false);
}
return(true);
}
public override void Render(Vector2f topLeft, Vector2f bottomRight)
{
if (IsCurrentlyWorn && currentSprite == baseSprite)
{
base.Render(topLeft, bottomRight);
return;
}
else if (IsCurrentlyCarried && currentSprite != CarriedSprite)
{
SetSprite(CarriedSprite);
base.Render(topLeft, bottomRight);
return;
}
//Render slaves beneath
IEnumerable <SpriteComponent> renderablesBeneath = from SpriteComponent c in slaves
//FIXTHIS
orderby c.DrawDepth ascending
where c.DrawDepth < DrawDepth
select c;
foreach (SpriteComponent component in renderablesBeneath.ToList())
{
component.Render(topLeft, bottomRight);
}
//Render this sprite
if (!visible)
{
return;
}
if (NotWornSprite == null)
{
return;
}
Sprite spriteToRender = NotWornSprite;
var bounds = spriteToRender.GetLocalBounds();
Vector2f renderPos = CluwneLib.WorldToScreen(
Owner.GetComponent <ITransformComponent>().Position);
spriteToRender.Position = new SFML.System.Vector2f(renderPos.X - (bounds.Width / 2),
renderPos.Y - (bounds.Height / 2));
if (Owner.GetComponent <ITransformComponent>().Position.X + bounds.Left + bounds.Width < topLeft.X ||
Owner.GetComponent <ITransformComponent>().Position.X > bottomRight.X ||
Owner.GetComponent <ITransformComponent>().Position.Y + bounds.Top + bounds.Height < topLeft.Y ||
Owner.GetComponent <ITransformComponent>().Position.Y > bottomRight.Y)
{
return;
}
spriteToRender.Scale = new SFML.System.Vector2f(HorizontalFlip ? -1 : 1, 1);
spriteToRender.Draw();
//Render slaves above
IEnumerable <SpriteComponent> renderablesAbove = from SpriteComponent c in slaves
//FIXTHIS
orderby c.DrawDepth ascending
where c.DrawDepth >= DrawDepth
select c;
foreach (SpriteComponent component in renderablesAbove.ToList())
{
component.Render(topLeft, bottomRight);
}
//Draw AABB
var aabb = AABB;
CluwneLib.drawRectangle((int)(renderPos.X - aabb.Width / 2), (int)(renderPos.Y - aabb.Height / 2), (int)aabb.Width, (int)aabb.Height, new SFML.Graphics.Color(0, 0, 255));
}
public override bool Update(Vector2i mouseS, IMapManager currentMap)
{
if (currentMap == null)
{
return(false);
}
mouseScreen = mouseS;
mouseWorld = CluwneLib.ScreenToWorld(mouseScreen);
if (pManager.CurrentPermission.IsTile)
{
return(false);
}
currentTile = currentMap.GetDefaultGrid().GetTile(mouseWorld);
if (!RangeCheck())
{
return(false);
}
var manager = IoCManager.Resolve <IClientEntityManager>();
IOrderedEnumerable <IEntity> snapToEntities =
from IEntity entity in manager.GetEntitiesInRange(mouseWorld, snapToRange)
where entity.Prototype == pManager.CurrentPrototype
orderby
(entity.GetComponent <ITransformComponent>(
).Position - mouseWorld).LengthSquared
ascending
select entity;
if (snapToEntities.Any())
{
IEntity closestEntity = snapToEntities.First();
if (closestEntity.TryGetComponent <ISpriteRenderableComponent>(out var component))
{
var closestSprite = component.GetCurrentSprite();
var closestBounds = closestSprite.GetLocalBounds();
var closestRect =
Box2.FromDimensions(
closestEntity.GetComponent <ITransformComponent>().Position.X - closestBounds.Width / 2f,
closestEntity.GetComponent <ITransformComponent>().Position.Y - closestBounds.Height / 2f,
closestBounds.Width, closestBounds.Height);
var sides = new Vector2[]
{
new Vector2(closestRect.Left + (closestRect.Width / 2f), closestRect.Top - closestBounds.Height / 2f),
new Vector2(closestRect.Left + (closestRect.Width / 2f), closestRect.Bottom + closestBounds.Height / 2f),
new Vector2(closestRect.Left - closestBounds.Width / 2f, closestRect.Top + (closestRect.Height / 2f)),
new Vector2(closestRect.Right + closestBounds.Width / 2f, closestRect.Top + (closestRect.Height / 2f))
};
Vector2 closestSide =
(from Vector2 side in sides orderby(side - mouseWorld).LengthSquared ascending select side).First();
mouseWorld = closestSide;
mouseScreen = (Vector2i)CluwneLib.WorldToScreen(mouseWorld);
}
}
if (CheckCollision())
{
return(false);
}
return(true);
}
public virtual void Render(Vector2 topLeft, Vector2 bottomRight)
{
//Render slaves beneath
IEnumerable <SpriteComponent> renderablesBeneath = from SpriteComponent c in slaves
//FIXTHIS
orderby c.DrawDepth ascending
where c.DrawDepth < DrawDepth
select c;
foreach (SpriteComponent component in renderablesBeneath.ToList())
{
component.Render(topLeft, bottomRight);
}
//Render this sprite
if (!visible)
{
return;
}
if (currentBaseSprite == null)
{
return;
}
Sprite spriteToRender = GetActiveDirectionalSprite();
ScreenCoordinates renderPos = CluwneLib.WorldToScreen(Owner.GetComponent <ITransformComponent>().LocalPosition);
var bounds = spriteToRender.GetLocalBounds();
SetSpriteCenter(spriteToRender, renderPos.Position);
if (Owner.GetComponent <ITransformComponent>().WorldPosition.X + bounds.Left + bounds.Width < topLeft.X ||
Owner.GetComponent <ITransformComponent>().WorldPosition.X > bottomRight.X ||
Owner.GetComponent <ITransformComponent>().WorldPosition.Y + bounds.Top + bounds.Height < topLeft.Y ||
Owner.GetComponent <ITransformComponent>().WorldPosition.Y > bottomRight.Y)
{
return;
}
spriteToRender.Scale = new Vector2f(HorizontalFlip ? -1 : 1, 1);
spriteToRender.Color = this.Color.Convert();
spriteToRender.Draw();
spriteToRender.Color = Color4.White.Convert();
//Render slaves above
IEnumerable <SpriteComponent> renderablesAbove = from SpriteComponent c in slaves
//FIXTHIS
orderby c.DrawDepth ascending
where c.DrawDepth >= DrawDepth
select c;
foreach (SpriteComponent component in renderablesAbove.ToList())
{
component.Render(topLeft, bottomRight);
}
//Draw AABB
var aabb = LocalAABB;
if (CluwneLib.Debug.DebugColliders)
{
CluwneLib.drawRectangle((int)(renderPos.X - aabb.Width / 2), (int)(renderPos.Y - aabb.Height / 2), aabb.Width, aabb.Height, Color4.Blue);
}
}
public override bool Update(Vector2i mouseS, IMapManager currentMap)
{
if (currentMap == null)
{
return(false);
}
spriteToDraw = GetDirectionalSprite(pManager.CurrentBaseSpriteKey);
var spriteBounds = spriteToDraw.GetLocalBounds();
mouseScreen = mouseS;
mouseWorld = CluwneLib.ScreenToWorld(mouseScreen);
if (pManager.CurrentPermission.IsTile)
{
return(false);
}
currentTile = currentMap.GetTileRef(mouseWorld);
//Align to similar if nearby found else free
if (currentTile.Tile.TileDef.IsWall)
{
return(false); //HANDLE CURSOR OUTSIDE MAP
}
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 manager = IoCManager.Resolve <IClientEntityManager>();
IOrderedEnumerable <IEntity> snapToEntities =
from IEntity entity in manager.GetEntitiesInRange(mouseWorld, snapToRange)
where entity.Prototype == pManager.CurrentPrototype
orderby
(entity.GetComponent <TransformComponent>(
ComponentFamily.Transform).Position - mouseWorld).LengthSquared()
ascending
select entity;
if (snapToEntities.Any())
{
IEntity closestEntity = snapToEntities.First();
ComponentReplyMessage reply = closestEntity.SendMessage(this, ComponentFamily.Renderable,
ComponentMessageType.GetSprite);
//if(replies.Any(x => x.messageType == SS13_Shared.GO.ComponentMessageType.CurrentSprite))
//{
// Sprite closestSprite = (Sprite)replies.Find(x => x.messageType == SS13_Shared.GO.ComponentMessageType.CurrentSprite).paramsList[0]; //This is safer but slower.
if (reply.MessageType == ComponentMessageType.CurrentSprite)
{
var closestSprite = (Sprite)reply.ParamsList[0]; //This is faster but kinda unsafe.
var closestBounds = closestSprite.GetLocalBounds();
var closestRect =
new FloatRect(
closestEntity.GetComponent <TransformComponent>(ComponentFamily.Transform).Position.X - closestBounds.Width / 2f,
closestEntity.GetComponent <TransformComponent>(ComponentFamily.Transform).Position.Y - closestBounds.Height / 2f,
closestBounds.Width, closestBounds.Height);
var sides = new List <Vector2f>
{
new Vector2f(closestRect.Left + (closestRect.Width / 2f), closestRect.Top - closestBounds.Height / 2f),
new Vector2f(closestRect.Left + (closestRect.Width / 2f), closestRect.Bottom() + closestBounds.Height / 2f),
new Vector2f(closestRect.Left - closestBounds.Width / 2f, closestRect.Top + (closestRect.Height / 2f)),
new Vector2f(closestRect.Right() + closestBounds.Width / 2f, closestRect.Top + (closestRect.Height / 2f))
};
Vector2f closestSide =
(from Vector2f side in sides orderby(side - mouseWorld).LengthSquared() ascending select side).First();
mouseWorld = closestSide;
mouseScreen = CluwneLib.WorldToScreen(mouseWorld).Round();
}
}
FloatRect spriteRectWorld = new FloatRect(mouseWorld.X - (spriteBounds.Width / 2f), mouseWorld.Y - (spriteBounds.Height / 2f),
spriteBounds.Width, spriteBounds.Height);
if (pManager.CollisionManager.IsColliding(spriteRectWorld))
{
return(false);
}
return(true);
}
public Vector2f ToRelativePosition(Vector2f worldPosition)
{
return(worldPosition - (CluwneLib.WorldToScreen(LightPosition) - LightAreaSize * 0.5f));
}
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));
if (pManager.CurrentPermission.IsTile)
{
return(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 <ITransformComponent>()
.Position - mouseWorld).LengthSquared() > rangeSquared)
{
return(false);
}
}
var nodes = new List <Vector2f>();
if (pManager.CurrentPrototype.MountingPoints != null)
{
nodes.AddRange(
pManager.CurrentPrototype.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.CurrentPrototype.PlacementOffset.X,
pManager.CurrentPrototype.PlacementOffset.Y);
mouseScreen = CluwneLib.WorldToScreen(mouseWorld).Round();
var range = pManager.CurrentPermission.Range;
if (range > 0)
{
if (
(pManager.PlayerManager.ControlledEntity.GetComponent <ITransformComponent>()
.Position - mouseWorld).LengthSquared() > range * range)
{
return(false);
}
}
return(true);
}
public virtual void Render(Vector2f topLeft, Vector2f bottomRight)
{
UpdateSlaves();
//Render slaves beneath
IEnumerable <IRenderableComponent> renderablesBeneath = from IRenderableComponent c in slaves
//FIXTHIS
orderby c.DrawDepth ascending
where c.DrawDepth < DrawDepth
select c;
foreach (IRenderableComponent component in renderablesBeneath.ToList())
{
component.Render(topLeft, bottomRight);
}
//Render this sprite
if (!visible)
{
return;
}
if (sprite == null)
{
return;
}
var ownerPos = Owner.GetComponent <TransformComponent>(ComponentFamily.Transform).Position;
Vector2f renderPos = CluwneLib.WorldToScreen(ownerPos);
SetSpriteCenter(renderPos);
var bounds = sprite.AABB;
if (ownerPos.X + bounds.Left + bounds.Width < topLeft.X ||
ownerPos.X > bottomRight.X ||
ownerPos.Y + bounds.Top + bounds.Height < topLeft.Y ||
ownerPos.Y > bottomRight.Y)
{
return;
}
sprite.HorizontalFlip = HorizontalFlip;
sprite.Draw();
//Render slaves above
IEnumerable <IRenderableComponent> renderablesAbove = from IRenderableComponent c in slaves
//FIXTHIS
orderby c.DrawDepth ascending
where c.DrawDepth >= DrawDepth
select c;
foreach (IRenderableComponent component in renderablesAbove.ToList())
{
component.Render(topLeft, bottomRight);
}
//Draw AABB
var aabb = AABB;
//CluwneLib.CurrentRenderTarget.Rectangle(renderPos.X - aabb.Width/2, renderPos.Y - aabb.Height / 2, aabb.Width, aabb.Height, Color.Lime);
if (_speechBubble != null)
{
_speechBubble.Draw(CluwneLib.WorldToScreen(Owner.GetComponent <TransformComponent>(ComponentFamily.Transform).Position),
new Vector2f(), aabb);
}
}
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);
}
