Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- 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");
- }
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement