core/src/ru/deadsoftware/cavecraft/game/GameRenderer.java

   1 package ru.deadsoftware.cavecraft.game;
   2
   3 import com.badlogic.gdx.Gdx;
   4 import com.badlogic.gdx.graphics.GL20;
   5 import com.badlogic.gdx.math.MathUtils;
   6 import com.badlogic.gdx.math.Vector2;
   7 import ru.deadsoftware.cavecraft.CaveGame;
   8 import ru.deadsoftware.cavecraft.GameScreen;
   9 import ru.deadsoftware.cavecraft.game.mobs.Mob;
  10 import ru.deadsoftware.cavecraft.game.objects.Drop;
  11 import ru.deadsoftware.cavecraft.game.objects.Player;
  12 import ru.deadsoftware.cavecraft.misc.Assets;
  13 import ru.deadsoftware.cavecraft.misc.Renderer;
  14
  15 public class GameRenderer extends Renderer {
  16
  17     private GameProc gameProc;
  18
  19     public GameRenderer(GameProc gameProc, float width, float heigth) {
  20         super(width, heigth);
  21         Gdx.gl.glClearColor(0f, .6f, .6f, 1f);
  22         this.gameProc = gameProc;
  23     }
  24
  25     private void drawWorldBackground() {
  26         int minX = (int) (camera.position.x / 16) - 1;
  27         int minY = (int) (camera.position.y / 16) - 1;
  28         int maxX = (int) ((camera.position.x + camera.viewportWidth) / 16) + 1;
  29         int maxY = (int) ((camera.position.y + camera.viewportHeight) / 16) + 1;
  30         if (minY < 0) minY = 0;
  31         if (maxY > gameProc.world.getHeight()) maxY = gameProc.world.getHeight();
  32         for (int y = minY; y < maxY; y++) {
  33             for (int x = minX; x < maxX; x++) {
  34                 if ((gameProc.world.getForeMap(x, y) == 0 || Items.BLOCKS.getValueAt(gameProc.world.getForeMap(x, y)).transparent)
  35                         && gameProc.world.getBackMap(x, y) > 0) {
  36                     spriteBatch.draw(
  37                             Assets.blockTextures[Items.BLOCKS.getValueAt(gameProc.world.getBackMap(x, y)).getTexture()],
  38                             x * 16 - camera.position.x, y * 16 - camera.position.y);
  39                     Assets.shade.setPosition(x * 16 - camera.position.x, y * 16 - camera.position.y);
  40                     Assets.shade.draw(spriteBatch);
  41                 }
  42                 if (gameProc.world.getForeMap(x, y) > 0 && Items.BLOCKS.getValueAt(gameProc.world.getForeMap(x, y)).background) {
  43                     spriteBatch.draw(
  44                             Assets.blockTextures[Items.BLOCKS.getValueAt(gameProc.world.getForeMap(x, y)).getTexture()],
  45                             x * 16 - camera.position.x, y * 16 - camera.position.y);
  46                 }
  47             }
  48         }
  49     }
  50
  51     private void drawWorldForeground() {
  52         int minX = (int) (camera.position.x / 16) - 1;
  53         int minY = (int) (camera.position.y / 16) - 1;
  54         int maxX = (int) ((camera.position.x + camera.viewportWidth) / 16) + 1;
  55         int maxY = (int) ((camera.position.y + camera.viewportHeight) / 16) + 1;
  56         if (minY < 0) minY = 0;
  57         if (maxY > gameProc.world.getHeight()) maxY = gameProc.world.getHeight();
  58         for (int y = minY; y < maxY; y++) {
  59             for (int x = minX; x < maxX; x++) {
  60                 if (gameProc.world.getForeMap(x, y) > 0 && !Items.BLOCKS.getValueAt(gameProc.world.getForeMap(x, y)).background) {
  61                     spriteBatch.draw(
  62                             Assets.blockTextures[Items.BLOCKS.getValueAt(gameProc.world.getForeMap(x, y)).getTexture()],
  63                             x * 16 - camera.position.x, y * 16 - camera.position.y);
  64                 }
  65             }
  66         }
  67     }
  68
  69     private void drawMob(Mob mob) {
  70         mob.draw(spriteBatch,
  71                 mob.position.x - camera.position.x - gameProc.world.getWidth() * 16, mob.position.y - camera.position.y);
  72         mob.draw(spriteBatch,
  73                 mob.position.x - camera.position.x, mob.position.y - camera.position.y);
  74         mob.draw(spriteBatch,
  75                 mob.position.x - camera.position.x + gameProc.world.getWidth() * 16, mob.position.y - camera.position.y);
  76     }
  77
  78     private void drawDrop(Drop drop) {
  79         switch (Items.ITEMS.get(drop.getId()).getType()) {
  80             case 0:
  81                 Assets.blockTextures[Items.ITEMS.get(drop.getId()).getTexture()].setPosition(drop.position.x - camera.position.x - gameProc.world.getWidth() * 16, drop.position.y - camera.position.y);
  82                 Assets.blockTextures[Items.ITEMS.get(drop.getId()).getTexture()].draw(spriteBatch);
  83                 Assets.blockTextures[Items.ITEMS.get(drop.getId()).getTexture()].setPosition(drop.position.x - camera.position.x, drop.position.y - camera.position.y);
  84                 Assets.blockTextures[Items.ITEMS.get(drop.getId()).getTexture()].draw(spriteBatch);
  85                 Assets.blockTextures[Items.ITEMS.get(drop.getId()).getTexture()].setPosition(drop.position.x - camera.position.x + gameProc.world.getWidth() * 16, drop.position.y - camera.position.y);
  86                 Assets.blockTextures[Items.ITEMS.get(drop.getId()).getTexture()].draw(spriteBatch);
  87         }
  88     }
  89
  90     private void drawPlayer(Player pl) {
  91         if (pl.move.x != 0 || Assets.playerSprite[0][2].getRotation() != 0) {
  92             Assets.playerSprite[0][2].rotate(Player.ANIM_SPEED);
  93             Assets.playerSprite[1][2].rotate(-Player.ANIM_SPEED);
  94             Assets.playerSprite[0][3].rotate(-Player.ANIM_SPEED);
  95             Assets.playerSprite[1][3].rotate(Player.ANIM_SPEED);
  96         } else {
  97             Assets.playerSprite[0][2].setRotation(0);
  98             Assets.playerSprite[1][2].setRotation(0);
  99             Assets.playerSprite[0][3].setRotation(0);
 100             Assets.playerSprite[1][3].setRotation(0);
 101         }
 102         if (Assets.playerSprite[0][2].getRotation() >= 60 || Assets.playerSprite[0][2].getRotation() <= -60)
 103             Player.ANIM_SPEED = -Player.ANIM_SPEED;
 104
 105         //back hand
 106         Assets.playerSprite[1][2].setPosition(
 107                 pl.position.x - camera.position.x - 6,
 108                 pl.position.y - camera.position.y);
 109         Assets.playerSprite[1][2].draw(spriteBatch);
 110         //back leg
 111         Assets.playerSprite[1][3].setPosition(
 112                 pl.position.x - camera.position.x - 6,
 113                 pl.position.y - camera.position.y + 10);
 114         Assets.playerSprite[1][3].draw(spriteBatch);
 115         //front leg
 116         Assets.playerSprite[0][3].setPosition(
 117                 pl.position.x - camera.position.x - 6,
 118                 pl.position.y - camera.position.y + 10);
 119         Assets.playerSprite[0][3].draw(spriteBatch);
 120         //head
 121         spriteBatch.draw(Assets.playerSprite[pl.dir][0],
 122                 pl.position.x - camera.position.x - 2,
 123                 pl.position.y - camera.position.y - 2);
 124         //body
 125         spriteBatch.draw(Assets.playerSprite[pl.dir][1],
 126                 pl.position.x - camera.position.x - 2, pl.position.y - camera.position.y + 8);
 127         //item in hand
 128         if (pl.inventory[gameProc.invSlot] > 0)
 129             switch (Items.ITEMS.get(pl.inventory[gameProc.invSlot]).getType()) {
 130                 case 0:
 131                     Assets.blockTextures[Items.ITEMS.get(pl.inventory[gameProc.invSlot]).getTexture()].setPosition(
 132                             pl.position.x - camera.position.x - 8 * MathUtils.sin(MathUtils.degRad * Assets.playerSprite[0][2].getRotation()),
 133                             pl.position.y - camera.position.y + 6 + 8 * MathUtils.cos(MathUtils.degRad * Assets.playerSprite[0][2].getRotation()));
 134                     Assets.blockTextures[Items.ITEMS.get(pl.inventory[gameProc.invSlot]).getTexture()].draw(spriteBatch);
 135                     break;
 136                 default:
 137                     Assets.itemTextures[Items.ITEMS.get(pl.inventory[gameProc.invSlot]).getTexture()].flip((pl.dir == 0), false);
 138                     Assets.itemTextures[Items.ITEMS.get(pl.inventory[gameProc.invSlot]).getTexture()].setRotation(
 139                             -45 + pl.dir * 90 + Assets.playerSprite[0][2].getRotation());
 140                     Assets.itemTextures[Items.ITEMS.get(pl.inventory[gameProc.invSlot]).getTexture()].setPosition(
 141                             pl.position.x - camera.position.x - 10 + (12 * pl.dir) - 8 * MathUtils.sin(MathUtils.degRad * Assets.playerSprite[0][2].getRotation()),
 142                             pl.position.y - camera.position.y + 2 + 8 * MathUtils.cos(MathUtils.degRad * Assets.playerSprite[0][2].getRotation()));
 143                     Assets.itemTextures[Items.ITEMS.get(pl.inventory[gameProc.invSlot]).getTexture()].draw(spriteBatch);
 144                     Assets.itemTextures[Items.ITEMS.get(pl.inventory[gameProc.invSlot]).getTexture()].flip((pl.dir == 0), false);
 145                     break;
 146             }
 147         //front hand
 148         Assets.playerSprite[0][2].setPosition(
 149                 pl.position.x - camera.position.x - 6,
 150                 pl.position.y - camera.position.y);
 151         Assets.playerSprite[0][2].draw(spriteBatch);
 152     }
 153
 154     private void drawCreative() {
 155         float x = camera.viewportWidth / 2 - Assets.creativeInv.getRegionWidth() / 2;
 156         float y = camera.viewportHeight / 2 - Assets.creativeInv.getRegionHeight() / 2;
 157         spriteBatch.draw(Assets.creativeInv, x, y);
 158         spriteBatch.draw(Assets.creativeScroll, x + 156,
 159                 y + 18 + (gameProc.creativeScroll * (72 / gameProc.maxCreativeScroll)));
 160         for (int i = gameProc.creativeScroll * 8; i < gameProc.creativeScroll * 8 + 40; i++) {
 161             if (i > 0 && i < Items.ITEMS.size())
 162                 switch (Items.ITEMS.get(i).getType()) {
 163                     case 0:
 164                         spriteBatch.draw(Assets.blockTextures[Items.ITEMS.get(i).getTexture()],
 165                                 x + 8 + ((i - gameProc.creativeScroll * 8) % 8) * 18,
 166                                 y + 18 + ((i - gameProc.creativeScroll * 8) / 8) * 18);
 167                         break;
 168                     case 1:
 169                         spriteBatch.draw(Assets.itemTextures[Items.ITEMS.get(i).getTexture()],
 170                                 x + 8 + ((i - gameProc.creativeScroll * 8) % 8) * 18,
 171                                 y + 18 + ((i - gameProc.creativeScroll * 8) / 8) * 18);
 172                         break;
 173                 }
 174         }
 175         for (int i = 0; i < 9; i++) {
 176             if (gameProc.player.inventory[i] > 0)
 177                 switch (Items.ITEMS.get(gameProc.player.inventory[i]).getType()) {
 178                     case 0:
 179                         spriteBatch.draw(Assets.blockTextures[Items.ITEMS.get(gameProc.player.inventory[i]).getTexture()],
 180                                 x + 8 + i * 18, y + Assets.creativeInv.getRegionHeight() - 24);
 181                         break;
 182                     case 1:
 183                         spriteBatch.draw(Assets.itemTextures[Items.ITEMS.get(gameProc.player.inventory[i]).getTexture()],
 184                                 x + 8 + i * 18, y + Assets.creativeInv.getRegionHeight() - 24);
 185                         break;
 186                 }
 187         }
 188     }
 189
 190     private void drawGUI() {
 191         if (gameProc.blockDmg > 0) {
 192             spriteBatch.draw(Assets.wreck[
 193                             10 * gameProc.blockDmg /
 194                                     Items.BLOCKS.getValueAt(gameProc.world.getForeMap(gameProc.cursorX, gameProc.cursorY)).getHp()],
 195                     gameProc.cursorX * 16 - camera.position.x,
 196                     gameProc.cursorY * 16 - camera.position.y);
 197         }
 198         if (gameProc.world.getForeMap(gameProc.cursorX, gameProc.cursorY) > 0 ||
 199                 gameProc.world.getBackMap(gameProc.cursorX, gameProc.cursorY) > 0 ||
 200                 gameProc.ctrlMode == 1 ||
 201                 !CaveGame.TOUCH)
 202             spriteBatch.draw(Assets.guiCur,
 203                     gameProc.cursorX * 16 - camera.position.x,
 204                     gameProc.cursorY * 16 - camera.position.y);
 205         spriteBatch.draw(Assets.invBar, camera.viewportWidth / 2 - Assets.invBar.getRegionWidth() / 2, 0);
 206         for (int i = 0; i < 9; i++) {
 207             if (gameProc.player.inventory[i] > 0) {
 208                 switch (Items.ITEMS.get(gameProc.player.inventory[i]).getType()) {
 209                     case 0:
 210                         spriteBatch.draw(Assets.blockTextures[Items.ITEMS.get(gameProc.player.inventory[i]).getTexture()],
 211                                 camera.viewportWidth / 2 - Assets.invBar.getRegionWidth() / 2 + 3 + i * 20,
 212                                 3);
 213                         break;
 214                     case 1:
 215                         spriteBatch.draw(Assets.itemTextures[Items.ITEMS.get(gameProc.player.inventory[i]).getTexture()],
 216                                 camera.viewportWidth / 2 - Assets.invBar.getRegionWidth() / 2 + 3 + i * 20,
 217                                 3);
 218                         break;
 219                 }
 220             }
 221         }
 222         spriteBatch.draw(Assets.invBarCur,
 223                 camera.viewportWidth / 2 - Assets.invBar.getRegionWidth() / 2 - 1 + 20 * gameProc.invSlot,
 224                 -1);
 225     }
 226
 227     private void drawTouchGui() {
 228         spriteBatch.draw(Assets.touchArrows[0], 26, camera.viewportHeight - 52);
 229         spriteBatch.draw(Assets.touchArrows[1], 0, camera.viewportHeight - 26);
 230         spriteBatch.draw(Assets.touchArrows[2], 26, camera.viewportHeight - 26);
 231         spriteBatch.draw(Assets.touchArrows[3], 52, camera.viewportHeight - 26);
 232         spriteBatch.draw(Assets.touchLMB, camera.viewportWidth - 52, camera.viewportHeight - 26);
 233         spriteBatch.draw(Assets.touchRMB, camera.viewportWidth - 26, camera.viewportHeight - 26);
 234         spriteBatch.draw(Assets.touchToggleMode, 78, camera.viewportHeight - 26);
 235         if (gameProc.ctrlMode == 1) {
 236             Assets.shade.setPosition(83, camera.viewportHeight - 21);
 237             Assets.shade.draw(spriteBatch);
 238         }
 239     }
 240
 241     private void drawGamePlay() {
 242         drawWorldBackground();
 243         drawPlayer(gameProc.player);
 244         for (Mob mob : gameProc.mobs) drawMob(mob);
 245         for (Drop drop : gameProc.drops) drawDrop(drop);
 246         drawWorldForeground();
 247         drawGUI();
 248     }
 249
 250     @Override
 251     public void render() {
 252         Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
 253
 254         spriteBatch.begin();
 255         switch (CaveGame.STATE) {
 256             case GAME_PLAY:
 257                 drawGamePlay();
 258                 break;
 259             case GAME_CREATIVE_INV:
 260                 drawGamePlay();
 261                 drawCreative();
 262                 break;
 263         }
 264
 265         if (CaveGame.TOUCH) drawTouchGui();
 266
 267         if (GameScreen.SHOW_DEBUG) {
 268             drawString("FPS: " + GameScreen.FPS, 0, 0);
 269             drawString("X: " + (int) (gameProc.player.position.x / 16), 0, 10);
 270             drawString("Y: " + (int) (gameProc.player.position.y / 16), 0, 20);
 271             drawString("Mobs: " + gameProc.mobs.size(), 0, 30);
 272             drawString("Drops: " + gameProc.drops.size(), 0, 40);
 273             drawString("Block: " + Items.BLOCKS.getKeyAt(gameProc.world.getForeMap(gameProc.cursorX, gameProc.cursorY)), 0, 50);
 274         }
 275
 276         spriteBatch.end();
 277     }
 278
 279 }