java - 时间延迟和 JInput

Question

好吧，我不知道如何表达这个问题，但也许我的代码会说明问题:

public class ControllerTest
{
    public static void main(String [] args)
    {
        GamePadController rockbandDrum = new GamePadController();
        DrumMachine drum = new DrumMachine();

        while(true)
        {
            try{

            rockbandDrum.poll();

            if(rockbandDrum.isButtonPressed(1)) //BLUE PAD HhiHat)
            {
                drum.playSound("hiHat.wav");
                Thread.sleep(50);
            }

            if(rockbandDrum.isButtonPressed(2)) //GREEN PAD (Crash)
            {
                //Todo: Change to Crash
                drum.playSound("hiHat.wav");
                Thread.sleep(50);
            }
            //Etc....
         }
     }
}

public class DrumMachine
{
    InputStream soundPlayer = null;
    AudioStream audio = null;
    static boolean running = true;

    public void playSound(String soundFile)
    {
        //Tak a sound file as a paramater and then
        //play that sound file
        try{
            soundPlayer = new FileInputStream(soundFile);
            audio = new AudioStream(soundPlayer);

        }
        catch(FileNotFoundException e){
            e.printStackTrace();
        }
        catch(IOException e){
            e.printStackTrace();
        }

        AudioPlayer.player.start(audio);
    }
    //Etc... Methods for multiple audio clip playing
}

现在的问题是，如果我降低延迟

Thread.sleep(50)

然后声音每秒播放多次，但如果我保持在这个级别或更高级别，我可能会错过正在播放的声音...

这是一个奇怪的问题，如果延迟太低，声音就会循环播放。但如果它太高，它就会错过播放声音。这只是我需要调整设置的问题，还是有任何其他方法可以在不循环播放声音的情况下轮询 Controller ？

编辑:如果我需要发布轮询 Controller 的代码，我会...

import java.io.*;
import net.java.games.input.*;
import net.java.games.input.Component.POV;


public class GamePadController
{
    public static final int NUM_BUTTONS = 13;

    // public stick and hat compass positions
    public static final int NUM_COMPASS_DIRS = 9;

    public static final int NW = 0;
    public static final int NORTH = 1;
    public static final int NE = 2;
    public static final int WEST = 3;
    public static final int NONE = 4;   // default value
    public static final int EAST = 5;
    public static final int SW = 6;
    public static final int SOUTH = 7;
    public static final int SE = 8;

    private Controller controller;

    private Component[] comps;  // holds the components

    // comps[] indices for specific components
    private int xAxisIdx, yAxisIdx, zAxisIdx, rzAxisIdx;
                                // indices for the analog sticks axes
    private int povIdx;         // index for the POV hat
    private int buttonsIdx[];   // indices for the buttons

    private Rumbler[] rumblers;
    private int rumblerIdx;      // index for the rumbler being used
    private boolean rumblerOn = false;   // whether rumbler is on or off

    public GamePadController()
    {
        // get the controllers
        ControllerEnvironment ce =
             ControllerEnvironment.getDefaultEnvironment();
        Controller[] cs = ce.getControllers();
        if (cs.length == 0) {
          System.out.println("No controllers found");
          System.exit(0);
        }
        else
          System.out.println("Num. controllers: " + cs.length);


        // get the game pad controller
        controller = findGamePad(cs);
        System.out.println("Game controller: " +
                           controller.getName() + ", " +
                           controller.getType());

        // collect indices for the required game pad components
        findCompIndices(controller);

        findRumblers(controller);
    } // end of GamePadController()


    private Controller findGamePad(Controller[] cs)
    /* Search the array of controllers until a suitable game pad
       controller is found (eith of type GAMEPAD or STICK).
    */
    {
        Controller.Type type;
        int i = 0;
        while(i < cs.length) {
            type = cs[i].getType();
            if ((type == Controller.Type.GAMEPAD) ||
                (type == Controller.Type.STICK))
                break;
            i++;
        }

        if (i == cs.length) {
            System.out.println("No game pad found");
            System.exit(0);
        }
        else
            System.out.println("Game pad index: " + i);

        return cs[i];
    }  // end of findGamePad()


