libgdx蛇逻辑解释

这是我正在读的一本书中的代码。这只是一个蛇的游戏。您可以将此代码粘贴到编辑器中，并将3个纹理文件更改为计算机上的纹理文件。代码运行良好，这可能真的很愚蠢，但我无法在蛇身部分和它们的位置之间建立联系。蛇的头部改变位置后，蛇的身体（而不是头部）如何确切地知道它应该去哪里？你能详细说明一下吗？多谢各位

//第1/2类：

 public class MyGdxGame extends Game {


@Override
public void create () {
setScreen(new GameScreen());
}

} 第2/2类：

package com.mygdx.game;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input;
import com.badlogic.gdx.ScreenAdapter;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.graphics.g2d.Batch;

import com.badlogic.gdx.utils.Array;

public class GameScreen extends ScreenAdapter{
    private static final float MOVE_TIME = 0.5F;
    private static final int SNAKE_MOVEMENT = 32;

    private static final int RIGHT = 0;
    private static final int LEFT = 1;
    private static final int UP = 2;
    private static final int DOWN = 3;

    private SpriteBatch batch;
    private Texture snakeHead;
    private Texture snakeBody;
    private Texture apple;

    private boolean appleAvailable = false;
    private int appleX, appleY;

    private float timer = MOVE_TIME;
    private int snakeX = 0, snakeY = 0;
    private int snakeXBeforeUpdate = 0, snakeYBeforeUpdate = 0;

    private int snakeDirection = RIGHT;

    private Array<BodyPart> bodyParts = new Array<BodyPart>();

    @Override
    public void show() {
        super.show();
        batch = new SpriteBatch();
        snakeHead = new Texture(Gdx.files.internal("snakehead.png"));
        snakeBody = new Texture(Gdx.files.internal("snakeBody.png"));
        apple = new Texture(Gdx.files.internal("apple.png"));
    }

    @Override
    public void render(float delta) {
        super.render(delta);
        queryInput();
        timer -= delta;
        if (timer <= 0) {
            timer = MOVE_TIME;
            moveSnake();
            checkForOutOfBounds();
            updateBodyPartsPosition();
        }
        checkAppleCollision();
        checkAndPlaceApple();
        clearScreen();
        draw();
    }

    private void queryInput() {
        boolean lPressed = Gdx.input.isKeyPressed(Input.Keys.LEFT);
        boolean rPressed = Gdx.input.isKeyPressed(Input.Keys.RIGHT);
        boolean uPressed = Gdx.input.isKeyPressed(Input.Keys.UP);
        boolean dPressed = Gdx.input.isKeyPressed(Input.Keys.DOWN);

        if (lPressed) snakeDirection = LEFT;
        if (rPressed) snakeDirection = RIGHT;
        if (uPressed) snakeDirection = UP;
        if (dPressed) snakeDirection = DOWN;
    }

    private void moveSnake() {
        snakeXBeforeUpdate = snakeX;
        snakeYBeforeUpdate = snakeY;
        switch (snakeDirection) {
            case RIGHT: {
                snakeX += SNAKE_MOVEMENT;
                return;
            }
            case LEFT: {
                snakeX -= SNAKE_MOVEMENT;
                return;
            }
            case UP: {
                snakeY += SNAKE_MOVEMENT;
                return;
            }
            case DOWN: {
                snakeY -= SNAKE_MOVEMENT;
                return;
            }
        }
    }

    private void checkForOutOfBounds() {
        if (snakeX >= Gdx.graphics.getWidth()) {
            snakeX = 0;
        }
        if (snakeX < 0) {
            snakeX = Gdx.graphics.getWidth() - SNAKE_MOVEMENT;
        }
        if (snakeY >= Gdx.graphics.getHeight()) {
            snakeY = 0;
        }
        if (snakeY < 0) {
            snakeY = Gdx.graphics.getHeight() - SNAKE_MOVEMENT;
        }
    }

    private void updateBodyPartsPosition() {
        if (bodyParts.size > 0) {
            BodyPart bodyPart = bodyParts.removeIndex(0);
            bodyPart.updateBodyPosition(snakeXBeforeUpdate, snakeYBeforeUpdate);
            bodyParts.add(bodyPart);
        }
    }

    private void checkAndPlaceApple() {
        if (!appleAvailable) {
            do {
                appleX = MathUtils.random(Gdx.graphics.getWidth() / SNAKE_MOVEMENT - 1) * SNAKE_MOVEMENT;
                appleY = MathUtils.random(Gdx.graphics.getHeight() / SNAKE_MOVEMENT - 1) * SNAKE_MOVEMENT;
                appleAvailable = true;
            } while (appleX == snakeX && appleY == snakeY);
        }
    }

    private void checkAppleCollision() {
        if (appleAvailable && appleX == snakeX && appleY == snakeY) {
            BodyPart bodyPart = new BodyPart(snakeBody);
            bodyPart.updateBodyPosition(snakeX, snakeY);
            bodyParts.insert(0,bodyPart);
            appleAvailable = false;
        }
    }

    private void clearScreen() {
        Gdx.gl.glClearColor(Color.BLACK.r, Color.BLACK.g, Color.BLACK.b, Color.BLACK.a);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
    }

