Ergebnis 1 bis 8 von 8

Thema: blöde switchs...

  1. #1
    Unregistriert
    Gast

    Standard blöde switchs...

    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
      }
    }
    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
    Achtung: Dies ist ein alter Thread im HTML und Webmaster Forum
    Diese Diskussion ist älter als 90 Tage. Die darin enthaltenen Informationen sind möglicherweise nicht mehr aktuell. Erstelle bitte zu deiner Frage ein neues Thema im Forum !!!!!

  2. #2
    König(in)
    Registriert seit
    06.06.2007
    Ort
    Bi
    Beiträge
    1.015
    Danke
    0
    Bekam 0 mal "Danke" in 0 Postings

    Standard AW: blöde switchs...

    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.
    Sämtlicher Code erhebt keinen Anspruch auf syntaktische Korrektheit geschweige denn Ausführbarkeit und ist für die Implementation außerhalb der Beispiele nicht geeignet.

    Kein Support für kommerzielle Scripts | Kein kostenloser Support via ICQ

  3. #3
    Unregistriert
    Gast

    Standard AW: blöde switchs...

    Zitat Zitat von K.Y.L.T. Beitrag anzeigen
    Die zusätzliche Blockung der case Teile ist überflüssig. (Die geschweiften Klammern)
    weiß ich, machts aber übersichtlicher (für mich Oo)

    Zitat Zitat von K.Y.L.T. Beitrag anzeigen
    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)

  4. #4
    Forum Guru Avatar von The User
    Registriert seit
    28.10.2007
    Ort
    Zwischen Pazifik und Atlantik...
    Beiträge
    4.044
    Danke
    0
    Bekam 0 mal "Danke" in 0 Postings

    Standard AW: blöde switchs...

    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

  5. #5
    König(in)
    Registriert seit
    06.06.2007
    Ort
    Bi
    Beiträge
    1.015
    Danke
    0
    Bekam 0 mal "Danke" in 0 Postings

    Standard AW: blöde switchs...

    Zitat Zitat von Unregistriert Beitrag anzeigen

    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.
    Sämtlicher Code erhebt keinen Anspruch auf syntaktische Korrektheit geschweige denn Ausführbarkeit und ist für die Implementation außerhalb der Beispiele nicht geeignet.

    Kein Support für kommerzielle Scripts | Kein kostenloser Support via ICQ

  6. #6
    Unregistriert
    Gast

    Standard AW: blöde switchs...

    Zitat Zitat von The User Beitrag anzeigen
    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...:
    Code:
    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
    }
    wie gesagt,selected läuft korrekt mit...vlt hat java auch einfach nur ein problem mit dem switch im switch..ôo

  7. #7
    König(in)
    Registriert seit
    06.06.2007
    Ort
    Bi
    Beiträge
    1.015
    Danke
    0
    Bekam 0 mal "Danke" in 0 Postings

    Standard AW: blöde switchs...

    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.
    Sämtlicher Code erhebt keinen Anspruch auf syntaktische Korrektheit geschweige denn Ausführbarkeit und ist für die Implementation außerhalb der Beispiele nicht geeignet.

    Kein Support für kommerzielle Scripts | Kein kostenloser Support via ICQ

  8. #8
    Unregistriert
    Gast

    Standard AW: blöde switchs...

    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:
    Code:
    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
    }

Ähnliche Themen

  1. ganz blöde anfänger frage ..... evanzo
    Von weiß_nix im Forum HTML & CSS Forum
    Antworten: 6
    Letzter Beitrag: 03.07.2007, 16:17
  2. blöde situation
    Von XbullyX im Forum Off Topic und Quasselbox
    Antworten: 3
    Letzter Beitrag: 21.02.2006, 01:33
  3. Blöde Frage
    Von im Forum Computer - Internet Forum
    Antworten: 6
    Letzter Beitrag: 15.08.2005, 13:14
  4. Blöde Frage aber ich komme nicht drauf
    Von Gast im Forum HTML & CSS Forum
    Antworten: 2
    Letzter Beitrag: 20.05.2005, 12:20
  5. Blöde Frage aber sorry
    Von Gast im Forum HTML & CSS Forum
    Antworten: 2
    Letzter Beitrag: 13.05.2005, 10:48

Stichworte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •