调整

pom.xml

@@ -33,6 +33,16 @@
 			<artifactId>spring-boot-starter-test</artifactId>
 			<scope>test</scope>
 		</dependency>
+		<dependency>
+			<groupId>io.netty</groupId>
+			<artifactId>netty-all</artifactId>
+			<version>4.1.76.Final</version>
+		</dependency>
+		<dependency>
+			<groupId>com.baomidou</groupId>
+			<artifactId>mybatis-plus-boot-starter</artifactId>
+			<version>3.5.2</version>
+		</dependency>
 	</dependencies>
 
 	<build>

src/main/java/com/example/tankbattle/Audio.java

@@ -57,12 +57,12 @@ public class Audio {
 
 	public void play() {
 		try {
-			byte[] b = new byte[1024 * 5];
+			byte[] b = new byte[1024*5];
 			int len = 0;
-			sourceDataLine.open(audioFormat, 1024 * 5);
+			sourceDataLine.open(audioFormat, 1024*5);
 			sourceDataLine.start();
-			System.out.println(audioInputStream.markSupported());
+			//System.out.println(audioInputStream.markSupported());
-			// audioInputStream.mark(12358946);
+			audioInputStream.mark(12358946);
 			while ((len = audioInputStream.read(b)) > 0) {
 				sourceDataLine.write(b, 0, len);
 			}

src/main/java/com/example/tankbattle/Bullet.java

@@ -1,7 +1,11 @@
 package com.example.tankbattle;
 
+import com.example.tankbattle.net.Client;
+import com.example.tankbattle.net.TankDieMessage;
+
 import java.awt.Graphics;
 import java.awt.Rectangle;
+import java.util.UUID;
 
 public class Bullet {
     private static final int SPEED = 6;
@@ -10,14 +14,53 @@ public class Bullet {
 
     private Rectangle rect = new Rectangle();
 
+    private UUID id = UUID.randomUUID();
+
+    private UUID playerId;
+
+    public UUID getPlayerId() {
+        return playerId;
+    }
+
+    public void setPlayerId(UUID playerId) {
+        this.playerId = playerId;
+    }
+
     private int x, y;
+
     private Dir dir;
 
     private boolean living = true;
+
+    public int getX() {
+        return x;
+    }
+
+    public void setX(int x) {
+        this.x = x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    public void setY(int y) {
+        this.y = y;
+    }
+
+    public Dir getDir() {
+        return dir;
+    }
+
+    public void setDir(Dir dir) {
+        this.dir = dir;
+    }
+
     TankFrame tf = null;
     private Group group = Group.BAD;
 
-    public Bullet(int x, int y, Dir dir, Group group, TankFrame tf) {
+    public Bullet(UUID playerId,int x, int y, Dir dir, Group group, TankFrame tf) {
+        this.playerId = playerId;
         this.x = x;
         this.y = y;
         this.dir = dir;
@@ -87,18 +130,34 @@ public class Bullet {
         if (x < 0 || y < 0 || x > TankFrame.GAME_WIDTH || y > TankFrame.GAME_HEIGHT) living = false;
     }
 
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
     public void collideWith(Tank tank){
-        if (this.group == tank.getGroup()) return;
+        if (this.playerId.equals(tank.getId())) {
-        if (this.rect.intersects(tank.rect)) {
+            return;
+        }
+        if (this.living && tank.isLiving() && this.rect.intersects(tank.rect)) {
             tank.die();
             this.die();
-            int eX = tank.getX() + Tank.WIDTH / 2 - Explode.WIDTH / 2;
+            Client.INSTANCE.send(new TankDieMessage(this.id, tank.getId()));
-            int eY = tank.getY() + Tank.HEIGHT / 2 - Explode.HEIGHT / 2;
-            tf.explodes.add(new Explode(eX, eY, tf));
         }
     }
 
-    private void die() {
+    public void die() {
         this.living = false;
     }
+
+    public boolean isLiving() {
+        return living;
+    }
+
+    public void setLiving(boolean living) {
+        this.living = living;
+    }
 }

src/main/java/com/example/tankbattle/Explode.java

@@ -1,6 +1,6 @@
 package com.example.tankbattle;
 
-import java.awt.*;
+import java.awt.Graphics;
 
 public class Explode {
     public static int WIDTH = ResourceMgr.explodes[0].getWidth();
@@ -8,22 +8,22 @@ public class Explode {
 
     private int x, y;
 
-    TankFrame tf = null;
-
     private int step = 0;
 
-    public Explode(int x, int y, TankFrame tf) {
+    public Explode(int x, int y) {
         this.x = x;
         this.y = y;
-        this.tf = tf;
+
+        new Thread(()->new Audio("audio/explode.wav").play()).start();
     }
 
     public void paint(Graphics g) {
 
         g.drawImage(ResourceMgr.explodes[step++], x, y, null);
 
-        if (step >= ResourceMgr.explodes.length)
+        if (step >= ResourceMgr.explodes.length) {
-            tf.explodes.remove(this);
+            TankFrame.INSTANCE.explodes.remove(this);
+        }
 
     }
 }

src/main/java/com/example/tankbattle/Main.java

@@ -1,19 +1,31 @@
 package com.example.tankbattle;
 
+import com.example.tankbattle.net.Client;
+
 public class Main {
     public static void main(String[] args) throws InterruptedException {
-        TankFrame tf = new TankFrame();
+        TankFrame tf = TankFrame.INSTANCE;
+        tf.setVisible(true);
 
-        int initTankCount = Integer.valueOf(PropertyMgr.get("initTankCount"));
+//        int initTankCount = Integer.valueOf(PropertyMgr.get("initTankCount"));
+//
+//        // 初始化敌方坦克
+//        for (int i = 0; i < initTankCount; i++) {
+//            tf.tanks.add(new Tank(50 + i * 80, 200, Dir.DOWN, Group.BAD, tf));
+//        }
 
-        // 初始化敌方坦克
+        new Thread(() -> new Audio("audio/war1.wav").loop()).start();
-        for (int i = 0; i < initTankCount; i++) {
+        new Thread(() -> {
-            tf.tanks.add(new Tank(50 + i * 80, 200, Dir.DOWN, Group.BAD, tf));
+            while (true) {
-        }
+                try {
+                    Thread.sleep(25);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                tf.repaint();
+            }
+        }).start();
 
-        while (true) {
+        Client.INSTANCE.connect();
-            Thread.sleep(50);
-            tf.repaint();
-        }
     }
 }

src/main/java/com/example/tankbattle/Tank.java

@@ -1,14 +1,22 @@
 package com.example.tankbattle;
 
-import java.awt.*;
+import com.example.tankbattle.net.BulletNewMessage;
+import com.example.tankbattle.net.Client;
+import com.example.tankbattle.net.TankJoinMessage;
+
+import java.awt.Color;
+import java.awt.Graphics;
+import java.awt.Rectangle;
 import java.util.Random;
+import java.util.UUID;
 
 public class Tank {
-    private static final int SPEED = 1;
+    private static final int SPEED = 2;
 
     public static int WIDTH = ResourceMgr.GoodTankD.getWidth();
     public static int HEIGHT = ResourceMgr.GoodTankD.getHeight();
 
+    private UUID id = UUID.randomUUID();
     Rectangle rect = new Rectangle();
 
     private Random random = new Random();
@@ -17,7 +25,7 @@ public class Tank {
 
     private Dir dir = Dir.DOWN;
 
-    private boolean moving = true;
+    private boolean moving = false;
 
     private TankFrame tf = null;
 
@@ -25,6 +33,28 @@ public class Tank {
 
     private Group group = Group.BAD;
 
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    public Tank(TankJoinMessage message) {
+        this.x = message.x;
+        this.y = message.y;
+        this.dir = message.dir;
+        this.moving = message.moving;
+        this.group = message.group;
+        this.id = message.id;
+
+        rect.x = this.x;
+        rect.y = this.y;
+        rect.width = WIDTH;
+        rect.height = HEIGHT;
+    }
+
     public Tank(int x, int y, Dir dir, Group group, TankFrame tf) {
         super();
         this.x = x;
@@ -42,7 +72,12 @@ public class Tank {
     public void fire(){
         int bX = this.x + Tank.WIDTH / 2 - Bullet.WIDTH / 2;
         int bY = this.y + Tank.HEIGHT / 2 - Bullet.HEIGHT / 2;
-        tf.bullets.add(new Bullet(bX, bY, this.dir, this.group, this.tf));
+        Bullet bullet = new Bullet(this.id, bX, bY, this.dir, this.group, this.tf);
+        tf.bullets.add(bullet);
+        Client.INSTANCE.send(new BulletNewMessage(bullet));
+        if (this.group == Group.GOOD) {
+            new Thread(() -> new Audio("audio/tank_fire.wav").play()).start();
+        }
     }
 
     public Dir getDir() {
@@ -70,6 +105,7 @@ public class Tank {
     }
 
     private void move() {
+        if (!living) return;
         if (!moving) return;
         switch (dir) {
             case LEFT:
@@ -88,30 +124,33 @@ public class Tank {
                 break;
         }
 
-        rect.x = this.x;
+
-        rect.y = this.y;
+        if (this.group == Group.BAD && random.nextInt(100) > 95) {
-        if (this.group == Group.BAD && random.nextInt(100) > 95) this.fire();
+            this.fire();
+        }
 
         if (this.group == Group.BAD && random.nextInt(100) > 95) {
             randomDir();
         }
 
         boundsCheck();
+        rect.x = this.x;
+        rect.y = this.y;
     }
 
     private void boundsCheck() {
-        if (this.x < 0) {
+        if (this.x < 2) {
             this.x = 2;
         }
         if (this.y < 28) {
             this.y = 28;
         }
 
-        if (this.x > TankFrame.GAME_WIDTH - Tank.WIDTH) {
+        if (this.x > TankFrame.GAME_WIDTH - Tank.WIDTH - 2) {
-            this.x = TankFrame.GAME_WIDTH - Tank.WIDTH;
+            this.x = TankFrame.GAME_WIDTH - Tank.WIDTH - 2;
         }
-        if (this.y > TankFrame.GAME_HEIGHT - Tank.HEIGHT) {
+        if (this.y > TankFrame.GAME_HEIGHT - Tank.HEIGHT - 2) {
-            this.y = TankFrame.GAME_HEIGHT - Tank.HEIGHT;
+            this.y = TankFrame.GAME_HEIGHT - Tank.HEIGHT - 2;
         }
     }
 
@@ -120,7 +159,23 @@ public class Tank {
     }
 
     public void paint(Graphics g) {
-        if (!living) tf.tanks.remove(this);
+//        if (!living) {
+//            tf.tanks.remove(this);
+//        }
+        Color color = g.getColor();
+        g.setColor(Color.YELLOW);
+        g.drawString(id.toString(), this.x, this.y - 20);
+        g.drawString("live=" + living, x, y - 10);
+        g.setColor(color);
+
+        if (!living) {
+            moving = false;
+            Color colorc = g.getColor();
+            g.setColor(Color.WHITE);
+            g.drawRect(x, y, WIDTH, HEIGHT);
+            g.setColor(colorc);
+            return;
+        }
         switch (dir) {
             case LEFT:
                 g.drawImage(this.group == Group.GOOD ? ResourceMgr.GoodTankL : ResourceMgr.BadTankL, x, y, null);
@@ -152,11 +207,24 @@ public class Tank {
         this.x = x;
     }
 
+    public boolean isLiving() {
+        return living;
+    }
+
+    public void setLiving(boolean living) {
+        this.living = living;
+    }
+
     public void setY(int y) {
         this.y = y;
     }
 
     public void die() {
         this.living = false;
+        int eX = this.getX() + Tank.WIDTH / 2 - Explode.WIDTH / 2;
+        int eY = this.getY() + Tank.HEIGHT / 2 - Explode.HEIGHT / 2;
+        TankFrame.INSTANCE.explodes.add(new Explode(eX, eY));
     }
+
+
 }

src/main/java/com/example/tankbattle/TankFrame.java

@@ -1,5 +1,10 @@
 package com.example.tankbattle;
 
+import com.example.tankbattle.net.Client;
+import com.example.tankbattle.net.TankDirChangedMessage;
+import com.example.tankbattle.net.TankStartMovingMessage;
+import com.example.tankbattle.net.TankStopMessage;
+
 import java.awt.Color;
 import java.awt.Frame;
 import java.awt.Graphics;
@@ -9,25 +14,54 @@ import java.awt.event.KeyEvent;
 import java.awt.event.WindowAdapter;
 import java.awt.event.WindowEvent;
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.UUID;
 
 public class TankFrame extends Frame {
 
-    Tank myTank = new Tank(200, 400, Dir.DOWN, Group.GOOD, this);
+    public static final TankFrame INSTANCE = new TankFrame();
+
+    Random random = new Random();
+
+    Tank myTank = new Tank(random.nextInt(GAME_WIDTH), random.nextInt(GAME_HEIGHT), Dir.DOWN, Group.GOOD, this);
 
     List<Bullet> bullets = new ArrayList<>();
-    List<Tank> tanks = new ArrayList<>();
+    Map<UUID, Tank> tanks = new HashMap<>();
     List<Explode> explodes = new ArrayList<>();
 
 
     static final int GAME_WIDTH = Integer.valueOf(PropertyMgr.get("gameWidth"));
     static final int GAME_HEIGHT = Integer.valueOf(PropertyMgr.get("gameHeight"));
 
-	public TankFrame() {
+    public void addBullet(Bullet bullet) {
+        bullets.add(bullet);
+    }
+
+    public void addTank(Tank tank) {
+        tanks.put(tank.getId(), tank);
+    }
+
+    public Tank findTankByUUID(UUID id){
+        return tanks.get(id);
+    }
+
+    public Bullet findBulletByUUID(UUID id) {
+        for (int i = 0; i < bullets.size(); i++) {
+            if (bullets.get(i).getId().equals(id)) {
+                return bullets.get(i);
+            }
+        }
+        return null;
+    }
+
+	private TankFrame() {
         setSize(GAME_WIDTH, GAME_HEIGHT);
         setResizable(false);
         setTitle("tank battle");
-        setVisible(true);
         this.addKeyListener(new MyKeyListener());
         addWindowListener(new WindowAdapter() {
             @Override
@@ -66,19 +100,17 @@ public class TankFrame extends Frame {
             bullets.get(i).paint(g);
         }
 
-        for (int i = 0; i < tanks.size(); i++) {
+        tanks.values().stream().forEach((e) -> e.paint(g));
-            tanks.get(i).paint(g);
-        }
 
         for (int i = 0; i < explodes.size(); i++) {
             explodes.get(i).paint(g);
         }
-
+        Collection<Tank> values = tanks.values();
         for (int i = 0; i < bullets.size(); i++) {
-            for (int j = 0; j < tanks.size(); j++)
+            for (Tank value : values) {
-                bullets.get(i).collideWith(tanks.get(j));
+                bullets.get(i).collideWith(value);
+            }
         }
-
 //        for (Iterator<Bullet> it = bullets.iterator(); it.hasNext()) {
 //            Bullet b = it.next();
 //            if (!b.live) it.remove();
@@ -99,21 +131,24 @@ public class TankFrame extends Frame {
             switch (key) {
                 case KeyEvent.VK_LEFT:
                     bL = true;
+                    setMainTankDir();
                     break;
                 case KeyEvent.VK_UP:
                     bU = true;
+                    setMainTankDir();
                     break;
                 case KeyEvent.VK_RIGHT:
                     bR = true;
+                    setMainTankDir();
                     break;
                 case KeyEvent.VK_DOWN:
                     bD = true;
+                    setMainTankDir();
                     break;
                 default:
                     break;
             }
-
+            new Thread(()->new Audio("audio/tank_move.wav").play()).start();
-            setMainTankDir();
         }
 
         @Override
@@ -122,15 +157,19 @@ public class TankFrame extends Frame {
             switch (key) {
                 case KeyEvent.VK_LEFT:
                     bL = false;
+                    setMainTankDir();
                     break;
                 case KeyEvent.VK_UP:
                     bU = false;
+                    setMainTankDir();
                     break;
                 case KeyEvent.VK_RIGHT:
                     bR = false;
+                    setMainTankDir();
                     break;
                 case KeyEvent.VK_DOWN:
                     bD = false;
+                    setMainTankDir();
                     break;
                 case KeyEvent.VK_CONTROL:
                     myTank.fire();
@@ -138,23 +177,44 @@ public class TankFrame extends Frame {
                 default:
                     break;
             }
-
-            setMainTankDir();
         }
 
         private void setMainTankDir() {
 
+            Dir dir = myTank.getDir();
+
             if (!bL && !bU && !bR && !bD) {
                 myTank.setMoving(false);
+                Client.INSTANCE.send(new TankStopMessage(getMainTank()));
             } else {
+                if (bL) {
+                    myTank.setDir(Dir.LEFT);
+                }
+                if (bU) {
+                    myTank.setDir(Dir.UP);
+                }
+                if (bR) {
+                    myTank.setDir(Dir.RIGHT);
+                }
+                if (bD) {
+                    myTank.setDir(Dir.DOWN);
+                }
+                if (!myTank.isMoving()) {
+                    Client.INSTANCE.send(new TankStartMovingMessage(getMainTank()));
+                }
+
                 myTank.setMoving(true);
-                if (bL) myTank.setDir(Dir.LEFT);
+                if (dir != myTank.getDir()) {
-                if (bU) myTank.setDir(Dir.UP);
+                    Client.INSTANCE.send(new TankDirChangedMessage(myTank));
-                if (bR) myTank.setDir(Dir.RIGHT);
+                }
-                if (bD) myTank.setDir(Dir.DOWN);
             }
         }
     }
+
+    public Tank getMainTank() {
+        return this.myTank;
+    }
+
 }
 
 

src/main/java/com/example/tankbattle/net/BulletNewMessage.java

@@ -0,0 +1,96 @@
+package com.example.tankbattle.net;
+
+import com.example.tankbattle.Bullet;
+import com.example.tankbattle.Dir;
+import com.example.tankbattle.Group;
+import com.example.tankbattle.TankFrame;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.UUID;
+
+public class BulletNewMessage extends Message {
+    UUID playerID;
+    UUID id;
+    int x, y;
+    Dir dir;
+    Group group;
+
+    public BulletNewMessage() {
+    }
+
+    public BulletNewMessage(Bullet bullet) {
+        this.playerID = bullet.getPlayerId();
+        this.id = bullet.getId();
+        this.x = bullet.getX();
+        this.y = bullet.getY();
+        this.dir = bullet.getDir();
+        this.group = bullet.getGroup();
+    }
+
+    @Override
+    public void handle() {
+        if (this.playerID.equals(TankFrame.INSTANCE.getMainTank().getId())) {
+            return;
+        }
+        Bullet bullet = new Bullet(this.playerID, x, y, dir, group, TankFrame.INSTANCE);
+        bullet.setId(this.id);
+        TankFrame.INSTANCE.addBullet(bullet);
+    }
+
+    @Override
+    public byte[] toBytes() {
+        byte[] bytes = null;
+        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
+             DataOutputStream dos = new DataOutputStream(baos)) {
+            dos.writeLong(this.playerID.getMostSignificantBits());
+            dos.writeLong(this.playerID.getLeastSignificantBits());
+            dos.writeLong(id.getMostSignificantBits());
+            dos.writeLong(id.getLeastSignificantBits());
+            dos.writeInt(x);
+            dos.writeInt(y);
+            dos.writeInt(dir.ordinal());
+            dos.writeInt(group.ordinal());
+            dos.flush();
+            bytes = baos.toByteArray();
+        } catch (Exception exception) {
+            exception.printStackTrace();
+        }
+        return bytes;
+    }
+
+    @Override
+    public void parse(byte[] bytes) {
+        try (DataInputStream dis = new DataInputStream(new ByteArrayInputStream(bytes))) {
+            this.playerID = new UUID(dis.readLong(), dis.readLong());
+            this.id = new UUID(dis.readLong(), dis.readLong());
+
+            this.x = dis.readInt();
+            this.y = dis.readInt();
+            this.dir = Dir.values()[dis.readInt()];
+            this.group = Group.values()[dis.readInt()];
+        } catch (IOException exception) {
+            exception.printStackTrace();
+        }
+    }
+
+    @Override
+    public MessageType getMessageType() {
+        return MessageType.BulletNew;
+    }
+
+    @Override
+    public String toString() {
+        return "BulletNewMessage{" +
+                "playerID=" + playerID +
+                ", id=" + id +
+                ", x=" + x +
+                ", y=" + y +
+                ", dir=" + dir +
+                ", group=" + group +
+                '}';
+    }
+}

src/main/java/com/example/tankbattle/net/Client.java

@@ -0,0 +1,53 @@
+package com.example.tankbattle.net;
+
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.nio.NioSocketChannel;
+
+public class Client {
+    public static final Client INSTANCE = new Client();
+
+    private Client() {
+    }
+
+    private Channel channel;
+    public void connect() {
+        EventLoopGroup group = new NioEventLoopGroup(1);
+        Bootstrap bootstrap = new Bootstrap();
+
+        try {
+            ChannelFuture channelFuture = bootstrap.group(group).channel(NioSocketChannel.class).handler(new ClientChannelInitializer())
+                    .connect("localhost", 8888);
+            channelFuture.addListener(new ChannelFutureListener() {
+                @Override
+                public void operationComplete(ChannelFuture future) throws Exception {
+                    if (!future.isSuccess()) {
+                        System.out.println("not connected");
+                    } else {
+                        System.out.println("connected");
+                        channel = future.channel();
+                    }
+                }
+            });
+            channelFuture.sync();
+            channelFuture.channel().closeFuture().sync();
+            System.out.println("connection closed");
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } finally {
+            group.shutdownGracefully();
+        }
+    }
+
+    public void send(Message message) {
+        System.out.println("send " + message.toString());
+        channel.writeAndFlush(message);
+    }
+
+    public void closeConnect(){
+    }
+}

src/main/java/com/example/tankbattle/net/ClientChannelInitializer.java

@@ -0,0 +1,15 @@
+package com.example.tankbattle.net;
+
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.socket.SocketChannel;
+
+public class ClientChannelInitializer extends ChannelInitializer<SocketChannel> {
+
+    @Override
+    protected void initChannel(SocketChannel socketChannel) throws Exception {
+        socketChannel.pipeline()
+                .addLast(new MessageEncoder())
+                .addLast(new MessageDecoder())
+                .addLast(new ClientHandler());
+    }
+}

src/main/java/com/example/tankbattle/net/ClientHandler.java

@@ -0,0 +1,18 @@
+package com.example.tankbattle.net;
+
+import com.example.tankbattle.TankFrame;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+
+public class ClientHandler extends SimpleChannelInboundHandler<Message> {
+    @Override
+    public void channelRead0(ChannelHandlerContext ctx, Message msg) throws Exception {
+        System.out.println(msg);
+        msg.handle();
+    }
+
+    @Override
+    public void channelActive(ChannelHandlerContext ctx) throws Exception {
+        ctx.writeAndFlush(new TankJoinMessage(TankFrame.INSTANCE.getMainTank()));
+    }
+}

src/main/java/com/example/tankbattle/net/Message.java

@@ -0,0 +1,8 @@
+package com.example.tankbattle.net;
+
+public abstract class Message {
+    public abstract void handle();
+    public abstract byte[] toBytes();
+    public abstract void parse(byte[] bytes);
+    public abstract MessageType getMessageType();
+}

src/main/java/com/example/tankbattle/net/MessageDecoder.java

@@ -0,0 +1,30 @@
+package com.example.tankbattle.net;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+
+import java.util.List;
+
+public class MessageDecoder extends ByteToMessageDecoder {
+    @Override
+    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
+        if (in.readableBytes() < 8) {
+            return;
+        }
+        in.markReaderIndex();
+        MessageType messageType = MessageType.values()[in.readInt()];
+        int length = in.readInt();
+        if (in.readableBytes() < length) {
+            in.resetReaderIndex();
+            return;
+        }
+
+        byte[] bytes = new byte[length];
+        in.readBytes(bytes);
+
+        Message message = (Message) Class.forName("com.example.tankbattle.net." + messageType.toString() + "Message").getDeclaredConstructor().newInstance();
+        message.parse(bytes);
+        out.add(message);
+    }
+}

src/main/java/com/example/tankbattle/net/MessageEncoder.java

@@ -0,0 +1,16 @@
+package com.example.tankbattle.net;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToByteEncoder;
+
+public class MessageEncoder extends MessageToByteEncoder<Message> {
+
+    @Override
+    protected void encode(ChannelHandlerContext ctx, Message msg, ByteBuf out) throws Exception {
+        out.writeInt(msg.getMessageType().ordinal());
+        byte[] data = msg.toBytes();
+        out.writeInt(data.length);
+        out.writeBytes(data);
+    }
+}

src/main/java/com/example/tankbattle/net/MessageType.java

@@ -0,0 +1,5 @@
+package com.example.tankbattle.net;
+
+public enum MessageType {
+    TankJoin, TankDirChanged, TankStop, TankStartMoving, BulletNew, TankDie,
+}

src/main/java/com/example/tankbattle/net/Server.java

@@ -0,0 +1,44 @@
+package com.example.tankbattle.net;
+
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.ChannelPipeline;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.group.ChannelGroup;
+import io.netty.channel.group.DefaultChannelGroup;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.util.concurrent.GlobalEventExecutor;
+
+public class Server {
+    public static ChannelGroup clients = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
+
+    public void serverStart() {
+        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
+        EventLoopGroup workerGroup = new NioEventLoopGroup(2);
+        try {
+            ServerBootstrap bootstrap = new ServerBootstrap();
+            ChannelFuture channelFuture = bootstrap.group(bossGroup, workerGroup)
+                    .channel(NioServerSocketChannel.class)
+                    .childHandler(new ChannelInitializer<SocketChannel>() {
+                        @Override
+                        protected void initChannel(SocketChannel ch) throws Exception {
+                            ChannelPipeline channelPipeline = ch.pipeline();
+                            channelPipeline.addLast(new MessageEncoder())
+                                    .addLast(new MessageDecoder())
+                                    .addLast(new ServerChildHandler());
+                        }
+                    }).bind(8888).sync();
+
+            ServerFrame.INSTANCE.updateServerMessage("server started!");
+            channelFuture.channel().closeFuture().sync();
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            workerGroup.shutdownGracefully();
+            bossGroup.shutdownGracefully();
+        }
+    }
+}

src/main/java/com/example/tankbattle/net/ServerChildHandler.java

@@ -0,0 +1,48 @@
+package com.example.tankbattle.net;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+
+public class ServerChildHandler extends ChannelInboundHandlerAdapter {
+
+    @Override
+    public void channelActive(ChannelHandlerContext ctx) throws Exception {
+        Server.clients.add(ctx.channel());
+    }
+
+    @Override
+    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+        ServerFrame.INSTANCE.updateClientMessage(msg.toString());
+        Server.clients.writeAndFlush(msg);
+
+		/*ByteBuf buf = null;
+		try {
+			buf = (ByteBuf)msg;
+
+			byte[] bytes = new byte[buf.readableBytes()];
+			buf.getBytes(buf.readerIndex(), bytes);
+			String s = new String(bytes);
+
+			if(s.equals("_bye_")) {
+				System.out.println("<22>ͻ<EFBFBD><CDBB><EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD>˳<EFBFBD>");
+				Server.clients.remove(ctx.channel());
+				ctx.close();
+			} else {
+				Server.clients.writeAndFlush(msg);
+			}*/
+
+        //System.out.println(buf);
+        //System.out.println(buf.refCnt());
+		/*} finally {
+			//if(buf != null && buf) ReferenceCountUtil.release(buf);
+			//System.out.println(buf.refCnt());
+		}*/
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+        cause.printStackTrace();
+        Server.clients.remove(ctx.channel());
+        ctx.close();
+    }
+}

src/main/java/com/example/tankbattle/net/ServerFrame.java

@@ -0,0 +1,51 @@
+package com.example.tankbattle.net;
+
+import java.awt.BorderLayout;
+import java.awt.Button;
+import java.awt.Font;
+import java.awt.Frame;
+import java.awt.GridLayout;
+import java.awt.Panel;
+import java.awt.TextArea;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+
+public class ServerFrame extends Frame {
+    public static final ServerFrame INSTANCE = new ServerFrame();
+    Button btnStart = new Button("start");
+    TextArea textLeft = new TextArea();
+    TextArea textRight = new TextArea();
+    Server server = new Server();
+
+    public ServerFrame() {
+        this.setSize(1600, 600);
+        this.setLocation(300, 30);
+        this.add(btnStart, BorderLayout.NORTH);
+        Panel panel = new Panel(new GridLayout(1, 2));
+        panel.add(textLeft);
+        panel.add(textRight);
+        this.add(panel);
+        textLeft.setFont(new Font("verderna", Font.PLAIN, 25));
+
+        this.addWindowListener(new WindowAdapter() {
+            @Override
+            public void windowClosing(WindowEvent e) {
+                System.exit(0);
+            }
+        });
+    }
+
+    public static void main(String[] args) {
+        ServerFrame.INSTANCE.setVisible(true);
+        ServerFrame.INSTANCE.server.serverStart();
+    }
+
+    public void updateServerMessage(String message) {
+        this.textLeft.setText(textLeft.getText() + message + System.lineSeparator());
+    }
+
+    public void updateClientMessage(String message) {
+        this.textRight.setText(textRight.getText() + message + System.lineSeparator());
+
+    }
+}

src/main/java/com/example/tankbattle/net/TankDieMessage.java

@@ -0,0 +1,96 @@
+package com.example.tankbattle.net;
+
+import com.example.tankbattle.Bullet;
+import com.example.tankbattle.Tank;
+import com.example.tankbattle.TankFrame;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.UUID;
+
+public class TankDieMessage extends Message{
+
+    UUID bulletId;
+    UUID id;
+
+    public TankDieMessage() {
+    }
+
+    public TankDieMessage(UUID playerId, UUID id) {
+        this.bulletId = playerId;
+        this.id = id;
+    }
+
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    @Override
+    public void handle() {
+        System.out.println("we got a tank die: " + id);
+        System.out.println("and my tank is: " + TankFrame.INSTANCE.getMainTank().getId());
+        Tank tank = TankFrame.INSTANCE.findTankByUUID(id);
+        System.out.println("i found a tank with this id: " + tank);
+
+        Bullet bullet = TankFrame.INSTANCE.findBulletByUUID(bulletId);
+        if (bullet != null) {
+            bullet.die();
+        }
+        if (this.id.equals(TankFrame.INSTANCE.getMainTank().getId())) {
+            TankFrame.INSTANCE.getMainTank().die();
+        } else {
+            Tank tanka = TankFrame.INSTANCE.findTankByUUID(id);
+            if (tanka != null) {
+                tanka.die();
+            }
+        }
+    }
+
+    @Override
+    public byte[] toBytes() {
+        byte[] bytes = null;
+        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
+             DataOutputStream dos = new DataOutputStream(baos)) {
+            dos.writeLong(bulletId.getMostSignificantBits());
+            dos.writeLong(bulletId.getLeastSignificantBits());
+            dos.writeLong(id.getMostSignificantBits());
+            dos.writeLong(id.getLeastSignificantBits());
+            dos.flush();
+            bytes = baos.toByteArray();
+
+        } catch (Exception exception) {
+            exception.printStackTrace();
+        }
+        return bytes;
+    }
+
+    @Override
+    public void parse(byte[] bytes) {
+        try (DataInputStream dis = new DataInputStream(new ByteArrayInputStream(bytes))) {
+            this.bulletId = new UUID(dis.readLong(), dis.readLong());
+            this.id = new UUID(dis.readLong(), dis.readLong());
+        } catch (IOException exception) {
+            exception.printStackTrace();
+        }
+    }
+
+    @Override
+    public MessageType getMessageType() {
+        return MessageType.TankDie;
+    }
+
+    @Override
+    public String toString() {
+        return "TankDieMessage{" +
+                "bulletId=" + bulletId +
+                ", id=" + id +
+                '}';
+    }
+}

src/main/java/com/example/tankbattle/net/TankDirChangedMessage.java

@@ -0,0 +1,132 @@
+package com.example.tankbattle.net;
+
+import com.example.tankbattle.Dir;
+import com.example.tankbattle.Tank;
+import com.example.tankbattle.TankFrame;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.UUID;
+
+public class TankDirChangedMessage extends Message{
+
+    UUID id;
+
+    Dir dir;
+
+    int x, y;
+
+    public TankDirChangedMessage() {
+    }
+
+    public TankDirChangedMessage(UUID id, int x, int y , Dir dir) {
+        super();
+        this.id = id;
+        this.x = x;
+        this.y = y;
+        this.dir = dir;
+    }
+
+    public TankDirChangedMessage(Tank tank) {
+        this.id = tank.getId();
+        this.dir = tank.getDir();
+        this.x = tank.getX();
+        this.y = tank.getY();
+    }
+
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public void setX(int x) {
+        this.x = x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    public void setY(int y) {
+        this.y = y;
+    }
+
+    public Dir getDir() {
+        return dir;
+    }
+
+    public void setDir(Dir dir) {
+        this.dir = dir;
+    }
+
+    @Override
+    public void handle() {
+        if (this.id.equals(TankFrame.INSTANCE.getMainTank().getId())) {
+            return;
+        }
+        Tank tank = TankFrame.INSTANCE.findTankByUUID(this.id);
+        if (tank != null) {
+            tank.setMoving(true);
+            tank.setX(this.x);
+            tank.setY(this.y);
+            tank.setDir(this.dir);
+        }
+    }
+
+    @Override
+    public byte[] toBytes() {
+        byte[] bytes = null;
+        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
+             DataOutputStream dos = new DataOutputStream(baos)) {
+            dos.writeLong(id.getMostSignificantBits());
+            dos.writeLong(id.getLeastSignificantBits());
+            dos.writeInt(x);
+            dos.writeInt(y);
+            dos.writeInt(dir.ordinal());
+            dos.flush();
+            bytes = baos.toByteArray();
+
+        } catch (Exception exception) {
+            exception.printStackTrace();
+        }
+        return bytes;
+    }
+
+    @Override
+    public void parse(byte[] bytes) {
+        try (DataInputStream dis = new DataInputStream(new ByteArrayInputStream(bytes))) {
+            this.id = new UUID(dis.readLong(), dis.readLong());
+
+            this.x = dis.readInt();
+            this.y = dis.readInt();
+            this.dir = Dir.values()[dis.readInt()];
+        } catch (IOException exception) {
+            exception.printStackTrace();
+        }
+    }
+
+    @Override
+    public MessageType getMessageType() {
+        return MessageType.TankDirChanged;
+    }
+
+    @Override
+    public String toString() {
+        return "TankDirChangedMessage{" +
+                "id=" + id +
+                ", dir=" + dir +
+                ", x=" + x +
+                ", y=" + y +
+                '}';
+    }
+}

src/main/java/com/example/tankbattle/net/TankJoinMessage.java

@@ -0,0 +1,109 @@
+package com.example.tankbattle.net;
+
+import com.example.tankbattle.Dir;
+import com.example.tankbattle.Group;
+import com.example.tankbattle.Tank;
+import com.example.tankbattle.TankFrame;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.UUID;
+
+public class TankJoinMessage extends Message{
+    public int x;
+    public int y;
+    public Dir dir;
+    public boolean moving;
+    public Group group;
+    public UUID id;
+
+    public TankJoinMessage() {
+    }
+
+    public TankJoinMessage(int x, int y, Dir dir, boolean moving, Group group, UUID id) {
+        super();
+        this.x = x;
+        this.y = y;
+        this.dir = dir;
+        this.moving = moving;
+        this.group = group;
+        this.id = id;
+    }
+
+    public TankJoinMessage(Tank tank) {
+        this.x = tank.getX();
+        this.y = tank.getY();
+        this.dir = tank.getDir();
+        this.group = tank.getGroup();
+        this.moving = tank.isMoving();
+        this.id = tank.getId();
+    }
+
+    @Override
+    public void parse(byte[] bytes) {
+        try (DataInputStream dis = new DataInputStream(new ByteArrayInputStream(bytes))) {
+
+            this.x = dis.readInt();
+            this.y = dis.readInt();
+            this.dir = Dir.values()[dis.readInt()];
+            this.moving = dis.readBoolean();
+            this.group = Group.values()[dis.readInt()];
+            this.id = new UUID(dis.readLong(), dis.readLong());
+        } catch (IOException exception) {
+            exception.printStackTrace();
+        }
+    }
+
+    @Override
+    public byte[] toBytes() {
+
+        byte[] bytes = null;
+        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
+             DataOutputStream dos = new DataOutputStream(baos)) {
+            dos.writeInt(x);
+            dos.writeInt(y);
+            dos.writeInt(dir.ordinal());
+            dos.writeBoolean(moving);
+            dos.writeInt(group.ordinal());
+            dos.writeLong(id.getMostSignificantBits());
+            dos.writeLong(id.getLeastSignificantBits());
+            dos.flush();
+            bytes = baos.toByteArray();
+
+        } catch (Exception exception) {
+            exception.printStackTrace();
+        }
+        return bytes;
+    }
+
+    @Override
+    public void handle() {
+        if (this.id.equals(TankFrame.INSTANCE.getMainTank().getId()) ||
+                TankFrame.INSTANCE.findTankByUUID(this.id) != null) {
+            return;
+        }
+        Tank tank = new Tank(this);
+        TankFrame.INSTANCE.addTank(tank);
+        Client.INSTANCE.send(new TankJoinMessage(TankFrame.INSTANCE.getMainTank()));
+    }
+
+    @Override
+    public MessageType getMessageType() {
+        return MessageType.TankJoin;
+    }
+
+    @Override
+    public String toString() {
+        return "TankJoinMessage{" +
+                "x=" + x +
+                ", y=" + y +
+                ", dir=" + dir +
+                ", moving=" + moving +
+                ", group=" + group +
+                ", id=" + id +
+                '}';
+    }
+}

src/main/java/com/example/tankbattle/net/TankStartMovingMessage.java

@@ -0,0 +1,131 @@
+package com.example.tankbattle.net;
+
+import com.example.tankbattle.Dir;
+import com.example.tankbattle.Tank;
+import com.example.tankbattle.TankFrame;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.UUID;
+
+public class TankStartMovingMessage extends Message{
+
+    UUID id;
+
+    int x, y;
+
+    Dir dir;
+
+    public TankStartMovingMessage() {
+    }
+
+    public TankStartMovingMessage(UUID id, int x, int y, Dir dir) {
+        this.id = id;
+        this.x = x;
+        this.y = y;
+        this.dir = dir;
+    }
+
+    public TankStartMovingMessage(Tank tank) {
+        this.id = tank.getId();
+        this.x = tank.getX();
+        this.y = tank.getY();
+        this.dir = tank.getDir();
+    }
+
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public void setX(int x) {
+        this.x = x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    public void setY(int y) {
+        this.y = y;
+    }
+
+    public Dir getDir() {
+        return dir;
+    }
+
+    public void setDir(Dir dir) {
+        this.dir = dir;
+    }
+
+    @Override
+    public void handle() {
+        if (this.id.equals(TankFrame.INSTANCE.getMainTank().getId())) {
+            return;
+        }
+        Tank tank = TankFrame.INSTANCE.findTankByUUID(this.id);
+        if (tank != null) {
+            tank.setMoving(true);
+            tank.setX(this.x);
+            tank.setY(this.y);
+            tank.setDir(this.dir);
+        }
+    }
+
+    @Override
+    public byte[] toBytes() {
+        byte[] bytes = null;
+        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
+             DataOutputStream dos = new DataOutputStream(baos)) {
+            dos.writeLong(id.getMostSignificantBits());
+            dos.writeLong(id.getLeastSignificantBits());
+            dos.writeInt(x);
+            dos.writeInt(y);
+            dos.writeInt(dir.ordinal());
+            dos.flush();
+            bytes = baos.toByteArray();
+
+        } catch (Exception exception) {
+            exception.printStackTrace();
+        }
+        return bytes;
+    }
+
+    @Override
+    public void parse(byte[] bytes) {
+        try (DataInputStream dis = new DataInputStream(new ByteArrayInputStream(bytes))) {
+            this.id = new UUID(dis.readLong(), dis.readLong());
+
+            this.x = dis.readInt();
+            this.y = dis.readInt();
+            this.dir = Dir.values()[dis.readInt()];
+        } catch (IOException exception) {
+            exception.printStackTrace();
+        }
+    }
+
+    @Override
+    public MessageType getMessageType() {
+        return MessageType.TankStartMoving;
+    }
+
+    @Override
+    public String toString() {
+        return "TankStartMovingMessage{" +
+                "id=" + id +
+                ", x=" + x +
+                ", y=" + y +
+                ", dir=" + dir +
+                '}';
+    }
+}

src/main/java/com/example/tankbattle/net/TankStopMessage.java

@@ -0,0 +1,115 @@
+package com.example.tankbattle.net;
+
+import com.example.tankbattle.Tank;
+import com.example.tankbattle.TankFrame;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.UUID;
+
+public class TankStopMessage extends Message{
+
+    UUID id;
+
+    private int x;
+
+    private int y;
+
+    public TankStopMessage() {}
+
+    public TankStopMessage(UUID id, int x, int y) {
+        this.id = id;
+        this.x = x;
+        this.y = y;
+    }
+
+    public TankStopMessage(Tank tank) {
+        this.id = tank.getId();
+        this.x = tank.getX();
+        this.y = tank.getY();
+    }
+
+    public UUID getId() {
+        return id;
+    }
+
+    public void setId(UUID id) {
+        this.id = id;
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public void setX(int x) {
+        this.x = x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    public void setY(int y) {
+        this.y = y;
+    }
+
+    @Override
+    public void handle() {
+        if (this.id.equals(TankFrame.INSTANCE.getMainTank().getId())) {
+            return;
+        }
+        Tank tank = TankFrame.INSTANCE.findTankByUUID(this.id);
+        if (tank != null) {
+            tank.setMoving(false);
+            tank.setX(this.x);
+            tank.setY(this.y);
+        }
+    }
+
+    @Override
+    public byte[] toBytes() {
+        byte[] bytes = null;
+        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
+             DataOutputStream dos = new DataOutputStream(baos)) {
+            dos.writeLong(id.getMostSignificantBits());
+            dos.writeLong(id.getLeastSignificantBits());
+            dos.writeInt(x);
+            dos.writeInt(y);
+            dos.flush();
+            bytes = baos.toByteArray();
+
+        } catch (Exception exception) {
+            exception.printStackTrace();
+        }
+        return bytes;
+    }
+
+    @Override
+    public void parse(byte[] bytes) {
+        try (DataInputStream dis = new DataInputStream(new ByteArrayInputStream(bytes))) {
+            this.id = new UUID(dis.readLong(), dis.readLong());
+
+            this.x = dis.readInt();
+            this.y = dis.readInt();
+        } catch (IOException exception) {
+            exception.printStackTrace();
+        }
+    }
+
+    @Override
+    public MessageType getMessageType() {
+        return MessageType.TankStop;
+    }
+
+    @Override
+    public String toString() {
+        return "TankStopMessage{" +
+                "id=" + id +
+                ", x=" + x +
+                ", y=" + y +
+                '}';
+    }
+}

src/test/java/com/example/tankbattle/ImageRotateTest.java

@@ -0,0 +1,42 @@
+package com.example.tankbattle;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import javax.imageio.ImageIO;
+import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+
+class ImageRotateTest {
+
+	@Test
+	void test() {
+		try {
+			BufferedImage tankL = ImageIO.read(ResourceMgr.class.getClassLoader().getResourceAsStream("images/tankL.gif"));
+			tankL = rotateImage(tankL, 90);
+			Assertions.assertNotNull(tankL);
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	
+	public BufferedImage rotateImage(final BufferedImage bufferedimage,
+            final int degree) {
+        int w = bufferedimage.getWidth();
+        int h = bufferedimage.getHeight();
+        int type = bufferedimage.getColorModel().getTransparency();
+        BufferedImage img;
+        Graphics2D graphics2d;
+        (graphics2d = (img = new BufferedImage(w, h, type))
+                .createGraphics()).setRenderingHint(
+                RenderingHints.KEY_INTERPOLATION,
+                RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+        graphics2d.rotate(Math.toRadians(degree), w / 2, h / 2);
+        graphics2d.drawImage(bufferedimage, 0, 0, null);
+        graphics2d.dispose();
+        return img;
+    }
+}

src/test/java/com/example/tankbattle/ImageTest.java

@@ -16,10 +16,9 @@ public class ImageTest {
     public void test(){
         System.out.println(ImageTest.class.getClassLoader());
         try {
-            BufferedImage image = ImageIO.read(new File("C:/work/javaprojects/Tank_60/src/images/bulletD.gif"));
+            BufferedImage image = ImageIO.read(new File("/images/bulletD.gif"));
             assertNotNull(image);
-            BufferedImage image2 = ImageIO.read(ImageTest.class.getClassLoader().getResourceAsStream("src/images" +
+            BufferedImage image2 = ImageIO.read(ImageTest.class.getClassLoader().getResourceAsStream("src/images/bulletD.gif"));
-                    "/bulletD.gif"));
             assertNotNull(image2);
         } catch (IOException exception) {
             exception.printStackTrace();

src/test/java/com/example/tankbattle/net/TankDirChangedMessageCoderTest.java

@@ -0,0 +1,69 @@
+package com.example.tankbattle.net;
+
+import com.example.tankbattle.Dir;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.embedded.EmbeddedChannel;
+import org.junit.jupiter.api.Test;
+
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class TankDirChangedMessageCoderTest {
+
+    @Test
+    void encode() {
+        EmbeddedChannel embeddedChannel = new EmbeddedChannel();
+        UUID id = UUID.randomUUID();
+        TankStartMovingMessage message = new TankStartMovingMessage(id, 5, 10, Dir.LEFT);
+        embeddedChannel.pipeline()
+                .addLast(new MessageEncoder());
+
+        embeddedChannel.writeOutbound(message);
+
+        ByteBuf buf = (ByteBuf) embeddedChannel.readOutbound();
+        MessageType messageType = MessageType.values()[buf.readInt()];
+        assertEquals(MessageType.TankStartMoving, messageType);
+
+        int length = buf.readInt();
+        assertEquals(28, length);
+
+        UUID uuid = new UUID(buf.readLong(), buf.readLong());
+        int x = buf.readInt();
+        int y = buf.readInt();
+        int dirOrdinal = buf.readInt();
+        Dir dir = Dir.values()[dirOrdinal];
+
+        assertEquals(5, x);
+        assertEquals(10, y);
+        assertEquals(Dir.LEFT, dir);
+        assertEquals(id, uuid);
+    }
+
+    @Test
+    void testDecoder() {
+        EmbeddedChannel ch = new EmbeddedChannel();
+
+
+        UUID id = UUID.randomUUID();
+        TankStartMovingMessage message = new TankStartMovingMessage(id, 5, 10, Dir.LEFT);
+        ch.pipeline()
+                .addLast(new MessageDecoder());
+
+        ByteBuf buf = Unpooled.buffer();
+        buf.writeInt(MessageType.TankStartMoving.ordinal());
+        byte[] bytes = message.toBytes();
+        buf.writeInt(bytes.length);
+        buf.writeBytes(bytes);
+
+        ch.writeInbound(buf.duplicate());
+
+        TankStartMovingMessage msg = (TankStartMovingMessage) ch.readInbound();
+
+        assertEquals(5, msg.getX());
+        assertEquals(10, msg.getY());
+        assertEquals(Dir.LEFT, msg.getDir());
+        assertEquals(id, msg.getId());
+    }
+}

src/test/java/com/example/tankbattle/net/TankJoinMessageCoderTest.java

@@ -0,0 +1,83 @@
+package com.example.tankbattle.net;
+
+import com.example.tankbattle.Dir;
+import com.example.tankbattle.Group;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.embedded.EmbeddedChannel;
+import org.junit.jupiter.api.Test;
+
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class TankJoinMessageCoderTest {
+
+    @Test
+    void testEncoder() {
+        EmbeddedChannel ch = new EmbeddedChannel();
+
+
+        UUID id = UUID.randomUUID();
+        TankJoinMessage msg = new TankJoinMessage(5, 10, Dir.DOWN, true, Group.BAD, id);
+        ch.pipeline()
+                .addLast(new MessageEncoder());
+
+        ch.writeOutbound(msg);
+
+        ByteBuf buf = (ByteBuf)ch.readOutbound();
+        MessageType messageType = MessageType.values()[buf.readInt()];
+        assertEquals(MessageType.TankJoin, messageType);
+
+        int length = buf.readInt();
+        assertEquals(33, length);
+
+        int x = buf.readInt();
+        int y = buf.readInt();
+        int dirOrdinal = buf.readInt();
+        Dir dir = Dir.values()[dirOrdinal];
+        boolean moving = buf.readBoolean();
+        int groupOrdinal = buf.readInt();
+        Group g = Group.values()[groupOrdinal];
+        UUID uuid = new UUID(buf.readLong(), buf.readLong());
+
+        assertEquals(5, x);
+        assertEquals(10, y);
+        assertEquals(Dir.DOWN, dir);
+        assertEquals(true, moving);
+        assertEquals(Group.BAD, g);
+        assertEquals(id, uuid);
+    }
+
+    @Test
+    void testDecoder() {
+        EmbeddedChannel ch = new EmbeddedChannel();
+
+
+        UUID id = UUID.randomUUID();
+        TankJoinMessage message = new TankJoinMessage(5, 10, Dir.DOWN, true, Group.BAD, id);
+        ch.pipeline()
+                .addLast(new MessageDecoder());
+
+        ByteBuf buf = Unpooled.buffer();
+        buf.writeInt(MessageType.TankJoin.ordinal());
+        byte[] bytes = message.toBytes();
+        buf.writeInt(bytes.length);
+        buf.writeBytes(bytes);
+
+        ch.writeInbound(buf.duplicate());
+
+        TankJoinMessage msg = (TankJoinMessage) ch.readInbound();
+
+
+
+        assertEquals(5, msg.x);
+        assertEquals(10, msg.y);
+        assertEquals(Dir.DOWN, msg.dir);
+        assertEquals(true, msg.moving);
+        assertEquals(Group.BAD, msg.group);
+        assertEquals(id, msg.id);
+    }
+
+
+}

src/test/java/com/example/tankbattle/net/TankStartMovingMessageTest.java

@@ -0,0 +1,71 @@
+package com.example.tankbattle.net;
+
+import com.example.tankbattle.Dir;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.embedded.EmbeddedChannel;
+import org.junit.jupiter.api.Test;
+
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class TankStartMovingMessageTest {
+
+    @Test
+    void testEncoder() {
+        EmbeddedChannel ch = new EmbeddedChannel();
+
+
+        UUID id = UUID.randomUUID();
+        Message message = new TankDirChangedMessage(id, 5, 10, Dir.LEFT);
+        ch.pipeline()
+                .addLast(new MessageEncoder());
+
+        ch.writeOutbound(message);
+
+        ByteBuf buf = (ByteBuf)ch.readOutbound();
+        MessageType messageType = MessageType.values()[buf.readInt()];
+        assertEquals(MessageType.TankDirChanged, messageType);
+
+        int length = buf.readInt();
+        assertEquals(28, length);
+
+        UUID uuid = new UUID(buf.readLong(), buf.readLong());
+        int x = buf.readInt();
+        int y = buf.readInt();
+        int dirOrdinal = buf.readInt();
+        Dir dir = Dir.values()[dirOrdinal];
+
+        assertEquals(5, x);
+        assertEquals(10, y);
+        assertEquals(Dir.LEFT, dir);
+        assertEquals(id, uuid);
+    }
+
+    @Test
+    void testDecoder() {
+        EmbeddedChannel ch = new EmbeddedChannel();
+
+
+        UUID id = UUID.randomUUID();
+        TankDirChangedMessage message = new TankDirChangedMessage(id, 5, 10, Dir.LEFT);
+        ch.pipeline()
+                .addLast(new MessageDecoder());
+
+        ByteBuf buf = Unpooled.buffer();
+        buf.writeInt(MessageType.TankDirChanged.ordinal());
+        byte[] bytes = message.toBytes();
+        buf.writeInt(bytes.length);
+        buf.writeBytes(bytes);
+
+        ch.writeInbound(buf.duplicate());
+
+        TankDirChangedMessage msgR = (TankDirChangedMessage)ch.readInbound();
+
+        assertEquals(5, msgR.getX());
+        assertEquals(10, msgR.getY());
+        assertEquals(Dir.LEFT, msgR.getDir());
+        assertEquals(id, msgR.getId());
+    }
+}