blöde switchs...

Unregistriert

Moin.einer meiner switchs ärgert mich mal wieder und ich hab langsam die schnauze voll oO theoretisch sieht es so aus: ein fenster wird geöffnet(bool1==true).danach hat man 4 Tasten zu auswahl: pfeil hoch(bewegt den pfeil auf dem bildschirm zum nächsten wort darüber), pfeil runter(dasselbe, nur eben umgedreht), enter(geht in einen anderen switch der je nachdem auf welches wort der pfeil zeigt eine aktion ausführt) und escape(verlässt das fenster). das ganze findet in der keyPressed(KeyEvent event)-methode statt.
und so sieht der code aus:

Code

if (bool1 == true)                               
{
  switch(event.getKeyCode())  // der switch richtet sich nach der taste die gedrückt wurde
  {
    case 10:              // enter
    {
      switch(selected)     //  selected ist die nummer des wortes auf das der pfeil gerade zeigt
      {
        case 1:               
        {
          bool2 = true;          // irrelevant
          bool1 = false;         // fenster schließt sich
          break;
        }
        case 2:
        {
          bool1 = false;       // funzt nich....
          break;
        }
        case 3:
        {
          bool1 = false;        // auch nich....
          break;
        }
        case 4:
        {
          bool1 = false;       // genauso wenig...
          break;
        }
        default: {break;}    // wird nie erreicht, aber der vollständigkeit halber
      }
    break;
    }
/***************************************************
Hier wird der Pfeil hoch und runter bewegt+"selected" erhöht oder erniedrigt
***************************************************/
    case 38:          // up
    {
      if (arrowy > 30)      // begrenzung nach oben    
      {
        arrowy -= 40;
        selected--;
      }
      break;
    }
    case 40:          // down
    {
      if (arrowy < 140)       // begrenzung nach unten
      {
        arrowy += 40;
        selected++;
      }
      break;
    }
    case 27:             // Escape
    {
      bool1 = false;   // funktioniert ôo
      break;
    }
    default: {break;}   // genauso wie das andere default - nie erreicht, trotzdem da
  }
}

Alles anzeigen

pfeil hoch und runter und escape funktioniern wunderbar, pfeil bewegt sich, selected läuft mit.problem ist der "innere" switch.da funktioniert nur case 1 problemlos. case 2,3,4 machen nichts(fenster sollte sich schließen, bleibt aber offen).zudem wird selected wieder auf 1 zurückgesetzt - was mir völlig schleierhaft ist wie das funktioniert, schließlich hab ich NIRGENS "selected = 1" zu stehn und selbst wenn das programm nach dem inneren switch in den äußeren geht(was er nicht tut) und case 38 ausführt kann bei "selected--" selected von 4 nicht auf 1 springen...
und ja ich weiß, mit nem mousemotionlistener und buttons etcpp. wär das alles viel einfacher und so aber ich möchte das so haben
plz help xD

K.Y.L.T.

Die zusätzliche Blockung der case Teile ist überflüssig. (Die geschweiften Klammern)

Ich würde mich aber fragen, was der wert hinter der Variabel selected zum ausgangszustand ist, da sie ja anscheinend nie korrekt gesetzt wird, sonst würdest du ja nicht auf den Wert 1 immer wieder landen.

Unregistriert

Zitat von K.Y.L.T.

Die zusätzliche Blockung der case Teile ist überflüssig. (Die geschweiften Klammern)

weiß ich, machts aber übersichtlicher (für mich Oo)

Zitat von K.Y.L.T.

Ich würde mich aber fragen, was der wert hinter der Variabel selected zum ausgangszustand ist, da sie ja anscheinend nie korrekt gesetzt wird, sonst würdest du ja nicht auf den Wert 1 immer wieder landen.

am anfang ist selected 1.wird gaaaaanz oben wo alle variablen gesetzt werden sofort zugeteilt, wird auch gleich am anfang gebraucht.
selected läuft ja korrekt mit (habs mit System.out.println(selected+"") überprüft).nur wenn ich dann enter drücke springts wieder auf 1 ohne das was anderes passiert(es sei denn sie ist schon auf 1, dann macht er case 1)

The User

Die { } sorgen ja für einen eigenen Gültigkeitsbereich, es kann also sinnvoll sein, wenn Variablen im case deklariert werden.
Den switch solltest du aber so machen:

Code

