draugr_contrib /SDK/api/CSharp/ClassLibrary1/SkyportConnection.cs

Language C# Lines 269
MD5 Hash 56c3b536e4946b0f01d648be1082b201 Estimated Cost $6,196 (why?)
Repository https://bitbucket.org/ehvattum/draugr_contrib.git View Raw File View Project SPDX
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
using System;
using System.Collections.Generic;
using System.IO;
using System.Net.Sockets;

namespace Skyport
{
    public class SkyportConnection
    {
        private readonly string host;
        private readonly SkyportObserver observer;
        private readonly int port;
        private TcpClient client;
        private StreamReader reader;
        private StreamWriter writer;

        public SkyportConnection(string HostName, int PortNumber, SkyportObserver ObserverArg)
        {
            observer = ObserverArg;
            host = HostName;
            port = PortNumber;
        }

        private void Send(object obj)
        {
            string str = fastJSON.JSON.Instance.ToJSON(obj,
                                                       new fastJSON.JSONParameters {EnableAnonymousTypes = true});
            writer.WriteLine(str);
        }

        private string ReadDataFromSocket()
        {
            string line = reader.ReadLine();
            return line;
        }

        private void Parse(Dictionary<string, object> obj)
        {
            object messageType;
            if (obj.TryGetValue("error", out messageType))
            {
                observer.OnError((string) messageType);
                return;
            }
            if (!obj.TryGetValue("message", out messageType))
            {
                Console.WriteLine("Error: JSON packet has no 'message' key");
                return;
            }
            Console.WriteLine("got: " + (string) messageType);
            switch ((string) messageType)
            {
                case "connect":
                    observer.OnHandshakeSuccessful();
                    break;
                case "gamestate":
                    ParseGamestate(obj);
                    break;
                case "action":
                    ParseAction(obj);
                    break;
                case "endturn":
                    observer.OnEndturn();
                    break;
                default:
                    Console.WriteLine("Got unknown message: " + messageType);
                    break;
            }
        }

        private void ParseGamestate(Dictionary<string, object> obj)
        {
            object turnNumber;
            object map;
            object players;
            obj.TryGetValue("turn", out turnNumber);
            obj.TryGetValue("map", out map);
            obj.TryGetValue("players", out players);
            if ((long) turnNumber == 0)
            {
                observer.OnGamestart(new Map(map));
            }
            else
            {
                List<object> playerArr = (List<object>) players;
                PlayerData[] playerDataList = new PlayerData[playerArr.Count];
                for (int i = 0; i < playerArr.Count; i++)
                {
                    playerDataList[i] = new PlayerData(playerArr[i]);
                }
                observer.OnGamestate((long) turnNumber, new Map(map), playerDataList);
            }
        }

        private void ParseAction(Dictionary<string, object> obj)
        {
            object player;
            object action;
            object type;
            obj.TryGetValue("from", out player);
            obj.TryGetValue("type", out type);
            obj.Remove("message");
            obj.Remove("from");
            obj.Remove("type");
            Dictionary<string, string> parameters = new Dictionary<string, string>();
            observer.OnAction((string) player, (string) type, obj);
        }

        /**
         * Public API
         */

        public void Run()
        {
            try
            {
                client = new TcpClient(host, port);
                Stream s = client.GetStream();
                reader = new StreamReader(s);
                writer = new StreamWriter(s);
                writer.AutoFlush = true;
                observer.OnConnectionEstablished(this);
            }
            catch (Exception e)
            {
                Console.WriteLine("Error establishing connection: " + e.Message);
            }
            while (true)
            {
                string data = ReadDataFromSocket();
                if (data == null)
                {
                    break;
                }
                data.TrimEnd('\r', '\n');
                object newobj;
                try
                {
                    newobj = fastJSON.JSON.Instance.Parse(data);
                }
                catch (Exception e)
                {
                    Console.WriteLine("Warning: Invalid JSON packet received: '" + data + "':" + e.Message);
                    return;
                }
                Dictionary<string, object> newdict = (Dictionary<string, object>) newobj;
                Parse(newdict);
            }
        }

