private void UpdateOfflineGame(WorldState state)
{
var id = 0u;
_offlineGame.Bot = _playerFactory.CreatePlayer(new Entity()
{
GameIdentity = Entity.GAME_IDENTITY.BOT, EntityState = state.Bot, Id = ++id
});
//TODO manual default state
if (state.Manual != null)
{
_offlineGame.Manual = _playerFactory.CreatePlayer(new Entity()
{
GameIdentity = Entity.GAME_IDENTITY.MANUAL, EntityState = state.Manual, Id = ++id
});
}
state.Uninvolved.ToList().ForEach(uninvolvedState => _offlineGame.RefugeList.Add(_playerFactory.CreatePlayer(new Entity()
{
GameIdentity = Entity.GAME_IDENTITY.UNINVOLVED, EntityState = uninvolvedState, Id = ++id
})));
//TODO refuge types
state.Refuges.ToList().ForEach(refugeState => _offlineGame.RefugeList.Add(new Refuge()
{
EntityState = refugeState, Id = ++id
}));
}
public override void OnStateMachineEnter(Animator animator, int stateMachinePathHash)
{
Brain.ClearListeners();
Brain.EnableCameraMovement();
VisibilityCanon.ResourceVisibilityMode = ResourceVisibilityMode.RevealAll;
VisibilityCanon.CellVisibilityMode = CellVisibilityMode.RevealAll;
ExplorationCanon.ExplorationMode = CellExplorationMode.AllCellsExplored;
VisibilityResponder.UpdateVisibility = true;
UnitMapIconManager.BuildIcons();
UnitMapIconManager.SetActive(true);
foreach (var element in PlayModeSensitiveElements)
{
element.IsActive = false;
}
Grid.Build(10, 7);
var playerCiv = CivFactory.Create(CivConfig.DefaultTemplate);
var barbarianCiv = CivFactory.Create(CivConfig.BarbarianTemplate);
PlayerFactory.CreatePlayer(playerCiv, BrainPile.HumanBrain);
PlayerFactory.CreatePlayer(barbarianCiv, BrainPile.BarbarianBrain);
foreach (var chunk in Grid.Chunks)
{
chunk.Refresh(Simulation.MapRendering.TerrainRefreshType.All);
}
}
private void GeneratePlayers(IMapGenerationVariables variables)
{
CivFactory.Clear();
foreach (var civTemplate in variables.Civilizations)
{
var newCiv = CivFactory.Create(civTemplate, variables.StartingTechs);
PlayerFactory.CreatePlayer(newCiv, BrainPile.HumanBrain);
}
var barbarianCiv = CivFactory.Create(CivConfig.BarbarianTemplate);
PlayerFactory.CreatePlayer(barbarianCiv, BrainPile.BarbarianBrain);
}
public Alarm(IPlayerFactory playerFactory)
{
if (playerFactory == null)
{
throw new ArgumentNullException(nameof(playerFactory), @"Player factory cannot be null.");
}
_defaultPlayer = playerFactory.CreatePlayer();
_playerA = playerFactory.CreatePlayer();
_playerB = playerFactory.CreatePlayer();
_defaultSoundCollection = new ObservableCollection <Uri>();
DefaultSoundCollection = new ReadOnlyObservableCollection <Uri>(_defaultSoundCollection);
}
public void DecomposePlayers(SerializableMapData mapData)
{
foreach (var playerData in mapData.Players)
{
var controlledCiv = CivFactory.AllCivilizations.FirstOrDefault(
civ => civ.Template.Name.Equals(playerData.ControlledCiv)
);
if (controlledCiv == null)
{
throw new InvalidOperationException("Could not find a civ of template " + playerData.ControlledCiv);
}
var playerBrain = BrainPile.AllBrains.FirstOrDefault(
brain => brain.Name.Equals(playerData.Brain)
);
if (playerBrain == null)
{
throw new InvalidOperationException("Could not find a brain of name " + playerData.Brain);
}
PlayerFactory.CreatePlayer(controlledCiv, playerBrain);
}
GameCore.ActivePlayer = mapData.ActivePlayer != null
? PlayerFactory.AllPlayers.First(player => player.Name.Equals(mapData.ActivePlayer))
: null;
}
public IActionResult StartCustomMatches(TeamOverView teamoverview)
{
List <Team> teams = new List <Team>();
foreach (var team in teamoverview.Teams)
{
var tempTeamp = _teamFactory.CreateTeam(team.Name);
tempTeamp.Players = team.Players.Select(x => _playerFactory.CreatePlayer(tempTeamp.Id, x.Posistion, x.Attack, x.Defense)).ToList();
teams.Add(tempTeamp);
}
//var teams = _teamGeneratorService.GenerateFixedTeams();
var matches = _matchGeneratorService.GenerateMatches(teams);
// Add secend set of matches
matches.AddRange(_matchGeneratorService.GenerateMatches(teams));
matches = matches.Select(x => _matchSimulatorService.RunSimulation(x)).ToList();
var viewmodel = _matchOverViewMapper.MapToMatchesOverView(matches);
viewmodel.PoolOverView = _PoolOverViewMapper.MapToPoolOverView(_poolFinalizeService.DeterminePoolResults(matches).Teams);
return(PartialView("_matchesOverView", viewmodel));
}
private Task Login(SocketBase socket)
{
LobbyPlayer player = _playerFactory.CreatePlayer(PlayerType.Lobby, socket) as LobbyPlayer
?? throw new ArgumentNullException();
return(_lobbyManager.TryAddPlayer(player));
}
public void OnJoin(IWorldClient client, JoinPacket packet)
{
DbCharacter character = _database.Characters.Include(x => x.User).FirstOrDefault(x => x.Id == packet.PlayerId);
if (character == null)
{
_logger.LogError($"Invalid player id received from client; cannot find player with id: {packet.PlayerId}");
return;
}
if (character.IsDeleted)
{
_logger.LogWarning($"Cannot connect with character '{character.Name}' for user '{character.User.Username}'. Reason: character is deleted.");
return;
}
if (character.User.Authority <= 0)
{
_logger.LogWarning($"Cannot connect with '{character.Name}'. Reason: User {character.User.Username} is banned.");
// TODO: send error to client
return;
}
client.Player = _playerFactory.CreatePlayer(character);
client.Player.Connection = client;
_worldSpawnPacketFactory.SendPlayerSpawn(client.Player);
client.Player.Object.Spawned = true;
client.Player.PlayerData.LoggedInAt = DateTime.UtcNow;
}
public string AddPlayer(string type, string username)
{
IPlayer player = playerFactory.CreatePlayer(type, username);
playerRepository.Add(player);
return(string.Format(ConstantMessages.SuccessfullyAddedPlayer, type, username));
}
public string AddPlayer(string type, string username)
{
player = playerFactory.CreatePlayer(type, username);
playerRepository.Add(player);
return($"Successfully added player of type {type} with username: {username}");
}
public string AddPlayer(string type, string username)
{
IPlayer player = playerFactory.CreatePlayer(type, username);
playerRepo.Add(player);
return($"Successsfully added card: {type} to user {username}");
}
public string AddPlayer(string type, string username)
{
var newPlayer = playerFactory.CreatePlayer(type, username);
playerRepo.Add(newPlayer);
return(string.Format(ConstantMessages.SuccessfullyAddedPlayer, newPlayer.GetType().Name, newPlayer.Username));
}
public PlayerInitialization(IPlayerFactory playerFactory, PlayerData playerData)
{
_playerFactory = playerFactory;
_player = _playerFactory.CreatePlayer();
_playerData = playerData;
_player.position = _playerData.Position;
}
public PlayerModel(IPlayerFactory playerFactory)
{
playerFactory.CreatePlayer();
_characterController = playerFactory.GetCharacterController();
_transform = playerFactory.GetTransform();
_camera = playerFactory.GetCamera();
_animator = playerFactory.GetAnimator();
}
public void CreateNewPlayer()
{
var newCiv = CivilizationFactory.Create(SelectedTemplate);
PlayerFactory.CreatePlayer(newCiv, BrainPile.HumanBrain);
Refresh();
}
public string AddPlayer(string type, string username)
{
var player = playerFactory.CreatePlayer(type, username);
this.playersRepository.Add(player);
var msg = string.Format(ConstantMessages.SuccessfullyAddedPlayer, type, username);
return(msg);
}
[ExcludeFromCodeCoverage] //Cannot Test for User Input
public void StartGame()
{
try
{
Board gameBoard = _boardFactory.CreateBoard();
Logger.Info("New Game Board created");
Player player = _playerFactory.CreatePlayer();
_userInterface.RenderMessage("Shuffle! New Game Started.");
player.SetPlayerName(_userInterface.AskForPlayerName());
player.SetLives();
Logger.Info("New Player Created");
_userInterface.ClearScreen();
_userInterface.RenderMessage($"Welcome {player.Name} to Shuffle!");
_userInterface.RenderMessage(
"Move your piece to the top of the board to win. Watch out for mines, hit two and its GAME OVER!");
_userInterface.NewLine();
bool success = gameBoard.DrawBoard();
if (!success)
{
throw new ApplicationException("Something went wrong while drawing the board");
}
_userInterface.NewLine();
_userInterface.RenderMessage("Ready Player One.");
Logger.Info("Turns Started");
TakeTurns(gameBoard, player);
string askToPlayAgainResult = _userInterface.AskToPlayAgain();
bool isNewGameWanted = _userInterface.ValidatePlayAgainResponse(askToPlayAgainResult);
if (isNewGameWanted)
{
_userInterface.ClearScreen();
StartGame();
}
else
{
_userInterface.ClearScreen();
_userInterface.RenderMessage($"Thanks for playing {player.Name}. Press any key to exit and press enter");
}
_userInterface.GetUserInput();
}
catch (Exception exception)
{
Logger.Error(exception, "An Error Occured: {0}", exception.Message);
_userInterface.RenderMessage($"An Error Occured: {exception}");
_userInterface.RenderMessage("Press Any Key to Exit");
_userInterface.GetUserInput();
}
}
public PlayerInitialization(IPlayerFactory playerFactory, GamePoolContext gamePoolContext)
{
_playerFactory = playerFactory;
_player = _playerFactory.CreatePlayer();
var _playerStruct = _playerFactory.GivePlayerData().PlayerStruct;
_player.transform.position = _playerStruct.StartPosition;
_playerStruct.Player = _player;
var _playerComponents = _playerFactory.GivePlayerData().PlayerComponents;
_playerComponents.Rigitbody = _playerStruct.Player.GetComponent <Rigidbody>();
var playerModel = new PlayerModel(_playerStruct, _playerComponents);
gamePoolContext.AddPlayerModel(playerModel);
}
public string AddPlayer(string type, string username)
{
var player = playerFactory.CreatePlayer(type, username);
try
{
players.Add(player);
}
catch (Exception e)
{
return(e.Message);
}
return(ConstantMessages.SuccessfullyAddedPlayer
.Replace("{0}", type)
.Replace("{1}", username));
}
public void Initialize()
{
_playerFactory.CreatePlayer(_context);
_uiFactory.CreatePlayerHUD(_context);
_uiFactory.CreateCamera(_context);
_context.ReplaceWorld(new Vector2Int(10, 10));
// _monsterFactory.CreateWorker(new Vector3Int(1, 0, 0));
// _monsterFactory.CreateWarrior(new Vector2(-2, 4));
// _monsterFactory.CreateBlackBuilding(new Vector2(-2, 0));
// _monsterFactory.CreateLich(new Vector2(2, 0));
// _monsterFactory.CreateSkeleton(new Vector2(2, 0));
// _monsterFactory.CreateHealer(new Vector2(0, 0));
}
public MainWindow(SovndClient client, ChannelDirectory channels, IPlayerFactory playerFactory, ISettingsProvider settings, Scrobbler scrobbler)
{
InitializeComponent();
toast = new Toast();
toast.Show();
_scrobbler = scrobbler;
_client = client;
_playerFactory = playerFactory;
_settings = settings.GetSettings();
AllowDrop = true;
channelbox.ItemsSource = channels.channels;
PreviewDragOver += OnPreviewDragEnter;
PreviewDragEnter += OnPreviewDragEnter;
DragEnter += OnPreviewDragEnter;
DragOver += OnPreviewDragEnter;
Drop += OnDrop;
Loaded += (_, __) =>
{
BindingOperations.EnableCollectionSynchronization(channels.channels, channels.channels);
App.WindowHandle = new WindowInteropHelper(this).Handle;
synchronization = SynchronizationContext.Current;
_client.Run();
if (!string.IsNullOrWhiteSpace(_settings.LastChannel))
{
_player = _playerFactory.CreatePlayer(_settings.LastChannel);
_client.SubscribeToChannel(_settings.LastChannel);
SetupChannel();
Logging.Event("Switched to previously set channel");
}
};
Closed += (_, __) =>
{
_client.Disconnect();
Spotify.ShutDown();
Process.GetCurrentProcess().Kill(); // TODO That's really inelegant
};
}
private void Channelbox_SelectionChanged(object sender, RoutedEventArgs e)
{
var channel = channelbox.SelectedItem as Channel;
if (channel != null)
{
DropChannel();
_settings.LastChannel = channel.Name;
_settings.Save();
_player = _playerFactory.CreatePlayer(channel.Name);
_client.SubscribeToChannel(channel.Name);
SetupChannel();
Logging.Event("Switched channels");
}
}
public IPlayerBuilder BuildGamePlayer(Player player)
{
var emptyPlayer = _playerFactory.CreatePlayer(PlayerType.Game, new LoginRequest
{
Connection = player.Connection,
Name = player.Name
});
Player = new GamePlayer
{
Connection = player.Connection,
Name = emptyPlayer.Name,
Score = 0,
Target = null,
WeaponType = WeaponTypes.Enemy,
LaserStrength = 1
};
return(this);
}
public IPlayer CreatePlayer(IRegistration playerParameters)
{
string name, spaceshipModel, engineModel, armourModel, weaponModel;
name = playerParameters.ParametersForPlayer["name"];
spaceshipModel = playerParameters.ParametersForPlayer["ship"];
engineModel = playerParameters.ParametersForPlayer["engine"];
armourModel = playerParameters.ParametersForPlayer["armour"];
weaponModel = playerParameters.ParametersForPlayer["weapon"];
ISpaceshipEngine engine = engineFactory.CreateEngine(engineModel);
IArmour armour = armourFactory.CreateArmour(armourModel);
IWeapon weapon = weaponFactory.CreateWeapon(weaponModel.ToLower());
weapon.Bullet = bulletFactory.CreateBullet();
ISpaceShip spaceship = spaceshipFactory.CreateSpaceship(spaceshipModel, engine, armour, weapon);
IPlayer player = playerFactory.CreatePlayer(name, spaceship);
return(player);
}
public PlayerInitialization(IPlayerFactory playerFactory, Vector2 positionPlayer)
{
_playerFactory = playerFactory;
_player = _playerFactory.CreatePlayer();
_player.position = positionPlayer;
}
internal void StartGame(IPlayerFactory playerFactory)
{
new Example3().StartGame(playerFactory.CreatePlayer(177));
}
public PlayerInitialization(IPlayerFactory playerFactory)
{
_playerFactory = playerFactory;
_player = _playerFactory.CreatePlayer();
}
public void Initialize()
{
Player = _playerFactory.CreatePlayer();
Player.Initialize();
_collisionSystem.RegisterEntity(Player);
}
private void Login(Session session, Packet packet)
{
IPlayer player;
short clientVersion;
short clientRevision;
LoginHandlerMode loginMode;
string playerName;
string loginKey;
try
{
clientVersion = packet.GetInt16();
clientRevision = packet.GetInt16();
loginMode = (LoginHandlerMode)packet.GetByte();
playerName = packet.GetString();
loginKey = packet.GetString();
}
catch (Exception)
{
ReplyError(session, packet, Error.Unexpected);
session.CloseSession();
return;
}
if (clientVersion <= Config.client_min_version && clientRevision < Config.client_min_revision)
{
ReplyError(session, packet, Error.ClientOldVersion);
session.CloseSession();
return;
}
LoginResponseData loginResponseData;
var loginResult = loginHandler.Login(loginMode, playerName, loginKey, out loginResponseData);
if (loginResult != Error.Ok)
{
ReplyError(session, packet, loginResult);
session.CloseSession();
return;
}
// If we are under admin only mode then kick out non admin
if (Config.server_admin_only && loginResponseData.Player.Rights == PlayerRights.Basic)
{
ReplyError(session, packet, Error.UnderMaintenance);
session.CloseSession();
return;
}
//Create the session id that will be used for the calls to the web server
string sessionId;
if (Config.server_admin_always && !Config.server_production)
{
sessionId = loginResponseData.Player.Id.ToString(CultureInfo.InvariantCulture);
loginResponseData.Player.Rights = PlayerRights.Bureaucrat;
}
else
{
SHA1 sha = new SHA1CryptoServiceProvider();
byte[] hash = sha.ComputeHash(Encoding.UTF8.GetBytes(loginResponseData.Player.Id + Config.database_salt + DateTime.UtcNow.Ticks + Config.Random.Next()));
sessionId = BitConverter.ToString(hash).Replace("-", String.Empty);
}
lock (loginLock)
{
bool newPlayer = !world.Players.TryGetValue(loginResponseData.Player.Id, out player);
//If it's a new player then add him to our session
if (newPlayer)
{
logger.Info(string.Format("Creating new player {0}({1}) IP: {2}", playerName, loginResponseData.Player.Id, session.RemoteIP));
player = playerFactory.CreatePlayer(loginResponseData.Player.Id, SystemClock.Now, SystemClock.Now, playerName, string.Empty, loginResponseData.Player.Rights, sessionId);
if (!world.Players.TryAdd(player.PlayerId, player))
{
session.CloseSession();
return;
}
}
else
{
player.Name = playerName;
}
logger.Info(string.Format("Player login in {0}({1}) IP: {2}", player.Name, player.PlayerId, session.RemoteIP));
}
locker.Lock(args =>
{
var lockedPlayer = (IPlayer)args[0];
return(lockedPlayer.IsInTribe ? new ILockable[] { lockedPlayer.Tribesman.Tribe } : new ILockable[0]);
}, new object[] { player }, player).Do(() =>
{
// If someone is already connected as this player, kick them off potentially
if (player.Session != null)
{
player.Session.CloseSession();
player.Session = null;
// Kick people off who are spamming logins
if (SystemClock.Now.Subtract(player.LastLogin).TotalMilliseconds < 1500)
{
session.CloseSession();
return;
}
}
// Setup session references
session.Player = player;
player.HasTwoFactorAuthenticated = null;
player.TwoFactorSecretKey = loginResponseData.Player.TwoFactorSecretKey;
player.Session = session;
player.SessionId = sessionId;
player.Rights = loginResponseData.Player.Rights;
player.LastLogin = SystemClock.Now;
player.Banned = loginResponseData.Player.Banned;
player.Achievements.Clear();
player.Achievements.AddRange(loginResponseData.Achievements);
player.ThemePurchases.Clear();
player.ThemePurchases.AddRange(loginResponseData.ThemePurchases);
dbManager.Save(player);
// If player was banned then kick his ass out
if (loginResponseData.Player.Banned)
{
ReplyError(session, packet, Error.Banned);
session.CloseSession();
return;
}
var reply = new Packet(packet);
reply.Option |= (ushort)Packet.Options.Compressed;
reply.AddString(Config.welcome_motd);
//Player Info
reply.AddUInt32(player.PlayerId);
reply.AddString(player.PlayerHash);
reply.AddUInt32(player.TutorialStep);
reply.AddBoolean(player.SoundMuted);
reply.AddBoolean(player.Rights >= PlayerRights.Admin);
reply.AddString(sessionId);
reply.AddString(player.Name);
reply.AddInt32(Config.newbie_protection);
reply.AddInt32(loginResponseData.Player.Balance);
reply.AddUInt32(UnixDateTime.DateTimeToUnix(player.Created.ToUniversalTime()));
reply.AddInt32(player.Tribesman == null
? 0
: tribeManager.GetIncomingList(player.Tribesman.Tribe).Count());
reply.AddInt16((short)(player.Tribesman == null ? 0 : player.Tribesman.Tribe.AssignmentCount));
//Server time
reply.AddUInt32(UnixDateTime.DateTimeToUnix(DateTime.UtcNow.ToUniversalTime()));
//Server rate
reply.AddString(Config.seconds_per_unit.ToString(CultureInfo.InvariantCulture));
// If it's a new player we send simply a 1 which means the client will need to send back a city name
// Otherwise, we just send the whole login info
if (player.GetCityCount() == 0)
{
reply.AddByte(1);
}
else
{
reply.AddByte(0);
PacketHelper.AddLoginToPacket(session, themeManager, reply);
SubscribeDefaultChannels(session, session.Player);
}
session.Write(reply);
// Restart any city actions that may have been stopped due to inactivity
foreach (var city in player.GetCityList()
.Where(city => city.Worker.PassiveActions.Values.All(x => x.Type != ActionType.CityPassive)))
{
city.Worker.DoPassive(city, actionFactory.CreateCityPassiveAction(city.Id), false);
}
});
}
private void Start()
{
player = factory.CreatePlayer(100);
}
