daily pastebin goal
15%
SHARE
TWEET

PlaceholderName.java

RandomGuy32 Sep 3rd, 2015 (edited) 88 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import javax.swing.JFrame;
  2. import javax.swing.JPanel;
  3. import javax.imageio.ImageIO;
  4. import java.awt.Graphics;
  5. import java.awt.image.BufferedImage;
  6. import java.io.IOException;
  7. import java.lang.InterruptedException;
  8. import java.util.List;
  9. import java.util.ArrayList;
  10. import java.awt.Dimension;
  11. import java.awt.Point;
  12. import java.io.DataOutputStream;
  13. import java.io.FileOutputStream;
  14. import java.io.FileInputStream;
  15. import java.io.File;
  16.  
  17. public class PlaceholderName {
  18.         public static final String version = "0.0.4.1";
  19.        
  20.         public static void main(String[] args) throws IOException, InterruptedException {
  21.                 // I hate all of this
  22.                 JFrame frame = new JFrame("PlaceholderName v" + version);
  23.                 Canvas canvas = new Canvas();
  24.                
  25.                 // canvas.setPreferredSize(new Dimension(Game.outerWidth, Game.outerHeight));
  26.                
  27.                 frame.getContentPane().add(canvas);
  28.                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  29.                 // frame.setSize(Game.outerWidth + 30, Game.outerHeight + 30);
  30.                
  31.                 frame.setResizable(true);
  32.                 canvas.setPreferredSize(new Dimension(Game.outerWidth, Game.outerHeight));
  33.                 frame.pack();
  34.                 frame.setResizable(false);
  35.                 frame.setLocation(10, 10);
  36.                
  37.                 frame.setVisible(true);
  38.                
  39.                 Level.loadTileset();
  40.                
  41.                 Level.addChunk(0, 0).addTile(0, 0, Level.tileset.get(1));
  42.                 Level.addChunk(1, 0).addTile(0, 0, Level.tileset.get(2));
  43.                 Level.addChunk(2, 0).addTile(0, 0, Level.tileset.get(3));
  44.                 Level.addChunk(3, 0).addTile(0, 0, Level.tileset.get(4));
  45.                 Level.addChunk(4, 0).addTile(0, 0, Level.tileset.get(5));
  46.                 Level.addChunk(5, 0).addTile(0, 0, Level.tileset.get(6));
  47.                 Level.addChunk(6, 0).addTile(0, 0, Level.tileset.get(7));
  48.                 Level.addChunk(7, 0).addTile(0, 0, Level.tileset.get(8));
  49.                
  50.                 // System.out.println(FileManager.ROOT);
  51.                
  52.                 FileManager.save("__test3");
  53.                
  54.                 Game.tick(canvas);
  55.         }
  56. }
  57. class Game {
  58.         public static final int tps = 20;
  59.         public static boolean running = true;
  60.         public static boolean paused = false;   // yeah, as if
  61.        
  62.         public static final int outerWidth = 896;
  63.         public static final int outerHeight = 512;
  64.        
  65.         public static void tick(Canvas canvas) throws InterruptedException {
  66.                 while (Game.running) {
  67.                         canvas.repaint();
  68.                         Thread.sleep(1000 / Game.tps);
  69.                 }
  70.         }
  71. }
  72. class FileManager {
  73.         public static final String ROOT = System.getProperty("user.dir") + "\\saves\\";
  74.         public static final byte FORMATVER = 2;
  75.        
  76.         public static void save(String fileName) throws IOException {
  77.                 File file = new File(ROOT + fileName + ".lvl");
  78.                 if (!file.exists()) {
  79.                         file.mkdirs();
  80.                         file.delete();
  81.                         file.createNewFile();
  82.                 }
  83.                
  84.                 // exactly
  85.                 DataOutputStream dataStream = new DataOutputStream(new FileOutputStream(file, false));
  86.                
  87.                 // first byte of data is save file format version
  88.                 // may be useful in the future
  89.                 dataStream.writeByte(FORMATVER);
  90.                
  91.                 /* == TILE DATA == */
  92.                 // chunks are written one by one into file
  93.                 for (int i = 0; i < Level.chunks.length; i++) {
  94.                         if (Level.chunks[i] == null || Level.chunks[i].tilesN == 0) {
  95.                                 // Unicode non-character 0xfdd0 is used as token for empty chunks
  96.                                 dataStream.writeShort(0xfdd0);
  97.                         }
  98.                         else {
  99.                                 // filled chunks are checked tile by tile, which are added to the file
  100.                                 for (int j = 0; j < 64; j++) {
  101.                                         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) {
  102.                                                 // a row of 8 empty tiles is represented by Unicode non-character 0xfdd1
  103.                                                 dataStream.writeShort(0xfdd1);
  104.                                                 // parser skips ahead 7 tiles
  105.                                                 j += 7;
  106.                                         }
  107.                                         // empty tiles are equal to null
  108.                                         else if (Level.chunks[i].tiles[j] == null) {
  109.                                                 dataStream.writeShort(0);
  110.                                         }
  111.                                         else {
  112.                                                 dataStream.writeShort(Level.chunks[i].tiles[j].id);
  113.                                         }
  114.                                 }
  115.                         }
  116.                 }
  117.                
  118.                
  119.                
  120.                 dataStream.flush();     // Java is just one giant joke
  121.                 dataStream.close();
  122.         }
  123.         public static void load(String fileName) throws IOException {
  124.                
  125.         }
  126. }
  127. class Level {
  128.         // Java taught me that your program becomes better when you have as many unnecessary classes as possible
  129.         public static List<Entity> entities = new ArrayList<Entity>();
  130.         public static List<Tile> tileset = new ArrayList<Tile>();
  131.        
  132.         public static Chunk getChunk(int x, int y) {
  133.                 return chunks[y * (Game.outerHeight / 128) + x];
  134.         }
  135.         public static Chunk addChunk(int x, int y) {
  136.                 if (Level.chunks[y * (Game.outerHeight / 128) + x] == null) {
  137.                         Level.chunks[y * (Game.outerHeight / 128) + x] = new Chunk();
  138.                 }
  139.                 else {
  140.                         System.out.println("NOTICE: Chunk at (" + x + "," + y + ") already exists.");
  141.                 }
  142.                 return Level.chunks[y * (Game.outerHeight / 128) + x];
  143.         }
  144.         public static void loadTileset() {
  145.                 Level.tileset.add(null);
  146.                 Level.tileset.add(new BasicFloortile());
  147.                 Level.tileset.add(new BasicCeilingtile());
  148.                 Level.tileset.add(new BasicWalltileLeft());
  149.                 Level.tileset.add(new BasicWalltileRight());
  150.                 Level.tileset.add(new BasicCornertileTopLeft());
  151.                 Level.tileset.add(new BasicCornertileTopRight());
  152.                 Level.tileset.add(new BasicCornertileBottomRight());
  153.                 Level.tileset.add(new BasicCornertileBottomLeft());
  154.         }
  155.         public static Chunk[] chunks = new Chunk[(Game.outerWidth / 128) * (Game.outerHeight / 128)];
  156. }
  157. class Chunk {
  158.         public Chunk() {};
  159.         public Chunk(Tile[] tiles_) {
  160.                 tiles = tiles_;
  161.         }
  162.        
  163.         public Tile[] tiles = new Tile[64];
  164.         public int tilesN = 0;
  165.        
  166.         public Tile getTile(int x, int y) {
  167.                 return this.tiles[y * 8 + x];
  168.         }
  169.         public void addTile(int x, int y, Tile tile) {
  170.                 if (this.tiles[y * 8 + x] == null) {
  171.                         this.tiles[y * 8 + x] = tile;
  172.                         this.tilesN++;
  173.                 }
  174.                 else {
  175.                         System.out.println("NOTICE: Tile at (" + x + "," + y + ") already exists.");
  176.                 }
  177.         }
  178. }
  179. class Canvas extends JPanel {
  180.         public Canvas() throws IOException {
  181.                 setDoubleBuffered(true);
  182.                 cursor = this.getMousePosition();
  183.         }
  184.        
  185.         public Point cursor;   
  186.         public BufferedImage loadImage(String name) {
  187.                 // ????
  188.                 try {
  189.                         return ImageIO.read(getClass().getResource("/assets/image/" + name));
  190.                 }
  191.                 catch (Throwable t) {
  192.                         // fuck everything
  193.                         t.printStackTrace();
  194.                         return null;
  195.                 }
  196.         }
  197.         public void paint(Graphics g) {
  198.                 /*
  199.                 for (int i = 0; i < Level.tileset.size(); i++) {
  200.                         g.drawImage(loadImage(Level.tileset.get(i).sprite), Level.tileset.get(i).x, Level.tileset.get(i).y, null);
  201.                 }
  202.                 */
  203.                 for (int i = 0; i < Level.chunks.length; i++) {
  204.                         if (Level.chunks[i] != null && Level.chunks[i].tilesN != 0) {
  205.                                 for (int j = 0; j < Level.chunks[i].tiles.length; j++) {
  206.                                         if (Level.chunks[i].tiles[j] != null) {
  207.                                                 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);
  208.                                         }
  209.                                 }
  210.                         }
  211.                 }
  212.                 for (int i = 0; i < Level.entities.size(); i++) {
  213.                         // fghjkl
  214.                         g.drawImage(loadImage(Level.entities.get(i).sprite.src), Level.entities.get(i).x, Level.entities.get(i).y, null);
  215.                 }
  216.         }
  217. }
  218. class Sprite {
  219.         public Sprite(String src_) {
  220.                 x = 0;
  221.                 y = 0;
  222.                 offsetX = 0;
  223.                 offsetY = 0;
  224.                 src = src_;
  225.         }
  226.         public Sprite(int x_, int y_, String src_) {
  227.                 x = x_;
  228.                 y = y_;
  229.                 offsetX = 0;
  230.                 offsetY = 0;
  231.                 src = src_;
  232.         }
  233.         public Sprite(int x_, int y_, int offsetX_, int offsetY_, String src_) {
  234.                 x = x_;
  235.                 y = y_;
  236.                 offsetX = offsetX_;
  237.                 offsetY = offsetY_;
  238.                 src = src_;
  239.         }
  240.        
  241.         public int x;
  242.         public int y;
  243.         public int offsetX;
  244.         public int offsetY;
  245.         public String src;
  246. }
  247. abstract class DynamicObject {
  248.         public DynamicObject(boolean[] solid_, String sprite_) {
  249.                 sprite = new Sprite(sprite_);
  250.                 solid = solid_;
  251.         }
  252.        
  253.         public final Sprite sprite;
  254.         public boolean[] solid;
  255.        
  256.         public boolean isSolid(String dir) {
  257.                 switch (dir) {
  258.                         case "top":
  259.                                 return this.solid[0];
  260.                         case "right":
  261.                                 return this.solid[1];
  262.                         case "bottom":
  263.                                 return this.solid[2];
  264.                         case "left":
  265.                                 return this.solid[3];
  266.                         default:
  267.                                 System.err.println("ERROR: Invalid argument in DynamicObject.isSolid(String).");
  268.                                 return false;
  269.                 }
  270.         }
  271. }
  272. abstract class AbstractEntity extends DynamicObject {
  273.         public AbstractEntity(int x_, int y_, boolean[] solid_, String sprite_) {
  274.                 super(solid_, sprite_);
  275.                 sprite.x = x_;
  276.                 sprite.y = y_;
  277.                 x = x_;
  278.                 y = y_;
  279.         }
  280.         public int x;
  281.         public int y;
  282. }
  283. class Entity extends AbstractEntity {
  284.         public Entity(int x_, int y_, boolean[] solid_, String sprite_, byte dir_) {
  285.                 super(x_, y_, solid_, sprite_);
  286.                 dir = dir_;
  287.                 velX = 0f;
  288.                 velY = 0f;
  289.         }
  290.        
  291.         public byte dir;
  292.         public float velX;
  293.         public float velY;
  294. }
  295. class Tile extends DynamicObject {
  296.         public Tile(boolean[] solid_, String sprite_, String name_) {
  297.                 super(solid_, sprite_);
  298.                 name = name_;
  299.                 id = Tile.idIndex;
  300.                 Tile.idIndex++;
  301.         }
  302.        
  303.         public String name;
  304.         public short id;
  305.        
  306.         public static short idIndex = 1;
  307. }
  308. class TileEntity extends AbstractEntity {
  309.         public TileEntity (int x_, int y_, short tileID) {
  310.                 super(x_, y_, new boolean[] {false, false, false, false}, Level.tileset.get(tileID).sprite.src);
  311.         }
  312. }
  313.  
  314. /* ============================================================= */
  315. /* ========================= TILES ============================= */
  316. /* ============================================================= */
  317.  
  318. class BasicFloortile extends Tile {
  319.         public BasicFloortile() {
  320.                 super(new boolean[] {true, true, true, true}, "tile/basic-floortile.png", "basic_floortile");
  321.         }
  322. }
  323. class BasicCeilingtile extends Tile {
  324.         public BasicCeilingtile() {
  325.                 super(new boolean[] {true, true, true, true}, "tile/basic-ceilingtile.png", "basic_ceilingtile");
  326.         }
  327. }
  328. class BasicWalltileLeft extends Tile {
  329.         public BasicWalltileLeft() {
  330.                 super(new boolean[] {true, true, true, true}, "tile/basic-walltile-left.png", "basic_walltile_left");
  331.         }
  332. }
  333. class BasicWalltileRight extends Tile {
  334.         public BasicWalltileRight() {
  335.                 super(new boolean[] {true, true, true, true}, "tile/basic-walltile-right.png", "basic_walltile_right");
  336.         }
  337. }
  338. class BasicCornertileTopLeft extends Tile {
  339.         public BasicCornertileTopLeft() {
  340.                 super(new boolean[] {true, true, true, true}, "tile/basic-cornertile-top-left.png", "basic_cornertile_top_left");
  341.         }
  342. }
  343. class BasicCornertileTopRight extends Tile {
  344.         public BasicCornertileTopRight() {
  345.                 super(new boolean[] {true, true, true, true}, "tile/basic-cornertile-top-right.png", "basic_cornertile_top_right");
  346.         }
  347. }
  348. class BasicCornertileBottomRight extends Tile {
  349.         public BasicCornertileBottomRight() {
  350.                 super(new boolean[] {true, true, true, true}, "tile/basic-cornertile-bottom-right.png", "basic_cornertile_bottom_right");
  351.         }
  352. }
  353. class BasicCornertileBottomLeft extends Tile {
  354.         public BasicCornertileBottomLeft() {
  355.                 super(new boolean[] {true, true, true, true}, "tile/basic-cornertile-bottom-left.png", "basic_cornertile_bottom_left");
  356.         }
  357. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top