├── .gitignore
└── src
    ├── me
        └── braysen
        │   └── goodwin
        │       ├── game
        │           └── entities
        │           │   ├── Food.java
        │           │   ├── Entity.java
        │           │   └── Snake.java
        │       └── network
        │           └── packet
        │               ├── PacketFood.java
        │               ├── PacketSnakeMove.java
        │               ├── Packet.java
        │               ├── PacketServerUpdate.java
        │               └── PacketSnake.java
    └── org
        └── hackusu
            └── aisnakeserver
                ├── manager
                    └── EntityManager.java
                ├── server
                    ├── ServerSocketManager.java
                    ├── NetworkManager.java
                    └── ClientConnection.java
                └── AISnakeServer.java


/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | .idea/
3 | *.iml
4 | out/


--------------------------------------------------------------------------------
/src/me/braysen/goodwin/game/entities/Food.java:
--------------------------------------------------------------------------------
 1 | package me.braysen.goodwin.game.entities;
 2 | 
 3 | 
 4 | import java.io.Serializable;
 5 | import java.util.UUID;
 6 | 
 7 | public class Food extends Entity implements Serializable {
 8 | 
 9 |     private static final long serialVersionUID = 1L;
10 | 
11 |     public Food(int x, int y, UUID uuid) {
12 |         super(uuid, x, y);
13 |     }
14 | 
15 | }
16 | 


--------------------------------------------------------------------------------
/src/org/hackusu/aisnakeserver/manager/EntityManager.java:
--------------------------------------------------------------------------------
 1 | package org.hackusu.aisnakeserver.manager;
 2 | 
 3 | import me.braysen.goodwin.game.entities.Entity;
 4 | 
 5 | import java.util.ArrayList;
 6 | 
 7 | public class EntityManager {
 8 | 
 9 |     private ArrayList<Entity> entities;
10 | 
11 |     public EntityManager() {
12 |         entities = new ArrayList<>();
13 |     }
14 | 
15 |     public ArrayList<Entity> getEntities() {
16 |         return entities;
17 |     }
18 | 
19 |     public void add(Entity e) {
20 |         entities.add(e);
21 |     }
22 | 
23 | }
24 | 


