Facebook
From Klient, 1 Year ago, written in Plain Text.
Embed
Download Paste or View Raw
Hits: 216
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Net.Sockets;
  6. using System.Net;
  7. using System.Collections;
  8. using System.Threading;
  9.  
  10. namespace ConsoleApplication1
  11. {
  12.  
  13.     class Program
  14.     {
  15.         public static int gamestate = 0;
  16.         public static int working = 0;
  17.         public static string ToBin(int value, int len)
  18.         {
  19.             return (len > 1 ? ToBin(value >> 1, len - 1) : null) + "01"[value & 1];
  20.         }
  21.         public static string[] DecodePacket(byte[] c)
  22.         {
  23.             string h = "";
  24.             string[] a = new string[4];
  25.             for (int i = 0; i < c.Length; i++)
  26.             {
  27.                 h = h + ToBin(c[i], 8);
  28.  
  29.             }
  30.             for (int i = 0; i < h.Length; i++)
  31.             {
  32.                 if (i <= 5)
  33.                     a[0] = a[0] + h[i];
  34.                 if (i > 5 && i <= 9)
  35.                     a[1] = a[1] + h[i];
  36.                 if (i > 9 && i <= 17)
  37.                     a[2] = a[2] + h[i];
  38.                 if (i > 17)
  39.                     a[3] = a[3] + h[i];
  40.  
  41.             }
  42.             return a;
  43.         }
  44.         public static BitArray Append(BitArray current, BitArray after)
  45.         {
  46.             var bools = new bool[current.Count + after.Count];
  47.             current.CopyTo(bools, 0);
  48.             after.CopyTo(bools, current.Count);
  49.             return new BitArray(bools);
  50.         }
  51.         static byte[] ResponseToPacket(byte[] c, ref string h)
  52.         {
  53.  
  54.             byte[] bytes = new byte[3];
  55.             BitArray HGH = new BitArray(0);
  56.             string[] packet = new string[4];
  57.             packet = DecodePacket(c);
  58.             switch (packet[0])
  59.             {
  60.                 case "100000":
  61.                     {
  62.                         h = packet[2];
  63.                         break;
  64.                     }
  65.                 case "110000":
  66.                     {
  67.                         Console.Write("Brawo wygrales\n");
  68.                         gamestate++;
  69.                         break;
  70.                     }
  71.                 case "001000":
  72.                     {
  73.                         Console.Write("To nie byla poprawna liczba\n");
  74.                         break;
  75.                     }
  76.                 case "100100":
  77.                     {
  78.                         gamestate++;
  79.                         Console.Write("Game has begun!\n");
  80.                         break;
  81.                     }
  82.                 case "111000":
  83.                     {
  84.                         Thread.Sleep(100);
  85.                         if (gamestate == 1)
  86.                         {
  87.                             if (packet[1] == "0000")
  88.                             {
  89.                                 Console.WriteLine("Timeout, no one managed to guess the number");
  90.                             }
  91.                             if (packet[1] == "1111")
  92.                             {
  93.                                 Console.WriteLine("You lost, second player managed to guess the number");
  94.                             }
  95.                             gamestate++;
  96.                         }
  97.  
  98.  
  99.                         break;
  100.                     }
  101.                 case "101000":
  102.                     {
  103.                         string time = packet[1] + packet[3];
  104.                         int czas = Convert.ToInt32(time, 2);
  105.                         Console.Write("Pozostaly czas to: ");
  106.                         Console.Write(czas);
  107.                         Console.Write("s\n");
  108.                         break;
  109.                     }
  110.  
  111.             }
  112.  
  113.             HGH.CopyTo(bytes, 0);
  114.  
  115.             Array.Reverse(bytes, 0, bytes.Length);
  116.  
  117.             return bytes;
  118.         }
  119.  
  120.         static byte[] ProtocolBuilder(string operation, string response, string idref)
  121.         {
  122.             byte[] data = new byte[3];
  123.             int pom1 = 0, pom2 = 0, pom3 = 0;
  124.             BitArray c = new BitArray(24);
  125.             BitArray g = new BitArray(24);
  126.             for (int i = 0; i < c.Length; i++)
  127.             {
  128.                 if (i <= 5)
  129.                 {
  130.                     if (operation[pom1] == '0')
  131.                         c[i] = false;
  132.                     else
  133.                         c[i] = true;
  134.                     pom1++;
  135.                 }
  136.                 if (i > 5 && i <= 9)
  137.                 {
  138.                     if (response[pom2] == '0')
  139.                         c[i] = false;
  140.                     else
  141.                         c[i] = true;
  142.                     pom2++;
  143.                 }
  144.                 if (i > 9 && i <= 17)
  145.                 {
  146.                     if (idref[pom3] == '0')
  147.                         c[i] = false;
  148.                     else
  149.                         c[i] = true;
  150.                     pom3++;
  151.                 }
  152.                 if (i > 17)
  153.                     c[i] = false;
  154.             }
  155.             for (int i = 0; i < c.Length; i++)
  156.             {
  157.                 g[g.Length - i - 1] = c[i];
  158.             }
  159.             g.CopyTo(data, 0);
  160.             Array.Reverse(data, 0, data.Length);
  161.             return data;
  162.         }
  163.         static void SendPacket(UdpClient klient, byte[] bytes, IPEndPoint sender)
  164.         {
  165.             klient.Send(bytes, bytes.Length);
  166.             klient.Receive(ref sender);
  167.         }
  168.         static byte[] ReceivePacket(ref UdpClient klient, ref IPEndPoint sender, ref string h)
  169.         {
  170.             byte[] ACK = new byte[3];
  171.             byte[] data = new byte[3];
  172.             data = klient.Receive(ref sender);
  173.  
  174.             ACK = ProtocolBuilder("111111", "0000", h);
  175.  
  176.             klient.Send(ACK, ACK.Length);
  177.             return data;
  178.         }
  179.         static void SecondChannel(int port, string h)
  180.         {
  181.             byte[] data = new byte[3];
  182.             UdpClient udpClient = new UdpClient("127.0.0.1", port + 10);
  183.  
  184.             IPEndPoint sender = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 0);
  185.             byte[] newArray = new byte[3];
  186.             newArray = ProtocolBuilder("111100", "0000", h);
  187.  
  188.             SendPacket(udpClient, newArray, sender);
  189.             while (true)
  190.             {
  191.                 if (gamestate == 2)
  192.                     break;
  193.                 data = ReceivePacket(ref udpClient, ref sender, ref h);
  194.                 working = 1;
  195.                 ResponseToPacket(data, ref h);
  196.                 working = 0;
  197.             }
  198.         }
  199.         static void Main(string[] args)
  200.         {
  201.             int port = 9051;
  202.             string h = "00000000";
  203.             byte[] data = new byte[3];
  204.             byte[] newArray = ProtocolBuilder("000000"/*Pole operacji(6)*/, "0000"/*Pole odp(4)*/, h/*Pole identyfikatora(8)*/);//pole operacji, pole odpowiedzi, pole identyfikatora
  205.             Array.Reverse(newArray, 0, newArray.Length);
  206.  
  207.  
  208.             UdpClient udpClient = new UdpClient("127.0.0.1", port);
  209.  
  210.             IPEndPoint sender = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 0);
  211.             SendPacket(udpClient, newArray, sender);
  212.             data = ReceivePacket(ref udpClient, ref sender, ref h);
  213.             string[] tab = new string[4];
  214.             tab = DecodePacket(data);
  215.             ResponseToPacket(data, ref h);
  216.  
  217.             string c;
  218.             int a;
  219.             Console.WriteLine("Waiting for game to begin...");
  220.             while (true)
  221.             {
  222.                 if (gamestate == 0)//czekanie na rozpoczecie gry przez serwer
  223.                 {
  224.                     data = ReceivePacket(ref udpClient, ref sender, ref h);
  225.                     ResponseToPacket(data, ref h);
  226.                     string c2 = h;
  227.                     Thread thread3 = new Thread(() => SecondChannel(port, c2));
  228.                     thread3.Start();
  229.                 }
  230.                 if (gamestate == 2)
  231.                 {
  232.                     newArray = ProtocolBuilder("110100", "0000", h);
  233.  
  234.                     SendPacket(udpClient, newArray, sender);
  235.                     break;
  236.                 }
  237.                 if (gamestate == 1)
  238.                 {
  239.                     Console.WriteLine("Proboje liczbe... ");
  240.                     c = Console.ReadLine();
  241.                     if (gamestate == 2)
  242.                     {
  243.                         Console.WriteLine("Niestety gra sie skonczyla");
  244.                         continue;
  245.                     }
  246.  
  247.                     a = Int32.Parse(c);
  248.                     string liczba = ToBin(a, 4);
  249.                     newArray = ProtocolBuilder("010000", liczba, h);
  250.  
  251.                     SendPacket(udpClient, newArray, sender);
  252.                     data = ReceivePacket(ref udpClient, ref sender, ref h);
  253.                     ResponseToPacket(data, ref h);
  254.                 }
  255.  
  256.             }
  257.         }
  258.     }
  259. }