Java 类org.bukkit.map.MapCursor 实例源码

@Override
protected void execute(Event e) {
    SkellettMapRenderer render = SkellettMapRenderer.getRenderer(map.getSingle(e));
    if (render != null) {
        render.update(new MapRenderTask() {
            @SuppressWarnings("deprecation")
            @Override
            public void render(MapView mapView, MapCanvas mapCanvas, Player player) {
                MapCursor cursor = new MapCursor((byte)x.getSingle(e).intValue(), (byte)y.getSingle(e).intValue(), (byte)direction.getSingle(e).intValue(), (byte) 2, true);
                try {
                    MapCursor.Type type = MapCursor.Type.valueOf(cursorType.getSingle(e).replace("\"", "").trim().replace(" ", "_").toUpperCase());
                    if (type != null) {
                        cursor.setType(type);
                    }
                } catch (IllegalArgumentException error) {
                    Bukkit.getConsoleSender().sendMessage(Skellett.cc(Skellett.prefix + "&cUnknown mapcursor type " + cursorType.getSingle(e)));
                    return;
                }
                mapCanvas.getCursors().addCursor(cursor);
            }
        });
    }
}

@Override
public void change(Event e, Object[] delta, Changer.ChangeMode mode){
    String input = (String)delta[0];
    if (mode == ChangeMode.SET) {
        try {
            MapCursor.Type type = MapCursor.Type.valueOf(input.replace("\"", "").trim().replace(" ", "_").toUpperCase());
            if (type != null) {
                cursor.getSingle(e).setType(type);
            }
        } catch (IllegalArgumentException error) {
            Bukkit.getConsoleSender().sendMessage(Skellett.cc(Skellett.prefix + "&cUnknown mapcursor type " + input));
            return;
        }
    }
}

@Override
@Nullable
protected MapCursor[] get(Event e) {
    ArrayList<MapCursor> cursors = new ArrayList<MapCursor>();
    MapCursorCollection collection = SkellettMapRenderer.getCanvas(map.getSingle(e)).getCursors();
    for (int i = 0; i < collection.size(); i++) {
        cursors.add(collection.getCursor(i));
    }
    return cursors.toArray(new MapCursor[cursors.size()]);
}

/**
 * Places the beacon cursors on the map
 * @param canvas
 * @param coordConverter
 * @param cursors
 * @param showUnclaimedBeacons
 */
@SuppressWarnings("deprecation")
private void setCursors(MapCanvas canvas, MapCoordinateConverter coordConverter, MapCursorCollection cursors, boolean showUnclaimedBeacons) {
    for (int i = 0; i < cursors.size(); i++) {
        cursors.removeCursor(cursors.getCursor(i));
    }
    for (Map.Entry<Point2D, CachedBeacon> entry : beaconRegisterCache.entrySet()) {
        Team team = entry.getValue().owner;
        if (!showUnclaimedBeacons && team == null) continue;
        Point2D point = entry.getKey();
        int x = coordConverter.blockXToPixelX((int) point.getX());
        if (x < 0 || x > 127) continue;
        int z = coordConverter.blockZToPixelZ((int) point.getY());
        if (z < 0 || z > 127) continue;
        // Only add cursors to the portion of the map that has been discovered
        if (canvas.getBasePixel(x, z) != 0) {
            x = x * 2 - 128; // Pixels range from 0 to 127, but cursors range from -128 to 127. (wtf)
            z = z * 2 - 128;
            int color = 16;
            if (team != null) {
                Scorecard sc = beaconz.getGameMgr().getSC(point);
                if (sc != null && sc.getBlockID(team) != null) {
                    color = sc.getBlockID(team).getData();
                }
            }
            TeamCursor teamCursor = TEAM_CURSORS[color];
            MapCursor cursor = cursors.addCursor(x, z, (byte)0);
            cursor.setDirection(teamCursor.direction);
            cursor.setType(teamCursor.type);
        }
    }
}

@Override
public void sendMap(MapView map) {
    if (getHandle().playerConnection == null) return;

    RenderData data = ((CraftMapView) map).render(this);
    Collection<MapIcon> icons = new ArrayList<MapIcon>();
    for (MapCursor cursor : data.cursors) {
        if (cursor.isVisible()) {
            icons.add(new MapIcon(cursor.getRawType(), cursor.getX(), cursor.getY(), cursor.getDirection()));
        }
    }

    PacketPlayOutMap packet = new PacketPlayOutMap(map.getId(), map.getScale().getValue(), icons, data.buffer, 0, 0, 0, 0);
    getHandle().playerConnection.sendPacket(packet);
}

@Override
public void sendMap(MapView map) {
    if (getHandle().playerConnection == null) return;

    RenderData data = ((CraftMapView) map).render(this);
    Collection<MapIcon> icons = new ArrayList<MapIcon>();
    for (MapCursor cursor : data.cursors) {
        if (cursor.isVisible()) {
            icons.add(new MapIcon(cursor.getRawType(), cursor.getX(), cursor.getY(), cursor.getDirection()));
        }
    }

    PacketPlayOutMap packet = new PacketPlayOutMap(map.getId(), map.getScale().getValue(), true, icons, data.buffer, 0, 0, 0, 0);
    getHandle().playerConnection.sendPacket(packet);
}

public RenderData() {
    this.buffer = new byte[128 * 128];
    this.cursors = new ArrayList<MapCursor>();
}

