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