示例#1
0
        /// <summary>
        /// Handles the specified <see cref="Message"/>.
        /// </summary>
        /// <param name="Device">The device.</param>
        /// <param name="Message">The message.</param>
        /// <param name="Cancellation">The cancellation.</param>
        public static async Task Handle(Device Device, Message Message, CancellationToken Cancellation)
        {
            var LoginMessage = (LoginMessage)Message;

            if (LoginMessage == null)
            {
                throw new LogicException(typeof(LoginHandler), nameof(LoginMessage) + " == null at Handle(Device, Message, CancellationToken).");
            }

            Device.State = State.Login;

            if (LoginHandler.Trusted(Device, LoginMessage) == false)
            {
                return;
            }

            Logging.Info(typeof(LoginHandler), "Login(" + LoginMessage.HighId + "-" + LoginMessage.LowId + ").");

            if (LoginMessage.HighId == 0 && LoginMessage.LowId == 0 && string.IsNullOrEmpty(LoginMessage.Token))
            {
                Player Player = await Players.Create();

                if (Player != null)
                {
                    await LoginHandler.Login(Device, LoginMessage, Player);
                }
                else
                {
                    Device.NetworkManager.SendMessage(new LoginFailedMessage(Reason.Maintenance));
                }
            }
            else
            {
                Player Player = await Players.Get(LoginMessage.HighId, LoginMessage.LowId);

                if (Player != null)
                {
                    if (string.Equals(LoginMessage.Token, Player.Token))
                    {
                        if (!Player.IsBanned)
                        {
                            await LoginHandler.Login(Device, LoginMessage, Player);
                        }
                        else
                        {
                            Device.NetworkManager.SendMessage(new LoginFailedMessage(Reason.Banned));
                        }
                    }
                    else
                    {
                        Device.NetworkManager.SendMessage(new LoginFailedMessage(Reason.Reset));
                    }
                }
                else
                {
                    Device.NetworkManager.SendMessage(new LoginFailedMessage(Reason.Reset));
                }
            }
        }
示例#2
0
        public void When_CreatingAnEngine_Then_BoardIsNotNull()
        {
            var engine = new Engine(
                new RuleMapBuilder(),
                Players.Create(2).ValueOrFailure());

            Assert.NotNull(engine.Board);
        }
        /// <summary>
        /// Handles the creation of the character.
        /// </summary>
        /// <param name="player">The player.</param>
        /// <param name="packet">The packet.</param>
        private static bool HandleCreation(Models.Entities.Player player, CharacterCreationPacket packet)
        {
            if (player.ClientId != packet.ClientId)
            {
                Accounts.Ban(player.DbPlayer.Account, Drivers.Messages.INVALID_CLIENT_ID, DbAccount.BanRangeType.Perm);
                return(false);
            }

            if (!packet.Job.ToString().StartsWith("Intern"))
            {
                Accounts.Ban(player.DbPlayer.Account, Drivers.Messages.INVALID_CLIENT_ID, DbAccount.BanRangeType.Perm);
                return(false);
            }

            if (packet.Model != 1003 && packet.Model != 1004 &&
                packet.Model != 2001 && packet.Model != 2002)
            {
                Accounts.Ban(player.DbPlayer.Account, Drivers.Messages.INVALID_MODEL, DbAccount.BanRangeType.Perm);
                return(false);
            }

            if (!ValidateCharacters(packet.Name))
            {
                player.ClientSocket.Send(MessageController.CreateNewPlayer(Drivers.Messages.Errors.INVALID_CHARS));
                return(true);
            }

            if (IsBannedName(packet.Name))
            {
                player.ClientSocket.Send(MessageController.CreateNewPlayer(Drivers.Messages.Errors.NAME_BANNED));
                return(true);
            }

            if (Players.GetPlayerByName(packet.Name, Drivers.Settings.WorldSettings.Server) != null)
            {
                player.ClientSocket.Send(MessageController.CreateNewPlayer(Drivers.Messages.Errors.NAME_TAKEN));
                return(true);
            }

            // stats fallback ...
            player.DbPlayer.Strength = 0;
            player.DbPlayer.Agility  = 0;
            player.DbPlayer.Vitality = 0;
            player.DbPlayer.Spirit   = 0;

            player.DbPlayer.Name  = packet.Name;
            player.Job            = packet.Job;
            player.Level          = 1;
            player.DbPlayer.Model = packet.Model;

            Players.Create(player.DbPlayer,
                           new ushort[] { player.Strength, player.Vitality, player.Agility, player.Spirit },
                           player.MaxHP, player.MaxMP);
            player.ClientSocket.Disconnect(Drivers.Messages.SUCCESS_CREATE);

            return(true);
        }
