03-重构设计模式之chain_of_responsibility责任链模式(子弹、坦克、墙碰撞)

ChainOfResponsibility

为请求创建了一个接收者对象的链。 这种模式给予请求的类型，对请求的发送者和接收者进行解耦。 这种类型的设计模式属于行为型模式。 在这种模式中，通常每个接收者都包含对另一个接收者的引用。

Main

public class Main {
    public static void main(String[] args) {
        Msg msg = new Msg();
        msg.setMsg("大家好:) <script> 996");

        FilterChain filterChain = new FilterChain();
        filterChain.add(new HTMLFilter()).add(new SensitiveFilter());

        FilterChain filterChain1 = new FilterChain();
        filterChain1.add(new FaceFilter()).add(new URLFilter());

        filterChain.add(filterChain1);

        filterChain.doFilter(msg);

        System.out.println(msg);
    }
}


class Msg {
    String name;
    String msg;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    @Override
    public String toString() {
        return "Msg{" +
                "name='" + name + '\'' +
                ", msg='" + msg + '\'' +
                '}';
    }
}

interface Filter {
    boolean doFilter(Msg m);
}

class HTMLFilter implements Filter{

    @Override
    public boolean doFilter(Msg m) {
        //处理msg
        String r = m.getMsg();
        r = r.replace('<', '[');
        r = r.replace('>', ']');
        m.setMsg(r);
        return true;
    }
}

class SensitiveFilter implements Filter{

    @Override
    public boolean doFilter(Msg m) {
        String r = m.getMsg();
        r = r.replaceAll("996", "955");
        m.setMsg(r);
        return false;
    }
}

class FaceFilter implements Filter{

    @Override
    public boolean doFilter(Msg m) {
        String r = m.getMsg();
        r = r.replace(":)", "~");
        m.setMsg(r);
        return true;
    }
}

class URLFilter implements Filter{

    @Override
    public boolean doFilter(Msg m) {
        String r = m.getMsg();
        r = r.replace("好", "早");
        m.setMsg(r);
        return true;
    }
}

class FilterChain implements Filter{
    List<Filter> filters = new ArrayList<>();
    public FilterChain add(Filter f){
        filters.add(f);
        return this;
    }

    public boolean doFilter(Msg msg){
        for (Filter filter : filters) {
            if(!filter.doFilter(msg)) return false;
        }
        return true;
    }

}

servletMain

+public class ServletMain {
    public static void main(String[] args) {
        Request request = new Request();
        request.str = "request";

        Response response = new Response();
        response.str = "response";

        System.out.println();
    }
}


class Msg {
    String name;
    String msg;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    @Override
    public String toString() {
        return "Msg{" +
                "name='" + name + '\'' +
                ", msg='" + msg + '\'' +
                '}';
    }
}

interface Filter {
    boolean doFilter(Request request, Response response);
}

class Request {
    String str;
}

class Response {
    String str;
}

class HTMLFilter implements Filter {

    @Override
    public boolean doFilter(Request request, Response response) {
        return false;
    }
}

class SensitiveFilter implements Filter {

    @Override
    public boolean doFilter(Request request, Response response) {
        return false;
    }
}

class FilterChain implements Filter {
    List<Filter> filters = new ArrayList<>();

    public FilterChain add(Filter f) {
        filters.add(f);
        return this;
    }

    public boolean doFilter(Request request, Response response) {
        for (Filter filter : filters) {
            if (!filter.doFilter(request, response)) return false;
        }
        return true;
    }

}

抽象出GameModel，将Model和View分离，同时GameModel作为Facade，负责与Frame打交道，同时负责内部事务

Tank

 public Tank(int x, int y, Dir dir, Group group, GameModel gm) 
 public void paint(Graphics g) {

        if (!living) tf.tanks.remove(this);
        if (!living) gm.tanks.remove(this);    
 }

TankFrame

    /*List<Bullet> bullets = new ArrayList<>();//子弹
    List<Tank> tanks = new ArrayList<>();//敌人坦克
    List<Explode> explodes = new ArrayList<>();//爆炸
    */

GameModel gm = new GameModel();
public void paint(Graphics g) {
    gm.paint();
}

Explode和Bullet

构造方法和属性更改为gm

关于射击的策略模式中的属性更改

GameModel

public class GameModel {

    Tank myTank = new Tank(200, 400, Dir.DOWN, Group.GOOD, this);//我的坦克
    java.util.List<Bullet> bullets = new ArrayList<>();//子弹
    java.util.List<Tank> tanks = new ArrayList<>();//敌人坦克
    List<Explode> explodes = new ArrayList<>();//爆炸

    public GameModel() {
        int initTankCount = PropertyManager.getInt("initTankCount");

        //初始化敌方坦克
        for (int i = 0; i < initTankCount; i++) {
            tanks.add(new Tank(50 + i * 80, 200, Dir.DOWN, Group.BAD, this));
        }

    }

    public void paint(Graphics g) {
        Color c = g.getColor();
        g.setColor(Color.WHITE);
        g.drawString("子弹数量" + bullets.size(), 10, 60);
        g.drawString("敌人数量" + tanks.size(), 10, 80);
        g.drawString("爆炸数量" + explodes.size(), 10, 100);
        g.setColor(c);

        myTank.paint(g);

        for (int i = 0; i < bullets.size(); i++) {
            bullets.get(i).paint(g);
        }
        for (int i = 0; i < tanks.size(); i++) {
            tanks.get(i).paint(g);
        }

        for (int i = 0; i < explodes.size(); i++) {
            explodes.get(i).paint(g);
        }

        //碰撞检测 collision detect
        for (int i = 0; i < bullets.size(); i++) {
            for (int j = 0; j < tanks.size(); j++) {
                bullets.get(i).collideWith(tanks.get(j));
            }
        }

    }