public RenderData() {
    this.buffer = new byte[128 * 128];
    this.cursors = new ArrayList<MapCursor>();
}

@SuppressWarnings("unchecked")
public boolean init(Expression<?>[] e, int matchedPattern, Kleenean isDelayed, ParseResult parser) {
    cursor = (Expression<MapCursor>) e[0];
    return true;
}

@SuppressWarnings("unchecked")
public boolean init(Expression<?>[] e, int matchedPattern, Kleenean isDelayed, ParseResult parser) {
    cursor = (Expression<MapCursor>) e[0];
    marker = parser.mark;
    return true;
}

@SuppressWarnings("unchecked")
public boolean init(Expression<?>[] e, int matchedPattern, Kleenean isDelayed, ParseResult parser) {
    cursor = (Expression<MapCursor>) e[0];
    return true;
}

@SuppressWarnings("unchecked")
public boolean init(Expression<?>[] e, int matchedPattern, Kleenean isDelayed, ParseResult parser) {
    cursor = (Expression<MapCursor>) e[0];
    return true;
}

@Override
public Class<? extends MapCursor> getReturnType() {
    return MapCursor.class;
}

public RenderData() {
    this.buffer = new byte[128 * 128];
    this.cursors = new ArrayList<MapCursor>();
}

public RenderData() {
    this.buffer = new byte[128 * 128];
    this.cursors = new ArrayList<MapCursor>();
}

public RenderData() {
    this.buffer = new byte[128 * 128];
    this.cursors = new ArrayList<MapCursor>();
}

public RenderData() {
    this.buffer = new byte[128 * 128];
    this.cursors = new ArrayList<MapCursor>();
}

public RenderData() {
    this.buffer = new byte[128 * 128];
    this.cursors = new ArrayList<MapCursor>();
}

public RenderData() {
    this.buffer = new byte[128 * 128];
    this.cursors = new ArrayList<MapCursor>();
}

public RenderData() {
    this.buffer = new byte[128 * 128];
    this.cursors = new ArrayList<MapCursor>();
}

public TeamCursor(MapCursor.Type type, int direction) {
    this.type = type;
    this.direction = (byte)direction;
}

public RenderData() {
    this.buffer = new byte[128 * 128];
    this.cursors = new ArrayList<MapCursor>();
}

public RenderData() {
    this.buffer = new byte[128 * 128];
    this.cursors = new ArrayList<MapCursor>();
}

public RenderData() {
    this.buffer = new byte[128 * 128];
    this.cursors = new ArrayList<MapCursor>();
}

public RenderData() {
    this.buffer = new byte[128 * 128];
    this.cursors = new ArrayList<MapCursor>();
}

@Deprecated public MapCursor(byte x, byte y, byte direction, byte type, boolean visible) {
}

public MapCursor.Type getType() {
    return null;
}

public void setType(MapCursor.Type type) {
}

public MapCursor getCursor(int index) {
    return null;
}

public boolean removeCursor(MapCursor cursor) {
    return false;
}

public MapCursor addCursor(MapCursor cursor) {
    return null;
}

public MapCursor addCursor(int x, int y, byte direction) {
    return null;
}

@Deprecated public MapCursor addCursor(int x, int y, byte direction, byte type) {
    return null;
}

@Deprecated public MapCursor addCursor(int x, int y, byte direction, byte type, boolean visible) {
    return null;
}

public RenderData() {
    this.buffer = new byte[128 * 128];
    this.cursors = new ArrayList<MapCursor>();
}

@Override
public void render(MapView view, MapCanvas canvas, Player player) {
    if (renderTask == null)
        return;

    ChunkInfoRenderingRequest request = renderedRequests.get(view.getId());
    if (request == null) {
        request = new ChunkInfoRenderingRequest(view.getId(),
                view.getCenterX(), view.getCenterZ(), view.getWorld()
                        .getName());
        renderedRequests.put(view.getId(), request);
        renderTask.add(request);
    }

    MapCursor cursor;

    final Location location = player.getLocation();
    final int playerX = ((location.getBlockX() - view.getCenterX()) >> 3) /*
                                                                           * +
                                                                           * 128
                                                                           */;
    final int playerZ = ((location.getBlockZ() - view.getCenterZ()) >> 3) /*
                                                                           * +
                                                                           * 128
                                                                           */;
    if (playerX < 128 && playerX >= -128 && playerZ < 128
            || playerZ >= -128) {
        final byte direction = (byte) (((int) location.getYaw() + 360) % 360 * 16 / 360);
        if (canvas.getCursors().size() == 0) {
            canvas.getCursors().addCursor(playerX, playerZ, direction,
                    MapCursor.Type.WHITE_POINTER.getValue());
        } else {
            cursor = canvas.getCursors().getCursor(0);
            cursor.setDirection(direction);
            cursor.setX((byte) (playerX));
            cursor.setY((byte) (playerZ));
        }
    }

    if (!request.isDone())
        return;

    final byte[][] data = request.getData();
    for (int ii = 0; ii < 2; ii++) {
        int currentLine = request.nextLine();
        for (int i = 0; i < 128; i++) {
            canvas.setPixel(i, currentLine, data[currentLine][i]);
        }
    }
}

public RenderData() {
    this.buffer = new byte[128 * 128];
    this.cursors = new ArrayList<MapCursor>();
}

public RenderData() {
    this.buffer = new byte[128 * 128];
    this.cursors = new ArrayList<MapCursor>();
}