コード例 #1
0
        private void OnCommandTransfer(string[] args)
        {
            string name = args[0];

            if (!wallets.TryGetValue(name, out Account sender))
            {
                BConsole.WriteLine("account name (", name, ") not found");
                return;
            }

            if (sender.Locked && !sender.Unlock(BConsole.ReadPassword("password: "******"can't unlock account");
                return;
            }

            Task.Run(async() =>
            {
                (string to, string error) = await web4b.GetAddressByUidAsync(args[1]);
                ulong value = Coin.ToBeryl(decimal.Parse(args[2]));
                ulong gas   = args.Length > 3 ? Coin.ToBeryl(decimal.Parse(args[3])) : 0;
                ulong?nonce = args.Length > 4 ? (ulong?)Convert.ToInt64(args[4]) : null;

                (string txid, string err) = await web4b.SendTransferAsync(sender.Key, to, value, gas, nonce);
                BConsole.WriteLine("txid=", txid);
            });
        }
コード例 #2
0
        /// <summary>
        /// Function that gets the windows version from the Registry
        /// </summary>
        /// <returns></returns>
        private string GetOSVersion()
        {
            RegistryKey key;

            try
            {
                if (!Environment.Is64BitOperatingSystem)
                {
                    key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion", false);
                }
                else
                {
                    RegistryKey localKey = RegistryKey.OpenBaseKey(Microsoft.Win32.RegistryHive.LocalMachine, RegistryView.Registry64);
                    key = localKey.OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion", false);
                }

                if (key != null)
                {
                    string releaseId   = key.GetValue("ReleaseId", "").ToString();
                    string productName = key.GetValue("ProductName", "Unknown OS").ToString();

                    string bit = Environment.Is64BitOperatingSystem ? "x64" : "x86";

                    return($"{productName} [{releaseId}] ({bit})");
                }
            }
            catch (Exception e)
            {
                BConsole.WriteLine("OS Error: " + e.Message, ConsoleColor.Red);
            }

            return("Unknown OS Version");
        }
コード例 #3
0
 private void OnCommandItems(string[] args)
 {
     foreach (var item in GameDB.Items.SelectAll())
     {
         BConsole.WriteLine(item);
     }
 }
コード例 #4
0
        private void OnCommandCoinBurn(string[] args)
        {
            Task.Run(async() =>
            {
                try
                {
                    string uid        = args[0];
                    decimal value     = decimal.Parse(args[1]);
                    PrivateKey signer = GameKey.CKD(uid);
                    string address    = signer.Address;

                    // 코인 회수
                    string txid = (await web4b.SendTransferAsync(signer, GameKey.Address, web4b.ToBeryl(value))).txid;
                    BConsole.WriteLine("txid=", txid);
                    if (null != txid)
                    {
                        // coinbase 와 uid 잔액 출력
                        BConsole.WriteLine("coinbase.balance=", (await web4b.GetBalanceAsync(GameKey.Address)).balance);
                        BConsole.WriteLine(uid, "(", address, ").balance=", (await web4b.GetBalanceAsync(address)).balance);
                    }
                }
                catch (Exception ex)
                {
                    BConsole.WriteLine("exception! ex=", ex);
                }
            });
        }
コード例 #5
0
        private void OnCommandWithdrawAndWaitReceipt(string[] args)
        {
            string name = args[0];

            if (!wallets.TryGetValue(name, out Account sender))
            {
                BConsole.WriteLine("account name (", name, ") not found");
                return;
            }

            if (sender.Locked && !sender.Unlock(BConsole.ReadPassword("password: "******"can't unlock account");
                return;
            }

            Task.Run(async() =>
            {
                string to   = args[1];
                ulong value = Coin.ToBeryl(decimal.Parse(args[2]));
                ulong gas   = args.Length > 3 ? Coin.ToBeryl(decimal.Parse(args[3])) : 0;
                ulong?nonce = args.Length > 4 ? (ulong?)Convert.ToInt64(args[4]) : null;

                (JObject receipt, string error) = await web4b.SendWithdrawAndWaitReceiptAsync(sender.Key, to, value, gas, nonce);
                BConsole.WriteLine("receipt=", receipt, ", error=", error);
            });
        }
コード例 #6
0
        private void OnConsoleCommandPeersLayout(string[] args)
        {
            byte n = Env.Value <byte>("n", 4);

            if (args.Length > 0)
            {
                byte.TryParse(args[0], out n);
            }

            // define layout
            ElasticLayout layout = ElasticLayout.DefineLayout(Peers.Count, n);

            for (byte x = 1; x <= layout.X; x++)
            {
                for (byte y = 1; y <= layout.Y; y++)
                {
                    for (byte z = 1; z <= layout.Z; z++)
                    {
                        Elastic3D coordinates = new Elastic3D(x, y, z);
                        string[]  peers       = Peers.ToArray <string>(coordinates, layout);

                        BConsole.WriteLine(ConsoleColor.DarkCyan, $"Coordinates{coordinates.ToString()}: nPeers={peers.Length}");
                        foreach (var peer in peers)
                        {
                            BConsole.WriteLine(EndPoint.ToString() == peer?ConsoleColor.Yellow : ConsoleColor.Gray, $" {peer}");
                        }
                    }
                }
            }

            BConsole.WriteLine(ConsoleColor.DarkCyan, $"ElasticLayout.DefineLayout({Peers.Count},{n})={layout.ToString()}");
        }
コード例 #7
0
        private bool TextBox(string textToDisplay)
        {
            try
            {
                string   title   = textToDisplay.Split('|')[0];
                string[] content = textToDisplay.Split(new[] { '|' }, 2);

                Array          values = Enum.GetValues(typeof(MessageBoxIcon));
                Random         random = new Random();
                MessageBoxIcon randomMessageBoxIcon = (MessageBoxIcon)values.GetValue(random.Next(values.Length));

                if (content.Length == 1)
                {
                    System.Windows.Forms.MessageBox.Show(title, "", MessageBoxButtons.OK, randomMessageBoxIcon);
                }
                else
                {
                    System.Windows.Forms.MessageBox.Show(content[1], title, MessageBoxButtons.OK, randomMessageBoxIcon);
                }
                return(true);
            }
            catch (Exception e)
            {
                BConsole.WriteLine("Visuals Error: " + e.Message, ConsoleColor.Red);
                return(false);
            }
        }
コード例 #8
0
 public void PrintAllDevices()
 {
     foreach (DeviceInfo d in Devices)
     {
         BConsole.WriteLine(d.ToString());
     }
 }
コード例 #9
0
        private void OnCommandItemIssue(string[] args)
        {
            string uid  = args[0];
            string name = args[1];

            // 해당 아이템이 존재하는지?
            if (!GameDB.Items.ContainsByName(name))
            {
                BConsole.WriteLine("unknown item name");
                return;
            }

            // 아이템 정보
            var item = GameDB.Items.SelectByName(name);

            if (null == item)
            {
                BConsole.WriteLine("unknown item name");
                return;
            }

            // 사용자에게 아이템 지급
            var inven = GameDB.Inventories.Select(uid);

            inven.Add(item.Code);
            GameDB.Inventories.Update(uid, inven);

            BConsole.WriteLine(uid, ".inven=", inven);
        }
コード例 #10
0
        /// <summary>
        /// Function that executes the provided command on the client, hidden or shown
        /// </summary>
        /// <param name="command">{hidden;show},command</param>
        /// <returns></returns>
        private bool RunCommand(string command)
        {
            try
            {
                string[] values = command.Split(',');
                if (values[0] == "hidden")
                {
                    Process          process   = new Process();
                    ProcessStartInfo startInfo = new ProcessStartInfo();
                    startInfo.WindowStyle = ProcessWindowStyle.Hidden;
                    startInfo.FileName    = "cmd.exe";
                    startInfo.Arguments   = $"/C c: & cd / & {values[1]}";
                    process.StartInfo     = startInfo;
                    process.Start();
                }
                else if (values[0] == "show")
                {
                    Process.Start("CMD.exe", $"/C c: & cd / & {values[1]} & pause");
                }
                else
                {
                    Process.Start("CMD.exe", $"/C c: & cd / & {command} & pause");
                }

                return(true);
            }
            catch (Exception e)
            {
                BConsole.WriteLine("Windows Error: " + e.Message, ConsoleColor.Red);
                return(false);
            }
        }
コード例 #11
0
        private void OnCommandAccountsView(string[] args)
        {
            string name = args[0];

            if (!wallets.TryGetValue(name, out Account account))
            {
                BConsole.WriteLine("account (", name, ") not found");
                return;
            }

            string key = account.Key;

            if (string.IsNullOrEmpty(key))
            {
                key = "Locked";
            }

            var o = new JObject();

            o.Put <string>("name", name);
            o.Put <string>("address", account.Address);
            o.Put <string>("secretKey", key);
            o.Put <JObject>("keystore", account.KeyStore);

            BConsole.WriteLine(o);
        }
コード例 #12
0
        private void OnMessageShopBuyRes(TcpSession session, GameMessage message)
        {
            // txid
            var item = message.Get <JObject>("item");

            BConsole.WriteLine("item=", item);
        }
コード例 #13
0
        private void OnMessageMarketBuyRes(TcpSession session, GameMessage message)
        {
            string  name  = message.Get <string>("itemname");
            decimal price = message.Get <decimal>("price");

            BConsole.WriteLine("market trade! item=", name, ", price=", price);
        }
コード例 #14
0
        private void OnMessageWithdrawRes(TcpSession session, GameMessage message)
        {
            // txid
            string txid = message.Get <string>("txid");

            BConsole.WriteLine("txid=", txid);
        }
コード例 #15
0
        private void OnMessageShopListRes(TcpSession session, GameMessage message)
        {
            // items
            var items = message.Get <JArray>("items");

            BConsole.WriteLine("shop=", items);
        }
コード例 #16
0
        private void OnMessageLogoutRes(TcpSession session, GameMessage message)
        {
            // 연결을 종료한다
            Stop();

            BConsole.WriteLine("logout success!");
        }
コード例 #17
0
 private void Receiver_OnDataReceived(Socket s, TransferCommandObject Object)
 {
     try
     {
         if (handlers.ContainsKey(Object.Handler))
         {
             if (handlers[Object.Handler].HandleCommand(s, Object))
             {
                 BConsole.WriteLine($"Command '{Object.Command}' executed successfully.", ConsoleColor.Green);
             }
             else
             {
                 BConsole.WriteLine($"Command '{Object.Command}' could not be executed.", ConsoleColor.Red);
             }
         }
         else
         {
             BConsole.WriteLine($"Unkown Handler '{Object.Handler}', please refer to the README.md", ConsoleColor.Red);
         }
     }
     catch (Exception e)
     {
         BConsole.WriteLine("Handler error: " + e.Message, ConsoleColor.Red);
     }
 }
コード例 #18
0
        private void OnMessagePong(TcpSession session, GameMessage pong)
        {
            long timestamp = pong.Value <long>("timestamp");
            long travel    = NetTime.Timestamp - timestamp;

            BConsole.WriteLine("travel_time: ", travel, "(ms)");
        }
コード例 #19
0
        /// <summary>
        /// Function that starts the infit client discovery
        /// </summary>
        public void Discover()
        {
            byte[] responseData = Encoding.ASCII.GetBytes(ExpectedReturnMessage);
            while (true)
            {
                UdpClient server = new UdpClient();
                server.EnableBroadcast = true;
                server.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
                server.Client.Bind(new IPEndPoint(IPAddress.Any, SharedProperties.BroadcastPort));
                IPEndPoint clientEp = new IPEndPoint(IPAddress.Any, SharedProperties.BroadcastPort);
                server.Client.EnableBroadcast = true;
                byte[] clientRequestData = server.Receive(ref clientEp);
                string clientRequest     = Encoding.ASCII.GetString(clientRequestData);
                if (clientRequest == BroadcastMessage)
                {
                    BConsole.WriteLine($"Received '{clientRequest}' from {clientEp.Address}, sending response: '{ExpectedReturnMessage}'", ConsoleColor.Magenta);

                    server.Send(responseData, responseData.Length, clientEp);
                    server.Close();
                }
                else
                {
                    BConsole.WriteLine($"Received '{clientRequest}' from {clientEp.Address}, ignoring!", ConsoleColor.Red);
                }
            }
        }
コード例 #20
0
        private void OnCommandUserDel(string[] args)
        {
            string uid    = args[0];
            bool   result = GameDB.Users.Delete(uid);

            BConsole.WriteLine("user(", uid, ") ", (!result ? "not " : string.Empty), "deleted!");
        }
コード例 #21
0
ファイル: Program.cs プロジェクト: GGG-KILLER/Templater
        /// <summary>
        /// Prints the help text to the console
        /// </summary>
        private static void HelpText( )
        {
            BConsole.WriteLine(
                @"Usage:
    templater template project folder [options...]
    or
    templater help

    template        A template on the templates folder and properly configured

    project folder  A folder that will be created and have the
                    contents moved to

    options...      Any number of options followed by values to be used by
                    the file processor. Example: -Author ""John Doe"" would
                    replace all instances of ""{Author}"" by ""John Doe""
                    in all files that aren't configured to be ignored by the
                    preprocessor.
Template creation:
    Simply put the directory of the template you want to create on the
    ""templates"" directory located on the same folder as this executable and
    then create a ""template.json"" file with at least one of the following keys:
    - ignore            (String array, Optional) Files the program should
                        ignore (won't be copied at all)
    - processIgnore     (String array, Optional) Files the file processor
                        should ignore (won't have values replaced)
    - setupTasks        (String array, Optional) Processes that should be ran
                        after copying and processing all files
    - tasksTimeout      (Integer, Default: 60000) Timeout in miliseconds that
                        the setup tasks should be individually ran for.
                        Use -1 to disable. 0 will break all setup tasks by
                        making them not run"
                );
        }
コード例 #22
0
        private void OnCommandSendTxAndWaitReceipt(string[] args)
        {
            string name = args[0];

            if (!wallets.TryGetValue(name, out Account sender))
            {
                BConsole.WriteLine("account name (", name, ") not found");
                return;
            }

            if (sender.Locked && !sender.Unlock(BConsole.ReadPassword("password: "******"can't unlock account");
                return;
            }

            Task.Run(async() =>
            {
                string to   = wallets.TryGetValue(args[1], out var receiver) ? (string)receiver.Address : args[1];
                ulong value = Coin.ToBeryl(decimal.Parse(args[2]));
                ulong gas   = args.Length > 3 ? Coin.ToBeryl(decimal.Parse(args[3])) : 0;
                ulong?nonce = args.Length > 4 ? (ulong?)Convert.ToInt64(args[4]) : null;

                var tx = await web4b.SendTransactionAndWaitReceiptAsync(sender.Key, to, value, gas, nonce);
                BConsole.WriteLine("tx=", tx);
            });
        }
コード例 #23
0
 private void ShowEnv()
 {
     BConsole.WriteLine();
     BConsole.WriteLine("ENVIRONMENT VALUES:");
     BConsole.WriteLine(ConsoleColor.Cyan, Env.ToString());
     BConsole.WriteLine();
 }
コード例 #24
0
        /// <summary>
        /// Async function that handles the incoming connection
        /// </summary>
        /// <param name="result"></param>
        private void HandleIncomingConnection(IAsyncResult result)
        {
            try
            {
                Socket oldSocket = (Socket)result.AsyncState;
                Socket newSocket = oldSocket.EndAccept(result);

                uint   clientId = clientCount++;
                Client client   = new Client(clientId, (IPEndPoint)newSocket.RemoteEndPoint);
                clients.Add(newSocket, client);
                clients.FirstOrDefault(m => m.Key == newSocket).Value.SetDataItem("test", "DEBUG_TEST_ITEM2");

                //call the client connected event, this is then passed up into the ServerViewModel.
                ClientConnected(client);

                newSocket.BeginReceive(client.Data, 0, dataSize, SocketFlags.None, new AsyncCallback(ReceiveData), newSocket);

                //tell the client to start sending back its client info.
                TransferCommandObject returnObject = new TransferCommandObject {
                    Command = "GetClientInfo", Handler = "SystemInfo"
                };
                SendDataObjectToSocket(DataByteType.Command, newSocket, ClientServerPipeline.BufferSerialize(returnObject));

                serverSocket.BeginAccept(new AsyncCallback(HandleIncomingConnection), serverSocket);
            }
            catch (Exception e)
            {
                BConsole.WriteLine(e.Message);
            }
        }
コード例 #25
0
        private void ProcessKey(ConsoleKeyInfo Key)
        {
            switch (Key.Key)
            {
            case ConsoleKey.Backspace:
                if (Cursor.X > 0)
                {
                    Str.Remove(Cursor.X - 1, 1);
                    Cursor.X--;
                }
                break;

            // Ctrl+V parser
            case ConsoleKey.V:
                ProcessClipboard(Key);
                Cursor.X = Str.Length;
                break;

            case ConsoleKey.Delete:
                if (Console.CursorLeft - 1 < Str.Length)
                {
                    Str.Remove(Cursor.X, 1);
                }
                break;

            case ConsoleKey.Home:
                Cursor.X = 0;
                break;

            case ConsoleKey.End:
                Cursor.X = Str.Length;
                break;

            case ConsoleKey.LeftArrow:
                if (Cursor.X > 0)
                {
                    Cursor.X--;
                }
                break;

            case ConsoleKey.RightArrow:
                if (Cursor.X < Str.Length)
                {
                    Cursor.X++;
                }
                break;

            default:
                if (Str.Length < (Width - 2) && TextKey(Key))
                {
                    Cursor.X++;

                    Str.Insert(Cursor.X - 1, Key.KeyChar);

                    BConsole.TL((( Int32 )Key.KeyChar).ToString("X2"));
                }
                break;
            }
        }
コード例 #26
0
 private void AddDevicesToCache(List <DeviceInfo> deviceInfos)
 {
     foreach (DeviceInfo device in deviceInfos)
     {
         Devices.Add(device);
         BConsole.WriteLine($"Added device {device.DeviceMac} {device.DeviceIp}");
     }
 }
コード例 #27
0
 protected virtual void OnCommandSyncTime(string[] args)
 {
     Task.Run(() =>
     {
         NetTime.Synchronize();
         BConsole.WriteLine("NetTime=", GetNetTime());
     });
 }
コード例 #28
0
 private void OnCommandServerSessions(string[] args)
 {
     foreach (var session in GameServer.Sessions)
     {
         string uid = GameServer.GetUidBySession(session);
         BConsole.WriteLine(uid, "=", session);
     }
 }
コード例 #29
0
        private void OnCommandItemDel(string[] args)
        {
            string name = args[0];

            bool result = GameDB.Items.DeleteByName(name);

            BConsole.WriteLine("deleting item(", name, ") ", result);
        }
コード例 #30
0
        protected virtual void OnCommandShowHelp(string[] args)
        {
            string format = $"{{0,-{maxCommandsLength}}}";

            foreach (var entry in Descriptions)
            {
                BConsole.WriteLine(string.Format(format, entry.Key), " - ", Color.DarkGray, entry.Value);
            }
        }