        public void SendHandshake(string AIName)
        {
            Send(new {message = "connect", revision = 1, name = AIName});
        }

        public void SendLoadout(string PrimaryWeapon, string SecondaryWeapon)
        {
            Dictionary<string, string> newdict = new Dictionary<string, string>();
            newdict.Add("message", "loadout");
            newdict.Add("primary-weapon", PrimaryWeapon);
            newdict.Add("secondary-weapon", SecondaryWeapon);
            Send(newdict);
        }

        public void SendMove(string whereto)
        {
            Send(new {message = "action", type = "move", direction = whereto});
        }

        public void AttackLaser(string whereto)
        {
            Send(new {message = "action", type = "laser", direction = whereto});
        }

        public void AttackMortar(long j, long k)
        {
            Send(new {message = "action", type = "mortar", direction = j + "," + k});
        }

        public void AttackDroid(string[] CommandSequence)
        {
            Send(new {message = "action", type = "droid", sequence = CommandSequence});
        }

        public void Mine()
        {
            Send(new {message = "action", type = "mine"});
        }

        public void Upgrade(string WeaponToUpgrade)
        {
            Send(new {message = "action", type = "upgrade", weapon = WeaponToUpgrade});
        }
    }

    public class PlayerData
    {
        public string PrimaryWeapon;
        public long PrimaryWeaponLevel;
        public string SecondaryWeapon;
        public long SecondaryWeaponLevel;
        public long health;
        public long j;
        public long k;
        public string name;
        public long score;

        public PlayerData(object obj)
        {
            Dictionary<string, object> newdict = (Dictionary<string, object>) obj;
            object primaryObj,
                   secondaryObj,
                   primaryStringObj,
                   secondaryStringObj,
                   primaryLevelObj,
                   secondaryLevelObj,
                   positionStringObj,
                   nameStringObj,
                   scoreObj,
                   healthObj;
            newdict.TryGetValue("primary-weapon", out primaryObj);
            newdict.TryGetValue("secondary-weapon", out secondaryObj);
            Dictionary<string, object> primaryDict = (Dictionary<string, object>) primaryObj;
            Dictionary<string, object> secondaryDict = (Dictionary<string, object>) secondaryObj;
            primaryDict.TryGetValue("name", out primaryStringObj);
            primaryDict.TryGetValue("level", out primaryLevelObj);
            secondaryDict.TryGetValue("name", out secondaryStringObj);
            secondaryDict.TryGetValue("level", out secondaryLevelObj);
            newdict.TryGetValue("name", out nameStringObj);
            newdict.TryGetValue("health", out healthObj);
            newdict.TryGetValue("score", out scoreObj);
            newdict.TryGetValue("position", out positionStringObj);
            string coordString = (string) positionStringObj;
            string[] coords = coordString.Split(',');
            j = Int64.Parse(coords[0]);
            k = Int64.Parse(coords[1]);
            name = (string) nameStringObj;
            score = (long) scoreObj;
            health = (long) healthObj;
            PrimaryWeapon = (string) primaryStringObj;
            SecondaryWeapon = (string) secondaryStringObj;
            PrimaryWeaponLevel = (long) primaryLevelObj;
            SecondaryWeaponLevel = (long) secondaryLevelObj;
        }
    }

    public class Map
    {
        public Map(object obj)
        {
            Dictionary<string, object> map = (Dictionary<string, object>) obj;
            object jLength, kLength, data;
            map.TryGetValue("j-length", out jLength);
            map.TryGetValue("k-length", out kLength);
            map.TryGetValue("data", out data);
            string[,] mapArray = new string[(long) jLength,(long) kLength];
            List<object> outer = (List<object>) data;
            for (int j = 0; j < outer.Count; j++)
            {
                List<object> inner = (List<object>) (outer[j]);
                for (int k = 0; k < inner.Count; k++)
                {
                    Console.Write(inner[k] + ", ");
                }
                Console.WriteLine("");
            }
        }
    }
}
Back to Top