PlaceholderName.java

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.imageio.ImageIO;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.lang.InterruptedException;
import java.util.List;
import java.util.ArrayList;
import java.awt.Dimension;
import java.awt.Point;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.File;

public class PlaceholderName {
    public static final String version = "0.0.4.1";

    public static void main(String[] args) throws IOException, InterruptedException {
        // I hate all of this
        JFrame frame = new JFrame("PlaceholderName v" + version);
        Canvas canvas = new Canvas();

        // canvas.setPreferredSize(new Dimension(Game.outerWidth, Game.outerHeight));

        frame.getContentPane().add(canvas);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        // frame.setSize(Game.outerWidth + 30, Game.outerHeight + 30);

        frame.setResizable(true);
        canvas.setPreferredSize(new Dimension(Game.outerWidth, Game.outerHeight));
        frame.pack();
        frame.setResizable(false);
        frame.setLocation(10, 10);

        frame.setVisible(true);

        Level.loadTileset();

        Level.addChunk(0, 0).addTile(0, 0, Level.tileset.get(1));
        Level.addChunk(1, 0).addTile(0, 0, Level.tileset.get(2));
        Level.addChunk(2, 0).addTile(0, 0, Level.tileset.get(3));
        Level.addChunk(3, 0).addTile(0, 0, Level.tileset.get(4));
        Level.addChunk(4, 0).addTile(0, 0, Level.tileset.get(5));
        Level.addChunk(5, 0).addTile(0, 0, Level.tileset.get(6));
        Level.addChunk(6, 0).addTile(0, 0, Level.tileset.get(7));
        Level.addChunk(7, 0).addTile(0, 0, Level.tileset.get(8));

        // System.out.println(FileManager.ROOT);

        FileManager.save("__test3");

        Game.tick(canvas);
    }
}
class Game {
    public static final int tps = 20;
    public static boolean running = true;
    public static boolean paused = false;   // yeah, as if

    public static final int outerWidth = 896;
    public static final int outerHeight = 512;

    public static void tick(Canvas canvas) throws InterruptedException {
        while (Game.running) {
            canvas.repaint();
            Thread.sleep(1000 / Game.tps);
        }
    }
}
class FileManager {
    public static final String ROOT = System.getProperty("user.dir") + "\\saves\\";
    public static final byte FORMATVER = 2;

    public static void save(String fileName) throws IOException {
        File file = new File(ROOT + fileName + ".lvl");
        if (!file.exists()) {
            file.mkdirs();
            file.delete();
            file.createNewFile();
        }

        // exactly
        DataOutputStream dataStream = new DataOutputStream(new FileOutputStream(file, false));

        // first byte of data is save file format version
        // may be useful in the future
        dataStream.writeByte(FORMATVER);

        /* == TILE DATA == */
        // chunks are written one by one into file
        for (int i = 0; i < Level.chunks.length; i++) {
            if (Level.chunks[i] == null || Level.chunks[i].tilesN == 0) {
                // Unicode non-character 0xfdd0 is used as token for empty chunks
                dataStream.writeShort(0xfdd0);
            }
            else {
                // filled chunks are checked tile by tile, which are added to the file
                for (int j = 0; j < 64; j++) {
                    if (j <= 56 && Level.chunks[i].tiles[j] == null && Level.chunks[i].tiles[j + 1] == null && Level.chunks[i].tiles[j + 2] == null && Level.chunks[i].tiles[j + 3] == null && Level.chunks[i].tiles[j + 4] == null && Level.chunks[i].tiles[j + 5] == null && Level.chunks[i].tiles[j + 6] == null && Level.chunks[i].tiles[j + 7] == null) {
                        // a row of 8 empty tiles is represented by Unicode non-character 0xfdd1
                        dataStream.writeShort(0xfdd1);
                        // parser skips ahead 7 tiles
                        j += 7;
                    }
                    // empty tiles are equal to null
                    else if (Level.chunks[i].tiles[j] == null) {
                        dataStream.writeShort(0);
                    }
                    else {
                        dataStream.writeShort(Level.chunks[i].tiles[j].id);
                    }
                }
            }
        }



        dataStream.flush(); // Java is just one giant joke
        dataStream.close();
    }
    public static void load(String fileName) throws IOException {

    }
}
class Level {
    // Java taught me that your program becomes better when you have as many unnecessary classes as possible
    public static List<Entity> entities = new ArrayList<Entity>();
    public static List<Tile> tileset = new ArrayList<Tile>();