示例#4
0
        public void When_PlacingFirstTile_Then_ReturnsNewStateWithSinglePlacedTile()
        {
            // Arrange
            var engine = new Engine(
                new RuleMapBuilder().Set(ImmutableList <IRule <PlaceTileGameAction> > .Empty),
                Players.Create(2).ValueOrFailure());

            // Act
            var newState = engine.Perform(MakePlaceTile(0, 0));

            // Assert
            Assert.Equal(1, newState.ValueOrFailure().Board.ToImmutableDictionary().Count);
        }
示例#5
0
        public void When_PlacingFirstTile_Then_ReturnsANewState()
        {
            // Arrange
            var engine = new Engine(
                new RuleMapBuilder().Set(ImmutableList <IRule <PlaceTileGameAction> > .Empty),
                Players.Create(2).ValueOrFailure());

            // Act
            var newState = engine.Perform(MakePlaceTile(0, 0));

            // Assert
            Assert.True(newState.HasValue);
        }
示例#6
0
        private async Task StartSimulator()
        {
            if (HasStarted)
            {
                return;
            }

            var fileName = Options.FileName;

            HasStarted = true;
            WantToStop = false;

            var noOfPeriods = Convert.ToInt32((int)Options.NoOfTimes / (int)Options.NoOfTimesPerPeriod);
            var cardPacks   = CardPackFactory.Create(Options.NoOfCardPacks);

            PlayManager.CardPacks = cardPacks;

            for (int period = CurrentPeriod; period < noOfPeriods; period++)
            {
                for (int i = 0; i < (int)Options.NoOfTimesPerPeriod; i++)
                {
                    var players = Players.Create(Options.NoOfPlayers);
                    var data    = await PlayManager.PlayAsync(players);

                    DataRecorder.Record(new[] { data });
                }

                await DataRecorder.SaveAsync(fileName, period == 0);

                CurrentPeriod = period;
                if (OnPeriodChange != null)
                {
                    OnPeriodChange.Invoke(period, noOfPeriods);
                }
                if (WantToStop)
                {
                    break;
                }
            }

            CurrentPeriod = (WantToStop) ? 0 : CurrentPeriod;
            if (OnPlayFinished != null && WantToStop == false)
            {
                OnPlayFinished.Invoke(Options.NoOfTimes, Options.NoOfTimesPerPeriod);
            }
            if (WantToStop && OnSimulatorStopped != null)
            {
                OnSimulatorStopped.Invoke();
            }
            HasStarted = false;
        }