--------------------------------------------------------------------------------
/src/me/braysen/goodwin/game/entities/Entity.java:
--------------------------------------------------------------------------------
 1 | package me.braysen.goodwin.game.entities;
 2 | 
 3 | import java.io.Serializable;
 4 | import java.util.UUID;
 5 | 
 6 | public abstract class Entity implements Serializable {
 7 | 
 8 |     private static final long serialVersionUID = 1L;
 9 | 
10 |     private int x, y;
11 |     private UUID uuid;
12 | 
13 |     public Entity(UUID uuid, int x, int y) {
14 |         this.x = x;
15 |         this.y = y;
16 |         this.uuid = uuid;
17 |     }
18 | 
19 |     public int getX() {
20 |         return x;
21 |     }
22 | 
23 |     public void setX(int x) {
24 |         this.x = x;
25 |     }
26 | 
27 |     public int getY() {
28 |         return y;
29 |     }
30 | 
31 |     public void setY(int y) {
32 |         this.y = y;
33 |     }
34 | 
35 |     public UUID getUUID() {
36 |         return uuid;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/me/braysen/goodwin/network/packet/PacketFood.java:
--------------------------------------------------------------------------------
 1 | package me.braysen.goodwin.network.packet;
 2 | 
 3 | import me.braysen.goodwin.game.entities.Food;
 4 | 
 5 | import java.io.ObjectInputStream;
 6 | import java.io.ObjectOutputStream;
 7 | 
 8 | public class PacketFood extends Packet {
 9 | 
10 |     private Food food;
11 | 
12 |     public PacketFood() {
13 |         super(PacketName.FOOD);
14 |     }
15 | 
16 |     @Override
17 |     public void writePacket(ObjectOutputStream objectOutputStream) throws Exception {
18 |         super.writePacket(objectOutputStream);
19 | 
20 |         objectOutputStream.writeObject(food);
21 |     }
22 | 
23 |     @Override
24 |     public void readPacket(ObjectInputStream objectInputStream) throws Exception {
25 |         super.readPacket(objectInputStream);
26 | 
27 |         this.food = (Food) objectInputStream.readObject();
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/me/braysen/goodwin/network/packet/PacketSnakeMove.java:
--------------------------------------------------------------------------------
 1 | package me.braysen.goodwin.network.packet;
 2 | 
 3 | import me.braysen.goodwin.game.entities.Snake;
 4 | 
 5 | import java.io.ObjectInputStream;
 6 | import java.io.ObjectOutputStream;
 7 | 
 8 | public class PacketSnakeMove extends Packet {
 9 | 
10 |     private Snake snake;
11 | 
12 |     public PacketSnakeMove(Snake snake) {
13 |         super(PacketName.SNAKE_MOVE);
14 |         this.snake = snake;
15 |     }
16 | 
17 |     @Override
18 |     public void writePacket(ObjectOutputStream objectOutputStream) throws Exception {
19 |         super.writePacket(objectOutputStream);
20 | 
21 |         // Server should never send a PacketSnakeMove
22 |     }
23 | 
24 |     @Override
25 |     public void readPacket(ObjectInputStream objectInputStream) throws Exception {
26 |         super.readPacket(objectInputStream);
27 | 
28 |         // Read UUID
29 | //        UUID snakeUUID = (UUID) objectInputStream.readObject();
30 | 
31 |         // Read Direction
32 | //        objectOutputStream.writeObject(snake.getDirection());
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/me/braysen/goodwin/network/packet/Packet.java:
--------------------------------------------------------------------------------
 1 | package me.braysen.goodwin.network.packet;
 2 | 
 3 | import java.io.ObjectInputStream;
 4 | import java.io.ObjectOutputStream;
 5 | import java.io.Serializable;
 6 | 
 7 | public abstract class Packet implements Serializable {
 8 | 
 9 |     private PacketName packetName;
10 | 
11 |     public Packet(PacketName packetName) {
12 |         this.packetName = packetName;
13 |     }
14 | 
15 |     public void writePacket(ObjectOutputStream objectOutputStream) throws Exception {
16 |         objectOutputStream.writeObject(packetName);
17 |     }
18 | 
19 |     public void readPacket(ObjectInputStream objectInputStream) throws Exception {
20 |         this.packetName = (PacketName) objectInputStream.readObject();
21 |     }
22 | 
23 |     public enum PacketName implements Serializable {
24 |         FOOD("f"),
25 |         SERVER_UPDATE("su"),
26 |         SNAKE("s"),
27 |         SNAKE_MOVE("sm");
28 | 
29 |         private final String name;
30 | 
31 |         PacketName(String name) {
32 |             this.name = name;
33 |         }
34 | 
35 |         public String getName() {
36 |             return name;
37 |         }
38 |     }
39 | 
40 | }
41 | 


--------------------------------------------------------------------------------
/src/org/hackusu/aisnakeserver/server/ServerSocketManager.java:
--------------------------------------------------------------------------------
 1 | package org.hackusu.aisnakeserver.server;
 2 | 
 3 | import java.net.ServerSocket;
 4 | import java.net.Socket;
 5 | 
 6 | public class ServerSocketManager extends Thread {
 7 | 
 8 |     private NetworkManager networkManager;
 9 | 
10 |     private int port;
11 |     private ServerSocket serverSocket;
12 | 
13 |     public ServerSocketManager(NetworkManager networkManager, int port) {
14 |         this.networkManager = networkManager;
15 |         this.port = port;
16 |     }
17 | 
18 |     @Override
19 |     public void run() {
20 |         try {
21 |             this.serverSocket = new ServerSocket(port);
22 | 
23 |             System.out.println("Started server on port: " + port);
24 | 
25 |             while (serverSocket.isBound()) {
26 |                 Socket socket = this.serverSocket.accept();
27 |                 ClientConnection clientConnection = new ClientConnection(networkManager, socket);
28 |                 this.networkManager.getClientConnections().add(clientConnection);
29 |                 clientConnection.start();
30 |             }
31 |         } catch (Exception e) {
32 |             e.printStackTrace();
33 |         }
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/org/hackusu/aisnakeserver/server/NetworkManager.java:
--------------------------------------------------------------------------------
 1 | package org.hackusu.aisnakeserver.server;
 2 | 
 3 | import me.braysen.goodwin.network.packet.PacketSnake;
 4 | import org.hackusu.aisnakeserver.manager.EntityManager;
 5 | 
 6 | import java.util.ArrayList;
 7 | 
 8 | public class NetworkManager {
 9 | 
10 |     private EntityManager entityManager;
11 | 
12 |     private ServerSocketManager serverSocketManager;
13 |     private ArrayList<ClientConnection> clientConnections;
14 |     private final int PORT = 42087;
15 | 
16 |     public NetworkManager(EntityManager entityManager) {
17 |         this.entityManager = entityManager;
18 |         this.clientConnections = new ArrayList<>();
19 |     }
20 | 
21 |     public void createServer() {
22 |         this.serverSocketManager = new ServerSocketManager(this, PORT);
23 |         this.serverSocketManager.start();
24 |     }
25 | 
26 |     public void updateClients() {
27 |         for (ClientConnection clientConnection : clientConnections) {
28 |             for (ClientConnection clientConnection1 : clientConnections) {
29 |                 PacketSnake packetServerUpdate = new PacketSnake(clientConnection1.getClientSnake());
30 |                 clientConnection.writePacket(packetServerUpdate);
31 |             }
32 |         }
33 |     }
34 | 
35 |     public ArrayList<ClientConnection> getClientConnections() {
36 |         return clientConnections;
37 |     }
38 | 
39 |     public EntityManager getEntityManager() {
40 |         return entityManager;
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/me/braysen/goodwin/network/packet/PacketServerUpdate.java:
--------------------------------------------------------------------------------
 1 | package me.braysen.goodwin.network.packet;
 2 | 
 3 | import me.braysen.goodwin.game.entities.Entity;
 4 | import me.braysen.goodwin.game.entities.Snake;
 5 | 
 6 | import java.io.ObjectInputStream;
 7 | import java.io.ObjectOutputStream;
 8 | import java.util.ArrayList;
 9 | 
10 | public class PacketServerUpdate extends Packet {
11 | 
12 |     private Snake snake;
13 |     private ArrayList<Entity> entities;
14 | 
15 |     public PacketServerUpdate(Snake snake) {
16 |         super(PacketName.SERVER_UPDATE);
17 |         this.snake = snake;
18 |     }
19 | 
20 |     public PacketServerUpdate(ArrayList<Entity> entities) {
21 |         this((Snake) null);
22 |         this.entities = entities;
23 |     }
24 | 
25 |     @Override
26 |     public void writePacket(ObjectOutputStream objectOutputStream) throws Exception {
27 |         super.writePacket(objectOutputStream);
28 | 
29 | 
30 |         // Write Entities list size
31 |         objectOutputStream.writeInt(entities.size());
32 | 
33 |         // Write Entities
34 |         for (Entity entity : entities) {
35 |             objectOutputStream.writeObject(entity);
36 |         }
37 |     }
38 | 
39 |     @Override
40 |     public void readPacket(ObjectInputStream objectInputStream) throws Exception {
41 |         PacketSnake packetSnake = new PacketSnake(null);
42 |         packetSnake.readPacket(objectInputStream);
43 |         this.snake = packetSnake.getSnake();
44 |     }
45 | 
46 |     public Snake getSnake() {
47 |         return snake;
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/me/braysen/goodwin/game/entities/Snake.java:
--------------------------------------------------------------------------------
 1 | package me.braysen.goodwin.game.entities;
 2 | 
 3 | import java.awt.Color;
 4 | import java.awt.Point;
 5 | import java.io.Serializable;
 6 | import java.util.ArrayList;
 7 | import java.util.UUID;
 8 | 
 9 | public class Snake extends Entity implements Serializable {
10 | 
11 |     private static final long serialVersionUID = 1L;
12 | 
13 |     private Direction direction;
14 |     private ArrayList<Point> trail;
15 |     private Color color;
16 |     private int tailLength;
17 | 
18 |     public Snake(int x, int y, UUID uuid, Color color) {
19 |         super(uuid, x, y);
20 |         this.trail = new ArrayList<>();
21 |         this.color = color;
22 |     }
23 | 
24 |     public Direction getDirection() {
25 |         return direction;
26 |     }
27 | 
28 |     public void setDirection(Direction direction) {
29 |         this.direction = direction;
30 |     }
31 | 
32 |     public ArrayList<Point> getTrail() {
33 |         return trail;
34 |     }
35 | 
36 |     public void setTrail(ArrayList<Point> trail) {
37 |         this.trail = trail;
38 |     }
39 | 
40 |     public Color getColor() {
41 |         return color;
42 |     }
43 | 
44 |     public void setColor(Color color) {
45 |         this.color = color;
46 |     }
47 | 
48 |     public int getTailLength() {
49 |         return tailLength;
50 |     }
51 | 
52 |     public void setTailLength(int tailLength) {
53 |         this.tailLength = tailLength;
54 |     }
55 | 
56 |     public enum Direction implements Serializable {
57 |         NORTH,
58 |         SOUTH,
59 |         EAST,
60 |         WEST
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/org/hackusu/aisnakeserver/AISnakeServer.java:
--------------------------------------------------------------------------------
 1 | package org.hackusu.aisnakeserver;
 2 | 
 3 | import org.hackusu.aisnakeserver.manager.EntityManager;
 4 | import org.hackusu.aisnakeserver.server.NetworkManager;
 5 | 
 6 | import java.net.ServerSocket;
 7 | import java.net.Socket;
 8 | 
 9 | public class AISnakeServer {
10 | 
11 |     private NetworkManager networkManager;
12 |     private EntityManager entityManager;
13 | 
14 |     public static void main(String[] args) {
15 |         AISnakeServer aiSnakeServer = new AISnakeServer();
16 |         aiSnakeServer.start();
17 |     }
18 | 
19 |     public AISnakeServer() {
20 |         this.entityManager = new EntityManager();
21 |         this.networkManager = new NetworkManager(entityManager);
22 |     }
23 | 
24 |     private ServerSocket serverSocket;
25 |     private Socket socket;
26 | 
27 |     public void start() {
28 | //        new Thread() {
29 | //            @Override
30 | //            public void run() {
31 | //                try {
32 | //                    serverSocket = new ServerSocket(48839);
33 | //                    Socket socket = serverSocket.accept();
34 | //
35 | //                    ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
36 | //                    objectOutputStream.flush();
37 | //
38 | //
39 | //                    Food food = new Food(0, 0, UUID.randomUUID());
40 | //                    while (true) {
41 | //                        Thread.sleep(100);
42 | //                        int data = food.getX() + (int) (Math.random() * 100);
43 | //                        food.setX(data);
44 | //                        objectOutputStream.writeObject(food);
45 | //                        objectOutputStream.reset();
46 | //                        objectOutputStream.flush();
47 | //                    }
48 | //                } catch (Exception e) {
49 | //                    e.printStackTrace();
50 | //                }
51 | //            }
52 | //        }.start();
53 | //        new Thread() {
54 | //            @Override
55 | //            public void run() {
56 | //                try {
57 | //                    Socket socket = new Socket("127.0.0.1", 48839);
58 | //
59 | //                    ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
60 | //
61 | //                    while (true) {
62 | //                        Food food = (Food) objectInputStream.readObject();
63 | //                        System.out.println(food.getX());
64 | //                    }
65 | //                } catch (Exception e) {
66 | //                    e.printStackTrace();
67 | //                }
68 | //            }
69 | //        }.start();
70 | 
71 |         this.networkManager.createServer();
72 |         this.serverLoop();
73 |     }
74 | 
75 |     public void serverLoop() {
76 |         while (true) {
77 |             try {
78 |                 Thread.sleep(3000);
79 |             } catch (Exception e) {
80 |                 e.printStackTrace();
81 |             }
82 |             networkManager.updateClients();
83 |         }
84 |     }
85 | 
86 | }
87 | 


--------------------------------------------------------------------------------
/src/org/hackusu/aisnakeserver/server/ClientConnection.java:
--------------------------------------------------------------------------------
 1 | package org.hackusu.aisnakeserver.server;
 2 | 
 3 | import me.braysen.goodwin.game.entities.Entity;
 4 | import me.braysen.goodwin.game.entities.Snake;
 5 | import me.braysen.goodwin.network.packet.Packet;
 6 | import me.braysen.goodwin.network.packet.PacketSnake;
 7 | 
 8 | import java.io.DataInputStream;
 9 | import java.io.DataOutputStream;
10 | import java.io.ObjectInputStream;
11 | import java.io.ObjectOutputStream;
12 | import java.net.Socket;
13 | import java.util.ArrayList;
14 | 
15 | public class ClientConnection extends Thread {
16 | 
17 |     private NetworkManager networkManager;
18 |     private ArrayList<Entity> entities;
19 |     private Socket socket;
20 |     private DataInputStream dataInputStream;
21 |     private DataOutputStream dataOutputStream;
22 |     private Snake clientSnake;
23 | 
24 |     private ObjectOutputStream objectOutputStream;
25 |     private ObjectInputStream objectInputStream;
26 | 
27 |     public ClientConnection(NetworkManager networkManager, Socket socket) {
28 |         this.networkManager = networkManager;
29 |         this.socket = socket;
30 |         this.entities = networkManager.getEntityManager().getEntities();
31 |     }
32 | 
33 |     @Override
34 |     public void run() {
35 |         try {
36 |             this.dataOutputStream = new DataOutputStream(socket.getOutputStream());
37 |             this.dataInputStream = new DataInputStream(socket.getInputStream());
38 | 
39 |             this.objectOutputStream = new ObjectOutputStream(dataOutputStream);
40 |             this.objectInputStream = new ObjectInputStream(dataInputStream);
41 |             this.objectOutputStream.flush();
42 |         } catch (Exception e) {
43 |             e.printStackTrace();
44 |         }
45 | 
46 |         while (socket != null && !socket.isClosed() && socket.isConnected() && objectInputStream != null) {
47 |             try {
48 | //                PacketServerUpdate packetServerUpdate = new PacketServerUpdate(clientSnake);
49 | //                packetServerUpdate.readPacket(objectInputStream);
50 | //                this.clientSnake = packetServerUpdate.getSnake();
51 | //                for (int i = 0; i < entities.size(); i++) {
52 | //                    if (entities.get(i).getUUID().equals(clientSnake.getUUID())) {
53 | //                        entities.set(i, clientSnake);
54 | //                    }
55 | //                }
56 | 
57 |                 PacketSnake packetSnake = new PacketSnake(null);
58 |                 packetSnake.readPacket(objectInputStream);
59 | 
60 |                 if (!entities.contains(packetSnake.getSnake())) {
61 |                     entities.add(packetSnake.getSnake());
62 |                 } else {
63 |                     for (int i = 0; i < entities.size(); i++) {
64 |                         if (entities.get(i).getUUID().equals(packetSnake.getSnake().getUUID())) {
65 |                             entities.set(i, packetSnake.getSnake());
66 |                         }
67 |                     }
68 |                 }
69 |             } catch (Exception e) {
70 |                 e.printStackTrace();
71 |                 return;
72 |             }
73 |         }
74 |     }
75 | 
76 |     public void writePacket(Packet packet) {
77 |         try {
78 |             packet.writePacket(objectOutputStream);
79 |             objectOutputStream.reset();
80 |             objectOutputStream.flush();
81 |         } catch (Exception e) {
82 |             e.printStackTrace();
83 |         }
84 |     }
85 | 
86 |     public Snake getClientSnake() {
87 |         return clientSnake;
88 |     }
89 | }
90 | 


--------------------------------------------------------------------------------
/src/me/braysen/goodwin/network/packet/PacketSnake.java:
--------------------------------------------------------------------------------
  1 | package me.braysen.goodwin.network.packet;
  2 | 
  3 | import me.braysen.goodwin.game.entities.Snake;
  4 | 
  5 | import java.io.ObjectInputStream;
  6 | import java.io.ObjectOutputStream;
  7 | 
  8 | public class PacketSnake extends Packet {
  9 | 
 10 |     private Snake snake;
 11 | 
 12 |     public PacketSnake(Snake snake) {
 13 |         super(PacketName.SNAKE);
 14 |         this.snake = snake;
 15 |     }
 16 | 
 17 |     @Override
 18 |     public void writePacket(ObjectOutputStream objectOutputStream) throws Exception {
 19 |         super.writePacket(objectOutputStream);
 20 | 
 21 |         objectOutputStream.writeObject(snake);
 22 |     }
 23 | 
 24 |     @Override
 25 |     public void readPacket(ObjectInputStream objectInputStream) throws Exception {
 26 |         super.readPacket(objectInputStream);
 27 | 
 28 |         this.snake = (Snake) objectInputStream.readObject();
 29 |     }
 30 | 
 31 |     public Snake getSnake() {
 32 |         return snake;
 33 |     }
 34 | 
 35 |     //    public PacketSnake(ArrayList<Snake> snakes) {
 36 | //        this((Snake) null);
 37 | //        this.snakes = snakes;
 38 | //    }
 39 | //
 40 | //    @Override
 41 | //    public void writePacket(DataOutputStream dataOutputStream) throws IOException {
 42 | //        super.writePacket(dataOutputStream);
 43 | //
 44 | //        // Write UUID
 45 | //        UUID snakeUUID = snake.getUUID();
 46 | //        dataOutputStream.writeLong(snakeUUID.getMostSignificantBits());
 47 | //        dataOutputStream.writeLong(snakeUUID.getLeastSignificantBits());
 48 | //
 49 | //        // Write x y
 50 | //        dataOutputStream.writeInt(snake.getX());
 51 | //        dataOutputStream.writeInt(snake.getY());
 52 | //
 53 | //        // Write Direction
 54 | //        dataOutputStream.writeByte(snake.getDirection().getDataCode());
 55 | //
 56 | //        // Write Trail
 57 | //        ArrayList<Point> snakeTrail = snake.getTrail();
 58 | //
 59 | //        dataOutputStream.writeInt(snakeTrail.size()); // Write length of snake's x and y map.
 60 | //        for (Point point : snakeTrail) {
 61 | //            dataOutputStream.writeInt(point.x);
 62 | //            dataOutputStream.writeInt(point.y);
 63 | //        }
 64 | //    }
 65 | //
 66 | //    @Override
 67 | //    public void readPacket(DataInputStream dataInputStream) throws IOException {
 68 | //        super.readPacket(dataInputStream);
 69 | //
 70 | //        // Read UUID
 71 | //        long mostSigBits = dataInputStream.readLong();
 72 | //        long leastSigBits = dataInputStream.readLong();
 73 | //        UUID snakeUUID = new UUID(mostSigBits, leastSigBits);
 74 | //
 75 | //        for (Snake snake : snakes) {
 76 | //            if (snake.getUUID().equals(snakeUUID)) {
 77 | //                this.snake = snake;
 78 | //            }
 79 | //        }
 80 | //        if (snake == null) {
 81 | //            this.snake = new Snake(0, 0, snakeUUID);
 82 | //        }
 83 | //
 84 | //        // Read x y
 85 | //        snake.setX(dataInputStream.readInt());
 86 | //        snake.setY(dataInputStream.readInt());
 87 | //
 88 | //        // Read Direction
 89 | //        snake.setDirection(Snake.Direction.fromDataCode(dataInputStream.readByte()));
 90 | //
 91 | //        // Read Trail
 92 | //        ArrayList<Point> snakeTrail = new ArrayList<>();
 93 | //        this.snake.setTrail(snakeTrail);
 94 | //
 95 | //        int trailSize = dataInputStream.readByte(); // Read length of snake's x and y map.
 96 | //        for (int i = 0; i < trailSize; i++) {
 97 | //            int x = dataInputStream.readInt();
 98 | //            int y = dataInputStream.readInt();
 99 | //            snakeTrail.add(new Point(x, y));
100 | //        }
101 | //    }
102 | //
103 | //    public Snake getSnake() {
104 | //        return snake;
105 | //    }
106 | }
107 | 


--------------------------------------------------------------------------------