    public static Chunk getChunk(int x, int y) {
        return chunks[y * (Game.outerHeight / 128) + x];
    }
    public static Chunk addChunk(int x, int y) {
        if (Level.chunks[y * (Game.outerHeight / 128) + x] == null) {
            Level.chunks[y * (Game.outerHeight / 128) + x] = new Chunk();
        }
        else {
            System.out.println("NOTICE: Chunk at (" + x + "," + y + ") already exists.");
        }
        return Level.chunks[y * (Game.outerHeight / 128) + x];
    }
    public static void loadTileset() {
        Level.tileset.add(null);
        Level.tileset.add(new BasicFloortile());
        Level.tileset.add(new BasicCeilingtile());
        Level.tileset.add(new BasicWalltileLeft());
        Level.tileset.add(new BasicWalltileRight());
        Level.tileset.add(new BasicCornertileTopLeft());
        Level.tileset.add(new BasicCornertileTopRight());
        Level.tileset.add(new BasicCornertileBottomRight());
        Level.tileset.add(new BasicCornertileBottomLeft());
    }
    public static Chunk[] chunks = new Chunk[(Game.outerWidth / 128) * (Game.outerHeight / 128)];
}
class Chunk {
    public Chunk() {};
    public Chunk(Tile[] tiles_) {
        tiles = tiles_;
    }

    public Tile[] tiles = new Tile[64];
    public int tilesN = 0;

    public Tile getTile(int x, int y) {
        return this.tiles[y * 8 + x];
    }
    public void addTile(int x, int y, Tile tile) {
        if (this.tiles[y * 8 + x] == null) {
            this.tiles[y * 8 + x] = tile;
            this.tilesN++;
        }
        else {
            System.out.println("NOTICE: Tile at (" + x + "," + y + ") already exists.");
        }
    }
}
class Canvas extends JPanel {
    public Canvas() throws IOException {
        setDoubleBuffered(true);
        cursor = this.getMousePosition();
    }

    public Point cursor;
    public BufferedImage loadImage(String name) {
        // ????
        try {
            return ImageIO.read(getClass().getResource("/assets/image/" + name));
        }
        catch (Throwable t) {
            // fuck everything
            t.printStackTrace();
            return null;
        }
    }
    public void paint(Graphics g) {
        /*
        for (int i = 0; i < Level.tileset.size(); i++) {
            g.drawImage(loadImage(Level.tileset.get(i).sprite), Level.tileset.get(i).x, Level.tileset.get(i).y, null);
        }
        */
        for (int i = 0; i < Level.chunks.length; i++) {
            if (Level.chunks[i] != null && Level.chunks[i].tilesN != 0) {
                for (int j = 0; j < Level.chunks[i].tiles.length; j++) {
                    if (Level.chunks[i].tiles[j] != null) {
                        g.drawImage(loadImage(Level.chunks[i].tiles[j].sprite.src), ((i % (Game.outerWidth / 128)) * 128) + ((j % 8) * 16), ((i / (Game.outerWidth / 128)) * 128) + ((j / 8) * 16), null);
                    }
                }
            }
        }
        for (int i = 0; i < Level.entities.size(); i++) {
            // fghjkl
            g.drawImage(loadImage(Level.entities.get(i).sprite.src), Level.entities.get(i).x, Level.entities.get(i).y, null);
        }
    }
}
class Sprite {
    public Sprite(String src_) {
        x = 0;
        y = 0;
        offsetX = 0;
        offsetY = 0;
        src = src_;
    }
    public Sprite(int x_, int y_, String src_) {
        x = x_;
        y = y_;
        offsetX = 0;
        offsetY = 0;
        src = src_;
    }
    public Sprite(int x_, int y_, int offsetX_, int offsetY_, String src_) {
        x = x_;
        y = y_;
        offsetX = offsetX_;
        offsetY = offsetY_;
        src = src_;
    }

