private void OnStopProcess(object sender, RoutedEventArgs e)
{
if (0 == ProcessCheckObj.Count)
{
NotifyMessageEx.ShowNotify(Tool.MainWindow.This, "请选择需要操作的进程", "错误");
return;
}
string id_list = "";
foreach (var id in ProcessCheckObj)
{
id_list += id;
id_list += "|";
}
string netid_list = "";
foreach (var id in RobotList)
{
netid_list += id;
netid_list += "|";
}
if (NetInterface.NetPostCodeAgvProcess(netid_list, id_list, Tool.RobotsHome.CmdAgvShell.cmd_stop_process) < 0)
{
NotifyMessageEx.ShowNotify(Tool.MainWindow.This, "停止失败", "错误");
}
TipsMessageEx.ShowTips(Tool.MainWindow.This, "停止请求发送成功", 18, 3, Colors.Green);
RobotList.Clear();
dcRobotInfo.Collection.ToList().ForEach(p => p.IsSelectedProcess = false);
AllObj.IsChecked = false;
}
private void OnUpdateShellBatch(object sender, RoutedEventArgs e)
{
string list = null;
foreach (string ep in SelectRobotInfoList)
{
if (!Tool.RobotsHome.RobotInfoCollect.GetInstance().IsConnectedHost(ep))
{
continue;
}
list += Tool.RobotsHome.RobotInfoCollect.GetInstance().FindNetId(ep) + "|";
}
if (null == list)
{
this.ShowNotify("请选择需要一键升级的车辆", "提示");
return;
}
Microsoft.Win32.OpenFileDialog ofd = new Microsoft.Win32.OpenFileDialog();
ofd.DefaultExt = ".tar";
ofd.Filter = "tar file|*.tar";
ofd.ShowDialog();
if (ofd.FileName == string.Empty)
{
return;
}
NetInterface.NetUpdateAgvShell(list, ofd.FileName);
WinShellProcessPercService.Show(this);
}
public void AddSessionHandler(SocketAsyncEventArgs e,NetInterface netif,MessageHandler handler)
{
long sessionID = Convert.ToInt64(e.UserToken);
SessionHandler sh = new SessionHandler(sessionID,e, netif, handler);
m_dicSessionHandler.Add(sessionID,sh);
PushSessionBuffer(e);
}
public void GenerateGenerationFromModel(string file)
{
Net net = new Net(
MindConstants.NUMBER_OF_INPUT_NODES,
MindConstants.NUMBER_OF_OUTPUT_NODES,
MindConstants.NUMBER_OF_HIDDEN_NODES,
MindConstants.NUMBER_OF_HIDDEN_LAYERS
);
net.LoadFromCSV(file);
best_sample = Instantiate(model);
best_sample.GetComponentInChildren <NetInterface>().Mind = net;
NetInterface best = best_sample.GetComponentInChildren <NetInterface>();
samples[0] = best_sample;
net = null;
for (int i = 1; i < Mathf.FloorToInt(NUMBER_OF_GENERATION_SAMPLES * MUTATION_PERCENTAGE); i++)
{
net = best.Mind.Clone();
net.Mutate();
InstantiateWithNet(i, net);
}
for (int i = Mathf.FloorToInt(NUMBER_OF_GENERATION_SAMPLES * MUTATION_PERCENTAGE); i < NUMBER_OF_GENERATION_SAMPLES; i++)
{
net = new Net(
MindConstants.NUMBER_OF_INPUT_NODES,
MindConstants.NUMBER_OF_OUTPUT_NODES,
MindConstants.NUMBER_OF_HIDDEN_NODES,
MindConstants.NUMBER_OF_HIDDEN_LAYERS
);
net.InitializeRandom();
InstantiateWithNet(i, net);
}
}
/////////////////////重新获取软件版本信息//////////////////////////
private int RefreshInfomtion(string net_id)
{
if ("" == FirmPath || "" == FirmEndPoint)
{
NotifyMessageEx.ShowNotify(Tool.MainWindow.This, "请先选择目标文件", "错误");
return(-1);
}
string id = TB_NodeId.Text.ToString();
string can_bus = ComboxNodeMode.Text;
int node_id;
int can_bus_type;
if (id == string.Empty)
{
node_id = 0;
}
else
{
node_id = Convert.ToInt32(id);
}
if (can_bus == string.Empty)
{
can_bus_type = 0;
}
else
{
can_bus_type = Convert.ToInt32(can_bus);
}
return(NetInterface.NetGetBinDetailInfo(net_id, FirmwareType, FirmEndPoint, node_id, can_bus_type));
}
//定时器刷新状态
private void DispatcherTimerTick(object sender, EventArgs e)
{
List <TaskFileDetailInfo> list = new List <TaskFileDetailInfo>();
NetInterface.NetGetPushFilesDetailInfo(Taskid, ref list);
Dictionary <string, TaskFileDetailInfo> tmpMap = list.ToDictionary(key => key.FileName, value => value);
ObservableCollection <TaskFileDetailInfo> infocollection = new ObservableCollection <TaskFileDetailInfo>(list);
dcContent.Collection = infocollection;
FileDetailList.DataContext = dcContent;
if (true == AllSelect)
{
dcContent.Collection.ToList().ForEach(p => p.IsFileSelected = true);
FilesCheckBox.IsChecked = true;
FileDetailList.ItemsSource = dcContent.Collection.ToList();
return;
}
if (SelectFileList.Count > 0)
{
foreach (string filename in SelectFileList)
{
if (tmpMap.ContainsKey(filename))
{
tmpMap[filename].IsFileSelected = true;
}
}
infocollection = new ObservableCollection <TaskFileDetailInfo>(tmpMap.Values.ToList());
dcContent.Collection = infocollection;
FileDetailList.DataContext = dcContent;
}
FileDetailList.ItemsSource = dcContent.Collection.ToList();
}
private void ProcessCommands()
{
if (currentAnimation != null && !currentAnimation.IsFinished) // command is in progress
{
return;
}
if (currentAnimation != null && currentAnimation.IsFinished) // command finishes
{
currentAnimation = null;
if (NetInterface.Get().localPlayer != null)
{
NetInterface.Get().localPlayer.RemoveLock(playingAnimationsLock);
}
}
if (animationQueue.Count == 0) // command is finished but there is no new command
{
return;
}
currentAnimation = animationQueue.Dequeue(); // start new command
if (NetInterface.Get().localPlayer != null)
{
NetInterface.Get().localPlayer.AddLock(playingAnimationsLock);
}
currentAnimation.Execute();
}
private void OnCloseWid(object sender, EventArgs e)
{
if (ResponseClose)
{
NetInterface.CancelPullOpreate();
}
}
protected override void OnCardAdded(Card c)
{
if (c is CreatureCard cAsCreatureCard)
{
cAsCreatureCard.Creature.RemoveFromCurrentTile();
}
else if (c is StructureCard cAsStructureCard)
{
cAsStructureCard.Structure.RemoveFromCurrentTile();
}
// remove the card from the scene
c.removeGraphicsAndCollidersFromScene();
// when cards are sent to grave they forget stat madifications
c.resetToBaseStatsWithoutSyncing();
// if network game mode need to sync creature stats here because the creature is set to not active so it won't sync itself
if (GameManager.gameMode == GameManager.GameMode.online)
{
NetInterface.Get().SyncCardStats(c);
if (c is CreatureCard)
{
NetInterface.Get().SyncCreatureStats((c as CreatureCard).Creature);
}
else if (c is StructureCard)
{
NetInterface.Get().SyncStructureStats((c as StructureCard).Structure);
}
}
}
protected override void OnCardAdded(Card c)
{
c.transform.localScale = Vector3.one * .5f;
if (c is CreatureCard)
{
(c as CreatureCard).SwapToCard();
}
else if (c is StructureCard)
{
(c as StructureCard).SwapToCard();
}
if (GameManager.gameMode != GameManager.GameMode.online)
{
}
else if (GameManager.gameMode == GameManager.GameMode.online)
{
if (c.Owner != NetInterface.Get().localPlayer)
{
c.removeGraphicsAndCollidersFromScene();
}
else
{
//Debug.Log("Adding to scene");
c.returnGraphicsAndCollidersToScene();
}
}
}
private void OnlineTurnEnd()
{
// disable button
endTurnButton.gameObject.SetActive(false);
// lock local player
NetInterface.Get().localPlayer.AddLock(activePlayerLock);
// reset player for new turn
NetInterface.Get().localPlayer.StartOfTurn();
// trigger effects
E_TurnEnd.Invoke();
SwitchActivePlayer();
foreach (Creature c in board.AllCreatures)
{
c.ResetForNewTurn();
}
foreach (Structure s in board.AllStructures)
{
s.ResetForNewTurn();
}
ActionBox.instance.gameObject.SetActive(false);
// send opponent message
NetInterface.Get().SyncEndTurn();
return;
}
public SessionHandler(long sessionID, object sessionObject, NetInterface netIF,MessageHandler del)
{
m_sessionID = sessionID;
m_sessionObject = sessionObject;
m_interface = netIF;
m_handler = del;
}
public void Surrender()
{
NetInterface.Get().SendSurrenderMessage();
// probably want to start a coroutine here that handles end of match
NetInterface.Reset();
SceneManager.LoadScene(ScenesEnum.MMDeckSelect);
}
public async void interfaceUp(NetInterface iface)
{
Debug.WriteLine("interfaceUp");
if (_broadcastInterfaceDescriptions.ContainsKey(iface))
{
string value = _broadcastInterfaceDescriptions[iface];
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Interfaces.Add("Broadcast: " + value);
});
}
if (_inboundInterfaceDescriptions.ContainsKey(iface))
{
string value = _inboundInterfaceDescriptions[iface];
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Interfaces.Add("Inbound: " + value);
});
}
if (_streamingInterfaceDescriptions.ContainsKey(iface))
{
string value = _streamingInterfaceDescriptions[iface];
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Interfaces.Add("Streaming: " + value);
});
}
}
/// <summary>
/// Sends a packet through the router's first NetInterface
/// </summary>
/// <param name="packet">Packet</param>
public void SendPacket(Packet packet)
{
NetInterface firstInterface = interfaceList[0];
// Finally send the packet to the interface
firstInterface.SendPacket(packet);
}
public FileTransFormPanel()
{
InitializeComponent();
This = this;
NetInterface.RegistPushCallback(PushFilesCallBack);
}
//文件重传
private void OnRepeatTransfrom(object sender, RoutedEventArgs e)
{
if (SelectFileList.Count <= 0)
{
NotifyMessageEx.ShowNotify(Tool.MainWindow.This, "请选择需要重传的文件！", "提示");
return;
}
string dirList = null;
foreach (string dir in SelectFileList)
{
if (dir == null)
{
continue;
}
dirList += dir + "|";
}
int retval = NetInterface.NetRepeatFilesToRemote(Taskid, dirList, dirList.Length);
if (retval < 0)
{
NotifyMessageEx.ShowNotify(Tool.MainWindow.This, "重传失败", "错误");
return;
}
TipsMessageEx.ShowTips(Tool.MainWindow.This, "任务继续，请稍后。。。", 18, 5, Colors.Green);
dcContent.Collection.ToList().ForEach(p => p.IsFileSelected = false);
SelectFileList.Clear();
FilesCheckBox.IsChecked = false;
}
//遍历标准文件夹
private void GetDirList(string fPath)
{
if (!Directory.Exists(fPath))
{
return;
}
string[] directories = Directory.GetDirectories(fPath);
foreach (string filePath in directories)
{
DirectoryInfo dirinfo = new DirectoryInfo(filePath);
FileDetailInfo Info = new FileDetailInfo();
Info.FileName = dirinfo.Name;
Info.IsEnable = true;
if (Directory.Exists(filePath))
{
Info.IsDir = true;
}
string splitstr = "standard";
int pos = filePath.IndexOf(splitstr);
Info.LocalDir = filePath.Substring(pos + splitstr.Length, filePath.Length - pos - splitstr.Length);
UInt32 CRC32 = 0;
NetInterface.NetCRC32(filePath, ref CRC32);
Info.LocalCRC = Convert.ToString(CRC32);;
Info.MotifyLocalTime = dirinfo.LastWriteTime.ToString();
LocalList.Add(Info);
}
GetFileList(fPath);
}
// stuff done after animation
private void AttackPart2(Damageable defender, int attackRoll)
{
// only trigger effects if the local player is the owner
if (NetInterface.Get().localPlayer == Controller)
{
TriggerOnAttackEvents(this, new OnAttackArgs()
{
target = defender
});
}
if (NetInterface.Get().localPlayer == defender.Controller)
{
defender.TriggerOnDefendEvents(this, new OnDefendArgs()
{
attacker = this
});
}
// perform damage calc
defender.TakeDamage(attackRoll, SourceCard);
TakeDamage(KeywordUtils.GetDefenderValue(defender.SourceCard), SourceCard);
// gray out creature to show it has already acted
UpdateHasActedIndicators();
// trigger after combat stuff
// poison
if (HasKeyword(Keyword.Poison) && defender.SourceCard is CreatureCard)
{
GameManager.Instance.kill((defender.SourceCard as CreatureCard).Creature);
}
}
static public int DeleteFile(string ep, List <TransFilesInfo> listDir)
{
if (0 == listDir.Count)
{
return(-1);
}
ProtoDeleteFiles info = new ProtoDeleteFiles();
foreach (var obj in listDir)
{
DeleteFiles file = new DeleteFiles();
file.FilePath.value_ = obj.Path;
file.FileType.value_ = obj.Type;
info.FileListList.Add(file);
}
byte[] b_data = null;
int len = 0;
b_data = new byte[info.length()];
if (!info.serialize(b_data, ref len))
{
return(-1);
}
unsafe
{
fixed(byte *data_stream = b_data)
{
return(NetInterface.NetDeleteRemoteFiles(ep, data_stream, len));
}
}
}
static public int SaveFile(string ep, List <TransFilesInfo> listFiles, string dir)
{
if (0 == listFiles.Count)
{
return(-1);
}
ProtoSendFiles info = new ProtoSendFiles();
foreach (var dirs in listFiles)
{
FileDir obj = new FileDir();
obj.FileName.value_ = dirs.Path;
info.FileList.Add(obj);
}
info.ToDir.value_ = dir;
byte[] b_data = null;
int len = 0;
b_data = new byte[info.length()];
if (!info.serialize(b_data, ref len))
{
return(-1);
}
unsafe
{
fixed(byte *data_stream = b_data)
{
return(NetInterface.NetPushFilesToRemote(ep, data_stream, len));
}
}
}
private void Update()
{
if (needToSyncStats && NetInterface.Get().gameSetupComplete)
{
needToSyncStats = false;
NetInterface.Get().SyncPlayerStats(this);
}
}
// stuff done before animation
public int Attack(Damageable defender)
{
int attackRoll = GetAttackRoll();
NetInterface.Get().SyncAttack(this, defender, attackRoll);
Attack(defender, attackRoll);
return(attackRoll);
}
public static NetInterface Get()
{
if (instance == null)
{
instance = new NetInterface();
}
return(instance);
}
// move card to a pile and remove it from the old one
public void MoveToCardPile(CardPile newPile, Card source)
{
ActualMove(newPile, source);
if (GameManager.gameMode == GameManager.GameMode.online)
{
NetInterface.Get().SyncMoveCardToPile(this, newPile, source);
}
}
private void Update()
{
if (needToSync && NetInterface.Get().gameSetupComplete)
{
NetInterface.Get().SyncCreatureStats(this);
needToSync = false;
}
}
public void addEffect(EffectActuator newEffect, Player effectOwner)
{
if (effectOwner != NetInterface.Get().localPlayer)
{
return;
}
effectsQueue.Add(newEffect);
}
public void addEffectToStartOfQueue(EffectActuator newEffect, string informationText, Player effectOwner)
{
if (effectOwner != NetInterface.Get().localPlayer)
{
return;
}
newEffect.informationText = informationText;
effectsQueue.Insert(0, newEffect);
}
void Update()
{
#if UNITY_EDITOR
mResourceManager.Update();
#endif
NetInterface.Update();
mGameTimerManager.Execute();
}
private void OnMouseCheckFileDetail(object sender, MouseButtonEventArgs e)
{
TextBlock tb = sender as TextBlock;
List <TaskFileDetailInfo> list = new List <TaskFileDetailInfo>();
string str = tb.Tag.ToString();
NetInterface.GetPushFilesDetailInfo(Convert.ToUInt64(str), ref list);
TransFromDetailInfoWid.Show(this, Convert.ToUInt64(str), list);
}
public List2List(string ip, string ep)
{
InitializeComponent();
This = this;
NetInterface.NetRegistPullCallback(WaitWindow.ChangeCallback);
EP = ep;
IP = ip;
RefreshList();
}
// Use to move a creature to a tile by an effect
public void MoveByEffect(Tile tile, Card source)
{
ActualMove(tile);
NetInterface.Get().SyncCreatureCoordinates(this, this.Tile.X, this.Tile.Y, source);
GameEvents.TriggerMovedEvents(this, new GameEvents.CreatureMovedArgs()
{
creature = this, source = source
});
}
public void InitNetWork(List<AcceptorConfig> acceptList, List<ConnectorConfig> connectList)
{
NetInterface login = new NetInterface(acceptList[0].m_strTitle, 1000, 2048, acceptList[0].m_handler);
m_interfaceList.Add(login);
}
