public bool ReplaceWith <T>(GameActorPosition original, T replacement)
{
int x = (int)Math.Floor(original.Position.X);
int y = (int)Math.Floor(original.Position.Y);
/*Tile item = GetActorAt(x, y);
*
* if (item != original.Actor)
* return false;
*/
Tiles[x][y] = null;
Tile tileReplacement = replacement as Tile;
if (replacement == null)
{
m_tileCount--;
return(true);
}
if (Tiles[x][y] == null)
{
m_tileCount++;
}
Tiles[x][y] = tileReplacement;
return(true);
}
public ISwitchableGameActor SwitchOff(GameActorPosition gameActorPosition, IAtlas atlas)
{
TilesetId = AlternativeTextures.Id("Open");
atlas.MoveToOtherLayer(new GameActorPosition(this, new Vector2(Position), LayerType.OnGroundInteractable), LayerType.ObstacleInteractable);
m_closed = false;
return(this);
}
public IEnumerable <GameActorPosition> ActorsAt(Vector2 position, LayerType type = LayerType.All, float width = 0.5f)
{
IEnumerable <ILayer <GameActor> > selectedLayers = Layers.Where(t => type.HasFlag(t.LayerType));
// for all layers except object layer
IEnumerable <ILayer <GameActor> > selectedTileLayers = selectedLayers.Where(t => LayerType.TileLayers.HasFlag(t.LayerType));
foreach (ILayer <GameActor> layer in selectedTileLayers)
{
GameActorPosition actorPosition = TileAt(layer, position);
if (actorPosition != null)
{
yield return(actorPosition);
}
}
var circle = new CircleShape(position, width);
IEnumerable <ILayer <GameActor> > selectedObjectLayers = selectedLayers.Where(t => LayerType.ObjectLayers.HasFlag(t.LayerType));
foreach (ILayer <GameActor> layer in selectedObjectLayers)
{
foreach (IGameObject gameObject in ((IObjectLayer)layer).GetGameObjects())
{
GameActorPosition actorPosition = GameObjectAt(gameObject, circle, position, layer);
if (actorPosition != null)
{
yield return(actorPosition);
}
}
}
}
public bool MoveToOtherLayer(GameActorPosition actor, LayerType layerType)
{
Remove(actor);
actor.Layer = layerType;
Add(actor);
return(true);
}
public void Update(IAtlas atlas)
{
List <Vector2I> free = atlas.FreePositionsAround(Position, LayerType.Obstacle | LayerType.Object).ToList();
if (free.Count == 0)
{
return;
}
// filter out position with PathTiles
free = free.Where(x => atlas.ActorsAt((Vector2)x, LayerType.Background).First().Actor.GetType() != typeof(PathTile)).ToList();
if (free.Count == 0)
{
return;
}
Vector2I targetPosition = free[m_rng.Next(free.Count)];
object[] args = { targetPosition };
Fruit fruit = (Fruit)Activator.CreateInstance(typeof(T), args);
GameActorPosition fruitPosition = new GameActorPosition(fruit, new Vector2(targetPosition), LayerType.ObstacleInteractable);
atlas.Add(fruitPosition);
NextUpdateAfter = m_updatePeriod;
}
public void Switch(GameActorPosition gameActorPosition, IAtlas atlas, ITilesetTable table)
{
var leverOn = new LeverSwitchOn(table, Position);
atlas.ReplaceWith(new GameActorPosition(this, (Vector2)Position, LayerType.ObstacleInteractable), leverOn);
if (Switchable == null) return;
leverOn.Switchable = Switchable.Switch(null, atlas, table);
}
public ISwitchableGameActor Switch(GameActorPosition gameActorPosition, IAtlas atlas, ITilesetTable table)
{
RcDoorClosed closedDoor = new RcDoorClosed(table, Position);
bool added = atlas.Add(new GameActorPosition(closedDoor, (Vector2)Position, LayerType.ObstacleInteractable), true);
if (!added) return this;
atlas.Remove(new GameActorPosition(this, (Vector2)Position, LayerType.OnGroundInteractable));
return closedDoor;
}
private void EatFruit(GameActorPosition applePosition)
{
var fruit = applePosition.Actor as Fruit;
if (fruit is IEatable)
{
Energy += ENERGY_FOR_EATING_FRUIT;
}
}
public override void Resolve(GameActorPosition target, IAtlas atlas, ITilesetTable table)
{
ICanPickGameObject picker = Sender as ICanPickGameObject;
IPickableGameActor pickItem = target.Actor as IPickableGameActor;
if (picker == null || pickItem == null) return;
if (picker.AddToInventory(pickItem))
atlas.Remove(target);
}
public void ReplaceWith(GameActorPosition original, GameActor replacement)
{
if ((original.Actor is Tile && replacement is GameObject) ||
(original.Actor is GameObject && replacement is Tile))
{
throw new ArgumentException("atlas.ReplaceWith tries replace Tile with GameObject or GameObject with Tile");
}
GetLayer(original.Layer).ReplaceWith(original, replacement);
}
public void Use(GameActorPosition senderPosition, IAtlas atlas, ITilesetTable tilesetTable)
{
IEnumerable<GameActorPosition> actorsInFrontOf =
atlas.ActorsInFrontOf(senderPosition.Actor as ICharacter).ToList();
if (actorsInFrontOf.Select(x => x.Actor).Contains(Switchable as GameActor))
{
GameActorPosition switchable = actorsInFrontOf.First(x => x.Actor == Switchable);
Switch(switchable, atlas, tilesetTable);
}
}
public void Switch(GameActorPosition gameActorPosition, IAtlas atlas)
{
if (m_On)
{
SwitchOff(gameActorPosition, atlas);
}
else
{
SwitchOn(gameActorPosition, atlas);
}
}
public void Switch(GameActorPosition gameActorPosition, IAtlas atlas, ITilesetTable table)
{
var leverOff = new LeverSwitchOff(table, Position);
atlas.ReplaceWith(new GameActorPosition(this, (Vector2)Position, LayerType.ObstacleInteractable), leverOff);
if (Switchable == null)
{
return;
}
leverOff.Switchable = Switchable.Switch(null, atlas, table) as ISwitchableGameActor;
}
public void Use(GameActorPosition senderPosition, IAtlas atlas)
{
IEnumerable <GameActorPosition> actorsInFrontOf =
atlas.ActorsInFrontOf(senderPosition.Actor as ICharacter).ToList();
if (actorsInFrontOf.Select(x => x.Actor).Contains(Switchable as GameActor))
{
GameActorPosition switchable = actorsInFrontOf.First(x => x.Actor == Switchable);
Switch(switchable, atlas);
}
}
public ISwitchableGameActor Switch(GameActorPosition gameActorPosition, IAtlas atlas)
{
if (m_closed)
{
SwitchOff(gameActorPosition, atlas);
}
else
{
SwitchOn(gameActorPosition, atlas);
}
return(this);
}
private static GameActorPosition TileAt(ILayer <GameActor> layer, Vector2 position)
{
GameActor actor = layer.GetActorAt((int)Math.Floor(position.X), (int)Math.Floor(position.Y));
if (actor == null)
{
return(null);
}
GameActorPosition actorPosition = new GameActorPosition(actor, position, layer.LayerType);
return(actorPosition);
}
public ISwitchableGameActor Switch(GameActorPosition gameActorPosition, IAtlas atlas, ITilesetTable table)
{
RcDoorClosed closedDoor = new RcDoorClosed(table, Position);
bool added = atlas.Add(new GameActorPosition(closedDoor, (Vector2)Position, LayerType.ObstacleInteractable), true);
if (!added)
{
return(this);
}
atlas.Remove(new GameActorPosition(this, (Vector2)Position, LayerType.OnGroundInteractable));
return(closedDoor);
}
public bool Add(GameActorPosition gameActorPosition)
{
IGameObject gameObject = gameActorPosition.Actor as IGameObject;
Debug.Assert(gameObject != null, "gameObject != null");
Vector2 position = gameActorPosition.Position;
gameObject.Position = position;
GameObjects.Add(gameObject);
return(true);
}
private static GameActorPosition GameObjectAt(IGameObject gameObject, IShape shape, Vector2 position, ILayer <GameActor> layer)
{
IShape gameObjectShape = gameObject.PhysicalEntity.Shape;
if (!gameObjectShape.CollidesWith(shape))
{
return(null);
}
GameActor actor = (GameActor)gameObject;
GameActorPosition actorPosition = new GameActorPosition(actor, position, layer.LayerType);
return(actorPosition);
}
private void RemoveSpeed(GameActorPosition target)
{
var actor = target.Actor as IForwardMovable;
var gameObject = target.Actor as IGameObject;
if (actor == null)
{
return;
}
Debug.Assert(gameObject != null, "gameObject != null");
Energy -= actor.ForwardSpeed * gameObject.Weight * ENERGY_COEF_FOR_CATCHING_MOVING_OBJECT;
actor.ForwardSpeed = 0;
}
public override void Resolve(GameActorPosition target, IAtlas atlas, ITilesetTable table)
{
if (target.Actor is Apple || target.Actor is Pear)
{
atlas.Remove(target);
}
var switcher = target.Actor as ISwitcherGameActor;
if (switcher != null)
{
switcher.Switch(target, atlas, table);
}
}
public override void Resolve(GameActorPosition target, IAtlas atlas)
{
ICanPickGameObject picker = Sender as ICanPickGameObject;
IPickableGameActor pickItem = target.Actor as IPickableGameActor;
if (picker == null || pickItem == null)
{
return;
}
if (picker.AddToInventory(pickItem))
{
atlas.Remove(target);
}
}
public void GoTo(string type, float distance = (float)0.1)
{
// ac:GoTo("Pinecone", 1.2)
GameActorPosition gameActorPosition = GetNearest(type);
if (gameActorPosition == null)
{
throw new Exception("No object of type " + type + " found.");
}
Vector2 position = gameActorPosition.Position;
if (gameActorPosition.Actor is Tile)
{
position = Tile.Center((Vector2I)position);
}
GoTo(position, distance);
}
public bool ReplaceWith <T>(GameActorPosition original, T replacement)
{
GameObject item = (GameObject)original.Actor;
if (item != original.Actor)
{
return(false);
}
GameObjects.Remove(item);
if (!(replacement is GameObject))
{
return(true);
}
GameObjects.Add(replacement as GameObject);
return(true);
}
private static void SetTileRelations(IAtlas atlas, Map map)
{
ObjectGroup foregroundObjects = map.ObjectGroups.FirstOrDefault(x => x.Name == "ForegroundObject");
Debug.Assert(foregroundObjects != null, "foregroundObjects != null");
List <TmxObject> tmxMapObjects = foregroundObjects.TmxMapObjects;
IEnumerable <TmxObject> switcherToSwitchablePolylines = tmxMapObjects.Where(x => x.Type == "SwitcherToSwitchable");
foreach (TmxObject switcherToSwitchablePolyline in switcherToSwitchablePolylines)
{
Polyline polyline = switcherToSwitchablePolyline.Polyline;
if (polyline == null)
{
throw new ArgumentException("Foreground object SwitcherToSwitchable is wrong type. Should be Polyline.");
}
List <Vector2> polylinePoints = PolylineTransform(map, switcherToSwitchablePolyline).ToList();
Vector2 source = polylinePoints.First();
Vector2 target = polylinePoints.Last();
IEnumerable <GameActorPosition> sourceGameActors = atlas.ActorsAt(source);
GameActorPosition switcherPosition = sourceGameActors.FirstOrDefault(x => x.Actor is ISwitcherGameActor);
if (switcherPosition == null)
{
Log.Instance.Error("SwitcherToSwitchable polyline expects Switcher type at [" + source.X + ";" + source.Y + "].");
return;
}
ISwitcherGameActor switcherGameActor = switcherPosition.Actor as ISwitcherGameActor;
IEnumerable <GameActorPosition> targetGameActors = atlas.ActorsAt(target);
GameActorPosition switchablePosition = targetGameActors.FirstOrDefault(x => x.Actor is ISwitchableGameActor);
if (switchablePosition == null)
{
Log.Instance.Error("SwitcherToSwitchable polyline expects Switchable type at [" + target.X + ";" + target.Y + "].");
return;
}
ISwitchableGameActor switchable = switchablePosition.Actor as ISwitchableGameActor;
if (switcherGameActor != null)
{
switcherGameActor.Switchable = switchable;
}
}
}
public override void Resolve(GameActorPosition target, IAtlas atlas)
{
ICanPickGameObject picker = Sender as ICanPickGameObject;
ICharacter character = Sender as ICharacter;
if (picker == null || character == null)
{
return;
}
Vector2 positionInFrontOf = target.Position;
// solving case when positions where character should place tile collides with character's position
if (target.Actor is Tile)
{
Tile tile = (target.Actor as Tile);
IPhysicalEntity physicalEntity = tile.GetPhysicalEntity(new Vector2I(positionInFrontOf));
bool collidesWithSource = physicalEntity.CollidesWith(character.PhysicalEntity);
if (collidesWithSource)
{
/* <- change to //* to switch
* // to the center of current tile
* character.Position = Vector2.Floor(character.Position) + Vector2.One/2;
*
* /*/
// back WRT his direction
do
{
character.Position = Physics.Utils.Move(character.Position, character.Direction, -0.01f);
} while (physicalEntity.CollidesWith(character.PhysicalEntity));
// */
}
}
GameActorPosition toLayDown = new GameActorPosition(target.Actor, positionInFrontOf, target.Layer);
bool added = atlas.Add(toLayDown, true);
if (added)
{
picker.RemoveFromInventory();
}
}
public bool Add(GameActorPosition gameActorPosition)
{
int x = (int)gameActorPosition.Position.X;
int y = (int)gameActorPosition.Position.Y;
if (Tiles[x][y] != null)
{
return(false);
}
Tile actor = gameActorPosition.Actor as Tile;
Tiles[x][y] = actor;
if (actor != null)
{
m_tileCount++;
}
return(true);
}
public bool Add(GameActorPosition gameActorPosition, bool collidesWithObstacles = false)
{
if (collidesWithObstacles)
{
IObjectLayer gameObjectLayer = GetLayer(LayerType.Object) as IObjectLayer;
Debug.Assert(gameObjectLayer != null, "gameObjectLayer != null");
Vector2 position = gameActorPosition.Position;
GameActor actor = gameActorPosition.Actor;
IPhysicalEntity physicalEntity;
if (actor is IGameObject)
{
physicalEntity = (actor as IGameObject).PhysicalEntity;
physicalEntity.Position = position;
}
else if (actor is Tile)
{
physicalEntity = (actor as Tile).GetPhysicalEntity(new Vector2I(gameActorPosition.Position));
}
else
{
throw new ArgumentException("actor is unknown Type");
}
bool anyCollision = gameObjectLayer.GetPhysicalEntities().Any(x => x.CollidesWith(physicalEntity));
if (anyCollision)
{
return(false);
}
bool anyObstacleOnPosition =
GetObstaceLayers().Any(x => x.GetActorAt(new Vector2I(gameActorPosition.Position)) != null);
if (anyObstacleOnPosition)
{
return(false);
}
}
ILayer <GameActor> layer = GetLayer(gameActorPosition.Layer);
return(layer.Add(gameActorPosition));
}
public override void Resolve(GameActorPosition target, IAtlas atlas, ITilesetTable table)
{
ICanPickGameObject picker = Sender as ICanPickGameObject;
ICharacter character = Sender as ICharacter;
if (picker == null || character == null) return;
Vector2 positionInFrontOf = target.Position;
// solving case when positions where character should place tile collides with character's position
if (target.Actor is Tile)
{
Tile tile = (target.Actor as Tile);
IPhysicalEntity physicalEntity = tile.GetPhysicalEntity(new Vector2I(positionInFrontOf));
bool collidesWithSource = physicalEntity.CollidesWith(character.PhysicalEntity);
if (collidesWithSource)
{
/* <- change to //* to switch
// to the center of current tile
character.Position = Vector2.Floor(character.Position) + Vector2.One/2;
/*/
// back WRT his direction
do
{
character.Position = Physics.Utils.Move(character.Position, character.Direction, -0.01f);
} while (physicalEntity.CollidesWith(character.PhysicalEntity));
// */
}
}
GameActorPosition toLayDown = new GameActorPosition(target.Actor, positionInFrontOf, target.Layer);
bool added = atlas.Add(toLayDown, true);
if (added)
{
picker.RemoveFromInventory();
}
}
/// <summary> /// Resolve implements default action implementation (where applicable) /// </summary> /// <param name="target">Target of the action</param> /// <param name="atlas"></param> /// <param name="tilesetTable"></param> public abstract void Resolve(GameActorPosition target, IAtlas atlas, ITilesetTable tilesetTable);
public override void Resolve(GameActorPosition target, IAtlas atlas, ITilesetTable table)
{
throw new System.NotImplementedException();
}
/// <summary> /// Resolve implements default action implementation (where applicable) /// </summary> /// <param name="target">Target of the action</param> /// <param name="atlas"></param> /// <param name="tilesetTable"></param> public abstract void Resolve(GameActorPosition target, IAtlas atlas, ITilesetTable tilesetTable);
private void EatFruit(GameActorPosition applePosition)
{
var fruit = applePosition.Actor as Fruit;
if (fruit is IEatable)
{
Energy += ENERGY_FOR_EATING_FRUIT;
}
}
public void Switch(GameActorPosition gameActorPosition, IAtlas atlas)
{
Switchable = Switchable?.SwitchOn(null, atlas);
}
private void RemoveSpeed(GameActorPosition target)
{
var actor = target.Actor as IForwardMovable;
var gameObject = target.Actor as IGameObject;
if (actor == null) return;
Debug.Assert(gameObject != null, "gameObject != null");
Energy -= actor.ForwardSpeed * gameObject.Weight * ENERGY_COEF_FOR_CATCHING_MOVING_OBJECT;
actor.ForwardSpeed = 0;
}
public void Burn(GameActorPosition gameActorPosition, IAtlas atlas, ITilesetTable table)
{
Ignite(atlas, table);
}
public void Burn(GameActorPosition gameActorPosition, IAtlas atlas)
{
atlas.Remove(gameActorPosition);
}
public void Remove(GameActorPosition target)
{
ReplaceWith(target, null);
}
public void Switch(GameActorPosition gameActorPosition, IAtlas atlas, ITilesetTable table)
{
Switchable = Switchable.Switch(null, atlas, table);
}
public void Burn(GameActorPosition gameActorPosition, IAtlas atlas, ITilesetTable table)
{
Ignite(atlas, table);
}
public void Burn(GameActorPosition gameActorPosition, IAtlas atlas, ITilesetTable table)
{
atlas.Remove(gameActorPosition);
}
/// <summary> /// Resolve implements default action implementation (where applicable) /// </summary> /// <param name="target">Target of the action</param> /// <param name="atlas"></param> public abstract void Resolve(GameActorPosition target, IAtlas atlas);
