java 如何在java中使精灵跳跃？

How to make sprite jump in java?

提问by DarrenKing

I have KeyEvents for a sprite for moving left, right, up and down. I was just messing around and was thinking ahead for another project in which I want the sprite to jump. It doesn't have to be fully realistic as I am just beginning. What I have is when the space bar is pressed, it will cause the sprite to jump, lets say "dy = -3". So then I have the KeyEvent for keyReleased, it will fall, "dy = -2". This does not work as the sprite just continues to fall...can someone shine some light?

我有一个用于向左、向右、向上和向下移动的精灵的 KeyEvents。我只是在胡闹，正在考虑另一个我希望精灵跳跃的项目。它不必完全现实，因为我才刚刚开始。我所拥有的是当按下空格键时，它会导致精灵跳跃，比如说“dy = -3”。那么我有keyReleased的KeyEvent，它会下降，“dy = -2”。这不起作用，因为精灵只是继续下降......有人可以发光吗？

Entire code: package collision;

整个代码：包冲突；

    import java.awt.Image;
    import java.awt.Rectangle;
    import java.awt.event.KeyEvent;

    import java.util.ArrayList;

    import javax.swing.ImageIcon;

    public class Craft {

    private String craft = "pelican.png";

    private int dx;
    private int dy;
    private int x;
    private int y;
    private int width;
    private int height;
    private boolean visible;
    private Image image;
    private ArrayList missiles;


    public Craft() {
    ImageIcon ii = new ImageIcon(this.getClass().getResource(craft));
    image = ii.getImage();
    width = image.getWidth(null);
    height = image.getHeight(null);
    missiles = new ArrayList();
    visible = true;
    x = 100;
    y = 300;
    }


    public void move() {

    x += dx;
    y += dy;

    if (x < 1) {
        x = 1;
    }

    if (y < 1) {
        y = 1;
    }

    }

    public int getX() {
    return x;
    }

    public int getY() {
    return y;
    }

    public Image getImage() {
    return image;
    }

    public ArrayList getMissiles() {
    return missiles;
    }

    public void setVisible(boolean visible) {
    this.visible = visible;
    }

    public boolean isVisible() {
    return visible;
    }

     public Rectangle getBounds() {
    return new Rectangle(x, y, width, height);
    }

    public void keyPressed(KeyEvent e) {

    int key = e.getKeyCode();

    if (key == KeyEvent.VK_SPACE) {

    }
    if (key == KeyEvent.VK_V){
        dx = 6;
    }

    if (key == KeyEvent.VK_LEFT) {
        dx = -1;
    }

    if (key == KeyEvent.VK_RIGHT) {
        dx = 2;
    }

    if (key == KeyEvent.VK_UP) {
        dy = -1;
    }

    if (key == KeyEvent.VK_DOWN) {
        dy = 1;
    }
    }

    public void fire() {
    missiles.add(new Missile(x + width, y + height/2));
    }

    public void keyReleased(KeyEvent e) {
    int key = e.getKeyCode();

    if (key == KeyEvent.VK_LEFT) {
        dx = 0;
    }
    if (key == KeyEvent.VK_SPACE) {

    }

    if (key == KeyEvent.VK_RIGHT) {
        dx = 0;
    }

    if (key == KeyEvent.VK_UP) {
        dy = 0;
    }

    if (key == KeyEvent.VK_DOWN) {
        dy = 0;
    }
    }
    }

As you may have noticed Im new to Java as well as game programming. All I want is the sprite to go up, then come back down. It will always remain stationary if that helps. The sprite just keeps jumping until he is hit by an on coming obstacle. I know there is code for other movements, but those will be removed once I start on next sprite.

您可能已经注意到，我是 Java 和游戏编程的新手。我想要的只是精灵上升，然后再下降。如果有帮助，它将始终保持静止。精灵会一直跳跃，直到被即将到来的障碍物击中。我知道还有其他动作的代码，但是一旦我开始下一个精灵，这些代码就会被删除。

回答by MadProgrammer

This is basic concept. Your implementation will change depending on the implementation of your engine.

这是基本概念。您的实现将根据引擎的实现而变化。

The basic idea is the player has a vertical delta which is changed over time by gravity. This effects the sprites vertical speed.

基本思想是玩家有一个垂直增量，随着时间的推移重力会发生变化。这会影响精灵的垂直速度。

