public async Task <IActionResult> UpdateDestinationByIdAsync(
            [FromRoute] string id,
            [FromBody] UpdateDestination command,
            CancellationToken cancellationToken = default(CancellationToken))
        {
            if (id != command.Id)
            {
                return(BadRequest());
            }
            await Mediator.Send(command, cancellationToken).ConfigureAwait(false);

            return(NoContent());
        }
Beispiel #2
0
        protected async Task ProcessCommand(UpdateDestination command)
        {
            if (command == null)
            {
                throw new ArgumentNullException(nameof(command));
            }

            var evento = (await NonEventSourceRepository.GetEvent(command.Id)).ToDomainEvent();

            evento.UpdateDestination(command.Location);
            await NonEventSourceRepository.UpdateEvent(evento);

            await notificationManager.NotifyParticipantsAsync((Notification.EventWithUserIds) evento.ToDataContractEvent(), Engaze.Core.DataContract.OccuredEventType.DestinationUpdated);
        }
        public static async Task All()
        {
            double rnd;
            byte   biomeHolder;
            Land   checkPosX;
            Land   checkPosY;
            Land   checkNegX;
            Land   checkNegY;
            Land   checkTile;

            /*
             * The following statements will populate the land values of the default array 1000 x 1000
             * as well as the tile cache array currently 400 x 250 which will
             * support the tile scale .1 (10x) on most resolution scales
             * ^^--pending optimization--^^
             * a roll is done to determine some land values as well as if the tile will be a new biome
             * and then check the previously drawn X & Y tiles for water or trees to increase clumping
             * before going on to generate full biomes, to scale
             * the biomes are then expanded on with more complex near-by random tile generation
             * done through multiple rescans of the default global land array for definition
             * default snow i = 40
             * default ore i = 5
             */

            for (int y = 0; y < 1000; y++)
            {
                for (int x = 0; x < 1000; x++)
                {
                    rnd = Random.Next(0, 10000);

                    /////////////////////////
                    // New Biome Initiator //
                    /////////////////////////

                    if (rnd < 5)
                    {
                        biomeHolder = 0;
                    }
                    else
                    {
                        biomeHolder = 1;
                    }

                    /////////////////////////////////////////////////////////////
                    // Randomly Generate and Instantiate Land Stored in Arrays //
                    /////////////////////////////////////////////////////////////

                    landArray[x, y]       = new Land();
                    landArray[x, y].biome = biomeHolder;

                    if (rnd <= 9390)
                    {
                        landArray[x, y].land = 0;
                    }
                    else if (rnd > 9390 && rnd <= 9400)
                    {
                        landArray[x, y].land = 2;
                    }
                    else if (rnd > 9400 && rnd <= 9800)
                    {
                        landArray[x, y].land = 3;
                    }
                    else if (rnd > 9800 && rnd <= 9900)
                    {
                        landArray[x, y].land = 4;
                    }
                    else if (rnd > 9900 && rnd <= 9995)
                    {
                        landArray[x, y].land = 5;
                    }
                    else if (rnd > 9995)
                    {
                        landArray[x, y].land = -6;
                    }

                    /////////////////////
                    // Realistic Water //
                    /////////////////////

                    if (landArray[Check.Min(x - 1, 0), y].land == 2 && rnd < 5300)
                    {
                        landArray[x, y].land = 2;
                    }
                    else if (landArray[x, Check.Min(y - 1, 0)].land == 2 && rnd < 5300)
                    {
                        landArray[x, y].land = 2;
                    }
                    else if (landArray[x, Check.Min(y - 1, 0)].land == 2 && landArray[Check.Min(x - 1, 0), y].land == 2 && rnd < 9900)
                    {
                        landArray[x, y].land = 2;
                    }

                    ///////////////////////
                    // Realistic Forests //
                    ///////////////////////

                    if (landArray[Check.Min(x - 1, 0), y].land == 5 && rnd < 3500)
                    {
                        landArray[x, y].land = 5;
                    }
                    else if (landArray[x, Check.Min(y - 1, 0)].land == 5 && rnd < 3500)
                    {
                        landArray[x, y].land = 5;
                    }
                    else if (landArray[x, Check.Min(y - 1, 0)].land == 5 && landArray[Check.Min(x - 1, 0), y].land == 5 && rnd < 9600)
                    {
                        landArray[x, y].land = 5;
                    }
                }
            }

            MainMenuOpen       = false;
            Show.CursorOutline = true;
            LogicClock40.Start();
            LogicClock100.Start();
            LogicClock250.Start();
            LogicClock500.Start();
            LogicClock1000.Start();
            UpdateDestination.Start();

            /////////////////////
            // Generate Biomes //
            /////////////////////

            for (int y = 0; y < 1000; y++)
            {
                for (int x = 0; x < 1000; x++)
                {
                    if (landArray[x, y].biome == 0)
                    {
                        rnd = Random.Next(2, 4);
                        landArray[x, y].biome = (int)rnd;
                        Biome(x - 1, y - 1, (int)rnd, landArray);
                    }
                    if (landArray[x, y].land == -6)
                    {
                        landArray[x, y].land = 6;
                        Land(x - 1, y - 1, 6, landArray);
                    }
                }
            }

            /////////////////////////////////////
            // Expanded Deserts || Default i < 50 //
            /////////////////////////////////////

            for (int i = 0; i < 30; i++)
            {
                for (int y = 0; y < 1000; y++)
                {
                    for (int x = 0; x < 1000; x++)
                    {
                        checkTile = landArray[x, y];
                        checkPosX = landArray[Check.Max(x + 1, 999), y];
                        checkPosY = landArray[x, Check.Max(y + 1, 999)];
                        checkNegX = landArray[Check.Min(x - 1, 0), y];
                        checkNegY = landArray[x, Check.Min(y - 1, 0)];
                        if (checkTile.biome != 3)
                        {
                            rnd = Random.Next(0, 1000);
                            if (checkNegX.biome == 3)
                            {
                                rnd = rnd * 1.25;
                            }
                            if (checkNegY.biome == 3)
                            {
                                rnd = rnd * 1.25;
                            }
                            if (checkPosX.biome == 3)
                            {
                                rnd = rnd * 1.25;
                            }
                            if (checkPosY.biome == 3)
                            {
                                rnd = rnd * 1.25;
                            }
                            if (rnd > 1120)
                            {
                                landArray[x, y].biome = 3;
                            }
                        }
                    }
                }
            }

            /////////////////////////////////////
            // Expanded Snow || Default i < 50 //
            /////////////////////////////////////

            for (int i = 0; i < 40; i++)
            {
                for (int y = 0; y < 1000; y++)
                {
                    for (int x = 0; x < 1000; x++)
                    {
                        checkTile = landArray[x, y];
                        checkPosX = landArray[Check.Max(x + 1, 999), y];
                        checkPosY = landArray[x, Check.Max(y + 1, 999)];
                        checkNegX = landArray[Check.Min(x - 1, 0), y];
                        checkNegY = landArray[x, Check.Min(y - 1, 0)];
                        if (checkTile.biome != 2)
                        {
                            rnd = Random.Next(0, 1000);
                            if (checkNegX.biome == 2)
                            {
                                rnd = rnd * 1.25;
                            }
                            if (checkNegY.biome == 2)
                            {
                                rnd = rnd * 1.25;
                            }
                            if (checkPosX.biome == 2)
                            {
                                rnd = rnd * 1.25;
                            }
                            if (checkPosY.biome == 2)
                            {
                                rnd = rnd * 1.25;
                            }
                            if (rnd > 1120)
                            {
                                landArray[x, y].biome = 2;
                            }
                        }
                    }
                }
            }

            ////////////////////////////////////
            // Sparse Nodes || Default i < 5 //
            ////////////////////////////////////

            for (int i = 0; i < 5; i++)
            {
                for (int y = 0; y < 1000; y++)
                {
                    for (int x = 0; x < 1000; x++)
                    {
                        checkTile = landArray[x, y];
                        checkPosX = landArray[Check.Max(x + 1, 999), y];
                        checkPosY = landArray[x, Check.Max(y + 1, 999)];
                        checkNegX = landArray[Check.Min(x - 1, 0), y];
                        checkNegY = landArray[x, Check.Min(y - 1, 0)];
                        if (landArray[x, y].biome != 3)
                        {
                            rnd = Random.Next(0, 1000);
                            int node = 6;
                            if (Random.Next(0, 6) == 5)
                            {
                                node = Random.Next(10, 19);
                            }

                            if (landArray[Check.Min(x - 1, 0), y].land == 6 && rnd > 650)
                            {
                                landArray[x, y].land = node;
                            }
                            if (landArray[x, Check.Min(y - 1, 0)].land == 6 && rnd > 650)
                            {
                                landArray[x, y].land = node;
                            }
                            if (landArray[Check.Max(x + 1, 999), y].land == 6 && rnd > 650)
                            {
                                landArray[x, y].land = node;
                            }
                            if (landArray[x, Check.Max(y + 1, 999)].land == 6 && rnd > 650)
                            {
                                landArray[x, y].land = node;
                            }
                        }
                        if (checkTile.land != 5 && checkTile.land != 2)
                        {
                            rnd = Random.Next(0, 1000);
                            if (checkNegX.land == 5)
                            {
                                rnd = rnd * 1.5;
                            }
                            if (checkNegY.land == 5)
                            {
                                rnd = rnd * 1.5;
                            }
                            if (checkPosX.land == 5)
                            {
                                rnd = rnd * 1.5;
                            }
                            if (checkPosY.land == 5)
                            {
                                rnd = rnd * 1.5;
                            }
                            if (rnd > 1050)
                            {
                                checkTile.land = 5;
                            }
                        }
                    }
                }
            }

            Edges();

            Player.WorldItems.Add(new GPS(50, 50, 0), 0);
        }