switch(selected)
{
    case 1:
          bool2 = true;          // irrelevant
          bool1 = false;         // fenster schließt sich
          break;
    default:
          bool1 = false;
}

Du solltest dir jedoch ein paar Gedanken machen:
Was ist bool1, wenn default erreicht wird?
Warum verwendest du Konstanten wie 10 oder 38, es gibt doch sicherlich Namen für diese Zahlen?

Viele liebe Grüße
The User

K.Y.L.T.

Zitat von Unregistriert

am anfang ist selected 1.wird gaaaaanz oben wo alle variablen gesetzt werden sofort zugeteilt, wird auch gleich am anfang gebraucht.
selected läuft ja korrekt mit (habs mit System.out.println(selected+"") überprüft).nur wenn ich dann enter drücke springts wieder auf 1 ohne das was anderes passiert(es sei denn sie ist schon auf 1, dann macht er case 1)

Bitte Poste einmal den gesamten Code , der dafür relvant ist.

Unregistriert

Zitat von The User
Die { } sorgen ja für einen eigenen Gültigkeitsbereich, es kann also sinnvoll sein, wenn Variablen im case deklariert werden.
Den switch solltest du aber so machen:
Code
switch(selected)
{
    case 1:
          bool2 = true;          // irrelevant
          bool1 = false;         // fenster schließt sich
          break;
    default:
          bool1 = false;
}
Du solltest dir jedoch ein paar Gedanken machen:
Was ist bool1, wenn default erreicht wird?
Warum verwendest du Konstanten wie 10 oder 38, es gibt doch sicherlich Namen für diese Zahlen?

Viele liebe Grüße
The User

ich verwende diese zahlen weil sie in java so festgelegt sind.der keycode für die enter-taste ist halt 10.die pfeiltasten 37-40. "default: bool1 = false" hab ich nirgens stehn.hab alle "default" und unnötige klammern rausgenommen, bringt aber keine änderung.

code der noch "irgendwie" damit zu tun hat...:

Java

import java.awt.*;
import java.awt.event.*;
import java.applet.*;


public class Test extends Applet implements Runnable, KeyListener, MouseListener, MouseMotionListener
{
  // Anfang Variablen
  int selected = 1;
  int arrowy = 190;


  private Image dbImage;
  private Graphics dbg;


  boolean startmenu = true;
  boolean bool1, bool2 = false;


  MyCursor mycursor;
  Maps map;
  Thread thread;
  // Ende Variablen


  // Anfang Ereignisprozeduren
  public void init()
  {
    setBackground(Color.white);
    thread = new Thread(this);


    addKeyListener(this);
    addMouseListener(this);
    addMouseMotionListener(this);
    this.resize(619, 619);


    /* C U R S O R */
    /* L O A D   G R A P H I C S */
  }

/*start(),stop(),run(),paint(),update()*/


/*******************************************************************************
                             K E Y E V E N T S
*******************************************************************************/

  public void keyPressed(KeyEvent event)
  {
    /* M E N U - K E Y S*/
    if (startmenu == true)
    {
      switch(event.getKeyCode())           // gleiches Bild mit "äußerem" und "innerem" switch,funktioniert auch nicht
      {
        case 10:


          switch(selected)
          {
            case 1:


              startmenu = false;
              setBackground(Color.black);
              break;




            case 2: break;


            case 3:


              destroy();
              break;


          }
          break;


        case 38:


          if (arrowy > 190)
          {
            arrowy -= 50;
            selected--;
          }
          break;


        case 40:


          if (arrowy < 290)
          {
            arrowy += 50;
            selected++;
          }
          break;
      }
    }
    else
    {
      if (bool1 == true)                      
      {
        switch(event.getKeyCode())
        {
          case 10:              // enter


            switch(selected)
            {
              case 1:


                bool1 = false;
                break;


              case 2:


                bool1 = false;
                break;


              case 3:


                bool1 = false;
                break;


              case 4:


                bool1 = false;
                break;
            }
            break;


          case 38:          // up


            if (arrowy > 30)
            {
              arrowy -= 40;
              selected--;
            }
            break;


          case 40:          // down


            if (arrowy < 140)
            {
              arrowy += 40;
              selected++;
            }
            break;


          case 27:             // Escape


            bool1 = false;
            break;


        }
      }
    }
    System.out.println(selected+"");
  }


/*andere leere Keyevents*/


/*Mausevents*/

/*andere Methoden*/


  // Ende Ereignisprozeduren
}