    private void draw() {
        batch.begin();
        batch.draw(snakeHead, snakeX, snakeY);
        for (BodyPart bodyPart : bodyParts) {
            bodyPart.draw(batch);
        }
        if (appleAvailable) {
            batch.draw(apple, appleX, appleY);
        }
        batch.end();
    }

    private class BodyPart {

        private int x, y;
        private Texture texture;

        public BodyPart(Texture texture) {
            this.texture = texture;
        }

        public void updateBodyPosition(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public void draw(Batch batch) {
            if (!(x == snakeX && y == snakeY)) batch.draw(texture, x, y);
        }
    }
}

package com.mygdx.game；
导入com.badlogic.gdx.gdx；
导入com.badlogic.gdx.Input；
导入com.badlogic.gdx.ScreenAdapter；
导入com.badlogic.gdx.graphics.Color；
导入com.badlogic.gdx.graphics.GL20；
导入com.badlogic.gdx.graphics.Texture；
导入com.badlogic.gdx.graphics.g2d.SpriteBatch；
导入com.badlogic.gdx.math.MathUtils；
导入com.badlogic.gdx.graphics.g2d.Batch；
导入com.badlogic.gdx.utils.Array；
公共类GameScreen扩展了ScreenAdapter{
专用静态最终浮动移动时间=0.5F；
私有静态最终int SNAKE_移动=32；
私有静态final int RIGHT=0；
私有静态final int LEFT=1；
专用静态最终整型=2；
私有静态最终整数向下=3；
专用SpriteBatch批次；
私家蛇头；
私有结构蛇体；
私家苹果；
私有布尔appleAvailable=false；
私人int appleX，appleY；
专用浮动计时器=移动时间；
私有int snakeX=0，snakeY=0；
私有int snakeXBeforeUpdate=0，snakeYBeforeUpdate=0；
私有int蛇形方向=右；
私有数组bodyParts=新数组（）；
@凌驾
公开展览（{
super.show（）；
批次=新的SpriteBatch（）；
snakeHead=新纹理（Gdx.files.internal（“snakeHead.png”）；
snakeBody=新纹理（Gdx.files.internal（“snakeBody.png”）；
apple=新纹理（Gdx.files.internal（“apple.png”）；
}
@凌驾
公共无效渲染（浮动增量）{
超级渲染（delta）；
查询输入（）；
定时器-=增量；
if（timer=Gdx.graphics.getWidth（））{
蛇x=0；
}
如果（蛇<0）{
snakeX=Gdx.graphics.getWidth（）-SNAKE\u移动；
}
如果（snakeY>=Gdx.graphics.getHeight（））{
snakeY=0；
}
如果（snakeY<0）{
snakeY=Gdx.graphics.getHeight（）；
}
}
私有void updateBodyPartsPosition（）{
如果（bodyParts.size>0）{
BodyPart BodyPart=bodyParts.removeIndex（0）；
bodyPart.updateBodyPosition（snakeXBeforeUpdate，SnakeBeforeUpdate）；
车身部件。添加（车身部件）；
}
}
私有void checkAndPlaceApple（）{
如果（！appleAvailable）{
做{
appleX=MathUtils.random（Gdx.graphics.getWidth（）/SNAKE\u MOVEMENT-1）*SNAKE\u MOVEMENT；
appleY=MathUtils.random（Gdx.graphics.getHeight（）/SNAKE\u MOVEMENT-1）*SNAKE\u MOVEMENT；
appleAvailable=true；
}while（appleX==snakeX&&appleY==snakeY）；
}
}
私有无效检查AppleCollision（）{
if（appleavaailable&&appleX==snakeX&&appleY==snakeY）{
车身部件车身部件=新车身部件（蛇形车身）；
车身部件。更新动态位置（蛇形、蛇形）；
车身部件。插入件（0，车身部件）；
appleAvailable=false；
}
}
私有无效清除屏幕（）{
gl.glClearColor（Color.BLACK.r，Color.BLACK.g，Color.BLACK.b，Color.BLACK.a）；
Gdx.gl.glClear（GL20.gl\u颜色\u缓冲\u位）；
}
私人提款（）{
batch.begin（）；
批量绘制（蛇头、蛇、蛇）；
用于（车身部件车身部件：车身部件）{
车身零件图（批次）；
}
如果（应用程序可用）{
批量绘制（苹果、苹果、苹果）；
}
batch.end（）；
}
私家车车身部件{
私有整数x，y；
私有纹理；
公共车身部件（纹理）{
这个纹理=纹理；
}
公共无效更新动态位置（整数x，整数y）{
这个.x=x；
这个。y=y；
}
公共作废提取（批量）{
如果（！（x==snakeX&&y==snakeY））批量绘制（纹理，x，y）；
}
}
}

首先，它会在moveSnake（）中移动头部，确保在移动之前跟踪头部的位置。然后在updateBodyPartsPosition（）中，它将身体的最后一部分放在头部刚刚移动的位置。

Yees。就这样。一个小问题。在代码的最后一行中，主要是在绘制方法中，在头部位置确定后绘制身体部位。然而，我认为蛇身出现在蛇头下方，因此直到蛇向前移动时才可见。为什么它们被画在蛇头下面？就像你说的，如果它们重叠的话，身体部分会被画在蛇头的顶部。没有照片我不知道你在看什么。