/// <summary> /// Initiates a push or bounce involving this object /// </summary> /// <param name="moveableObject">The object that is potentially being moved</param> /// <param name="direction">The direction that the specified object is directing this object</param> public void PushOrBounce(IMovingItem moveableObject, Direction direction) { bool canCauseBounceBack = this.Properties.Get(GameObjectProperties.Capability) == ObjectCapability.CanPushOrCauseBounceBack; var moveableObjectMovementChecker = moveableObject.Properties.Get(GameObjectProperties.MovementChecker); var ps = moveableObjectMovementChecker.CanBePushedOrBounced(moveableObject, this, direction, canCauseBounceBack); switch (ps) { case PushStatus.Yes: { moveableObject.Move(direction, MovementSpeed.Pushed); return; } case PushStatus.Bounce: { var reverseDirection = direction.Reversed(); moveableObject.Move(reverseDirection, MovementSpeed.BounceBack); this.Move(reverseDirection, MovementSpeed.BounceBack); moveableObject.PlaySound(GameSound.BoulderBounces); return; } case PushStatus.No: { return; } default: throw new InvalidOperationException(); } }
public PushStatus CanBePushedOrBounced(IMovingItem toBeMoved, IMovingItem byWhom, Direction direction, bool isBounceBackPossible) { // if this object is not moveable then the answer's no if (toBeMoved.Properties.Get(GameObjectProperties.Solidity) != ObjectSolidity.Moveable) { return(PushStatus.No); } // if the moving object cannot move other objects then the answer's no // the moving object cannot be a moveable object - moveable objects can't push other moveable objects if (!byWhom.Properties.Get(GameObjectProperties.Capability).CanMoveAnother() || byWhom.Properties.Get(GameObjectProperties.Solidity) == ObjectSolidity.Moveable) { return(PushStatus.No); } // check if this object can move in the specified direction if (CanMove(toBeMoved, direction, isBounceBackPossible)) { return(PushStatus.Yes); } // if bounceback is not a possibility then the answer's no if (byWhom.Properties.Get(GameObjectProperties.Capability) != ObjectCapability.CanPushOrCauseBounceBack || !isBounceBackPossible) { return(PushStatus.No); } // this object will be able to bounceback only if the object that is pushing it can move backwards IMovementChecker mc = byWhom.Properties.Get(GameObjectProperties.MovementChecker); var willBounceBack = mc.CanBePushedBackDueToBounceBack(byWhom, direction.Reversed()); var result = willBounceBack ? PushStatus.Bounce : PushStatus.No; return(result); }
public override void SteppedOnBy(IMovingItem movingItem) { if (movingItem is Player) { this.Mine._countdown = TimeSpan.Zero; } }
public static bool CanMoveInDirection(this IMovingItem gameObject, Direction direction) { IMovementChecker mc = gameObject.Properties.Get(GameObjectProperties.MovementChecker); var result = mc.CanMoveForwards(gameObject, direction); return(result); }
private bool CanMoveTo(IMovingItem objectToCheck, Direction direction, TilePos proposedDestination, bool isBounceBackPossible) { var objectsOnTile = GlobalServices.GameState.GetItemsOnTile(proposedDestination); var result = CanObjectOccupySameTile(objectToCheck, objectsOnTile, direction, isBounceBackPossible); return(result); }
protected virtual bool CanObjectOccupySameTile(IMovingItem gameObject, IGameObject objectAlreadyOnTile, Direction direction, bool isBounceBackPossible) { var solidity = objectAlreadyOnTile.Properties.Get(GameObjectProperties.Solidity); switch (solidity) { case ObjectSolidity.Stationary: case ObjectSolidity.Insubstantial: // neither of these will stop this object moving onto the same tile return(true); case ObjectSolidity.Impassable: // the target tile is already occupied and this object cannot move onto it return(false); case ObjectSolidity.Moveable: { // todo instead of using the same movementchecker, we need to use the movement checker of the boulder instead if (!(objectAlreadyOnTile is MovingItem moveableItem)) { // There shouldn't be any Moveable objects that are not MovingItems as that would be a contradiction return(false); } var canMove = CanBePushedOrBounced(moveableItem, gameObject, direction, isBounceBackPossible); if (canMove == PushStatus.Yes || canMove == PushStatus.Bounce) { return(true); } return(false); } default: throw new InvalidOperationException(); } }
public override void SteppedOnBy(IMovingItem movingItem) { if (movingItem is Player) { this.Mine._mineState = new InactiveState(this.Mine); } }
protected override bool CanObjectOccupySameTile(IMovingItem gameObject, IGameObject objectAlreadyOnTile, Direction direction, bool isBounceBackPossible) { if (objectAlreadyOnTile.Properties.Get(GameObjectProperties.DeadlyToTouch)) { return(false); } return(base.CanObjectOccupySameTile(gameObject, objectAlreadyOnTile, direction, isBounceBackPossible)); }
public bool CanBePushedBackDueToBounceBack(IMovingItem gameObject, Direction direction) { if (gameObject == null) { throw new ArgumentNullException(nameof(gameObject)); } return(CanMove(gameObject, direction, false)); }
/// <summary> /// Builds an interaction object from the two specified game objects /// </summary> /// <param name="updatedItem">An object that has just moved position</param> /// <param name="actedUponItem">An object whose position overlaps the first object</param> /// <returns>An instance of an interaction object</returns> private static IInteraction BuildInteraction(IMovingItem updatedItem, IGameObject actedUponItem) { var result = actedUponItem is IMovingItem secondMovingItem ? (IInteraction) new InteractionWithMovingItems(updatedItem, secondMovingItem) : new InteractionWithStaticItems(actedUponItem, updatedItem); return(result); }
/// <inheritdoc /> public void UpdatePosition(IMovingItem item) { if (item == null) { throw new ArgumentNullException(nameof(item)); } this._grid.UpdatePosition(item); }
public bool CanMoveForwards(IMovingItem source, Direction direction) { if (source == null) { throw new ArgumentNullException(nameof(source)); } bool canCauseBounceBack = source.Properties.Get(GameObjectProperties.Capability) == ObjectCapability.CanPushOrCauseBounceBack; var result = CanMove(source, direction, canCauseBounceBack); return(result); }
private bool CanObjectOccupySameTile(IMovingItem gameObject, IEnumerable <IGameObject> objectsOnTile, Direction direction, bool isBounceBackPossible) { foreach (var item in objectsOnTile) { if (!CanObjectOccupySameTile(gameObject, item, direction, isBounceBackPossible)) { return(false); } } return(true); }
public InteractionWithStaticItems(IGameObject staticItem, IMovingItem movingItem) { if (staticItem == null) { throw new ArgumentNullException(nameof(staticItem)); } if (staticItem is IMovingItem) { throw new ArgumentOutOfRangeException(nameof(staticItem)); } this._staticItem = staticItem; this._movingItem = movingItem ?? throw new ArgumentNullException(nameof(movingItem)); }
private bool CanMove(IMovingItem objectToCheck, Direction direction, bool isBounceBackPossible) { if (objectToCheck.MovementBoundary == null) { throw new InvalidOperationException("MovementBoundary is not set for " + objectToCheck + "."); } TilePos proposedDestination = objectToCheck.TilePosition.GetPositionAfterOneMove(direction); if (!objectToCheck.MovementBoundary.IsPositionWithinBoundary(proposedDestination)) { return(false); } var result = CanMoveTo(objectToCheck, direction, proposedDestination, isBounceBackPossible); return(result); }
public InteractionWithMovingItems([NotNull] IMovingItem primaryItem, [NotNull] IMovingItem secondaryItem) { this._primaryItem = primaryItem ?? throw new ArgumentNullException(nameof(primaryItem)); this._secondaryItem = secondaryItem ?? throw new ArgumentNullException(nameof(secondaryItem)); }
public BoundaryCurrentRoom([NotNull] IMovingItem gameObject) { this._gameObject = gameObject ?? throw new ArgumentNullException(nameof(gameObject)); }
public abstract void SteppedOnBy(IMovingItem movingItem);
public void SteppedOnBy(IMovingItem movingItem) { this._mineState.SteppedOnBy(movingItem); }
public override void SteppedOnBy(IMovingItem movingItem) { // nothing to do }
public override void SteppedOnBy(IMovingItem movingItem) { this.Mine._mineState = new FiredState(this.Mine); }
internal static bool IsAlive(this IMovingItem mi) { var result = mi.IsExtant; return(result); }
public IBoundMovement GetBoundedInRoom(IMovingItem gameObject) { return(new BoundaryCurrentRoom(gameObject)); }
public void UpdatePosition(IMovingItem gameObject) { this._gameObjectCollection.UpdatePosition(gameObject); }
public ItemWallCollision(IMovingItem item, in Rectangle collision)