Alles anzeigen

wie gesagt,selected läuft korrekt mit...vlt hat java auch einfach nur ein problem mit dem switch im switch..ôo

K.Y.L.T.

Schon beim ersten Blick fällt auf, dass du uns da was wichtiges vorenthalten hast.

Der von dir gepostete code zeigt den Fehler auf, du setzt im oberen Teil bei dem zweiten Switch zwar startmenu auf false, aber nie bool1 auf true. Ob du nun was anderes Probiert hast oder nicht, auf jeden fall kann das so nicht gehen.

Unregistriert

bool1 wird in einem anderen teil der keypressed-methode auf true gesetzt.den teil hab ich nich gepostet weil das alles nicht mehr überschaubar wäre.würde bool1 nicht irgendwo true werden würde ich ja nie in den switch rein kommen was ja relativ suboptimal wär..dann wüsst ich ja nichtmal ob er nun funzt oder nich.
also hier nochmal der GANZE code, wenn ihr euch das unbedingt antun wollt:

Java

import java.awt.*;
import java.awt.event.*;
import java.applet.*;


public class WarRobots extends Applet implements Runnable, KeyListener, MouseListener, MouseMotionListener
{
  // Anfang Variablen
  int counter, i, actualfield, keycode, nextfield, direction, OB,
      mouseX, mouseY, tempMouseX, tempMouseY;
  int selected = 1;
  int arrowy = 190;
  private int field, fbc;


  Image image, statwindow, orderwindow, arrow, landscape;
  private Image dbImage;
  private Graphics dbg;


  boolean startmenu = true;
  boolean statballoon, orderballoon, move, testnextfield,
          walkWhere, walkNow = false;


  MyCursor mycursor;
  Maps map;
  Character[] chars;
  Thread thread;
  // Ende Variablen


  // Anfang Ereignisprozeduren
  public void init()
  {
    setBackground(Color.white);
    thread = new Thread(this);


    addKeyListener(this);
    addMouseListener(this);
    addMouseMotionListener(this);
    this.resize(619, 619);


    /* C U R S O R */
    mycursor = new MyCursor();                                                  // new MyCursor-Object
    mycursor.x = 310;                                                           // start-coord
    mycursor.y = 310;                                                           // start-coord
    mycursor.truex = 310;                                                           // start-coord
    mycursor.truey = 310;                                                           // start-coord
    mycursor.cursor = getImage(getCodeBase(),"pics\\cursor\\cursor.jpg");       // cursor image


    /* L O A D   G R A P H I C S */
      // Windows'n'stuff
    statwindow = getImage(getCodeBase(),"pics\\window.jpg");
    orderwindow = getImage(getCodeBase(),"pics\\orderballoon.jpg");
    arrow = getImage(getCodeBase(),"pics\\arrow.jpg");
  }

  public void start()
  {
    /* M A P */
    map = new Maps();
    map.map1();
    mycursor.xlimit = map.field[2].x;                                           // x-border (left)
    mycursor.ylimit = map.field[map.sizeX*2].y;                                 // y-border (upper)
    mycursor.xlimit2 = map.field[map.sizeX-3].x;                                // x-border (right)
    mycursor.ylimit2 = map.field[map.sizeX*(map.sizeY-3)].y;                    // y-border (lower)
    mycursor.mapX = map.sizeX;


    chars = new Character[map.chars];
    chars[0] = new Character();
    chars[0].R0815();
    chars[0].icon = getImage(getCodeBase(),"pics\\chars\\temp.jpg");
    chars[0].x = 5;
    chars[0].y = 5;
    chars[0].truex = 5;
    chars[0].truey = 5;
    map.field[chars[0].getField(map.sizeX)].occupiedBy = chars[0].name;


    thread.start();
  }

  public void stop() {}


