public void ChangeTo(StatisticsInfo info)
{
Bps.SuspendUpdate();
Pps.SuspendUpdate();
Bps.Add(Tuple.Create(startTime, info.Bps));
Pps.Add(Tuple.Create(startTime, info.Pps));
startTime++;
if (Bps.Count > MaxPoints)
{
Bps.RemoveAt(0);
Pps.RemoveAt(0);
}
Bps.ResumeUpdate();
Pps.ResumeUpdate();
foreach (var key in info.TransportLayer.Keys)
{
TransportLayer.UpdateOrAdd(key, info.TransportLayer[key]);
}
foreach (var key in info.ApplicationLayer.Keys)
{
ApplicationLayer.UpdateOrAdd(key, info.ApplicationLayer[key]);
}
foreach (var key in info.NetworkLayer.Keys)
{
NetworkLayer.UpdateOrAdd(key, info.NetworkLayer[key]);
}
}
public override void Load()
{
Instance = this;
NetworkLayer = new NetworkLayer();
if (!Main.dedServ)
{
MouseEvents.ButtonPressed += (sender, args) =>
{
if (args.Button != MouseButton.Right)
{
return;
}
if (NetworkLayer.Interact())
{
Main.mouseRight = Main.mouseRightRelease = false;
if (PlayerInput.MouseKeys.Contains("Mouse2"))
{
PlayerInput.MouseKeys.Remove("Mouse2");
}
}
};
}
}
internal override void ConnectToInput(NetworkLayer inputLayer)
{
_inputLayer = inputLayer;
Weights = new Matrix3D(inputLayer.OutputDepth, inputLayer.OutputHeight, inputLayer.OutputWidth);
Weights.RandomInit();
}
public static void SaveNetworkLayerWeightsToFile(NetworkLayer layer, string filename)
{
using (StreamWriter writer = new StreamWriter(new FileStream(filename, FileMode.Create)))
{
writer.Write(layer.ToString());
}
}
public EvaluatorInputLayer(NetworkLayer modelLayer, int multiLayers) : base(modelLayer)
{
OutputActivation = new NativeArray2D <float>(modelLayer.Size, EVALUATOR_BUCKET_SLICE_SIZE);
//WeightedInput = new NativeArray2D<float>(modelLayer.Size, EVALUATOR_BUCKET_SLICE_SIZE);
Error = new NativeArray2D <float>(Size, EVALUATOR_BUCKET_SLICE_SIZE);
WeightGradients = new NativeArray <float>(ModelLayer.Weights.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
}
public static MultiLayerNetwork CreateTwoLayerPerceptronNetwork(int layer1Size, int layer2Size, int inputDim)
{
NetworkLayer layer1 = CreatePerceptronLayer(layer1Size, inputDim);
NetworkLayer layer2 = CreatePerceptronLayer(layer2Size, layer1Size);
IList <NetworkLayer> layers = new List <NetworkLayer>()
{
layer1, layer2
};
return(MultiLayerNetwork.Of(layers));
}
public static NetworkLayer CreatePerceptronLayer(int size, int perceptronDim)
{
IList <Neuron> neurons = new List <Neuron>();
for (int i = 0; i < size; i++)
{
Perceptron perceptron = new Perceptron(perceptronDim);
perceptron.InitRandomWeights();
neurons.Add(perceptron);
}
return(NetworkLayer.Of(neurons));
}
public static double CalculateErrorProbability(this NetworkLayer layer, IList <NetworkTeachingPair> teachingSet)
{
double errorsCount = 0;
foreach (NetworkTeachingPair pair in teachingSet)
{
if (!layer.FireSignal(pair.Input).EqualsElementwiseWithPrecision(pair.Output, 0.001))
{
errorsCount++;
}
}
return(errorsCount / teachingSet.Count);
}
// create a new network using two parent networks
public NeuralNet(NeuralNet dad, NeuralNet mum)
{
netLayers = new NetworkLayer[layerInfo.Length - 1];
for (int x = 0; x < netLayers.Length; x++)
{
// create the network layers
netLayers[x] = new NetworkLayer(layerInfo[x], layerInfo[x + 1]);
// generate random weights for the new neurons
mutationValue = Random.Range(0.05f, 0.2f);
netLayers[x].GenerateWeightsChild(dad.netLayers[x].neuronWeights, mum.netLayers[x].neuronWeights, mutationValue, mutationChance);
}
}
// create an initial network
public NeuralNet()
{
// set number of layers
netLayers = new NetworkLayer[layerInfo.Length - 1];
for (int x = 0; x < netLayers.Length; x++)
{
// create the network layers
netLayers[x] = new NetworkLayer(layerInfo[x], layerInfo[x + 1]);
// generate random weights for the new neurons
netLayers[x].GenerateWeights(minWeight, maxWeight);
}
}
public static void Main()
{
// write your code here
LinkLayer ll = new LinkLayer();
NetworkLayer network = new NetworkLayer(1, ll);
ApplicationLayer app = new ApplicationLayer(network);
ll.NewMessageReceived += BlinkLed;
_device = new LocalDevice(999, app, "Netduino", "Netduino");
ll.Start();
}
public void DrawNetwork(List <NetworkLayer> layers)
{
List <ScatterPoint> previousLayerPoints = new List <ScatterPoint>();
for (int l = 0; l < layers.Count; l++)
{
NetworkLayer layer = layers[l];
OxyPlot.Wpf.ScatterSeries series = new OxyPlot.Wpf.ScatterSeries();
series.MarkerType = OxyPlot.MarkerType.Circle;
series.MarkerSize = 5;
OxyPlotControl.Series.Add(series);
ObservableCollection <ScatterPoint> points = new ObservableCollection <ScatterPoint>();
for (int i = 0; i < layer.NeuronsNumber; i++)
{
OxyPlot.Wpf.LineSeries lineSeries = new OxyPlot.Wpf.LineSeries();
lineSeries.Color = Color.FromArgb(128, 78, 97, 102);
lineSeries.StrokeThickness = 1;
lineSeries.DataFieldX = "X";
lineSeries.DataFieldY = "Y";
lineSeries.MarkerSize = 0;
lineSeries.LineStyle = OxyPlot.LineStyle.Solid;
OxyPlotControl.Series.Add(lineSeries);
double x = schemaHeight - l * (schemaHeight / (double)layers.Count);
double y = schemaWidth - i * (schemaWidth / (double)layer.NeuronsNumber);
points.Add(new ScatterPoint(x, y));
ObservableCollection <NeuronDataPoint> linePoints = new ObservableCollection <NeuronDataPoint>();
foreach (var previousLayerPoint in previousLayerPoints)
{
linePoints.Add(new NeuronDataPoint(x, y, 5.5));
linePoints.Add(new NeuronDataPoint(previousLayerPoint.X, previousLayerPoint.Y, 5.5));
}
lineSeries.ItemsSource = linePoints;
lineSeries.TrackerFormatString = "Waga: {Weight}";
}
previousLayerPoints = new List <ScatterPoint>(points);
series.ItemsSource = points;
series.TrackerFormatString = "";
}
OxyPlotControl.InvalidatePlot(true);
OxyPlotControl.IsLegendVisible = false;
}
void Start()
{
net = UnityEngine.Object.FindObjectOfType <NetworkLayer>();
hostButton = gameObject.transform.FindChild("Host Button").GetComponent <Button>();
connectButton = gameObject.transform.FindChild("Connect Button").GetComponent <Button>();
startButton = gameObject.transform.FindChild("Start Button").GetComponent <Button>();
backButton = gameObject.transform.FindChild("Back Button").GetComponent <Button>();
addressInput = gameObject.transform.FindChild("Address Input").GetComponent <InputField>();
label = gameObject.transform.FindChild("Info Label").GetComponent <Text>();
connectionList = gameObject.transform.FindChild("Connection List").GetComponent <Text>();
defaultLabel = label.text;
defaultStart = startButton.gameObject.transform.GetComponentInChildren <Text>().text;
connectionList.text = "Connected hosts:";
}
StandardFeedForward _ReadFeedForward(NetworkLayer layer)
{
var descriptor = LayerDescriptor.CreateFrom(layer);
var bias = _lap.Create(layer.OutputSize, 0f);
bias.Data = layer.Bias;
var weight = _lap.Create(layer.InputSize, layer.OutputSize, 0f);
weight.Data = layer.Weight;
return(new StandardFeedForward(weight, bias, _activation[descriptor.Activation]));
}
private Dictionary <string, NetworkLayer> processLayers(Dictionary <string, NetworkLayer> sourcedictionary, Dictionary <string, NetworkLayer> destinationDictionary)
{
Dictionary <string, NetworkLayer> differences = new Dictionary <string, NetworkLayer>();
foreach (KeyValuePair <string, NetworkLayer> g in sourcedictionary)
{
NetworkLayer ignoreme = null;
if (!destinationDictionary.TryGetValue(g.Key, out ignoreme))
{
differences.Add(g.Key, g.Value);
}
}
return(differences);
}
/// <summary>
/// Creates a descriptor from a network layer
/// </summary>
/// <param name="layer">The network layer to use as a source</param>
public static LayerDescriptor CreateFrom(NetworkLayer layer)
{
return(new LayerDescriptor {
Activation = layer.Activation,
WeightInitialisation = layer.WeightInitialisation,
Regularisation = layer.Regularisation,
WeightUpdate = layer.WeightUpdate,
LayerTrainer = layer.LayerTrainer,
Lambda = layer.Lambda,
Momentum = layer.Momentum,
DecayRate = layer.DecayRate,
DecayRate2 = layer.DecayRate2,
Dropout = layer.Dropout
});
}
void Start()
{
controller = UnityEngine.Object.FindObjectOfType <GameController>();
net = UnityEngine.Object.FindObjectOfType <NetworkLayer>();
UpdateModeText();
backPack = new GameObject[backPackCapacity];
backPackText = new Text[backPackCapacity];
for (int i = 0; i < backPackCapacity; i++)
{
backPackText[i] = Instantiate(backPackTextPrefeb) as Text;
backPackText[i].transform.SetParent(canvas.transform);
backPackText[i].rectTransform.anchoredPosition = new Vector2(-10f, -10f - 20f * i);
}
ShowBackPackItem();
}
public static void Main()
{
NetworkLayer net = Singleton.Instance;
if (net == null)
{
Debug.Print("Failed to initialize network layer");
return;
}
Monitor monitor = new Monitor();
NetworkTest test = new NetworkTest(net, monitor);
test.Run(null);
}
public void Run()
{
NetworkLayer lastLayer = null;
double[] previousOutput = inputLayer.inputs;
foreach (NetworkLayer layer in this.hiddenLayers)
{
layer.forward(previousOutput);
previousOutput = layer.outputs;
lastLayer = layer;
}
outputLayer.data = this.data;
outputLayer.lastHiddenLayer = lastLayer;
outputLayer.softmax();
loss = outputLayer.loss();
Console.WriteLine("Loss: " + outputLayer.loss());
}
// set up object references and init variables
void Start()
{
pickup = FindObjectOfType <PickupObject>();
net = Object.FindObjectOfType <NetworkLayer>();
player = pickup.gameObject;
playerCamera = GameObject.Find("Main Camera").GetComponent <Camera>();
birdViewCamera = GameObject.Find("Bird View Camera").GetComponent <Camera>();
playerViewCanvas = GameObject.Find("Player View Canvas").GetComponent <Canvas>();
playerView = true;
birdViewCamera.enabled = false;
Object.FindObjectOfType <CameraController>().enabled = false;
var i = 0;
foreach (var obj in FindObjectsOfType <Pickupable>())
{
obj.id = ++i;
}
}
public void build(Configuration configuration)
{
NetworkLayer[] hiddenLayers = new NetworkLayer[configuration.hiddenLayersSize + 1];
int i = 0;
int lastDim = configuration.inputDimension;
foreach (int dim in configuration.hiddenLayersDimensions)
{
hiddenLayers[i] = new NetworkLayer(lastDim, dim);
lastDim = dim;
i += 1;
}
hiddenLayers[i] = new NetworkLayer(lastDim, configuration.outputDimension);
model = new NeuralNetworkModel(
hiddenLayers,
new OutputLayer()
);
}
public static bool AddDataset(IBasicMap pBasicMap, IDatasetName pDatasetName, Collection <object> m_DatasetCol, bool blnAddData)
{
bool functionReturnValue = false;
functionReturnValue = false;
////如果是特征数据集,则添加里边的所有要素类
IFeatureDataset pFeatDS = default(IFeatureDataset);
IEnumDataset pEnumDataSet = default(IEnumDataset);
IDataset pDataset = default(IDataset);
IFeatureClass pFeatCls = default(IFeatureClass);
IFeatureLayer pFeatLayer = default(IFeatureLayer);
IName pName = default(IName);
ILayer pLayer = default(ILayer);
ITopologyLayer pTopoLayer = default(ITopologyLayer);
//Dim pEnumLyr As IEnumLayer
ITinWorkspace pTinWS = default(ITinWorkspace);
IEnumFeatureClass pEnumFeatCls = null;
IRasterCatalogDisplayProps pRasterCatalogPro = default(IRasterCatalogDisplayProps);
//ClsErrorHandle pfrmError = new ClsErrorHandle();
//ClsLayerRender pLayerRender = null;
if (pDatasetName is IFeatureDatasetName)
{
pName = pDatasetName as IName;
pFeatDS = pName.Open() as IFeatureDataset;
pEnumDataSet = pFeatDS.Subsets;
pDataset = pEnumDataSet.Next();
m_DatasetCol.Add(pDataset);
if (pDataset == null)
{
return(false);
}
////根据数据集的类型,添加特征数据集中的所有要素类(拓扑,一般的,栅格目录,网络)
while ((pDataset != null))
{
if (pDataset.Type == esriDatasetType.esriDTFeatureClass)
{
//pLayerRender = new ClsLayerRender();
//// 陈昉 2008-12-3 修改 修改原因 添加SDE图层时从数据库读取符号化信息
//pFeatLayer = null;
//if (pDataset.Workspace.Type == esriWorkspaceType.esriRemoteDatabaseWorkspace)
//{
// pFeatLayer = pLayerRender.GetRendererLayer((IFeatureClass)pDataset);
//}
if (pFeatLayer == null)
{
pFeatLayer = new FeatureLayer();
pFeatCls = pDataset as IFeatureClass;
pFeatLayer.Name = pFeatCls.AliasName;
pFeatLayer.FeatureClass = pFeatCls;
}
if (pDataset.Type == esriDatasetType.esriDTRasterCatalog)
{
// Dim pRaster
}
if (blnAddData == true)
{
//pMap.AddLayer pFeatLayer
AddLyrToBasicMap(pBasicMap, pFeatLayer);
SortLayer(pBasicMap, pFeatLayer);
}
// pSelectedCln.Add(pFeatLayer)
}
else if (pDataset.Type == esriDatasetType.esriDTTopology)
{
pTopoLayer = new TopologyLayer() as ITopologyLayer;
pTopoLayer.Topology = pDataset as ITopology;
pLayer = pTopoLayer as ILayer;
pLayer.Name = pDataset.Name;
if (blnAddData == true)
{
//pMap.AddLayer pLayer
AddLyrToBasicMap(pBasicMap, pLayer);
SortLayer(pBasicMap, pLayer);
}
//pSelectedCln.Add(pFeatLayer)
}
pDataset = pEnumDataSet.Next();
}
functionReturnValue = true;
////添加拓扑图层
}
else if (pDatasetName is ITopologyName)
{
ITopology pTopo = null;
pName = pDatasetName as IName;
pDataset = pName.Open() as IDataset;
pTopoLayer = new TopologyLayer() as ITopologyLayer;
pTopoLayer.Topology = pDataset as ITopology;
pLayer = pTopoLayer as ILayer;
pLayer.Name = pDataset.Name;
m_DatasetCol.Add(pDataset);
if (blnAddData == true)
{
//pMap.AddLayer pLayer
AddLyrToBasicMap(pBasicMap, pLayer);
SortLayer(pBasicMap, pLayer);
}
//pSelectedCln.Add(pLayer)
if (MessageBox.Show("要把拓扑里边的所有要素类也添加到当前地图中吗?", "提示", MessageBoxButtons.YesNo, MessageBoxIcon.Question)
== DialogResult.Yes)
{
IFeatureClassContainer pFeatClsContainer = default(IFeatureClassContainer);
pFeatClsContainer = pTopo as IFeatureClassContainer;
pEnumFeatCls = pFeatClsContainer.Classes;
pFeatCls = pEnumFeatCls.Next();
pFeatLayer = new FeatureLayer();
////循环拓扑中的每个要素类,并添加到当前地图中
while ((pFeatCls != null))
{
pFeatLayer.FeatureClass = pFeatCls;
pFeatLayer.Name = pFeatCls.AliasName;
if (blnAddData == true)
{
//pMap.AddLayer pFeatLayer
AddLyrToBasicMap(pBasicMap, pFeatLayer);
SortLayer(pBasicMap, pFeatLayer);
}
//pSelectedCln.Add(pFeatLayer)
pFeatCls = pEnumFeatCls.Next();
}
}
functionReturnValue = true;
////添加网络数据
}
else if (pDatasetName is IGeometricNetworkName)
{
INetworkCollection pNetworkCollection = default(INetworkCollection);
IGeometricNetwork pGeometricNetwork = default(IGeometricNetwork);
IDataset pGeoDataset = default(IDataset);
pName = pDatasetName as IName;
pGeoDataset = pName.Open() as IDataset;
m_DatasetCol.Add(pGeoDataset);
if (pGeoDataset.Type == esriDatasetType.esriDTGeometricNetwork)
{
////这里对网络数据进行处理
IFeatureClassContainer pFeatureClassContainer = null;
pGeometricNetwork = pGeoDataset as IGeometricNetwork;
pFeatureClassContainer = pGeometricNetwork as IFeatureClassContainer;
for (int i = 0; i < pFeatureClassContainer.ClassCount; i++)
{
pFeatCls = pFeatureClassContainer.get_Class(i);
pFeatLayer = new FeatureLayer();
pFeatLayer.Name = pFeatCls.AliasName;
pFeatLayer.FeatureClass = pFeatCls;
if (blnAddData == true)
{
// pMap.AddLayer pFeatLayer
AddLyrToBasicMap(pBasicMap, pFeatLayer);
SortLayer(pBasicMap, pFeatLayer);
}
//pSelectedCln.Add(pFeatLayer)
}
}
else
{
pFeatDS = pGeoDataset as IFeatureDataset;
pNetworkCollection = pFeatDS as INetworkCollection;
////如果是用户选择一个网络技术打开的话,肯定只有一个网络在里边,其实
////可以不需要循环,而用GeometricNetwork(0)代替循环
for (int j = 0; j < pNetworkCollection.GeometricNetworkCount; j++)
{
pGeometricNetwork = pNetworkCollection.get_GeometricNetwork(j);
for (int i = 0; i <= 3; i++)
{
switch (i)
{
case 0:
pEnumFeatCls = pGeometricNetwork.get_ClassesByType(esriFeatureType.esriFTSimpleJunction);
break;
case 1:
pEnumFeatCls = pGeometricNetwork.get_ClassesByType(esriFeatureType.esriFTSimpleEdge);
break;
case 2:
pEnumFeatCls = pGeometricNetwork.get_ClassesByType(esriFeatureType.esriFTComplexJunction);
break;
case 3:
pEnumFeatCls = pGeometricNetwork.get_ClassesByType(esriFeatureType.esriFTComplexEdge);
break;
}
pFeatCls = pEnumFeatCls.Next();
while ((pFeatCls != null))
{
pFeatLayer = new FeatureLayer();
pFeatLayer.Name = pFeatCls.AliasName;
pFeatLayer.FeatureClass = pFeatCls;
pFeatCls = pEnumFeatCls.Next();
if (blnAddData == true)
{
//pMap.AddLayer pFeatLayer
AddLyrToBasicMap(pBasicMap, pFeatLayer);
SortLayer(pBasicMap, pFeatLayer);
}
// pSelectedCln.Add(pFeatLayer)
functionReturnValue = true;
}
}
}
}
////添加栅格目录，并设置为显示最新时相
}
else if (pDatasetName is IRasterCatalogName)
{
pName = pDatasetName as IName;
pDataset = pName.Open() as IDataset;
m_DatasetCol.Add(pDataset);
pFeatLayer = new GdbRasterCatalogLayer() as IFeatureLayer;
pFeatLayer.FeatureClass = pDataset as IFeatureClass;
pFeatLayer.Name = pDataset.Name;
//'//如果是SDE的栅格目录
//If pFeatLayer.DataSourceType = "SDE Raster Catalog" Then
// Dim pFeatLayerDef As IFeatureLayerDefinition
// pFeatLayerDef = pFeatLayer
// '//设置最初显示地图范围内最近时相的数据
// pFeatLayerDef.DefinitionExpression = "objectid in (select objectid from" & vbNewLine & _
// "(select a.objectid, b.receive_date,rank()" & vbNewLine & _
// "over(partition by a.name,a.resolution order by b.receive_date desc) as cid" & vbNewLine & _
// "from " & pFeatLayer.Name & " a, sj_t_tense b" & vbNewLine & _
// "where a.tense = b.tense" & vbNewLine & "and b.online_state = 1) t2" & vbNewLine & _
// "where " & pFeatLayer.Name & ".objectid=t2.objectid and t2.cid = 1)"
//End If
////设置当栅格目录中的图幅在地图上超过16个的时候，以格网来显示，而不显示栅格本身
pRasterCatalogPro = pFeatLayer as IRasterCatalogDisplayProps;
////不用数量来控制了,而以比例尺来控制
pRasterCatalogPro.DisplayRasters = 16;
pRasterCatalogPro.UseScale = true;
////设置一个比例,在此临界栅格数据将会在框架显示与实际栅格显示之间转换
pRasterCatalogPro.TransitionScale = 50000;
if (blnAddData == true)
{
//pMap.AddLayer pFeatLayer
AddLyrToBasicMap(pBasicMap, pFeatLayer);
//SortLayer(pBasicMap, pFeatLayer)
}
//pSelectedCln.Add(pFeatLayer)
functionReturnValue = true;
}
else if (pDatasetName is IRasterDatasetName)
{
IRasterLayer pRasterLayer = default(IRasterLayer);
pName = pDatasetName as IName;
pDataset = pName.Open() as IDataset;
m_DatasetCol.Add(pDataset);
pRasterLayer = new RasterLayer();
pRasterLayer.CreateFromDataset((IRasterDataset)pDataset);
pRasterLayer.Name = pDataset.Name;
AddLyrToBasicMap(pBasicMap, pRasterLayer);
functionReturnValue = true;
////添加TIN图层
}
else if (pDatasetName is ITinWorkspace)
{
pTinWS = pDatasetName as ITinWorkspace;
ITinLayer pTinLyr = default(ITinLayer);
pTinLyr = new TinLayer();
pTinLyr.Dataset = pTinWS.OpenTin(pDatasetName.Name);
pTinLyr.Name = pDatasetName.Name;
if (blnAddData == true)
{
//pMap.AddLayer pTinLyr
AddLyrToBasicMap(pBasicMap, pTinLyr);
SortLayer(pBasicMap, pTinLyr);
}
//pSelectedCln.Add(pTinLyr)
functionReturnValue = true;
}
else if (pDatasetName is INetworkDatasetName)
{
//Dim pNetWorkDS As INetworkDataset
try
{
INetworkLayer pNetLayer = default(INetworkLayer);
pName = pDatasetName as IName;
pNetLayer = new NetworkLayer() as INetworkLayer;
pNetLayer.NetworkDataset = pName.Open() as INetworkDataset;
pLayer = pNetLayer as ILayer;
pLayer.Name = pName.NameString;
if (blnAddData == true)
{
AddLyrToBasicMap(pBasicMap, pLayer);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "异常", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
////添加一般的要素类,未写完。。。。。。
}
else
{
pName = pDatasetName as IName;
pDataset = pName.Open() as IDataset;
pFeatCls = pDataset as IFeatureClass;
m_DatasetCol.Add(pDataset);
if (pFeatCls.FeatureType == esriFeatureType.esriFTAnnotation)
{
pFeatLayer = new FDOGraphicsLayer() as IFeatureLayer;
}
else if (pFeatCls.FeatureType == esriFeatureType.esriFTDimension)
{
pFeatLayer = new DimensionLayer() as IFeatureLayer;
}
else
{
pFeatLayer = new FeatureLayer();
//pLayerRender = new ClsLayerRender();
//// 陈昉 2008-12-3 修改 修改原因 添加SDE图层时从数据库读取符号化信息
//if (pDataset.Workspace.Type == esriWorkspaceType.esriRemoteDatabaseWorkspace)
//{
// pFeatLayer = pLayerRender.GetRendererLayer((IFeatureClass)pDataset);
//}
}
//印骅 20081205 添加"Not"
if ((pFeatLayer != null))
{
//pFeatLayer.Name = pDataset.Name
pFeatLayer.Name = pFeatCls.AliasName;
pFeatLayer.FeatureClass = pDataset as IFeatureClass;
}
if (blnAddData == true)
{
//pMap.AddLayer pFeatLayer
AddLyrToBasicMap(pBasicMap, pFeatLayer);
SortLayer(pBasicMap, pFeatLayer);
}
//pSelectedCln.Add(pFeatLayer)
functionReturnValue = true;
}
return(functionReturnValue);
//'//添加Coverage图层
//ElseIf vItem.SmallIcon = "Coverage" Then
//AddSelectedLayer = ADDCoverageLayer(pMap, pCurrentFilePath.Path, _
//vItem.Text, pSelectedCln, blnAddData)
}
internal abstract void ConnectToInput(NetworkLayer inputLayer);
public WWW networkCall(int url, string strJson)
{
NetworkLayer nl = GameObject.FindObjectOfType <NetworkLayer>();
return(nl.syncWithServer(url, strJson));
}
void FixedUpdate()
{
// Update the NetworkDriver. It schedules a job so we must wait for that job with Complete
m_ServerDriver.ScheduleUpdate().Complete();
// Accept all new connections
while (true)
{
var con = m_ServerDriver.Accept();
// "Nothing more to accept" is signaled by returning an invalid connection from accept
if (!con.IsCreated)
{
break;
}
m_connections.Add(con);
// Debug.Log("Connected is " + con.InternalId);
// var idData = new DataStreamWriter(4, Allocator.Temp);
// idData.Write(con.InternalId);
// DataStreamReader strm;
// m_ServerDriver.PopEventForConnection(con, out strm);
//m_ServerDriver.Send(NetworkPipeline.Null, con, idData);
}
List <Player> clientList = ServerManager.GetClients();
for (int i = 0; i < m_connections.Length; ++i)
{
DataStreamReader strm;
NetworkEvent.Type cmd;
// Pop all events for the connection
while ((cmd = m_ServerDriver.PopEventForConnection(m_connections[i], out strm)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
var readerCtx = default(DataStreamReader.Context);
byte data = strm.ReadByte(ref readerCtx);
CMD command = (CMD)data;
switch (command)
{
case CMD.CONNECT:
var id = ServerManager.RegisterPlayer(m_connections[i].InternalId);
Debug.Log("Connected " + id);
byte[] idData = NetworkLayer.newCommand(CMD.CONNECT, BitConverter.GetBytes(id));
var newID = new DataStreamWriter(idData.Length, Allocator.Temp);
newID.Write(idData);
m_ServerDriver.Send(NetworkPipeline.Null, m_connections[i], newID);
break;
case CMD.PLAYER_UPDATE:
byte[] playerByte = strm.ReadBytesAsArray(ref readerCtx, 32);
var player = ByteConverter.toPlayer(playerByte);
ServerManager.OnUpdatePlayer(player);
break;
case CMD.SHOOT:
var shootBye = NetworkLayer.newCommand(CMD.SHOOT, BitConverter.GetBytes(m_connections[i].InternalId));
var shootData = new DataStreamWriter(shootBye.Length, Allocator.Temp);
shootData.Write(shootBye);
for (int y = 0; y < m_connections.Length; ++y)
{
if (m_connections[i] != m_connections[y])
{
m_ServerDriver.Send(NetworkPipeline.Null, m_connections[y], shootData);
}
}
;
break;
case CMD.PLAYER_DIE:
Debug.LogWarning(" S DIE");
var dieByte = NetworkLayer.newCommand(CMD.PLAYER_DIE, BitConverter.GetBytes(m_connections[i].InternalId));
var dieData = new DataStreamWriter(dieByte.Length, Allocator.Temp);
dieData.Write(dieByte);
for (int y = 0; y < m_connections.Length; ++y)
{
m_ServerDriver.Send(NetworkPipeline.Null, m_connections[y], dieData);
}
;
break;
}
for (int clientIndex = 0; clientIndex < clientList.Count; clientIndex++)
{
byte[] playerData = NetworkLayer.newCommand(CMD.PLAYER_UPDATE, ByteConverter.playerToByte(clientList[clientIndex]));
var player = new DataStreamWriter(playerData.Length, Allocator.Temp);
player.Write(playerData);
m_ServerDriver.Send(NetworkPipeline.Null, m_connections[i], player);
}
;
// Send the pong message with the same id as the ping
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
// This connection no longer exist, remove it from the list
// The next iteration will operate on the new connection we swapped in so as long as it exist the
// loop can continue
Debug.Log("Desconnected " + m_connections[i].InternalId);
byte[] disconnectData = NetworkLayer.newCommand(CMD.PLAYER_DISCONNECTED, BitConverter.GetBytes(m_connections[i].InternalId));
var player = new DataStreamWriter(disconnectData.Length, Allocator.Temp);
player.Write(disconnectData);
ServerManager.OnDisconnectPlayer(m_connections[i].InternalId);
m_connections.RemoveAtSwapBack(i);
for (int y = 0; y < m_connections.Length; ++y)
{
m_ServerDriver.Send(NetworkPipeline.Null, m_connections[y], player);
}
;
if (i >= m_connections.Length)
{
break;
}
}
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the KelpNet.Common.Functions.Container.DeepNetwork class.
/// </summary>
///
/// <param name="function"> The function. </param>
/// <param name="name"> (Optional) The name. </param>
/// <param name="inputNames"> (Optional) List of names of the inputs. </param>
/// <param name="outputNames"> (Optional) List of names of the outputs. </param>
////////////////////////////////////////////////////////////////////////////////////////////////////
public DeepNetwork([CanBeNull] NetworkLayer function, [CanBeNull] string name = FUNCTION_NAME, [CanBeNull] string[] inputNames = null, [CanBeNull] string[] outputNames = null) : base(name, inputNames, outputNames)
{
Layers = new[] { function };
}
public void LoadData(IList ilist_0)
{
try
{
List <ILayer> list = new List <ILayer>();
for (int i = 0; i < ilist_0.Count; i++)
{
if (ilist_0[i] is IGxLayer)
{
list.Add((ilist_0[i] as IGxLayer).Layer);
}
else
{
IGxDataset gxDataset = ilist_0[i] as IGxDataset;
if (gxDataset != null)
{
IDataset dataset = gxDataset.Dataset;
if (dataset != null)
{
if (dataset.Type == esriDatasetType.esriDTFeatureClass)
{
IFeatureClass featureClass = (IFeatureClass)dataset;
IFeatureLayer featureLayer;
if ((gxDataset as IGxObject).Category.IndexOf("CAD") != -1)
{
if (featureClass.FeatureType == esriFeatureType.esriFTCoverageAnnotation)
{
featureLayer = new CadAnnotationLayer() as IFeatureLayer;
}
else
{
featureLayer = new CadFeatureLayer() as IFeatureLayer;
}
featureLayer.FeatureClass = featureClass;
featureLayer.Name = featureClass.AliasName;
}
else if (featureClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
featureLayer = new FDOGraphicsLayer() as IFeatureLayer;
featureLayer.FeatureClass = featureClass;
featureLayer.Name = featureClass.AliasName;
}
else if (featureClass.FeatureType == esriFeatureType.esriFTDimension)
{
featureLayer = new DimensionLayer() as IFeatureLayer;
featureLayer.FeatureClass = featureClass;
featureLayer.Name = featureClass.AliasName;
}
else
{
featureLayer = new FeatureLayer();
featureLayer.FeatureClass = featureClass;
featureLayer.Name = featureClass.AliasName;
}
list.Add(featureLayer);
}
else if (dataset.Type == esriDatasetType.esriDTCadDrawing)
{
if ((gxDataset as IGxObject).Category == "CAD绘图")
{
ICadLayer item = new CadLayer() as ICadLayer;
item.CadDrawingDataset = gxDataset.Dataset as ICadDrawingDataset;
item.Name = gxDataset.Dataset.Name;
list.Add(item);
}
else
{
IEnumGxObject children = (gxDataset as IGxObjectContainer).Children;
children.Reset();
for (IGxDataset gxDataset2 = children.Next() as IGxDataset; gxDataset2 != null; gxDataset2 = (children.Next() as IGxDataset))
{
IFeatureClass featureClass = gxDataset2.Dataset as IFeatureClass;
if (featureClass != null)
{
IFeatureLayer featureLayer;
if (featureClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
featureLayer = new FDOGraphicsLayer() as IFeatureLayer;
featureLayer.FeatureClass = featureClass;
featureLayer.Name = featureClass.AliasName;
}
else
{
featureLayer = new CadFeatureLayer() as IFeatureLayer;
featureLayer.FeatureClass = featureClass;
featureLayer.Name = featureClass.AliasName;
}
list.Add(featureLayer);
}
}
}
}
else if (dataset.Type == esriDatasetType.esriDTFeatureDataset)
{
IEnumDataset subsets = dataset.Subsets;
subsets.Reset();
for (IDataset dataset2 = subsets.Next(); dataset2 != null; dataset2 = subsets.Next())
{
if (dataset2.Type == esriDatasetType.esriDTFeatureClass)
{
IFeatureClass featureClass = dataset2 as IFeatureClass;
if (featureClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
IFeatureLayer item = new FDOGraphicsLayer() as IFeatureLayer;
item.FeatureClass = featureClass;
item.Name = featureClass.AliasName;
list.Add(item);
}
else
{
list.Add(new FeatureLayer
{
FeatureClass = featureClass,
Name = featureClass.AliasName
});
}
}
else if (dataset2.Type == esriDatasetType.esriDTTopology)
{
ITopologyLayer topologyLayer = new TopologyLayer() as ITopologyLayer;
topologyLayer.Topology = (dataset2 as ITopology);
(topologyLayer as ILayer).Name = dataset2.Name;
list.Add(topologyLayer as ILayer);
}
}
}
else if (dataset.Type == esriDatasetType.esriDTTopology)
{
if (System.Windows.Forms.MessageBox.Show("是否将参加拓扑-" + dataset.Name + "-的所有要素添加到地图中", "添加拓扑层", System.Windows.Forms.MessageBoxButtons.YesNo, System.Windows.Forms.MessageBoxIcon.Asterisk) == System.Windows.Forms.DialogResult.Yes)
{
IEnumFeatureClass classes = (dataset as IFeatureClassContainer).Classes;
classes.Reset();
for (IFeatureClass featureClass2 = classes.Next(); featureClass2 != null; featureClass2 = classes.Next())
{
list.Add(new FeatureLayer
{
FeatureClass = featureClass2,
Name = featureClass2.AliasName
});
}
}
ITopologyLayer topologyLayer = new TopologyLayer() as ITopologyLayer;
topologyLayer.Topology = (dataset as ITopology);
(topologyLayer as ILayer).Name = dataset.Name;
list.Add(topologyLayer as ILayer);
}
else if (dataset.Type == esriDatasetType.esriDTTin)
{
list.Add(new TinLayer
{
Dataset = (ITin)dataset,
Name = dataset.Name
});
}
else if (dataset.Type == esriDatasetType.esriDTRasterDataset || dataset.Type == esriDatasetType.esriDTRasterBand)
{
bool flag = true;
if (!((IRasterPyramid)dataset).Present)
{
if (ApplicationRef.PyramidPromptType == PyramidPromptType.AlwaysBuildNoPrompt)
{
((IRasterPyramid)dataset).Create();
}
else if (ApplicationRef.PyramidPromptType == PyramidPromptType.AlwaysPrompt)
{
System.Windows.Forms.DialogResult dialogResult = BuildPyramidSet.Show();
if (dialogResult == System.Windows.Forms.DialogResult.Yes)
{
((IRasterPyramid)dataset).Create();
}
else if (dialogResult == System.Windows.Forms.DialogResult.Cancel)
{
flag = false;
}
}
}
if (flag)
{
IRasterLayer rasterLayer = new RasterLayer
{
Cached = true
};
rasterLayer.CreateFromDataset((IRasterDataset)dataset);
rasterLayer.Name = dataset.Name;
list.Add(rasterLayer);
}
}
else
{
if (dataset.Type == esriDatasetType.esriDTTable)
{
try
{
IRasterCatalogTable rasterCatalogTable = new RasterCatalogTable();
rasterCatalogTable.Table = (ITable)dataset;
rasterCatalogTable.Update();
IRasterCatalogLayer rasterCatalogLayer = new RasterCatalogLayer() as IRasterCatalogLayer;
rasterCatalogLayer.Create(rasterCatalogTable);
rasterCatalogLayer.Name = dataset.BrowseName;
list.Add(rasterCatalogLayer);
goto IL_8B0;
}
catch (Exception ex)
{
try
{
IStandaloneTableCollection standaloneTableCollection = this.method_0() as IStandaloneTableCollection;
IPropertySet connectionProperties = dataset.Workspace.ConnectionProperties;
bool flag2 = false;
for (int j = 0; j < standaloneTableCollection.StandaloneTableCount; j++)
{
ITable table = standaloneTableCollection.get_StandaloneTable(j).Table;
if (
connectionProperties.IsEqual(
(table as IDataset).Workspace.ConnectionProperties) &&
(table as IDataset).Name == dataset.Name)
{
flag2 = true;
}
else
{
standaloneTableCollection.AddStandaloneTable(new StandaloneTable
{
Table = dataset as ITable
});
}
}
}
catch (Exception exception_)
{
CErrorLog.writeErrorLog(this, exception_, "");
}
goto IL_8B0;
}
}
if (dataset.Type == esriDatasetType.esriDTGeometricNetwork)
{
IGeometricNetwork geometricNetwork = dataset as IGeometricNetwork;
if (geometricNetwork != null)
{
IEnumFeatureClass enumFeatureClass = geometricNetwork.get_ClassesByType(esriFeatureType.esriFTSimpleJunction);
enumFeatureClass.Reset();
for (IFeatureClass featureClass3 = enumFeatureClass.Next(); featureClass3 != null; featureClass3 = enumFeatureClass.Next())
{
list.Add(new FeatureLayer
{
FeatureClass = featureClass3,
Name = (featureClass3 as IDataset).Name
});
}
enumFeatureClass = geometricNetwork.get_ClassesByType(esriFeatureType.esriFTComplexJunction);
enumFeatureClass.Reset();
for (IFeatureClass featureClass3 = enumFeatureClass.Next(); featureClass3 != null; featureClass3 = enumFeatureClass.Next())
{
list.Add(new FeatureLayer
{
FeatureClass = featureClass3,
Name = (featureClass3 as IDataset).Name
});
}
enumFeatureClass = geometricNetwork.get_ClassesByType(esriFeatureType.esriFTSimpleEdge);
enumFeatureClass.Reset();
for (IFeatureClass featureClass3 = enumFeatureClass.Next(); featureClass3 != null; featureClass3 = enumFeatureClass.Next())
{
list.Add(new FeatureLayer
{
FeatureClass = featureClass3,
Name = (featureClass3 as IDataset).Name
});
}
enumFeatureClass = geometricNetwork.get_ClassesByType(esriFeatureType.esriFTComplexEdge);
enumFeatureClass.Reset();
for (IFeatureClass featureClass3 = enumFeatureClass.Next(); featureClass3 != null; featureClass3 = enumFeatureClass.Next())
{
list.Add(new FeatureLayer
{
FeatureClass = featureClass3,
Name = (featureClass3 as IDataset).Name
});
}
}
}
else if (dataset.Type == esriDatasetType.esriDTNetworkDataset)
{
INetworkDataset networkDataset = dataset as INetworkDataset;
INetworkLayer item = new NetworkLayer() as INetworkLayer;
item.NetworkDataset = networkDataset;
list.Add(item as ILayer);
if (System.Windows.Forms.MessageBox.Show("是否将参加网络要素集-" + dataset.Name + "-的所有要素添加到地图中", "添加拓扑层", System.Windows.Forms.MessageBoxButtons.YesNo, System.Windows.Forms.MessageBoxIcon.Asterisk) == System.Windows.Forms.DialogResult.Yes)
{
IEnumFeatureClass classes = (dataset as IFeatureClassContainer).Classes;
classes.Reset();
for (IFeatureClass featureClass2 = classes.Next(); featureClass2 != null; featureClass2 = classes.Next())
{
list.Add(new FeatureLayer
{
FeatureClass = featureClass2,
Name = featureClass2.AliasName
});
}
}
}
}
}
}
}
IL_8B0 :;
}
int num = list.Count;
ILayer layer = null;
for (int i = num - 1; i >= 0; i--)
{
layer = list[i];
if (layer is IRasterCatalogLayer)
{
this.method_0().AddLayer(layer);
(this.method_0() as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGeography, layer, null);
list.RemoveAt(i);
num--;
}
}
for (int i = num - 1; i >= 0; i--)
{
layer = list[i];
if (layer is IRasterLayer)
{
this.method_0().AddLayer(layer);
(this.method_0() as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGeography, layer, null);
list.RemoveAt(i);
num--;
}
}
for (int i = num - 1; i >= 0; i--)
{
layer = list[i];
if (layer is ITinLayer)
{
this.method_0().AddLayer(layer);
(this.method_0() as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGeography, layer, null);
list.RemoveAt(i);
num--;
}
}
for (int i = num - 1; i >= 0; i--)
{
layer = list[i];
if (layer is ICadLayer)
{
this.method_0().AddLayer(layer);
(this.method_0() as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGeography, layer, null);
list.RemoveAt(i);
num--;
}
}
for (int i = num - 1; i >= 0; i--)
{
layer = list[i];
if (layer is IFeatureLayer)
{
IFeatureLayer featureLayer = layer as IFeatureLayer;
IFeatureClass featureClass = featureLayer.FeatureClass;
if (featureClass.ShapeType == esriGeometryType.esriGeometryPolygon || featureClass.ShapeType == esriGeometryType.esriGeometryEnvelope)
{
this.method_0().AddLayer(layer);
(this.method_0() as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGeography, layer, null);
list.RemoveAt(i);
num--;
}
}
}
for (int i = num - 1; i >= 0; i--)
{
layer = list[i];
if (layer is IFeatureLayer)
{
IFeatureLayer featureLayer = layer as IFeatureLayer;
IFeatureClass featureClass = featureLayer.FeatureClass;
if (featureClass.ShapeType == esriGeometryType.esriGeometryLine || featureClass.ShapeType == esriGeometryType.esriGeometryBezier3Curve || featureClass.ShapeType == esriGeometryType.esriGeometryCircularArc || featureClass.ShapeType == esriGeometryType.esriGeometryEllipticArc || featureClass.ShapeType == esriGeometryType.esriGeometryPath || featureClass.ShapeType == esriGeometryType.esriGeometryPolyline)
{
try
{
this.method_0().AddLayer(layer);
goto IL_B56;
}
catch
{
goto IL_B56;
}
goto IL_B4D;
IL_B56:
(this.method_0() as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGeography, layer, null);
list.RemoveAt(i);
num--;
}
}
IL_B4D :;
}
for (int i = num - 1; i >= 0; i--)
{
layer = list[i];
if (layer is IFeatureLayer)
{
IFeatureLayer featureLayer = layer as IFeatureLayer;
IFeatureClass featureClass = featureLayer.FeatureClass;
if (featureClass.ShapeType == esriGeometryType.esriGeometryMultipoint || featureClass.ShapeType == esriGeometryType.esriGeometryPoint)
{
this.method_0().AddLayer(layer);
(this.method_0() as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGeography, layer, null);
list.RemoveAt(i);
num--;
}
}
}
for (int i = num - 1; i >= 0; i--)
{
layer = list[i];
this.method_0().AddLayer(layer);
(this.method_0() as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGeography, layer, null);
list.RemoveAt(i);
num--;
}
}
catch (Exception ex)
{
ex.ToString();
}
}
private void InitializeOneLayerNetwork()
{
oneLayerNetwork = NeuralNetworksUtils.CreatePerceptronLayer(
Commons.ONE_LAYER_NETWORK_DIM, Commons.NEURONS_DIM);
}
public void Learn(NetworkParameters networkParameters, LearningParameters learningParameters)
{
using (Py.GIL())
{
layersModule = Py.Import("Python.layers");
mlpModule = Py.Import("Python.mlp");
network = mlpModule.MultilayerPerceptron(
networkParameters.NumberOfEpochs,
networkParameters.Seed,
networkParameters.LearningRate,
networkParameters.Momentum,
networkParameters.Problem,
networkParameters.ErrType,
networkParameters.BiasesEnabled
);
NetworkLayer previousLayer = null;
if (networkParameters.Problem == ProblemType.REGRESSION)
{
previousLayer = new NetworkLayer()
{
NeuronsNumber = 1
}
}
;
else if (networkParameters.Problem == ProblemType.CLASSIFICATION)
{
previousLayer = new NetworkLayer()
{
NeuronsNumber = 2
}
}
;
NetworkLayer[] layers = networkParameters.Layers.OrderBy(x => x.LayerNumber).ToArray();
if (networkParameters.Problem == ProblemType.REGRESSION)
{
layers[layers.Length - 1].NeuronsNumber = 1;
}
else if (networkParameters.Problem == ProblemType.CLASSIFICATION)
{
layers[layers.Length - 1].NeuronsNumber = networkParameters.ClassesNumber;
}
for (int i = 0; i < layers.Length; i++)
{
NetworkLayer layer = layers[i];
dynamic curr_layer = null;
switch (layer.ActFun)
{
case "Sigmoid":
curr_layer = layersModule.SigmoidLayer(layer.NeuronsNumber, previousLayer.NeuronsNumber);
break;
case "Relu":
curr_layer = layersModule.ReluLayer(layer.NeuronsNumber, previousLayer.NeuronsNumber);
break;
case "Linear":
curr_layer = layersModule.LinearLayer(layer.NeuronsNumber, previousLayer.NeuronsNumber);
break;
case "Tanh":
curr_layer = layersModule.TanhLayer(layer.NeuronsNumber, previousLayer.NeuronsNumber);
break;
default:
System.Windows.MessageBox.Show(string.Format("Nieznana funkcja aktywacji {0}", layer.ActFun.ToString()), "Błąd", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Error);
return;
}
previousLayer = layer;
network.add_layer(curr_layer);
}
if (networkParameters.Problem == ProblemType.CLASSIFICATION) //X - punkty, y - etykiety
{
network.fit(learningParameters.Points.Select(x => new double[] { x.X, x.Y }).ToArray(), learningParameters.Points.Select(x => x.Class).ToArray());
}
else if (networkParameters.Problem == ProblemType.REGRESSION) //X - wartości x, y - wartości y
{
network.fit(learningParameters.Points.Select(x => x.X).ToArray(), learningParameters.Points.Select(x => x.Y).ToArray());
}
System.Windows.MessageBox.Show("ok");
}
}
void FixedUpdate()
{
// Update the ping client UI with the ping statistics computed by teh job scheduled previous frame since that
// is now guaranteed to have completed
//PingClientUIBehaviour.UpdateStats(m_numPingsSent, m_lastPingTime);
// Update the NetworkDriver. It schedules a job so we must wait for that job with Complete
m_ClientDriver.ScheduleUpdate().Complete();
// If the client ui indicates we should be sending pings but we do not have an active connection we create one
if (ServerEndPoint.IsValid && !m_clientToServerConnection.IsCreated)
{
m_clientToServerConnection = m_ClientDriver.Connect(ServerEndPoint);
}
// If the client ui indicates we should not be sending pings but we do have a connection we close that connection
if (!ServerEndPoint.IsValid && m_clientToServerConnection.IsCreated)
{
ClientManager.UnregisterPlayer();
m_clientToServerConnection.Disconnect(m_ClientDriver);
m_clientToServerConnection = default(NetworkConnection);
}
if (ClientManager.instance.started && m_clientToServerConnection.IsCreated)
{
Player player = ClientManager.instance.myPlayer;
byte[] playerByte = NetworkLayer.newCommand(CMD.PLAYER_UPDATE, ByteConverter.playerToByte(player));
var playerData = new DataStreamWriter(playerByte.Length, Allocator.Temp);
playerData.Write(playerByte);
m_clientToServerConnection.Send(m_ClientDriver, playerData);
}
DataStreamReader strm;
NetworkEvent.Type cmd;
// Process all events on the connection. If the connection is invalid it will return Empty immediately
while ((cmd = m_clientToServerConnection.PopEvent(m_ClientDriver, out strm)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Connect)
{
var commandConnect = new DataStreamWriter(1, Allocator.Temp);
commandConnect.Write((byte)CMD.CONNECT);
m_clientToServerConnection.Send(m_ClientDriver, commandConnect);
}
else if (cmd == NetworkEvent.Type.Data)
{
var readerCtx = default(DataStreamReader.Context);
byte data = strm.ReadByte(ref readerCtx);
CMD command = (CMD)data;
switch (command)
{
case CMD.CONNECT:
ClientManager.instance.RegisterPlayer(strm.ReadInt(ref readerCtx));
break;
case CMD.PLAYER_UPDATE:
byte[] playerByte = strm.ReadBytesAsArray(ref readerCtx, 32);
var player = ByteConverter.toPlayer(playerByte);
ClientManager.OnUpdatePlayer(player);
break;
case CMD.PLAYER_DISCONNECTED:
var playerID = strm.ReadInt(ref readerCtx);
ClientManager.OnDisconnectPlayer(playerID);
Debug.Log("Client R Disconneted player: " + playerID);
break;
case CMD.SHOOT:
var connID = strm.ReadInt(ref readerCtx);
ClientManager.MakeShoot(connID);
break;
case CMD.PLAYER_DIE:
Debug.LogWarning(" C DIE");
var scoreID = strm.ReadInt(ref readerCtx);
ClientManager.ScoreIncrease(scoreID);
break;
default:
Debug.Log("Client CMD " + Enum.GetName(typeof(CMD), command));
break;
}
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
// If the server disconnected us we clear out connection
ClientManager.UnregisterPlayer();
m_clientToServerConnection = default(NetworkConnection);
}
}
}