    public int x;
    public int y;
    public int offsetX;
    public int offsetY;
    public String src;
}
abstract class DynamicObject {
    public DynamicObject(boolean[] solid_, String sprite_) {
        sprite = new Sprite(sprite_);
        solid = solid_;
    }

    public final Sprite sprite;
    public boolean[] solid;

    public boolean isSolid(String dir) {
        switch (dir) {
            case "top":
                return this.solid[0];
            case "right":
                return this.solid[1];
            case "bottom":
                return this.solid[2];
            case "left":
                return this.solid[3];
            default:
                System.err.println("ERROR: Invalid argument in DynamicObject.isSolid(String).");
                return false;
        }
    }
}
abstract class AbstractEntity extends DynamicObject {
    public AbstractEntity(int x_, int y_, boolean[] solid_, String sprite_) {
        super(solid_, sprite_);
        sprite.x = x_;
        sprite.y = y_;
        x = x_;
        y = y_;
    }
    public int x;
    public int y;
}
class Entity extends AbstractEntity {
    public Entity(int x_, int y_, boolean[] solid_, String sprite_, byte dir_) {
        super(x_, y_, solid_, sprite_);
        dir = dir_;
        velX = 0f;
        velY = 0f;
    }

    public byte dir;
    public float velX;
    public float velY;
}
class Tile extends DynamicObject {
    public Tile(boolean[] solid_, String sprite_, String name_) {
        super(solid_, sprite_);
        name = name_;
        id = Tile.idIndex;
        Tile.idIndex++;
    }

    public String name;
    public short id;

    public static short idIndex = 1;
}
class TileEntity extends AbstractEntity {
    public TileEntity (int x_, int y_, short tileID) {
        super(x_, y_, new boolean[] {false, false, false, false}, Level.tileset.get(tileID).sprite.src);
    }
}

/* ============================================================= */
/* ========================= TILES ============================= */
/* ============================================================= */

class BasicFloortile extends Tile {
    public BasicFloortile() {
        super(new boolean[] {true, true, true, true}, "tile/basic-floortile.png", "basic_floortile");
    }
}
class BasicCeilingtile extends Tile {
    public BasicCeilingtile() {
        super(new boolean[] {true, true, true, true}, "tile/basic-ceilingtile.png", "basic_ceilingtile");
    }
}
class BasicWalltileLeft extends Tile {
    public BasicWalltileLeft() {
        super(new boolean[] {true, true, true, true}, "tile/basic-walltile-left.png", "basic_walltile_left");
    }
}
class BasicWalltileRight extends Tile {
    public BasicWalltileRight() {
        super(new boolean[] {true, true, true, true}, "tile/basic-walltile-right.png", "basic_walltile_right");
    }
}
class BasicCornertileTopLeft extends Tile {
    public BasicCornertileTopLeft() {
        super(new boolean[] {true, true, true, true}, "tile/basic-cornertile-top-left.png", "basic_cornertile_top_left");
    }
}
class BasicCornertileTopRight extends Tile {
    public BasicCornertileTopRight() {
        super(new boolean[] {true, true, true, true}, "tile/basic-cornertile-top-right.png", "basic_cornertile_top_right");
    }
}
class BasicCornertileBottomRight extends Tile {
    public BasicCornertileBottomRight() {
        super(new boolean[] {true, true, true, true}, "tile/basic-cornertile-bottom-right.png", "basic_cornertile_bottom_right");
    }
}
class BasicCornertileBottomLeft extends Tile {
    public BasicCornertileBottomLeft() {
        super(new boolean[] {true, true, true, true}, "tile/basic-cornertile-bottom-left.png", "basic_cornertile_bottom_left");
    }
}