  public void run()
  {
    Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
    while(true)
    {
/*******************************************************************************
                     C U R S O R   M O V E M E N T
*******************************************************************************/
      if (move == true)
      {
        if (testnextfield == true)
        {
          switch(keycode)
          {
            case 37:
              if (mycursor.truex <= 31)
              {
                move = false;
                break;
              }
              nextfield = mycursor.x-30;
              direction = 1;
              break;


            case 38:
              if (mycursor.truey <= 31)
              {
                move = false;
                break;
              }
              nextfield = mycursor.y-30;
              direction = 2;
              break;


            case 39:
              if (mycursor.truex >= (map.sizeX-2)*31)
              {
                move = false;
                break;
              }
              nextfield = mycursor.x+30;
              direction = 3;
              break;


            case 40:
              if (mycursor.truey >= (map.sizeY-2)*31)
              {
                move = false;
                break;
              }
              nextfield = mycursor.y+30;
              direction = 4;
              break;
          }
          testnextfield = false;
        }
        if (move == true)
          mycursor.move();


        switch(direction)
        {
          case 1:
            if (nextfield == mycursor.x)
            {
              mycursor.x--;
              move = false;
              direction = 0;
            }
            break;


          case 2:
            if (nextfield == mycursor.y)
            {
              mycursor.y--;
              move = false;
              direction = 0;
            }
            break;


          case 3:
            if (nextfield == mycursor.x)
            {
              mycursor.x++;
              move = false;
              direction = 0;
            }
            break;


          case 4:
            if (nextfield == mycursor.y)
            {
              mycursor.y++;
              move = false;
              direction = 0;
            }
            break;
        }
      }
/*******************************************************************************
                         W I N D O W   M O V E M E N T
*******************************************************************************/
      if (mycursor.x >= 588)                                                    // right out of window
      {
        mycursor.x -= 31*2;


        for (counter = 0; counter < map.totalsize; counter++)
          map.field[counter].x -= 2;


        for (counter = 0; counter < ((map.sizeX*3)+18)*2+(map.sizeY*6); counter++)
          map.deadend[counter].x -= 2;


        mycursor.xlimit = map.field[2].x;                                       // x-border (left)
        mycursor.xlimit2 = map.field[map.sizeX-3].x;                            // x-border (right)

        for (int loop = 0; loop < map.chars; loop++)
          chars[loop].x -= 2*31;

        move = false;
      }


      if (mycursor.x <= 31)                                                      // left out of window
      {
        mycursor.x += 31*2;


        for (counter = 0; counter < map.totalsize; counter++)
          map.field[counter].x += 2;


        for (counter = 0; counter < ((map.sizeX*3)+18)*2+(map.sizeY*6); counter++)
          map.deadend[counter].x += 2;


        mycursor.xlimit = map.field[2].x;                                       // x-border (left)
        mycursor.xlimit2 = map.field[map.sizeX-3].x;                            // x-border (right)


        for (int loop = 0; loop < map.chars; loop++)
          chars[loop].x += 2*31;

        move = false;
      }


      if (mycursor.y <= 31)                                                    // up out of window
      {
        mycursor.y += 31*2;


        for (counter = 0; counter < map.totalsize; counter++)
          map.field[counter].y += 2;


        for (counter = 0; counter < ((map.sizeX*3)+18)*2+(map.sizeY*6); counter++)
          map.deadend[counter].y += 2;


        mycursor.ylimit = map.field[map.sizeX*2].y;                                 // y-border (upper)
        mycursor.ylimit2 = map.field[map.sizeX*(map.sizeY-3)].y;                    // y-border (lower)


        for (int loop = 0; loop < map.chars; loop++)
          chars[loop].y += 2*31;

        move = false;
      }


      if (mycursor.y >= 588)                                                      // down out of window
      {
        mycursor.y -= 31*2;


        for (counter = 0; counter < map.totalsize; counter++)
          map.field[counter].y -= 2;


        for (counter = 0; counter < ((map.sizeX*3)+18)*2+(map.sizeY*6); counter++)
          map.deadend[counter].y -= 2;


        mycursor.ylimit = map.field[map.sizeX*2].y;                                 // y-border (upper)
        mycursor.ylimit2 = map.field[map.sizeX*(map.sizeY-3)].y;                    // y-border (lower)

        for (int loop = 0; loop < map.chars; loop++)
          chars[loop].y -= 2*31;

        move = false;
      }


      try
      {
        thread.sleep(20);
      }  catch(Exception ex){}
      repaint();
    }
  }

