public static void OnColonyChange(Players.Player player, Colony oldColony, Colony newColony)
{
if (player.ShouldSendData && newColony != null)
{
NetworkWrapper.Send(GetPacket(newColony), player);
}
}
private void HandleNetworkCommunitiesUpdate(NetworkWrapper network)
{
void Update()
{
listViewCommunities.Items.Clear();
var items = network.Communities
.OrderByDescending(e => e.Nodes.Count)
.Select(e => new ListViewItem(e.Id.ToString())
{
SubItems = { e.Nodes.Count.ToString() }
})
.ToArray();
listViewCommunities.Items.AddRange(items);
}
if (listViewCommunities.InvokeRequired)
{
listViewCommunities.Invoke((MethodInvoker)Update);
}
else
{
Update();
}
}
protected void Start()
{
//duplicate instances will be auto disabled by UNET because we have a network identity component
Instance = this;
DontDestroyOnLoad(gameObject);
DontDestroyOnLoad(battleCam.gameObject);
NetworkWrapper.OnEnterScene(NetworkWrapper.Scene.Battle);
int wave = 0;
int stepSize = numWaves / (spawnGroups.Count - 1);
foreach (SpawnGroup spawn in spawnGroups)
{
spawn.WaveIndex = wave;
spawn.NumWaves = numWaves;
wave += stepSize;
}
spawnGroups[spawnGroups.Count - 1].WaveIndex = numWaves - 1;
availableSpawnPoints = new List <bool>();
for (int i = 0; i < battleCam.EnemySpawnPoints.Count; i++)
{
availableSpawnPoints.Add(true);
}
RemainingEnemySpawnPoints = availableSpawnPoints.Count;
PersistentPlayer.localAuthority.CmdSpawnBattlePlayer();
if (isServer)
{
StartBattle();
}
}
public void SerializationTargetTestsSimplePasses()
{
var gameObject = new GameObject();
var obj1 = gameObject.AddComponent <TestObjOne>();
var obj2 = gameObject.AddComponent <TestObjTwo>();
obj1.StringValue = "testValue";
obj1.NumericValue = 1337;
obj2.StringValue = "otherValue";
obj2.NumericValue = 1338;
obj2.ByteValue = 0xff;
var networkMessage = new NetworkWrapper(new Guid(), new[] { obj1, obj2 });
//Convert networkMessage into Json
var networkMessageJson = Serializer.Serialize(networkMessage);
//Deserialize said Json to erase the type info
var deserializedMessage = Serializer.Deserialize <NetworkWrapper>(networkMessageJson);
var results = deserializedMessage.GameObjects.Select(c => Serializer.IdentifyBestTypeMatch(JObject.FromObject(c)))
.ToList();
Assert.True(results.Any(c => c.Type == typeof(TestObjOne)));
Assert.True(results.Any(c => c.Type == typeof(TestObjTwo)));
}
private MasterDataSource()
{
var networkConfiguration = new NetworkWrapper();
var uiDispatcher = new UiDispatcher();
var peopleNetworkMessenger = new PeopleNetworkMessenger(networkConfiguration, uiDispatcher);
PeopleDataSource = new PeopleDataSource(peopleNetworkMessenger);
}
public static void TeleportPlayer(Players.Player target, Vector3 position)
{
using (ByteBuilder byteBuilder = ByteBuilder.Get()) {
byteBuilder.Write(ClientMessageType.ReceivePosition);
byteBuilder.Write(position);
NetworkWrapper.Send(byteBuilder, target);
}
}
private void HandleNetworkAdd(NetworkWrapper network)
{
listNetworks.Invoke((MethodInvoker) delegate
{
listNetworks.Items.Add(network.Name);
listNetworks.SelectedIndex = listNetworks.Items.Count - 1;
});
}
public static NetworkWrapper Wrap(this Net net)
{
if (wrapperCache == null)
{
wrapperCache = new NetworkWrapper(net);
}
return(wrapperCache);
}
public void CreateRoomButtonClicked(InputField roomName)
{
if (roomName.text.Length == 0)
{
return;
}
TitleUIManager.PlayButtonSound();
NetworkWrapper.StartServer(roomName.text);
NavigateToRoomSessionMenu(roomName.text);
}
private void Start()
{
if (Instance != null)
{
Debug.LogError("Multiple NetworkWrapper objects exist.");
Destroy(gameObject);
return;
}
Instance = this;
discovery = GetComponent <CustomNetworkDiscovery>();
manager = GetComponent <CustomNetworkManager>();
}
private void HandleNetworkStatsUpdate(NetworkWrapper network)
{
void Update()
{
listViewStats.Items.Clear();
var i1 = new ListViewItem("Vertices");
i1.SubItems.Add(network.Stats.Nodes.ToString());
var i2 = new ListViewItem("Edges");
i2.SubItems.Add(network.Stats.Edges.ToString());
var i3 = new ListViewItem("Components");
i3.SubItems.Add(network.Stats.Components.ToString());
var i4 = new ListViewItem("Degree centrality");
i4.SubItems.Add(network.Stats.DegreeCentrality.ToString(DoubleFormat));
var i5 = new ListViewItem("Closeness centrality");
i5.SubItems.Add(network.Stats.ClosenessCentrality.ToString(DoubleFormat));
var i6 = new ListViewItem("Mean distance");
i6.SubItems.Add(network.Stats.MeanDistance.ToString(DoubleFormat));
var i7 = new ListViewItem("Clustering coefficient");
i7.SubItems.Add(network.Stats.ClusteringCoefficient.ToString(DoubleFormat));
var i8 = new ListViewItem("Diameter");
i8.SubItems.Add(network.Stats.Diameter.ToString());
listViewStats.Items.AddRange(new[] { i1, i2, i3, i4, i5, i6, i7, i8 });
}
if (listViewStats.InvokeRequired)
{
listViewStats.Invoke((MethodInvoker)Update);
}
else
{
Update();
}
}
public static void SendPacket(Players.Player player)
{
if (player.IsConnected)
{
int builder = player.GetTempValues(false).GetOrDefault("pipliz.builderlimit", 0);
int digger = player.GetTempValues(false).GetOrDefault("pipliz.diggerlimit", 0);
using (ByteBuilder b = ByteBuilder.Get()) {
b.Write(General.Networking.ClientMessageType.ReceiveConstructionLimits);
b.Write(builder);
b.Write(digger);
NetworkWrapper.Send(b.ToArray(), player);
}
}
}
private void UpdatePlayerVariables()
{
using (ByteBuilder bRaw = ByteBuilder.Get())
{
bRaw.Write(ClientMessageType.ReceiveServerPerClientSettings);
using (ByteBuilder b = ByteBuilder.Get())
{
b.Write(_playerVariables.ToString());
bRaw.WriteCompressed(b);
}
NetworkWrapper.Send(bRaw.ToArray(), Player.ID);
}
Player.SendHealthPacket();
}
public static void sendSilent(Players.Player player, string message, ChatColour colour = ChatColour.white, ChatStyle style = ChatStyle.normal, Pipliz.Chatting.ChatSenderType sender = Pipliz.Chatting.ChatSenderType.Server)
{
ChatSenderType type = ChatSenderType.Server;
if (!(player.ID == NetworkID.Server))
{
string messageBuilt = buildMessage(message, colour, style);
using (ByteBuilder byteBuilder = ByteBuilder.Get())
{
byteBuilder.Write((ushort)ClientMessageType.Chat);
byteBuilder.Write((byte)type);
byteBuilder.Write(messageBuilt);
NetworkWrapper.Send(byteBuilder.ToArray(), player, NetworkMessageReliability.ReliableWithBuffering);
}
}
}
private void HandleNetworkPlotUpdate(NetworkWrapper network)
{
if (network.Plot == null)
{
return;
}
if (pictureBoxNetworkPlot.InvokeRequired)
{
pictureBoxNetworkPlot.Invoke((MethodInvoker) delegate
{
pictureBoxNetworkPlot.Image = network.Plot;
});
}
else
{
pictureBoxNetworkPlot.Image = network.Plot;
}
}
public void CreateRoomButtonClicked(InputField roomName)
{
if (roomName.text.Length == 0)
{
return;
}
if (roomName.text.All(x => char.IsNumber(x) || x == '.'))
{
NetworkWrapper.ConnectToServer(roomName.text);
NavigateToRoomSessionMenu(roomName.text);
return;
}
TitleUIManager.PlayButtonSound();
NetworkWrapper.StartServer(roomName.text);
NavigateToRoomSessionMenu(roomName.text);
}
public async Task DoesNotCall_CollectionPropertyGetter_EveryTimeElementIsAdded()
{
var networkList = new List <string> {
"Network1", "Network2"
};
string serialized = await Serializer.SerializeWrapper(new NetworkWrapper { NetworkList = networkList });
Assert.Equal(@"{""NetworkList"":[""Network1"",""Network2""]}", serialized);
NetworkWrapper obj = await Serializer.DeserializeWrapper <NetworkWrapper>(serialized);
int i = 0;
foreach (string network in obj.NetworkList)
{
Assert.Equal(networkList[i], network);
i++;
}
}
protected void Start()
{
if (Instance)
{
Destroy(battleCam.gameObject);
Destroy(gameObject);
return;
}
Instance = this;
DontDestroyOnLoad(gameObject);
DontDestroyOnLoad(battleCam.gameObject);
NetworkWrapper.OnEnterScene(NetworkWrapper.Scene.Battle);
battleSceneName = SceneManager.GetActiveScene().name;
int wave = 0;
int stepSize = numWaves / (spawnGroups.Count - 1);
foreach (SpawnGroup spawn in spawnGroups)
{
spawn.WaveIndex = wave;
spawn.NumWaves = numWaves;
wave += stepSize;
}
spawnGroups[spawnGroups.Count - 1].WaveIndex = numWaves - 1;
availableSpawnPoints = new List <bool>();
for (int i = 0; i < battleCam.EnemySpawnPoints.Count; i++)
{
availableSpawnPoints.Add(true);
}
RemainingEnemySpawnPoints = availableSpawnPoints.Count;
PersistentPlayer.localAuthority.CmdSpawnBattlePlayer();
if (isServer)
{
StartBattle();
}
}
/// <summary>
/// Button click method (set in the inspector) for buttons on the list of rooms
/// </summary>
/// <param name="buttonClicked"></param>
public void RoomSelected(GameObject buttonClicked)
{
TitleUIManager.PlayButtonSound();
Text t = buttonClicked.GetComponentInChildren <Text>();
if (t != null)
{
string ipAddress = NetworkWrapper.discovery.GetAddressOfRoom(t.text);
if (ipAddress != null)
{
NetworkWrapper.ConnectToServer(ipAddress);
NavigateToRoomSessionMenu(t.text);
}
else
{
Debug.LogErrorFormat("No room of name {0}", t.text);
}
}
else
{
Debug.LogError("Cannot get name of room selected.");
}
}
private static void Main(string [] args)
{
//get our cities
var cities = CreateCities().ToList();
//Each city is an object the chromosome is a special case as it needs
//to contain each city only once. Therefore, our chromosome will contain
//all the cities with no duplicates
//we can create an empty population as we will be creating the
//initial solutions manually.
var population = new Population(false, false);
//create the initial solutions (chromosomes)
for (var p = 0; p < populationSize; p++)
{
var chromosome = new Chromosome();
foreach (var city in cities)
{
chromosome.Genes.Add(new Gene(city));
}
chromosome.Genes.ShuffleFast();
population.Solutions.Add(chromosome);
}
//create the elite operator
var elite = new Elite(5);
//create crossover operator
var crossover = new Crossover(0.85)
{
CrossoverType = CrossoverType.DoublePointOrdered
};
//create the SwapMutate operator
var mutate = new SwapMutate(0.02);
//note that for network fitness evaluation we simply pass null instead of a fitness
//function.
var ga = new GeneticAlgorithm(population, null);
//subscribe to the generation and run complete events
ga.OnGenerationComplete += ga_OnGenerationComplete;
ga.OnRunComplete += ga_OnRunComplete;
//add the operators
ga.Operators.Add(elite);
ga.Operators.Add(crossover);
ga.Operators.Add(mutate);
/****************************************************************************************
* Up until now the GA is configured as if it were a non-distributed example except,
* the fitness function is not specified (see note above)
*
* The NetworkWrapper (below) adds the networking and the Consul class adds service
* discovery functionality.
*
***************************************************************************************/
//we can point the service discovery client at any node running a consul service, typically
//this would be the localhost. An explicit IP/Port is stated here for clarity, see the
//constructor overloads for more details.
IServiceDiscovery serviceDiscovery = new GAF.ServiceDiscovery.Consul.Client("192.168.1.90", 8500);
/****************************************************************************************
* The StaticServices class is a IServiceDiscovery implementation that can be used to access
* the specified endpoints. Use this is no specific discovery service is available.
*
***************************************************************************************
* var endpoints = new List<IPEndPoint> ();
* endpoints.Add (NetworkWrapper.CreateEndpoint ("127.0.0.1:11000"));
* endpoints.Add (NetworkWrapper.CreateEndpoint ("127.0.0.1:11001"));
*
* IServiceDiscovery serviceDiscovery = new GAF.ServiceDiscovery.ServiceEndpoints (endpoints);
*/
var networkWrapper = new NetworkWrapper(ga, serviceDiscovery, "Example.IRemoteFitness.dll", true);
_stopWatch = new Stopwatch();
_stopWatch.Start();
//locally declared terminate function
networkWrapper.GeneticAlgorithm.Run(TerminateAlgorithm);
Console.ReadLine();
}
public void SendSync(object obj)
{
var message = new NetworkWrapper(this.Guid, new[] { obj });
_connectHandlerInstance.SendTcpUpdate(message);
}
private void InitializationServer(string wsAddress, int wsPort, int wsTimeOut, string wsDataBase)
{
_networkWrapper = new NetworkWrapper(wsAddress, Convert.ToInt32(wsPort), Convert.ToInt32(wsTimeOut), wsDataBase);
_networkWrapper.Start();
}
private void button_Click(object sender, RoutedEventArgs e)
{
_net = new NetworkWrapper(2222);
_net.Connected += _net_Connected2;
}
private void HandleNetworkRemove(NetworkWrapper network)
{
listNetworks.Items.Remove(network.Name);
}
