コード例 #1
0
ファイル: Map.cs プロジェクト: SvenEV/OrangeBugReloaded
        private async Task<bool> MoveCoreAsync(Point sourcePosition, Point targetPosition, ITransactionWithMoveSupport transaction)
        {
            var source = await GetAsync(sourcePosition);
            var target = await GetAsync(targetPosition);

            var oldSource = source;
            var oldTarget = target;

            source.Tile.EnsureNotNull();
            target.Tile.EnsureNotNull();

            if (source.Tile.Entity == Entity.None)
            {
                // Cancel if there's no entity to move
                transaction.IsSealed = true;
                return false;
            }

            var move = new EntityMoveInfo(source.Tile.Entity, sourcePosition, targetPosition);
            transaction.Moves.Push(move);

            IBeginMoveArgs beginMoveArgs = new GameplayArgs(transaction, this);
            IDetachArgs detachArgs = new GameplayArgs(transaction, this);
            IAttachArgs attachArgs = new GameplayArgs(transaction, this);

            // OnBeginMove: Notify entity that a move has been initiated
            await source.Tile.Entity.BeginMoveAsync(beginMoveArgs);
            beginMoveArgs.ValidateResult();
            if (transaction.IsSealed) return false;

            var newSource = source.WithTile(Tile.Compose(source.Tile, beginMoveArgs.ResultingEntity));
            if (transaction.Set(sourcePosition, source, newSource))
                source = newSource;

            move.Entity = beginMoveArgs.ResultingEntity;

            // Detach: Remove the entity from the source tile
            await source.Tile.DetachEntityAsync(detachArgs);
            detachArgs.ValidateResult();
            if (transaction.IsSealed) return false;

            // Attach: Add the entity to the target tile
            await target.Tile.AttachEntityAsync(attachArgs);
            attachArgs.ValidateResult();
            if (transaction.IsSealed) return false;

            // Detach from old tile, attach to new tile have succeeded
            // => Apply changes to transaction
            var newSource2 = source.WithTile(detachArgs.Result);
            if (transaction.Set(sourcePosition, source, newSource2))
                source = newSource2;

            var newTarget = target.WithTile(attachArgs.Result);
            if (transaction.Set(targetPosition, target, newTarget))
                target = newTarget;

            // Emit events
            var moveEvent = new EntityMoveEvent(sourcePosition, targetPosition, oldSource.Tile, target.Tile);
            transaction.Emit(moveEvent);

            if (source.Tile.Entity != Entity.None)
            {
                // A new entity has been created at source position
                var spawnEvent = new EntitySpawnEvent(sourcePosition, source.Tile.Entity);
                transaction.Emit(spawnEvent);
            }

            if (oldTarget.Tile.Entity != Entity.None)
            {
                // The entity at target position has either been replaced
                // or it has been moved/collected/... during a nested move
                var oldTargetEntityOverwritten =
                    !(transaction.Events.OfType<EntityDespawnEvent>().Any(ev => ev.Position == targetPosition) ||
                    transaction.Events.OfType<EntityMoveEvent>().Any(ev => ev.SourcePosition == targetPosition));

                if (oldTargetEntityOverwritten)
                {
                    // If replaced, emit despawn event
                    var despawnEvent = new EntityDespawnEvent(targetPosition, oldTarget.Tile.Entity);
                    transaction.Emit(despawnEvent);
                }
            }

            transaction.Moves.Pop();
            return true;
        }
コード例 #2
0
ファイル: Map.cs プロジェクト: SvenEV/OrangeBugReloaded
        public async Task<IReadOnlyCollection<FollowUpEvent>> UpdateTilesAsync(IEnumerable<Point> positions, ITransactionWithMoveSupport transaction)
        {
            var initialPoints = new HashSet<Point>(positions);
            var followUpEvents = new List<FollowUpEvent>();
            var now = DateTimeOffset.Now;

            // Notify the initial tiles and tiles that are directly or indirectly
            // (transitively) dependent on them in topological order
            await Dependencies.DoAsyncWorkFollowingDependenciesAsync(initialPoints, async p =>
            {
                // Try to get from transaction first; if that fails get from map
                var tileInfo = transaction.Changes.TryGetValue(p);
                if (tileInfo == TileInfo.Empty) tileInfo = await GetAsync(p);

                followUpEvents.Add(new FollowUpEvent(p, transaction.Initiator, now + tileInfo.Tile.FollowUpDelay));

                var completionArgs = new GameplayArgs(transaction, this);
                await tileInfo.Tile.OnEntityMoveTransactionCompletedAsync(completionArgs);
                completionArgs.ValidateResult();

                if (transaction.IsSealed)
                    return null; // Null terminates the loop

                var newTileInfo = tileInfo.WithTile(completionArgs.Result);
                
                if (transaction.Set(p, tileInfo, newTileInfo))
                {
                    // TODO: Test and check whether this is sufficient
                    // (Initial idea:
                    // Somehow modify events that have been emitted during the move.
                    // E.g. when a balloon is moved onto an InkTile the move event's target
                    // still contains the balloon with its old color.
                    // Here, after the InkTile has changed the balloons color, we have to
                    // change that event to reflect the changes of InkTile and balloon.
                    // We probably have to emit spawn/despawn events as well.)
                    if (tileInfo.Tile.Entity != Entity.None)
                    {
                        if (newTileInfo.Tile.Entity == Entity.None)
                            transaction.Emit(new EntityDespawnEvent(p, tileInfo.Tile.Entity));
                        else
                            transaction.Emit(new EntityChangeEvent(p, newTileInfo.Tile.Entity));
                    }
                    else
                    {
                        if (newTileInfo.Tile.Entity != Entity.None)
                            transaction.Emit(new EntitySpawnEvent(p, newTileInfo.Tile.Entity));
                    }
                    return true;
                }

                return initialPoints.Contains(p);
            });

            return followUpEvents;
        }
コード例 #3
0
ファイル: Map.cs プロジェクト: SvenEV/OrangeBugReloaded
        /// <inheritdoc/>
        public async Task<MoveResult> DespawnAsync(Point position, ITransactionWithMoveSupport transaction)
        {
            var tileInfo = await GetAsync(position);
            tileInfo.Tile.EnsureNotNull();

            // No entity => nothing to despawn
            if (tileInfo.Tile.Entity == Entity.None)
                return new MoveResult(transaction, true, Enumerable.Empty<FollowUpEvent>());

            transaction.Moves.Push(new EntityMoveInfo(tileInfo.Tile.Entity, position, position));

            // Try to detach entity
            var detachArgs = new GameplayArgs(transaction, this);
            await tileInfo.Tile.DetachEntityAsync(detachArgs);
            detachArgs.ValidateResult();

            if (transaction.IsSealed)
                return new MoveResult(transaction, false, Enumerable.Empty<FollowUpEvent>());

            var newTileInfo = tileInfo.WithTile(detachArgs.Result);
            transaction.Set(position, tileInfo, newTileInfo);
            transaction.Emit(new EntityDespawnEvent(position, tileInfo.Tile.Entity));

            // Update tile
            var followUpEvents = await UpdateTilesAsync(new[] { position }, transaction);

            return new MoveResult(transaction, true, followUpEvents);
        }