  public void paint(Graphics g)         // paint ist wohl selbsterklärend
  {
    if (startmenu == true)
    {
      g.drawString("Start", 300, 200);
      g.drawString("LevelCode", 300, 250);
      g.drawString("Quit", 300, 300);
      g.drawImage(arrow, 260, arrowy, this);
    }
    else
    {
      /* D R A W   F I E L D S */
      for (int loop = 0; loop < map.totalsize; loop++)
        g.drawImage(getImage(getCodeBase(), map.field[loop].landscape.picture), map.field[loop].x*31, map.field[loop].y*31, this);


      for (int loop = 0; loop < ((map.sizeX*3)+18)*2+(map.sizeY*6); loop++)
        g.drawImage(getImage(getCodeBase(), map.deadend[loop].landscape.picture), map.deadend[loop].x*31, map.deadend[loop].y*31, this);


      /* D R A W   C H A R S */
      g.drawImage(chars[0].icon, chars[0].x*31, chars[0].y*31, this);

      /* D R A W   C U R S O R */
      g.drawImage(mycursor.cursor, mycursor.x, mycursor.y, this);


      if (orderballoon == true)
      {
        g.drawImage(orderwindow, 0, 0, this);
        g.drawImage(arrow, 20, arrowy, this);
        g.setColor(Color.black);
        g.drawString("Move", 40, 40);
        g.drawString("Attack", 40, 80);
        g.drawString("Status", 40, 120);
        g.drawString("End", 40, 160);
      }


      if (statballoon == true)
      {
        g.drawImage(statwindow, 0, 463, this);
        g.setColor(Color.black);
        g.drawString("Type: " + map.field[mycursor.getField()].landscape.name, 100, 480);
        g.drawString("Defence: " + map.field[mycursor.getField()].landscape.defence, 100, 500);
        g.drawString("Dodge: " + map.field[mycursor.getField()].landscape.dodge, 100, 520);
        g.drawString("X: " + map.field[mycursor.getField()].truex, 100, 540);
        g.drawString("Y: " + map.field[mycursor.getField()].truey, 100, 560);
        g.drawString("Number: " + map.field[mycursor.getField()].number, 100, 580);
      }
    }
  }


  public void update(Graphics g)       // doublebuffer
  {
    if (dbImage == null)
    {
      dbImage = createImage (this.getSize().width, this.getSize().height);
      dbg = dbImage.getGraphics ();
    }


    dbg.setColor (getBackground ());
    dbg.fillRect (0, 0, this.getSize().width, this.getSize().height);


    dbg.setColor (getForeground());
    paint(dbg);


    g.drawImage (dbImage, 0, 0, this);
  }


/*******************************************************************************
                             K E Y E V E N T S
*******************************************************************************/

  public void keyPressed(KeyEvent event)
  {
    /* M E N U - K E Y S*/
    if (startmenu == true)         <---------------- hier ist besagter switch
    {
      switch(event.getKeyCode())
      {
        case 10:
          switch(selected)
          {
            case 1:
              startmenu = false;
              setBackground(Color.black);
              break;


            case 2:
              break;


            case 3:
              destroy();
              break;
          }


        case 38:
          if (arrowy > 190)
          {
            arrowy -= 50;
            selected--;
          }
          break;


        case 40:
          if (arrowy < 290)
          {
            arrowy += 50;
            selected++;
          }
          break;
      }
    }
    /* B A T T L E - K E Y S */
    else
    {
      if (orderballoon == true)                               // Orderballoon commands
      {
        switch(event.getKeyCode())
        {
          case 10:              // enter
            switch(selected)
            {
              case 1:
                walkWhere = true;
                orderballoon = false;
                break;


              case 2:
                orderballoon = false;
                break;


              case 3:
                orderballoon = false;
                break;


              case 4:
                orderballoon = false;
                break;
            }
            break;


          case 38:          // up
            if (arrowy > 30)
            {
              arrowy -= 40;
              selected--;
            }
            break;


          case 40:         // down
            if (arrowy < 140)
            {
              arrowy += 40;
              selected++;
            }
            break;


          case 27:             // Escape
            orderballoon = false;
            break;


        }
      }
      if (orderballoon == false && move == false && walkWhere == false)
      {
        if (move == false)
        {
          /* M O V E M E N T */
          if (event.getKeyCode() >= 37 && event.getKeyCode() <= 40)
          {
            keycode = event.getKeyCode();
            mycursor.keycode = keycode;
            move = true;
            testnextfield = true;
          }
          /* W I N D O W S */
          switch(event.getKeyCode())
          {
            case 10:
              if (map.field[mycursor.getField()].isOccupied() == true)
              {
                orderballoon = true;
                arrowy = 30;
                selected = 1;
              }
              break;


            case 32:
              if (statballoon == true)
                statballoon = false;
              else
                statballoon = true;
              break;
          }
        }
      }
      if (walkWhere == true)
      {
        /* M O V E M E N T */
        if (event.getKeyCode() >= 37 && event.getKeyCode() <= 40)
        {
          keycode = event.getKeyCode();
          mycursor.keycode = keycode;
          move = true;
          testnextfield = true;
        }
        switch(event.getKeyCode())
        {
          case 10:
            walkNow = true;
            break;


          case 27:
            walkWhere = false;
            break;
        }
      }
    }
    System.out.println(selected+"");
  }


