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