示例#7
0
        /// <summary>
        /// The handler for the auth request packet.
        /// </summary>
        /// <param name="client">The client.</param>
        /// <param name="packet">The packet.</param>
        private static bool Handle(Models.Client.AuthClient client, Models.Packets.AuthRequestPacket packet)
        {
            client.Account  = packet.Account;
            client.Password = packet.Password;
            var server   = Repositories.Server.ServerList.GetServerInfo(packet.Server);
            var canLogin = server != null;
            var response = new Models.Packets.AuthResponsePacket();

            if (canLogin)
            {
                try
                {
                    var dbAccount = Accounts.GetAccountByUserNameAndPassword(client.Account, client.Password);
                    if (dbAccount == null)
                    {
                        response.Status = Enums.AuthenticationStatus.InvalidAccountIDOrPassword;
                    }
                    else
                    {
                        client.Authenticated = true;
                        if (dbAccount.Banned && dbAccount.BanDate.HasValue)
                        {
                            bool shouldUnban = false;
                            switch (dbAccount.BanRange)
                            {
                            case DbAccount.BanRangeType.OneDay:
                            {
                                shouldUnban = DateTime.Now >= dbAccount.BanDate.Value.AddDays(1);
                                break;
                            }

                            case DbAccount.BanRangeType.ThreeDays:
                            {
                                shouldUnban = DateTime.Now >= dbAccount.BanDate.Value.AddDays(3);
                                break;
                            }

                            case DbAccount.BanRangeType.OneWeek:
                            {
                                shouldUnban = DateTime.Now >= dbAccount.BanDate.Value.AddDays(7);
                                break;
                            }

                            case DbAccount.BanRangeType.OneMonth:
                            {
                                shouldUnban = DateTime.Now >= dbAccount.BanDate.Value.AddMonths(1);
                                break;
                            }

                            case DbAccount.BanRangeType.ThreeMonths:
                            {
                                shouldUnban = DateTime.Now >= dbAccount.BanDate.Value.AddMonths(3);
                                break;
                            }

                            case DbAccount.BanRangeType.SixMonths:
                            {
                                shouldUnban = DateTime.Now >= dbAccount.BanDate.Value.AddMonths(6);
                                break;
                            }

                            case DbAccount.BanRangeType.OneYear:
                            {
                                shouldUnban = DateTime.Now >= dbAccount.BanDate.Value.AddYears(1);
                                break;
                            }
                            }

                            canLogin = shouldUnban;
                            if (shouldUnban)
                            {
                                dbAccount.Banned = false;
                                dbAccount.Update();
                            }
                            else
                            {
                                response.Status = Enums.AuthenticationStatus.AccountBanned;
                            }
                        }

                        if (canLogin)
                        {
                            client.ClientId = Drivers.Repositories.Safe.IdentityGenerator.GetClientId();

                            response.ClientId  = client.ClientId;
                            response.IPAddress = server.IPAddress;
                            response.Port      = server.Port;
                            response.Status    = Enums.AuthenticationStatus.Ready;

                            if (string.IsNullOrWhiteSpace(dbAccount.FirstLoginIP))
                            {
                                dbAccount.FirstLoginIP   = client.ClientSocket.IPAddress;
                                dbAccount.FirstLoginDate = DateTime.Now;
                            }

                            dbAccount.LastServer    = server.Name;
                            dbAccount.LastIP        = client.ClientSocket.IPAddress;
                            dbAccount.LastAuthKey   = client.ClientId.ToString("X") + ";" + DateTime.Now.ToBinary();
                            dbAccount.LastLoginDate = DateTime.Now;
                            dbAccount.Update();

                            var dbPlayer = Players.GetPlayerByAccount(dbAccount);
                            if (dbPlayer == null)
                            {
                                dbPlayer = Players.Create(dbAccount);
                            }
                            dbPlayer.AuthKey = dbAccount.LastAuthKey;
                            dbPlayer.Update();
                        }
                    }
                }
                catch (Exception e)
                {
                    response.Reset();
                    response.Status = Enums.AuthenticationStatus.DatebaseError;

                                        #if DEBUG
                                        #if TRACE
                    ErrorLogger.Log(StackTracing.GetCurrentMethod().Name, e);
                                        #else
                    ErrorLogger.Log(Drivers.Messages.Errors.DB_ERROR, e);
                                        #endif
                                        #else
                    Global.Message(e.ToString());
                                        #endif
                }
            }

            client.ClientSocket.Send(response);
            return(false);
        }
        public void Given_LastPlayerInBound_When_FindingNextPlayer_Then_Is1()
        {
            int count = 4;

            Assert.Equal(1, Players.Create(count).ValueOrFailure().NextPlayer(count));
        }
 public void Given_Player1_When_FindingNextPlayer_Then_Is2()
 {
     Assert.Equal(2, Players.Create(2).ValueOrFailure().NextPlayer(1));
 }
示例#10
0
 public void Given_NumberOutsideRange_When_FindingNextPlayer_Then_Is1()
 {
     Assert.Equal(1, Players.Create(2).ValueOrFailure().NextPlayer(0));
     Assert.Equal(1, Players.Create(2).ValueOrFailure().NextPlayer(3));
 }
示例#11
0
 public void Given_6Players_When_CreatingPlayers_Then_NoneIsArgumentOutOfRangeException()
 {
     Players.Create(6).MatchNone(exception => Assert.IsType <ArgumentOutOfRangeException>(exception));
 }
示例#12
0
 public void Given_2Players_When_CreatingPlayers_Then_SomeIsReturned()
 {
     Assert.NotNull(Players.Create(2).ValueOrFailure());
 }