  public void keyReleased(KeyEvent event){}
  public void keyTyped(KeyEvent event){}
  public void mousePressed(MouseEvent event)
  {
    mouseX = event.getX();
    mouseY = event.getY();
  }
  public void mouseClicked(MouseEvent event)
  {
    if (startmenu == false)
    {
      mycursor.truex = map.field[this.getField(event.getX()/31, event.getY()/31)].truex*31;
      mycursor.x = map.field[this.getField(event.getX()/31, event.getY()/31)].truex*31;
      mycursor.truey = map.field[this.getField(event.getX()/31, event.getY()/31)].truey*31;
      mycursor.y = map.field[this.getField(event.getX()/31, event.getY()/31)].truey*31;
    }
  }
  public void mouseReleased(MouseEvent event){}
  public void mouseEntered(MouseEvent event){}
  public void mouseExited(MouseEvent event){}
  public void mouseMoved(MouseEvent event){}

  public void mouseDragged(MouseEvent event)
  {
    if (mouseX > event.getX())          // drag left
    {
      for (counter = 0; counter < map.totalsize; counter++)
        map.field[counter].x += (event.getX() - mouseX)/5;

      for (counter = 0; counter < ((map.sizeX*3)+18)*2+(map.sizeY*6); counter++)
        map.deadend[counter].x += (event.getX() - mouseX)/5;

      for (int loop = 0; loop < map.chars; loop++)
          chars[loop].x += (event.getX() - mouseX)/5;

      mouseX = event.getX();
    }
    if (mouseX < event.getX())                         // drag right
    {
      for (counter = 0; counter < map.totalsize; counter++)
        map.field[counter].x -= (mouseX - event.getX())/5;


      for (counter = 0; counter < ((map.sizeX*3)+18)*2+(map.sizeY*6); counter++)
        map.deadend[counter].x -= (mouseX - event.getX())/5;


      for (int loop = 0; loop < map.chars; loop++)
          chars[loop].x -= (mouseX - event.getX())/5;

      mouseX = event.getX();
    }
    if (mouseY > event.getY())          // drag up
    {
      for (counter = 0; counter < map.totalsize; counter++)
        map.field[counter].y += (event.getY() - mouseY)/5;


      for (counter = 0; counter < ((map.sizeX*3)+18)*2+(map.sizeY*6); counter++)
        map.deadend[counter].y += (event.getY() - mouseY)/5;

      for (int loop = 0; loop < map.chars; loop++)
          chars[loop].y += (event.getY() - mouseY)/5;


      mouseY = event.getY();
    }
    if (mouseY < event.getY())                         // drag down
    {
      for (counter = 0; counter < map.totalsize; counter++)
        map.field[counter].y -= (mouseY - event.getY())/5;


      for (counter = 0; counter < ((map.sizeX*3)+18)*2+(map.sizeY*6); counter++)
        map.deadend[counter].y -= (mouseY - event.getY())/5;

      for (int loop = 0; loop < map.chars; loop++)
          chars[loop].y -= (mouseY - event.getY())/5;


      mouseY = event.getY();
    }
    repaint();
  }

/*
Calculates the number of the field besides the cursor in any direction.
(0 = no direction, 1 = left, 2 = up, 3 = right, 4 = down)
*/
  private int besideCursor(int dir)
  {
    switch(dir)
    {
      case 0:
      {
        fbc = mycursor.getField();
        break;
      }
      case 1:
      {
        fbc = mycursor.getField()-1;
        break;
      }
      case 2:
      {
        fbc = mycursor.getField()-map.sizeX;
        break;
      }
      case 3:
      {
        fbc = mycursor.getField()+1;
        break;
      }
      case 4:
      {
        fbc = mycursor.getField()+map.sizeX;
        break;
      }
      default: {break;}
    }
    return fbc;
  }

  private int getField(int x, int y)
  {
    field = (y * map.sizeX) + x;
    return field;
  }
  // Ende Ereignisprozeduren
}

Alles anzeigen

Tags