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. }