    private void findCompIndices(Controller controller)
    /* Store the indices for the analog sticks axes
       (x,y) and (z,rz), POV hat, and
       button components of the controller.
    */
    {
        comps = controller.getComponents();
        if (comps.length == 0) {
            System.out.println("No Components found");
            System.exit(0);
        }
        else
            System.out.println("Num. Components: " + comps.length);

        // get the indices for the axes of the analog sticks: (x,y) and (z,rz)
        xAxisIdx = findCompIndex(comps, Component.Identifier.Axis.X, "x-axis");
        yAxisIdx = findCompIndex(comps, Component.Identifier.Axis.Y, "y-axis");

        zAxisIdx = findCompIndex(comps, Component.Identifier.Axis.Z, "z-axis");
        rzAxisIdx = findCompIndex(comps, Component.Identifier.Axis.RZ, "rz-axis");

        // get POV hat index
        povIdx = findCompIndex(comps, Component.Identifier.Axis.POV, "POV hat");

        findButtons(comps);
    }  // end of findCompIndices()


    private int findCompIndex(Component[] comps,
                           Component.Identifier id, String nm)
    /* Search through comps[] for id, returning the corresponding
       array index, or -1 */
    {
        Component c;
        for(int i=0; i < comps.length; i++) {
            c = comps[i];
            if ((c.getIdentifier() == id) && !c.isRelative()) {
                System.out.println("Found " + c.getName() + "; index: " + i);
                return i;
            }
        }

        System.out.println("No " + nm + " component found");
        return -1;
    }  // end of findCompIndex()


    private void findButtons(Component[] comps)
    /* Search through comps[] for NUM_BUTTONS buttons, storing
       their indices in buttonsIdx[]. Ignore excessive buttons.
       If there aren't enough buttons, then fill the empty spots in
       buttonsIdx[] with -1's. */
    {
        buttonsIdx = new int[NUM_BUTTONS];
        int numButtons = 0;
        Component c;

        for(int i=0; i < comps.length; i++) {
            c = comps[i];
            if (isButton(c)) {    // deal with a button
                if (numButtons == NUM_BUTTONS)   // already enough buttons
                    System.out.println("Found an extra button; index: " + i + ". Ignoring it");
                else {
                    buttonsIdx[numButtons] = i;  // store button index
                    System.out.println("Found " + c.getName() + "; index: " + i);
                    numButtons++;
                }
            }
        }

        // fill empty spots in buttonsIdx[] with -1's
        if (numButtons < NUM_BUTTONS) {
            System.out.println("Too few buttons (" + numButtons +
                               "); expecting " + NUM_BUTTONS);
            while (numButtons < NUM_BUTTONS) {
                buttonsIdx[numButtons] = -1;
                numButtons++;
            }
        }
    }  // end of findButtons()


    private boolean isButton(Component c)
    /* Return true if the component is a digital/absolute button, and
       its identifier name ends with "Button" (i.e. the
       identifier class is Component.Identifier.Button).
    */
    {
        if (!c.isAnalog() && !c.isRelative()) {    // digital and absolute
            String className = c.getIdentifier().getClass().getName();
            // System.out.println(c.getName() + " identifier: " + className);
            if (className.endsWith("Button"))
                return true;
        }
        return false;
    }  // end of isButton()


    private void findRumblers(Controller controller)
    /* Find the rumblers. Use the last rumbler for making vibrations,
       an arbitrary decision. */
    {
        // get the game pad's rumblers
        rumblers = controller.getRumblers();
        if (rumblers.length == 0) {
            System.out.println("No Rumblers found");
            rumblerIdx = -1;
        }
        else {
            System.out.println("Rumblers found: " + rumblers.length);
            rumblerIdx = rumblers.length-1;    // use last rumbler
        }
    }  // end of findRumblers()


    // ----------------- polling and getting data ------------------


    public void poll()
    // update the component values in the controller
    {
        controller.poll();
    }


    public int getXYStickDir()
    // return the (x,y) analog stick compass direction
    {
      if ((xAxisIdx == -1) || (yAxisIdx == -1)) {
          System.out.println("(x,y) axis data unavailable");
          return NONE;
      }
      else
         return getCompassDir(xAxisIdx, yAxisIdx);
    } // end of getXYStickDir()


    public int getZRZStickDir()
    // return the (z,rz) analog stick compass direction
    {
        if ((zAxisIdx == -1) || (rzAxisIdx == -1)) {
            System.out.println("(z,rz) axis data unavailable");
            return NONE;
        }
        else
            return getCompassDir(zAxisIdx, rzAxisIdx);
    } // end of getXYStickDir()


