internal Client(INetworkClient client, MatchConfig config) : base(client, config) { CurrentInput = new MatchInput(config); InputContext = new MatchInputContext(CurrentInput); NetworkClient.OnRecievedInputs += OnRecievedInputs; NetworkClient.OnRecievedState += OnRecievedState; }
public RegexConfiguration GetConfiguration(string path) { MatchConfig matcher = Matcher.GetConfiguration(path); ReplaceConfig replacer = Replacer.GetConfiguration(path); return(new RegexConfiguration(matcher, replacer)); }
public void StartMatch(MatchConfig config) { using (var rental = ObjectPool <MatchStartMessage> .Shared.Borrow()) { rental.RentedObject.MatchConfig = config; Connection.Send(MessageCodes.MatchStart, rental.RentedObject); } }
public void SendConfig(MatchConfig config) { using (var rental = ObjectPool <ServerUpdateConfigMessage> .Shared.Borrow()) { rental.RentedObject.MatchConfig = config; Connection.Send(MessageCodes.UpdateConfig, rental.RentedObject); } }
public void SetConfiguration(Configuration config) { Config = config; var newConfig = new MatchConfig(); newConfig.FieldSize = new Coordinates(Config.GetValue <int>("mbc_field_width"), Config.GetValue <int>("mbc_field_height")); newConfig.NumberOfRounds = Config.GetValue <int>("mbc_match_rounds"); var initShips = new ShipList(); foreach (var length in Config.GetList <int>("mbc_ship_sizes")) { initShips.Add(new Ship(length)); } newConfig.StartingShips = initShips; newConfig.TimeLimit = Config.GetValue <int>("mbc_player_timeout"); newConfig.GameMode = 0; foreach (var mode in Config.GetList <GameMode>("mbc_game_mode")) { newConfig.GameMode |= mode; } if (!newConfig.GameMode.HasFlag(GameMode.Classic)) { throw new NotImplementedException("The " + newConfig.GameMode.ToString() + " game mode is not supported."); } newConfig.Random = new Random(); ApplyEvent(new MatchConfigChangedEvent(newConfig)); }
public void PositionForCompetitor_StepForwardGivesExpectedLocations() { var config = new MatchConfig { InitialRange = 100, StepForwardProportion = 0.5f, MaximumLocationRandomisation = 0, MinimumLocationRandomisation = 0 }; var steps = Enumerable.Range(-3, 3); var results = steps.Select(p => config.PositionForCompetitor(1, 1, p)); var expectedXLocations = new float[] { config.InitialRange * 8, config.InitialRange * 4, config.InitialRange * 2, config.InitialRange, config.InitialRange / 2, config.InitialRange / 4, config.InitialRange / 8 }; var i = 0; foreach (var position in results) { Assert.AreEqual(expectedXLocations[i], position.magnitude); i++; } }
public void VerifyStart() { var matchConfig = new MatchConfig(501, 1, false, 3, true, "opponent", true, 0); var controller = new MatchConfigController(this.switcher.Object, this.dataBase.Object); controller.Start(matchConfig); this.switcher.Verify(x => x.StartMatch(matchConfig), Times.Once, "StartMatch was not called"); }
internal Server(INetworkServer server, MatchConfig config) : base(server, config) { // TODO(james7132): Run server simulation for momentary state syncs NetworkServer.ReceivedInputs += OnRecievedInputs; CurrentInput = new MatchInput(config); NextInput = new MatchInput(config); InputBuffer = new MatchInput[1]; }
/// <summary> /// Wraps a controller and sets up the thread aborter on the current thread. /// </summary> /// <param name="controllerWrap"></param> public TimedController(MatchConfig config, IController controllerWrap) { controller = controllerWrap; Match = config; controller = controllerWrap; controller.ControllerMessageEvent += ReceiveMessage; aborter = new ThreadTimeoutAborter(Thread.CurrentThread, Match.TimeLimit); }
public async Task Execute(MatchConfig config, bool loadStage = true) { if (!IsValidConfig(config)) { throw new ArgumentException("Attempted to start game with invalid config"); } await RunGame(config, loadStage); }
GameScene(MatchConfig config) { //IMPLEMENT INITIALIZATION LISTS this.objectsG = new List<GameObject>(); this.objectsNG = new List<GameObject>(); GameScene.scene = this; this.config = config; }
public TestInputSource(MatchConfig config) { input = new MatchInput(config); for (int i = 0; i < input.PlayerCount; i++) { input.PlayerInputs[i].IsValid = true; } }
internal Client(INetworkClient client, MatchConfig config) : base(client, config) { NetworkClient.OnRecievedState += OnRecievedState; NetworkClient.OnRecievedInputs += OnRecievedInputs; InputContext = new MatchInputContext(config); InputHistory = new InputHistory <MatchInput>(new MatchInput(config)); NetworkConfig = Config.Get <NetworkConfig>(); InputSendTimer = 0; }
protected override async Task RunGame(MatchConfig config, bool loadStage = true) { var results = await CreateMatch(config).RunMatch(config, loadStage); await Config.Get <SceneConfig>().MatchEndScene.LoadAsync(); var viewFactories = Object.FindObjectsOfType <ViewFactory <PlayerMatchStats, PlayerConfig> >(); await Task.WhenAll(results.PlayerStats.Select(p => BuildResultViews(p, viewFactories))); }
internal static MatchConfigModel Map(MatchConfig matchConfig) { return(new MatchConfigModel() { Id = matchConfig.Id, End = matchConfig.End, Start = matchConfig.Start }); }
public static IMatchController CreateHost(this INetworkStrategy strategy, NetworkHost host, MatchConfig config) { var server = strategy.CreateServer(host.Server, config); var client = strategy.CreateClient(host.Client, config); return(new NetworkHostController(client, server)); }
private static void Main(string[] args) { // ////////////////////////////////////////////////////////////// // // Create an instance of our Ultron thinker via ThinkerPrototype. // // If we created directly with new, it would not be properly // // configured. // // ////////////////////////////////////////////////////////////// // // Create a configuration for a default ColorShapeLinks match MatchConfig mc = new MatchConfig(); // Get the fully qualified name of our basic Ultron thinker string ultronFullName = typeof(UltronThinker).FullName; // Create a prototype for our thinker ThinkerPrototype tp = new ThinkerPrototype(ultronFullName, "", mc); // Create an instance of our basic Ultron thinker IThinker ultronThinker = tp.Create(); // //////////////////////////////////////////////////////// // // Create a board so we can test how our thinker will play. // // //////////////////////////////////////////////////////// // // A cancellation token, will be ignored CancellationToken ct = new CancellationToken(); // Create a ColorShapeLinks board with default size Board board = new Board(); // Show initial board Console.WriteLine("\n=== Initial board ===\n"); ShowBoard(board); // Make some moves manually board.DoMove(PShape.Round, 0); // White plays round piece in col 0 board.DoMove(PShape.Square, 4); // Red plays square piece in col 4 board.DoMove(PShape.Square, 5); // White plays round piece in col 5 // Show board after our three manual moves Console.WriteLine("\n=== Board after three manual moves ===\n"); ShowBoard(board); // What move would Ultron make at this moment? FutureMove ultronMove = ultronThinker.Think(board, ct); // Show move Console.WriteLine($"-> Ultron will play {ultronMove}"); // Make the move selected by Ultron board.DoMove(ultronMove.shape, ultronMove.column); // Show board after Ultron made its move Console.WriteLine("\n=== Board after Ultron made move ===\n"); ShowBoard(board); }
internal Server(INetworkServer server, MatchConfig config) : base(server, config) { NetworkServer.ReceivedInputs += OnRecievedInputs; NetworkServer.PlayerRemoved += OnRemovePlayer; InputContext = new MatchInputContext(config); InputHistory = new InputHistory <MatchInput>(new MatchInput(config)); NetworkConfig = Config.Get <NetworkConfig>(); ClientTimesteps = new Dictionary <int, uint>(); StateSendTimer = 0; }
public TestInputSource(MatchConfig config) { input = new MatchInput(config); for (int i = 0; i < input.PlayerCount; i++) { var playerInput = input[i]; playerInput.IsValid = true; input[i] = playerInput; } }
internal Server(INetworkServer server, MatchConfig config) : base(server, config) { NetworkServer.ReceivedInputs += OnRecievedInputs; InputContext = new MatchInputContext(config); LatestInput = new MatchInput[1]; LatestInput[0] = new MatchInput(config); InputHistory = new InputHistory <MatchInput>(LatestInput[0]); NetworkConfig = Config.Get <NetworkConfig>(); ClientTimesteps = new Dictionary <uint, uint>(); StateSendTimer = 0; }
public void GetResolution_continues_game_with_remaining_time() { var timeMatchRule = new TimeMatchRule(); var config = new MatchConfig { Stocks = 5, PlayerConfigs = new PlayerConfig[4] }; var state = new MatchState(config) { Time = 100 }; Assert.AreEqual(null, timeMatchRule.GetResolution(state)); }
public void GetResolution_zero_time_results_in_timeout() { var timeMatchRule = new TimeMatchRule(); var config = new MatchConfig { Stocks = 5, PlayerConfigs = new PlayerConfig[4] }; var state = new MatchState(config) { Time = 0 }; Assert.AreEqual(MatchResolution.Tie, timeMatchRule.GetResolution(state)); }
// [Server] Loads this MatchManager's config from the MatchSetupController's final config. private IEnumerator LoadMatchConfigCoroutine(MatchSetupController controller) { Debug.Log(debugTag + "Grabbing config from MatchSetupController..."); while (!controller.Ready) { yield return(null); } this.config = controller.InitialConfig; Debug.Log(debugTag + "Config loaded! Sending to Broadcaster..."); matchDataBroadcaster.MatchConfigStr = JsonUtility.ToJson(controller.InitialConfig); }
public void Simulate_each_simulate_decreases_remaining_time() { var timeMatchRule = new TimeMatchRule(); var config = new MatchConfig { Stocks = 5, PlayerConfigs = new PlayerConfig[4] }; var state = new MatchState(config) { Time = 100 }; var input = new MatchInput(config); var inputContext = new MatchInputContext(input); Assert.AreEqual(99, timeMatchRule.Simulate(state, inputContext).Time); }
public InControlInputSource(MatchConfig config) { this.config = config; controllerMapping = new PlayerControllerMapping(); input = new MatchInput(config); ValidMask = 0; for (var i = 0; i < config.PlayerCount; i++) { if (!config.PlayerConfigs[i].IsLocal) { continue; } ValidMask |= (byte)(1 << i); } Debug.Log($"Valid Mask: {ValidMask}"); }
// public void CalcBaseValue() // { // // Calculates the value of the resources built-in to the card // if (this.category == "Tile") // { // this.baseValue = 0; // int retrievedPrice = 0; // ResourceInfo.pricesMut.TryGetValue(this.resource, out retrievedPrice); // this.baseValue = (retrievedPrice * this.quantity); //Could be 0, that's okay // // Calculates the value of the resources on cards in the stack, if any // for (int i = 0; i < this.cardStack.Count; i++) // { // retrievedPrice = 0; // if (this.cardStack[i].Subtitle == "Resource") // { // ResourceInfo.pricesMut.TryGetValue(this.cardStack[i].Resource, out retrievedPrice); // this.baseValue += (retrievedPrice * this.cardStack[i].FooterValue); // } // else if (this.cardStack[i].Subtitle == "Investment" && !this.cardStack[i].PercFlag) // { // this.baseValue += this.cardStack[i].FooterValue; // } // else if (this.cardStack[i].Subtitle == "Sabotage" && !this.cardStack[i].PercFlag) // { // this.baseValue -= this.cardStack[i].FooterValue; // } // if // } // for cardStack size // } // else if (this.card.Category == "Market") // { // // Base Value will not be used for Market Cards - Reference ResourceInfo instead. // // ResourceInfo.prices.TryGetValue(this.resource, out this.baseValue); // // Debug.Log(debug + "Base value for " + this.resource + " was found to be " + this.baseValue); // } // } // CalcBaseValue() // Calculates the value of the resources on cards in the stack, if any // public void CalcValueMod() // { // if (this.category == "Tile") // { // this.valueMod = 0; // for (int i = 0; i < this.cardStack.Count; i++) // { // if (this.cardStack[i].Subtitle == "Investment" && this.cardStack[i].PercFlag) // { // this.valueMod += this.cardStack[i].FooterValue; // } // else if (this.cardStack[i].Subtitle == "Sabotage" && this.cardStack[i].PercFlag) // { // this.valueMod -= this.cardStack[i].FooterValue; // } // if-else // } // for cardStack size // } // else if (this.category == "Market") // { // // NOTE: Currently, this is the same code for Tile. This is here incase it needs to // // to change at some point. // this.valueMod = 0; // // Debug.Log("Stack Size :" + this.stackSize); // // Debug.Log("Stack Count: " + this.cardStack.Count); // for (int i = 0; i < this.cardStack.Count; i++) // { // if (this.cardStack[i].Subtitle == "Investment" && this.cardStack[i].PercFlag) // { // this.valueMod += this.cardStack[i].FooterValue; // // Debug.Log("Should be working! " + this.cardStack[i].footerValue); // } // else if (this.cardStack[i].Subtitle == "Sabotage" && this.cardStack[i].PercFlag) // { // this.valueMod -= this.cardStack[i].FooterValue; // // Debug.Log("Should be working! -" + this.cardStack[i].footerValue); // // this.valueMod -= this.cardStack[i].footerValue; // NOTE: Only do locally! // } // if-else // } // for cardStack size // } // if-else category // } // CalcValueMod() // Calculates the total value this card, and updates the // totalValue field on this GridUnit object // public void CalcTotalValue() // { // // Debug.Log(debug + "Category: " + this.category); // // Reset all value data and recalculate // if (this.category == "Tile") // { // this.totalValue = 0; // this.CalcBaseValue(); // this.CalcValueMod(); // this.totalValue = (double)this.baseValue // + ((double)this.baseValue * ((double)this.valueMod) / 100d); // // Debug.Log(debug + "[GridUnit] Tile " + this.x + ", " + this.y + " base value: " + // // this.baseValue); // // Debug.Log(debug + "[GridUnit] Tile " + this.x + ", " + this.y + " total value: " + // // this.totalValue); // if (this.totalValue < 0) // { // this.bankrupt = true; // // GameManager.BankruptTile(this); // } // bankrupt check // } // else if (this.category == "Market") // { // // Reset all value data and recalculate // this.totalValue = 0; // this.CalcBaseValue(); // this.CalcValueMod(); // // Debug.Log(debug + "Resource: " + this.resource + " ----------------------"); // // Debug.Log(debug + "Old PriceMut: " + ResourceInfo.pricesMut[this.resource]); // // // ResourceInfo.prices.TryGetValue(this.resource, out this.baseValue); // // Debug.Log(debug + "Base Value : " + ResourceInfo.prices[this.resource]); // // Debug.Log(debug + "Value Mod : " + this.valueMod); // // Debug.Log(debug + "Calculating..."); // this.totalValue = (double)ResourceInfo.prices[this.resource] // + ((double)ResourceInfo.prices[this.resource] * ((double)this.valueMod) / 100d); // // Debug.Log("Total Value: " + this.totalValue); // ResourceInfo.pricesMut[this.resource] = (int)this.totalValue; // // cardDis.UpdateFooter(this, ResourceInfo.pricesMut[this.resource]); // // tileObj.GetComponent<CardState>().footerValue = ResourceInfo.pricesMut[this.resource]; // // Debug.Log(debug + "New PriceMut: " + ResourceInfo.pricesMut[this.resource]); // // // ResourceInfo.prices.TryGetValue(this.resource, out this.baseValue); // // Debug.Log(debug + "Base Value : " + ResourceInfo.prices[this.resource]); // // Debug.Log(debug + "Value Mod : " + this.valueMod); // } // if tile // } // CalcTotalValue() // COROUTINES ################################################################################## // [Client/Server] Parses the Match Config from MatchDataBroadcaster public IEnumerator ParseMatchConfigCoroutine() { yield return(StartCoroutine(GrabMatchDataBroadCasterCoroutine())); while (this.config == null) { Debug.Log(debugTag + "Parsing Config..."); this.config = JsonUtility.FromJson <MatchConfig>(matchDataBroadcaster.MatchConfigStr); Debug.Log(debugTag + "Config parsed as: " + this.config); if (this.config == null) { yield return(null); } } }
public InControlInputSource(MatchConfig config) { input = new MatchInput(config); ValidMask = 0; playerInputs = new IInputSource <PlayerInput> [config.PlayerCount]; for (var i = 0; i < config.PlayerCount; i++) { playerInputs[i] = new InControlPlayerInputSource(config.PlayerConfigs[i]); if (!config.PlayerConfigs[i].IsLocal) { continue; } ValidMask |= (byte)(1 << i); } Debug.Log($"Valid Mask: {ValidMask}"); }
void Awake() { // Look for the MatchManager first --------------------------------------------------------- referenceObj = GameObject.Find("MatchManager(Clone)"); // If found, swipe the config info to know how many Player objects to destroy -------------- if (referenceObj != null) { MatchDataBroadcaster mdb = referenceObj.GetComponent <MatchDataBroadcaster>(); MatchConfig config = JsonUtility.FromJson <MatchConfig>(mdb.MatchConfigStr); for (int i = 1; i <= config.MaxPlayerCount; i++) { string playerStr; playerStr = "Player (" + i + ")"; referenceObj = GameObject.Find(playerStr); SafeDestroy(referenceObj); } } // Attempt to stop hosting and destroy the NetworkManager ---------------------------------- referenceObj = GameObject.Find("NetworkManager"); if (referenceObj != null) { NetworkManager networkManager = referenceObj.GetComponent <NetworkManager>(); if (networkManager != null) { networkManager.StopHost(); // networkManager.StopClient(); } SafeDestroy(referenceObj); } // Continue by destroying the MatchManager, as it's not needed anymore --------------------- referenceObj = GameObject.Find("MatchManager(Clone)"); SafeDestroy(referenceObj); }
protected override async Task InitializeMatch(MatchManager manager, MatchConfig config) { if (NetworkManager.IsServer) { NetworkManager.Server.PlayerUpdated += ServerHandleClientReady; foreach (var client in NetworkManager.Server.Clients) { Debug.Log($"Setting {client.PlayerID} not ready"); client.IsReady = false; } } if (NetworkManager.IsClient) { NetworkManager.Client.OnServerReady += ClientHandleServerReady; } await base.InitializeMatch(manager, config); // Wait for remote players to be ready var tasks = new List <Task>(); if (NetworkManager.IsClient && !NetworkManager.Client.IsServerReady) { Debug.Log("Client: Set to Ready."); NetworkManager.Client.SetReady(true); tasks.Add(ClientReady.Task); } if (NetworkManager.IsServer && !AllClientsAreReady) { Debug.Log("Waiting on clients..."); tasks.Add(ServerReady.Task); } await Task.WhenAll(tasks); if (NetworkManager.IsClient) { NetworkManager.Client.OnServerReady -= ClientHandleServerReady; } if (NetworkManager.IsServer) { NetworkManager.Server.PlayerUpdated -= ServerHandleClientReady; } }
void Start() { Debug.Log(debugTag + "Initializing..."); // [Client/Server] if (!hasAuthority) { this.config = JsonUtility.FromJson <MatchConfig>(matchDataBroadcaster.MatchConfigStr); Debug.Log(debugTag + "Grabbed config for client: " + matchDataBroadcaster.MatchConfigStr); Debug.Log(debugTag + "Creating Decks..."); masterDeck = new MasterDeck(config.DeckFlavor); masterDeckMutable = new MasterDeck(config.DeckFlavor); return; } // [Server] InitializeMatch(); }
public IMatchController CreateMatchController(MatchConfig config) { var strategy = GetNetworkStrategy(); if (IsHost) { return(strategy.CreateHost(Host, config)); } else if (IsClient) { return(strategy.CreateClient(Client, config)); } else if (IsServer) { return(strategy.CreateServer(Server, config)); } else { return(new MatchController(config)); } }