This implementation also has a re-bound delta, which allows the sprite to re-bound rather the "stopping" suddenly. The re-bound is effected by a re-bound degradation, which reduces the amount of re-bound on each re-bound.

这个实现也有一个重新绑定的增量，它允许精灵重新绑定而不是突然“停止”。回弹受回弹降解的影响，这减少了每次回弹时的回弹量。

This simulates a game character, so you'll need to hit Spaceto start it bouncing...

这模拟了一个游戏角色，所以你需要点击Space它才能开始弹跳......

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import javax.swing.AbstractAction;
import javax.swing.ActionMap;
import javax.swing.InputMap;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.KeyStroke;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class JumpingSprite {

    public static void main(String[] args) {
        new JumpingSprite();
    }

    public JumpingSprite() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                }

                JFrame frame = new JFrame("Test");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new BorderLayout());
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public static class TestPane extends JPanel {

        protected static final int SPRITE_HEIGHT = 10;
        protected static final int SPRITE_WIDTH = 10;
        private float vDelta; // The vertical detla...
        private float rbDelta; // Rebound delta...
        private float rbDegDelta; // The amount the rebound is degradation...
        private int yPos; // The vertical position...
        private float gDelta; // Gravity, how much the vDelta will be reduced by over time...
        private Timer engine;
        private boolean bounce = false;

        public TestPane() {

            yPos = getPreferredSize().height - SPRITE_HEIGHT;
            vDelta = 0;
            gDelta = 0.25f;
            // This is how much the re-bound will degrade on each cycle...
            rbDegDelta = 2.5f;

            InputMap im = getInputMap(WHEN_IN_FOCUSED_WINDOW);
            ActionMap am = getActionMap();
            im.put(KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0), "jump");
            am.put("jump", new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    // Can only bound when we're actually on the ground...
                    // You might want to add fudge factor here so that the 
                    // sprite can be within a given number of pixels in order to
                    // jump again...
                    if (yPos + SPRITE_HEIGHT == getHeight()) {
                        vDelta = -8;
                        rbDelta = vDelta;
                        bounce = true;
                    }
                }
            });

            engine = new Timer(40, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    int height = getHeight();
                    // No point if we've not been sized...
                    if (height > 0) {
                        // Are we bouncing...
                        if (bounce) {
                            // Add the vDelta to the yPos
                            // vDelta may be postive or negative, allowing
                            // for both up and down movement...
                            yPos += vDelta;
                            // Add the gravity to the vDelta, this will slow down
                            // the upward movement and speed up the downward movement...
                            // You may wish to place a max speed to this
                            vDelta += gDelta;
                            // If the sprite is not on the ground...
                            if (yPos + SPRITE_HEIGHT >= height) {
                                // Seat the sprite on the ground
                                yPos = height - SPRITE_HEIGHT;
                                // If the re-bound delta is 0 or more then we've stopped
                                // bouncing...
                                if (rbDelta >= 0) {
                                    // Stop bouncing...
                                    bounce = false;
                                } else {
                                    // Add the re-bound degregation delta to the re-bound delta
                                    rbDelta += rbDegDelta;
                                    // Set the vDelta...
                                    vDelta = rbDelta;
                                }
                            }
                        }
                    }
                    repaint();
                }
            });
            engine.start();
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(200, 200);
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            int width = getWidth() - 1;
            int xPos = (width - SPRITE_WIDTH) / 2;
            g2d.drawOval(xPos, yPos, SPRITE_WIDTH, SPRITE_HEIGHT);
            g2d.dispose();
        }
    }
}

回答by Dennis Mills

Well I can think of one way. It involves some complex amounts of math (parabola). So i'm going to provide a very simple answer.

嗯，我可以想到一种方法。它涉及一些复杂的数学（抛物线）。所以我将提供一个非常简单的答案。

int y = 0;

and in the method that tests for the spacebar...

并在测试空格键的方法中......

if (y !< 1){
    if (y < 30){

   y += 1;

   }

   if (y > 30){

    y -= 1;


    }
}

I haven't tested it out yet, but it should work in theory....But it won't animate anything, this code is only going to take the sprites Y value and make it go up. That's just about the easiest jumping method that can exist....

我还没有测试过它，但理论上它应该可以工作......但它不会动画任何东西，这段代码只会获取精灵 Y 值并让它上升。这只是可能存在的最简单的跳跃方法......