    private int getCompassDir(int xA, int yA)
    // Return the axes as a single compass value
    {
        float xCoord = comps[ xA ].getPollData();
        float yCoord = comps[ yA ].getPollData();
        // System.out.println("(x,y): (" + xCoord + "," + yCoord + ")");

        int xc = Math.round(xCoord);
        int yc = Math.round(yCoord);
        // System.out.println("Rounded (x,y): (" + xc + "," + yc + ")");

        if ((yc == -1) && (xc == -1))   // (y,x)
            return NW;
        else if ((yc == -1) && (xc == 0))
            return NORTH;
        else if ((yc == -1) && (xc == 1))
            return NE;
        else if ((yc == 0) && (xc == -1))
            return WEST;
        else if ((yc == 0) && (xc == 0))
            return NONE;
        else if ((yc == 0) && (xc == 1))
            return EAST;
        else if ((yc == 1) && (xc == -1))
            return SW;
        else if ((yc == 1) && (xc == 0))
            return SOUTH;
        else if ((yc == 1) && (xc == 1))
            return SE;
        else {
            System.out.println("Unknown (x,y): (" + xc + "," + yc + ")");
            return NONE;
        }
    }  // end of getCompassDir()

    public int getHatDir()
    // Return the POV hat's direction as a compass direction
    {
        if (povIdx == -1) {
            System.out.println("POV hat data unavailable");
            return NONE;
        }
        else {
            float povDir = comps[povIdx].getPollData();
            if (povDir == POV.CENTER)  //   0.0f
                return NONE;
            else if (povDir == POV.DOWN)  // 0.75f
                return SOUTH;
            else if (povDir == POV.DOWN_LEFT)  // 0.875f
                return SW;
            else if (povDir == POV.DOWN_RIGHT)  // 0.625f
                return SE;
            else if (povDir == POV.LEFT)  // 1.0f
                return WEST;
            else if (povDir == POV.RIGHT)  // 0.5f
                return EAST;
            else if (povDir == POV.UP)  // 0.25f
                return NORTH;
            else if (povDir == POV.UP_LEFT)  // 0.125f
                return NW;
            else if (povDir == POV.UP_RIGHT)  // 0.375f
                return NE;
            else  { // assume center
                System.out.println("POV hat value out of range: " + povDir);
                return NONE;
            }
        }
    }  // end of getHatDir()


    public boolean[] getButtons()
    /* Return all the buttons in a single array. Each button value is
       a boolean. */
    {
        boolean[] buttons = new boolean[NUM_BUTTONS];
        float value;
        for(int i=0; i < NUM_BUTTONS; i++) {
            value = comps[ buttonsIdx[i] ].getPollData();
            buttons[i] = ((value == 0.0f) ? false : true);
        }
        return buttons;
    }  // end of getButtons()


    public boolean isButtonPressed(int pos)
    /* Return the button value (a boolean) for button number 'pos'.
       pos is in the range 1-NUM_BUTTONS to match the game pad
       button labels.
    */
    {
      if ((pos < 1) || (pos > NUM_BUTTONS)) {
          System.out.println("Button position out of range (1-" +
                              NUM_BUTTONS + "): " + pos);
          return false;
      }

      if (buttonsIdx[pos-1] == -1)   // no button found at that pos
          return false;

      float value = comps[ buttonsIdx[pos-1] ].getPollData();
         // array range is 0-NUM_BUTTONS-1

      return ((value == 0.0f) ? false : true);
    } // end of isButtonPressed()


    // ------------------- Trigger a rumbler -------------------

    public void setRumbler(boolean switchOn)
    // turn the rumbler on or off
    {
        if (rumblerIdx != -1) {
            if (switchOn)
                rumblers[rumblerIdx].rumble(0.8f);  // almost full on for last rumbler
            else  // switch off
                rumblers[rumblerIdx].rumble(0.0f);
            rumblerOn = switchOn;    // record rumbler's new status
        }
    }  // end of setRumbler()

    public boolean isRumblerOn()
    {  return rumblerOn;  }

} // end of GamePadController class

Answer 1

我认为您在这里使用了错误的设计模式。你应该使用 observer pattern对于这类事情。

轮询循环效率不高，正如您所注意到的，并没有真正产生预期的结果。

我不确定您在对象内部使用什么来检测是否按下了某个键，但如果它是一个 GUI 架构，例如 Swing或 AWT它将通过使用 EventListeners 等基于观察者模式。