    public Tank getMainTank() {
        return myTank;
    }
}

抽象出GameObject让坦克、子弹等继承

public abstract class GameObject {
    int x,y;

    public abstract void paint(Graphics g);
}

GameModel

//    List<Bullet> bullets = new ArrayList<>();//子弹
//    List<Tank> tanks = new ArrayList<>();//敌人坦克
//    List<Explode> explodes = new ArrayList<>();//爆炸
private List<GameObject> objects = new ArrayList<>();
ColliderChain chain = new ColliderChain();
 //互相碰撞
        for (int i = 0; i < objects.size(); i++) {
            for (int j = i+1; j < objects.size(); j++) {
                GameObject o1 = objects.get(i);
                GameObject o2 = objects.get(j);
                chain.collide(o1,o2);
            }

碰撞接口

/**
 * 两个游戏物体间的碰撞
 */
public interface Collider {
    boolean collide(GameObject o1,GameObject o2);
}

BulletTankCollider

public class BulletTankCollider implements Collider{
    @Override
    public boolean collide(GameObject o1, GameObject o2) {
        if (o1 instanceof Bullet && o2 instanceof Tank){
            Bullet b = (Bullet)o1;
            Tank t = (Tank)o2;
            if (b.collideWith(t)){
                return false;
            }
        }else if (o2 instanceof Bullet && o1 instanceof Tank){
            return collide(o2,o1);
        }
        return true;
    }
}

TankTankCollider

public class TankTankCollider implements Collider {
    @Override
    public boolean collide(GameObject o1, GameObject o2) {
        if (o1 instanceof Tank && o2 instanceof Tank) {
            Tank t1 = (Tank) o1;
            Tank t2 = (Tank) o2;
            if (t1.getRect().intersects(t2.getRect())) {
                t1.turnAround();
                t2.turnAround();
            }
        }
        return true;

    }

ColliderChain

public class ColliderChain implements Collider{
    private List<Collider> colliders = new LinkedList<>();

    public ColliderChain(){
        add(new BulletTankCollider());
        add(new TankTankCollider());
    }

    public void add(Collider c){
        colliders.add(c);
    }

    public boolean collide(GameObject o1, GameObject o2) {
        for (int i = 0; i < colliders.size(); i++) {
            if (colliders.get(i).collide(o1, o2)){
                return false;
            }
        }
        return true;
    }
}

tank.back():用oldX和oldY记录上一步的位置，坦克相互撞击后回到上一步 添加一堵墙 GameModel做成单例 对GameModel的add方法做优化

 public void back(){
        x = oldX;
        y = oldY;
    }

wall

public class Wall extends GameObject{

    int w,h;

    public Rectangle rect;

    public Wall(int x, int y, int w, int h) {
        this.x = x;
        this.y = y;
        this.w = w;
        this.h = h;
        this.rect = new Rectangle(x,y,w,h);
    }

    @Override
    public void paint(Graphics g) {
        Color c = g.getColor();
        g.setColor(Color.DARK_GRAY);
        g.fillRect(x,y,w,h);
        g.setColor(c);
    }

GameModel

    private void init(){
        //初始化主战坦克
        myTank = new Tank(200, 400, Dir.DOWN, Group.GOOD);
        int initTankCount = PropertyManager.getInt("initTankCount");

        //初始化敌方坦克
        for (int i = 0; i < initTankCount; i++) {
            add(new Tank(50 + i * 80, 200, Dir.DOWN, Group.BAD, this));
            new Tank(50 + i * 80, 200, Dir.DOWN, Group.BAD);
        }

        //初始化墙
        add(new Wall(150,150,200,50));
        add(new Wall(550,150,200,50));
        add(new Wall(300,300,50,200));
        add(new Wall(550,300,50,200));
    }

TankWallCollider

public class TankWallCollider implements Collider{
    @Override
    public boolean collide(GameObject o1, GameObject o2) {
        if (o1 instanceof Tank && o2 instanceof Wall){
            Tank t = (Tank) o1;
            Wall w = (Wall) o2;
            if (t.rect.intersects(w.rect)){
                t.back();
            }
        }else if (o2 instanceof Tank && o1 instanceof Wall){
            return collide(o2,o1);
        }
        return true;
    }
}

BulletWallCollider

public class BulletWallCollider implements Collider{
    @Override
    public boolean collide(GameObject o1, GameObject o2) {
        if (o1 instanceof Bullet && o2 instanceof Wall){
            Bullet b = (Bullet)o1;
            Wall w = (Wall) o2;
            if (b.rect.intersects(w.rect)){
                b.die();
            }
        }else if (o2 instanceof Bullet && o1 instanceof Wall){
            return collide(o2,o1);
        }
        return true;
    }
}

ColliderChain

 public ColliderChain(){
        add(new BulletTankCollider());
        add(new TankTankCollider());
        add(new BulletWallCollider());
        add(new TankWallCollider());
 }

   
    public boolean collide(GameObject o1, GameObject o2) {
        for (int i = 0; i < colliders.size(); i++) {
            if (!colliders.get(i).collide(o1, o2)){
                return false;
            }
    }

GameModel中的主战tank做成单例

private static final GameModel INSTANCE = new GameModel();
    static {
        INSTANCE.init();
    }

    Tank myTank ;//我的坦克