suche nach varible POSITION ... fuer das pixel-maennchen

S

scriptCoad

Aktives Mitglied
hallo,

in meiner klasse weiss ich nicht wie aus der Klasse Aikai-cat die methode MyTask > run ... den wert position1 position11 kriegt.

die variable muesste doch public vorhanden sein?

Java:
package aikaicat;



import java.util.Date;
import java.util.Timer;
import java.util.TimerTask; 
/* import javax.swing.*;
import java.util.ArrayList;
import java.io.*;
import java.lang.*;
import javax.xml.parsers.*;
import org.xml.sax.*;
import org.w3c.dom.*;
import java.text.*; */

//xn 25.9.11 added a cvs server ...

// things the class kat74 can do




class Katze4_74 {
  // katze so machen dass eine version rennt
  // main >
    
    
    
    
  // erste startet von position 0 4
  // zweite startet randommaessig von punkt x y
  // dritte startet von dem savepunkt aus
  //
  // position1 position11 uebergeben an naechste funktion -> generate path
  //
  // funktion generate main
  //
  //
    
    
    
  // 8 15
  public static int position1 = 2;
  public static int position11 = 4;
  // wo wird position1 neu definiert
  // klasse x
 
 
 
  public static int position2 = 5;    // position kaese
  public static int position21 = 2; // position kaese im umkreis von der katze
                                    // spawnen lassen, 3 kreise
 
  public static int ccountera = 0;
  public static int ccounter1 = 0;
  public static int ctimer2 = 0;
  static int val = -1;
  public static int position4 = 0; // position fuer den user suchen
  public static int position5 = 0;
 
 
  //private static NumberFormat cf =
  //NumberFormat.getCurrencyInstance();
 
  // sachen die gerade bei der katze passieren
  // kaese taucht auf, die katze rennt herum
  // die katze unterhaelt sich mit einem
 
  // katze rennt in jogging klammotten
 
  // katze findet essen (maus)
 
  // katze findet einen freund (vogel)
 
  // katze guckt tv

  // katze braet eier
 
  // katze fisch aus dem fish-glas
 
  // katze findet ein eltern foto
 
 
  // class ruft
  //     generate_path auf
  //    test1 auf
  //    > main auf
  //    versuchen dass main mehr macht, da sonst nur lol2 rauskommt
    
  // generate_path wird mit position112, position113 aufrufen
  //
 
  // in der klasse dafuer sorgen dass in einem intervall von 100 millisekunden ein neuer counter aufgerufen wird ...
  //
 
  private static int generate_path (int position112, int position113) {
    // testen, ob werte negiert werden, wenn sich
    // katze rechts vom kaese bewegt
    // differenz x posi
    // differenz y posi
    int tmp412 = position112 - position1;
    int tmp413 = position113 - position11;
    // schnittpunkt ...
    int[] patternd = {1,2,1,1,2,1,2,1,1,2,1,2,2,1,2,1,2,1,2};
    double tmp145 = Math.floor(tmp412 / 2);
    // -> 2
    // bei geraden laengen, davor-verlegen
  
    // bei patternd[1] .. abrunden
    // bei patternd[2] .. aufrunden ...
  
    // TODO: modifier einfuegen, 2 felder verschieben
    double tmp419 = Math.random() * 18;
    tmp419 = Math.round(tmp419);
    int tmp420 = new Double(tmp419).intValue();
  
  
    // move corrected to man, now move goes
    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  
    int[] man = new int[10];
    int[][] move = new int[255][255];
  
  
  
  
    //int[][] move = int[255][255];
  
    int tmp1124 = tmp412; //hoehe1;
    int tmp1125 = tmp413; // position x;
  
    // startpunkt position ...
    int c11 = position1; // x1
    int c12 = position11; // y1
    int c1 = 0;
  
  
    int trigger1 = 0;
    int trigger21 = 0;
    int trigger2 = 0;
    int i1 = 0; // x= x position
    int i2 = 0; // counter array 1
    int i3 = 7 - position1; // uebernehmen von position-y
    int i4 = 0; // counter array 2
  
    // umlenkpunkt von hinten nach verlagern
    //
    //   xx
    //   x
    // xxx
    //
    //
    //
    //
  
  
    while (trigger1 == 0) {
      if (i1 == tmp145)
        trigger21 = 1;
    
      if (i1 > 50) {
        trigger1 = 1;
      }
    
      if (trigger21 == 1) {
      while (trigger21 == 1) {
        move[i2][0] = 0;
        move[i2][1] = -1;  
      
        if (i3 <= position11 + tmp413)
          trigger21 = 0;
      
        if (i2 > 50) {
          trigger21 = 0;
        }
      
        i2 ++;
        i3 --;
      }
      } else {
      if (i1 >= position1 && i1 < position1 + tmp412) {
        move[i2][0] = 1;
        move[i2][1] = 0;
      
        i2 ++;
      }
      }
    
      i1 ++;
    }
  
    // pattern 1,2,1,1,2,1,2,1,1,2,1,2,2,1,2,1,2,1,2
    //
    //return move;
    return(2);
  }
 
  //move = generate_move[0];
  //position1 = generate_move[1];
  //position2 = generate_move[2]; // ...................
 
 
  /* public static int[][] generate_move(int position, int position2, int position41, int position42) {
  
    //
    //
    //
    //
    //
    //
    //
    //
    //
    //
    //
  
  
  
  
  
    int [][][] return_value1 = new int[1024][1024][2];
  
  
  
  
  
  
  
  
    int[][] move = new int[1024][1024];
  
    int c3 = 0;
  
    int triggeri1 = 0;
    //for (int i = 0; i < 60; i ++) {
      // randomposition0 --> rechts, ... 1= x, 2= y-position
      double val32 = Math.random() * 3;
      val32 = Math.round(val32);
      triggeri1 = 0;
      for (int c2 = 0; c2 < 4; c2++) {
        if (position+1 < 7 && position1+1 < 15) {
          move[c3][0] = 0;
          move[c3][1] = 1;
          position += 0;
          position1 ++;
          c3 ++;
        } else {
          triggeri1 ++;
        }
      }
      for (int c4 = 0; c4 < 4 - triggeri1; c4 ++) {
        position41 += 0;
        position42 += 1;
      }
      triggeri1 = 0;
      for (int c2 = 0; c2 < 4; c2++) {
        if (position1 > 0 && position < 7) {
          move[c3][0] = -1;
          move[c3][1] = 0;
          position ++;
          position1 += 0;
          c3 ++;
        } else {
          triggeri1 ++;
        }
      }
      for (int c4 = 0; c4 < 4 - triggeri1; c4 ++) {
        position41 += -1;
        position42 += 0;
      }
      triggeri1 = 0;
      //3
      for (int c2 = 0; c2 < 4; c2++) {
        if (position1 > 0 && position > 0) {
          move[c3][0] = 0;
          move[c3][1] = -1;
          position += -1;
          position1 += 0;
          c3 ++;
        } else {
          triggeri1 ++;
        }
      }
      for (int c4 = 0; c4 < 4 - triggeri1; c4 ++) {
        position41 += 0;
        position42 --;
      }
      triggeri1 = 0;
      for (int c2 = 0; c2 < 4; c2++) {
        if (position1 < 15 && position1 > 0) {
          move[c3][0] = 1;
          move[c3][1] = 0;
          position --;
          position1 += 0;
          c3 ++;
        } else {
          triggeri1 ++;
        }
      }
      for (int c4 = 0; c4 < 4 - triggeri1; c4 ++) {
        position41 += 0;
        position42 += 1;
      }
    //}
  
    for (int i = 0; i < 26; i ++) {
      //System.out.println(move[I][0]+" "+move[I][1]);
    }
   
   
   
   
   
   
   
   
    //System.out.println("asd sadsad sdasd");
   
   
    //int[][] move11 = new int[256][256];
   
    return (move, position41, position42);
  }
  */
 
  //public static int[][][] test_1 (int [] position41, int [] position42) {
   
  //  int[][][] move = new int[10][10][10];
   
   
   
   
   
   
   
  //  return (move);
  //}
 
  public static int test_1 (int[] position41, int [] position42) {
     
    int testbla;
    testbla = 1;
    return(testbla);
  }
 
  public static void main(String[] args) {
    // neue position in main generieren
    // 
    // 
    // 
   
    // in main methode .. 
    // generate_path aufrufen ... 
    // mit methode path, und path2 
     
    // ... 
   
   
   
   
    //System.out.println("lol2");
   
    // first thing, find cat ... echo position1 position11
    //
    // klasse erstmal testen mit der timer methode
    // timer wird gestartet mit <--
    //
    //
   
   
    //
    //
    //
    //
    //
    //
    //
   
    // dunno!
    // move
    // test_1
   
    // testen wie man move1 ausgibt, ohne dass ein error besteht ...
   
    // klasse soll als erstes katze ausgeben
    // als zweites kaese pointen
    // als drittes kaese essen
    //
    // timer fuer das teil 11-2 11-2 1-2
    // 
    // 
    // 
   
    // int move --> keine verwendung  
     
     
     
    int[][] move = new int[1024][1024];
   
    // int test1 erst im speicher aufrufen
    int[][] test_1 = new int[255][255];
   
    // move testen .. move variablen aus test uebergeben ...
    // und punkte wo die hinlaufen muss zurueckgeben
    //..
   
    // aktuelle position?
    // name fuer die variable <position>
    // warum sind variablen position41 nicht global
    // warum sind die variablen so benannt
    // testen ob position41 richtig ist, oder ob der ort fuer die platzierung position1 heisst ... 
   
    // position0 = 
   
    // als naechstes machen: den pointer, pointer4 ausgeben, der bei jedem aufruf von katze weitergegeben wird
    // 
    // als erstes generate_move machen, der ermoeglicht dass die katze einen neuen weg geht, wenn diese aufgehoert hat
    // 
   
    //
   
   
   
   
   
   
    //move = test_1(position41, position42);
    // move weiter testen
   
    //position41 = test[0][0][1];
    //position42 = test[0][0][2];
   
   
    // 
   
    // 
   
   
   
   
   
   
   
    // TODO: fuer generate path, 3 verschiedene funktionen machen, 
    // daystack mit integrieren
    // fuer hoehe y verschieben, eine position vorher y verschieben
   
    // TODO: xml liste mit importieren
    // ball mit implementieren ... 
    //
    // verschiedene moves, mit uebergang machen, aus
    // den xml beschreibungen und bewegungen machen ...
   
    //Document doc = getDocument("test.xml");
    //Element root = doc.getDocumentElement();
    //Element movieElement = (Element)root.getFirstChild();
    //item i;
    //while (movieElement != null)
    //  {
    //  i = getMovie(movieElement);
    //  String number = i.number;
    //  //String msg = Integer.toString(i.number);
    //  //msg += ": " + m.title;
    //  //msg += " (" + cf.format(m.price) + ")";
    //  System.out.println(msg);
    //  movieElement =
    //  (Element)movieElement.getNextSibling();
    //  }
    //    
   
    // item_stack[] ...
    // randomposition fuer kaese generieren  
   
    //
   
   
    // position35 ueberpruefen
   
   
   
   
   
   
    // position35 --> keine verwendung
   
    // move aufrufen, test1, random_stack generieren, timer starten
    double position35 = Math.random() * 15;
    double position36 = 0;
    position35 = Math.round(position35);
   
    int position43 = 7;
    int position44 = 2;
    int position41 = 0;
    int position42 = 0;
   
    int c3 = 0;
    //int[][] move = new int[1024][1024];
    //move = generate_path(position2, position21);
    //move = generate_move(position, position1, position, position1);
   
   
    //System.out.println("lol");
   
    //for (int i = 0; i < 20; i ++) {
    //  System.out.println(move[I][0]+" "+move[I][1]);
   
    //}
   
   
   
   
   
    //move = generate_path2(position, position1);
   
   
   
    // 0 4
    // 6 2
   
   
    //for (int i = 0; i < 20; i ++) { 
    //  System.out.println(move[I][0]+" "+move[I][1]);
    //}
   
   
   
   
   
   
   
    // 1 2 1 1   1 1 0.5 2 0.5 1
    // vorlaeufiger test ... 1 runden, und dann eine kurze
    // pause und dann n runden
    int[][] val3121 = new int[2][4];
    int[] val415 = {0,1,2,3};
    val3121[0] = val415;
    int[] val515 = {3,2,1,0};
    val3121[1] = val515;
    int c14 = 0;
   
   
    // richtungsweisung, rechtsrum linksrum
    int[] val4122 = {1,1,2,1,2,1,1,2,1,2,2,2,1,2,1,2,2,2,1,2,2,2,2,1,2};
   
    int trigger85 = 1;
    int trigger51 = 0;
   
    int[] item_stack = new int[256];
    String[] item_stack1 = new String[256];
   
    item_stack[0] = 4;
    item_stack[1] = 3;
    item_stack1[0] = "kaese";
    // timer, count cat
    // int[] move = new int [4048000];
   
    double val112 = Math.random() * 1; // 2
    val112 = Math.round(val112);
   
    double tmp12 = Math.random() * 1; // 
    tmp12 = Math.round(tmp12);
   
    int tmp1113 = new Double(tmp12).intValue();
    //
    //
    //
    //
    //
    //
    //
   
   
    // patha generieren ... 
   
   
   
   
    // item_stack[] ...
    // 
    // randomposition fuer kaese generieren
   
   
   
   
   
    //int position = 2;
    //int position1 = 3;
    // timer, count cat
    // int[] move = new int [4048000];
   
   
   
   
   
   
   
   
   
   
    // verschieben von koordinaten system 
    // aufruf mehrerer pfade, ... pfade generieren
   
    // aufrufen von springerzug ...
    // pausen machen ....
    // 
    // 
    // 
    // 
    // 
   
    // verschiedene pfade generieren ...
    // von anfangspunkt 3-4 felder in die richtung
    // den schnittpunkt verlagern
    // 
    // 
    // 
    // 
    // 
   
    // --
    // kaese, zu dem kaese hingehen ...
    // xml liste machen, mit aufgaben ...
    // wo der kaese drin ist
    // 
    // zu dem kaese hingehen
    // an dem kaese richen
    // warten
    // 
   
    // script machen um zu kaese hinzugehen
    // den umlenkpunkt fur die katze kuenstlich verkuezen 6:4
    int xpos1 = 2;
    int ypos1 = 0;
   
    int xpos2 = 4;
    int ypos2 = 3;
   
    // specials fuer die maus mit dem fahhrad ueberlegen ...
    // textausgabe machen fuer
    // *ihr katze hat einen ueberschlag gemacht*
    // *ihr katze macht einen 5 m wheeli auf einem rad*
    // *ihre katze grindet mit dem fahhrad eine 90^ s-kurve*
    // 
   
    // scanner klasse um in 180^ zu sehen
   
    //
    // den stack beibehalten evtl. arraylisten machen laufen, warten ...
    // ducken ... rennen, implementieren, .... xml listen importieren, und
    // die uebergaenge mit implementieren
    // 
    // dinge betrachten als clear-type datenbank machen, und shepp programm
    // dafuer machen, tier 12 machen
    // 
    // umfassendes referate zu abstrakten heterogenen datenbank-netzen
    // machen, und das modul fuer sehen, und dinge betrachen auf das modell
    // anwenden
    // 
    // 
    // objektstack erweitern
    // 
    // 
    // objekte, zum sehen
    // 
    // objekte aus dem sichtfeld() { inc c = 7; // objektstack items[]
    // positionx positiony .. items1[] item names, item is visible ... item
    // ... level
    // 
    // objektstack sichtfeld auf 180^ grade erweitern sichtfeld drehen
    // ... auf grad objekte darauf abrattern, und auf alle objekte pointer
    // auf objektstack legen
    //
   
    // bewegungen fuer die katze erweitern
    // springerzug
    // zug
    // um die ecke gehen ...
    // 180^
    // 
    // normaler zug
    // marsch
    // wandern
    // rennen
    // kontrollieren
    // still stehen
    // *additional rush, einfach eine diagonale bilden, und im zickzack gehen
    //
    // normaler zug
    // springerzug
    // kleine pausen
    // normal gehen
    // 
    // marsch
    // grosse entfernungen zuruecklegen
    // sicher ab und zu springerzug
    // weitergehen
    // 
    // rennen
    // risikofactor ... 1:n
    // gegenkontrollieren mit schmerzen
    // 
    // kleine pausen
    // immer ein feld laufen und dann stehen bleiben
    // 
    // normal gehen
    // springerzug, kleines stueck gehen, pause
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
   
    // 
    // 
    // 
   
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
    // 
   
    // pausen einbauen ...
    // in den item-stack pausen einbauen
    // 
    // 
    // 
   
    // 
    //  v kurz v lang
    //  
    // 1:1:1:1:0:1:1:1:1:0:1:0:1:1:1:0 ~ :1:1:0 :0:0:1 v lang 1:1:1:0:1:1:1~
    // :1:1:0:1 :0:1~ :1:0 :0:1
    //
   
    /*int[][] patterna = new int[255][255];
    patterna[0][0] = 1;
    patterna[0][1] = 1;
    patterna[0][2] = 1;
    patterna[0][3] = 1;
    patterna[0][4] = 0;
    patterna[0][5] = 1;
    patterna[0][6] = 1;
    patterna[0][7] = 1;
    patterna[0][8] = 0;
   
    patterna[1][0] = 1;
    patterna[1][1] = 1;
    patterna[1][2] = 1;
    patterna[1][3] = 0;
    patterna[1][4] = 1;
    patterna[1][5] = 1;
    patterna[1][6] = 1;
    patterna[1][7] = 1;
    patterna[1][8] = 1;
    patterna[1][9] = 0;
    patterna[1][0] = 1; */
   
    //
    // for (1-20) ... move generieren ... random(1-4) ... laufrichtung rechts
    // ... -> 1:1:1:4
    // 
    // feld in eine richtung laufen .. pause = 0 0 0 0 0 0 0 fuer pause NULL
    // nehmen
    //
   
    // if (val41 == 3) {
    //   System.out.println("lol");
   
    // }
   
    // patternc = 0,0,0,1 bewegrichtung, anfangen mit pause ...
   
    // --*
    //double val51 = Math.random() * 3;
    //val51 = Math.round(val51);
   
    //String[][] move = new String[10][10]; // = new String[256][256];
   
    // --
    // for (int i = 0; i < 1; i++) {
    //  // direction
    //  // trigger_init starten
    //  // nach init, variable change einlegen, um richtung zu aendern auf
    //  // rechts ...
    //  // 
    //  double val32 = Math.random() * 3;
     
    //  // move hinzufuegen
    //  // for (int 1-7)
    //  move[I][0] = "NULL";
    //  move[I][1] = "";
   
   
   
   
    //System.out.println("position= "+position+" "+position1);
    // TEST: die startposition von 7 2 auf 0 0 verlegen, und testen ob die startposition genau
    // ausgegeben wird.
    // TEST: die ersten 4 felder nach rechts gehen, danach keine bewegung mehr
   
   
   
    // generate day stack
    // choose task ...
    // generate_path, generate_move, generate_path (2)
       
    //move = generate_path(position2, position21);
   
   
    // versuch timer starten
   
    Timer timer = new Timer();
    //                                    fehlende variable, ccounter1 = 1
    //                                    rausfinden wofuer position1, position11 gebraucht wird
    // position1, position11 gehoeren wozu ... ?
   
    // erst gucknen wo position1 generiert wird, und dann
    // suchen in wiefern position1 uebergeben werden
   
   
    // suchen warum, position43, und position44, weitergegeben werden, testen was in den variablen ist
   
   
   
    // testen ob position1 position11 weitergegeben werden
   
   
   
   
    //System.out.println(position1 + " " + position11);
   
    System.out.println("1st: " + position1 + " " + position11);
   
   
   
    MyTask task = new MyTask(40, timer, move, position1, position11, position43, position44);
    // Schedule the task to run every 3,000 millisecs or 3 seconds starting
    // right from the beginning.
    timer.schedule( task, 0, 1000 );
   
   
    // timer starten
    // fehler suchen
   
    // fehler 1: 
    // fehler 2: die variable wird mit move uebergeben
   
  }
}

// in der class testen ob timer angaben stimmen
// die klasse MyTask von MyTask wird nur einmal aufgerufen
// die repeats, wenn gespeichert wurde mit uebergeben
// 

// class Mytask gets value from main ... 


// die klasse mytask wird aufgerufen mit handler position1 als uebergabewert
class MyTask extends TimerTask {
  // MyTask task = new MyTask(40, timer, move, position1, position11, position43, position44);
  // test: which variable goes here
  // new MyTask(40, timer, move, position1, position11, position43, position44);
     
     
     
  int maxNumberOfTimesToRun = 0;
  // A reference to a date object
  Date currentDateTime = null;
  static int counter = 1;
  static int ccounterb = 0;
  // set ccounterb is correct
  // in each run, get ccounterb, and reset it to "0"
 
 
 
  //     MyTask task = new MyTask(40, timer, move, position1, position11, position43, position44);
 
 
 
  //static int[] move_4;
  Timer myTimer = null;
  //private static double position1;
  //private static double position11;
  static double position2 = 0;
  int move[][] = new int[1024][1024];
 
  // testen, bis wo position1 geht
 
 
  static int position1 = 0;
  static int position11 = 10;
  //static int position43 = 0;
  //static int position44 = 0;
 
 
 
 
 
 
 
 
 
  // -----> her einfuegen, dass position1 aufgerufen wird
 
  static int position4 = 0;
 
 
  // Default Constructor
  public MyTask( int maxCounter, Timer aTimer, int[][] amove, int aposition1, int aposition11, int aposition43, int aposition44 )
  {
    super();
    maxNumberOfTimesToRun = maxCounter;
    myTimer = aTimer;
    move = amove;
    int position1 = aposition1;
    int position11 = aposition11;
    int position43 = aposition43;
    int position44 = aposition44;
    //move_4 = amove_4;
  }
  // den counter 1 immer in der klasse run aufrufen
  // damit counter 1 nicht seine wertigkeit verliert, countera mit in den header der funktion uebernehmeb
  //
  //
  //
 
  // Override the abstract method  run()
  public void run()
  {
    if ( MyTask.counter <= maxNumberOfTimesToRun )
    {
     
      //int position1 = MyTask.counter;
      // if give spell position1
      System.out.println(position1);
     
       
      // System.out.println( MyTask.counter );
      // Create a current date instance
      currentDateTime = new Date( System.currentTimeMillis() );
      // Display the current date object as a string
      // string goes graphical item
      //System.out.println("counter sollte ausgegeben werden >> " + position1 + " " + position11);
     
     
     
      //System.out.println(position1 + " " + position11);
      //System.out.println(aposition1);
     
      String line = "";
     
      // variablen testen die weitergegeben wurden
     
      // .. 
     
     
     
     
     
     
     
      // graphische ausgabe so machen, dass der ganze terminal belegt wird
      //
      //
     
      // position aposition43 so augeben dass ein kleines i in der graphic erscheint
     
     
     
     
      // testen wie positionierungsausgabe x1 y1 ausgegeben wird ...
      // testen ob levelwaende/ coordinaten richtig getroffen werden
     
     
      // testen ob test move auf level richtig angewand wird
     
     
     
     
      //for (int i = 0; i < 16; i ++) {
      //  System.out.println(move[I][0]+" "+move[I][1]);
      //}

      // counter soll diejenige variable treffen ... 
      // ausgegeben wird das gane mit print(line)
      // variable line scheint zu stimmen
     
     
      // 1. line ueberpruefen warum die figur nicht richtig in der reihe steht
      //
     
      // 2 die position aus funktion() zurueckerhalten
     
      // 3. den kaese erscheinen lassen
     
     
     
      // figur reihe: 
      // c2
     
      // if counter c2 == hit_figur, jump target
      //System.out.println("+                                +");
     
     
     
     
      // erster overrider ... if position != test a ...- -> do it
      // zweiter overrider ... if
     
     
      // in dem prog, vorgang der updates aktualisieren
      // den neuen schritt immer direkt in die for-schleife einbauen
     
      int trigger4 = 0;
      for (int c = 0; c < 7; c ++) {
        line = " ";
          for (int c2 = 0; c2 < 15; c2 ++) {
           trigger4 = 0;
           //System.out.println("if("+position1+" == "+c+" && "+position+" == "+c2+")");
           
           // in dem programm, bei jedem aufruf .. die ganze prozedur 4x aufrugen ... gerade, gerade, seitlich
           // mit einem brake dass funktion nur 2x aufgerufen wird
           
           
           // bei jedem aufruf position11 & position1 aufrufen
           // _____________________________
          if (c == position11 && c2 == position1) {
            line += ". 0 "; // if position11 == position1 .. add jumper
            trigger4 = 1;
          }
         
          // kaese spawnen lassen
          if (c == position43 && c2 == position44) {
            line += ". * ";
            trigger4 = 1;
          }
         
          if (trigger4 == 0) {
              line += ".   ";
          }
          }
       
        line += "\n";
        //System.out.println(line);
     
     
      }
      // position1 und position11 ausgeben
     
     
      //System.out.println(ccounterb);
      ccounterb ++;
     
      position1 += move[position4][0];
      position11 += move[position4][1];
     
      // position += move[position4][0];
      // position1 += move[position4][1];
     
      //System.out.println("+                                +");
      //System.out.println("\n\n");
     
     
      position4 ++;
      MyTask.counter++;
    }
    else
    {
      // Since we reached the counter max, cancel the task
      cancel();
      // Also cancel the timer since I'm the only one using it.
      // This might not be true in all case
      //
      //
    }
  }
}


   
    /*
    // TODO: ads asdsdasd ... 
    for (int i = 0; i < 10; i++) {
     
      // position berechnen
      // randomposition0 --> rechts, ... 1= x, 2= y-position
      double val32 = Math.random() * 3;
      val32 = Math.round(val32);
      if (val32 == 0) {
        if (val112 == 0) {
          if (tmp12 == 0 && position <= 14 && position1 >= 1) {
            move[c3][0] = 1;
            move[c3][1] = 0;
            c3 ++;
            move[c3][0] = 0;
            move[c3][1] = -1;
            c3 ++;
            // TODO: fuer das move 8 nullen einfuegen 
          }
          if (tmp12 == 1 && position <= 14 && position1 <= 7) {
            move[c3][0] = 1;
            move[c3][1] = 0;
            c3 ++;
            move[c3][0] = 0;
            move[c3][1] = 1;
            c3 ++;
          }
          position41 += move[c3-2][0];
          position42 += move[c3-2][1];
          position41 += move[c3-1][0];
          position42 += move[c3-1][1];
        }
        if (val112 == 1) {
          if (position1 >= 2) {
            move[c3][0] = -1;
            move[c3][1] = 0;
            c3 ++;
            move[c3][0] = -1;
            move[c3][1] = 0;
            c3 ++;
          }
          position41 += move[c3-2][0];
          position42 += move[c3-2][1];
          position41 += move[c3-1][0];
          position42 += move[c3-1][1];
        }
        if (val112 == 2) {
          if (position1 >= 1) {
            move[c3][0] = -1;
            move[c3][1] = 0;
            c3 += 2;
          }
          position41 += move[c3-1][0];
          position42 += move[c3-1][1];
        }
      }
      if (val32 == 1) {
        if (val112 == 0) {
          if (tmp12 == 0 && position >= 1 && position1 <= 7) {
            move[c3][0] = 0;
            move[c3][1] = 1;
            c3 ++;
            move[c3][0] = -1;
            move[c3][1] = 0;
            c3 ++;
          }
          if (tmp12 == 1 && position <= 14 && position1 <= 7) {
            move[c3][0] = 0;
            move[c3][1] = 1;
            c3 ++;
            move[c3][0] = 0;
            move[c3][1] = 1;
            c3 ++;
          }
          position41 += move[c3-2][0];
          position42 += move[c3-2][1];
     position41 += move[c3-2][0];
          position42 += move[c3-2][1];
        }
        if (val112 == 1) {
          if (position1 <= 13) {
            move[c3][0] = 1;
            move[c3][1] = 0;
            c3 ++;
            move[c3][0] = 1;
            move[c3][1] = 0;
            c3 ++;
          }
          position41 += move[c3-2][0];
          position42 += move[c3-2][1];
          position41 += move[c3-1][0];
          position42 += move[c3-1][1];
        }
        if (val112 == 2) {
          if (position <= 14) {
            move[c3][0] = 1;
            move[c3][1] = 0;
            c3 ++;
          }
          position41 += move[c3-1][0];
          position42 += move[c3-1][1];
        }
      }
      if (val32 == 2) {
        // direction = down, 1 move left, 0 move right
        if (val112 == 0) {
          if (tmp12 == 1 && position >= 1 && position1 <= 7) {

            move[c3][0] = -1;
            move[c3][1] = 0;
            c3 ++;
            move[c3][0] = 0;
            move[c3][1] = 1;
            c3 ++;
          }
          if (tmp12 == 0 && position >= 1 && position1 >= 1) {
            move[c3][0] = -1;
            move[c3][1] = 0;
            c3 ++;
            move[c3][0] = 0;
            move[c3][1] = -1;
            c3 ++;
          }
          position41 += move[c3-2][0];
          position42 += move[c3-2][1];
          position41 += move[c3-1][0];
          position42 += move[c3-1][0];
        }
        if (val112 == 1) {
          if (position1 <= 6) {
            move[c3][0] = 0;
            move[c3][1] = -1;
            c3 ++;
            move[c3][0] = 0;
            move[c3][1] = -1;
            c3 ++;
          }
          position41 += move[c3-2][0];
          position42 += move[c3-2][1];
          position41 += move[c3-1][0];
          position42 += move[c3-1][1];
        }
        if (val112 == 2) {
          if (position1 <= 7) {
            move[c3][0] = 0;
            move[c3][1] = -1;
            c3 ++;
          }
          position41 += move[c3-1][0];
          position42 += move[c3-1][1];
        }
      }
      if (val32 == 3) {
        if (val112 == 0) {
          if (tmp12 == 1 && position >= 1 && position1 >= 1) {
            move[c3][0] = 0;
            move[c3][1] = -1;
            c3 ++;
            move[c3][0] = 0;
            move[c3][1] = -1;
            c3 ++;
          }
          if (tmp12 == 0 && position <= 14 && position1 >= 1) {
            move[c3][0] = 0;
            move[c3][1] = -1;
            c3 ++;
            move[c3][0] = 0;
            move[c3][1] = 1;
            c3 ++;
          }
          position41 += move[c3-2][0];
          position42 += move[c3-2][1];
          position41 += move[c3-1][0];
          position42 += move[c3-1][1];
        }
        if (val112 == 1) {
          if (position1 >= 2) {
            move[c3][0] = -1;
            move[c3][1] = 0;
            c3 ++;
            move[c3][0] = -1;
            move[c3][1] = 0;
            c3 ++;
          }
          position41 += move[c3-2][0];
          position42 += move[c3-2][1];
          position41 += move[c3-1][0];
          position42 += move[c3-1][1];
        }
        if (val112 == 2) {
          if (position1 >= 1) {
            move[c3-1][0] = -1;
            move[c3-1][1] = 0;
            c3 ++;
          }
          position41 += move[c3-1][0];
          position42 += move[c3-1][1];
        }
      }
    }
} */

/*
class MyTask extends TimerTask {
  int maxNumberOfTimesToRun = 0;
  // A reference to a date object
  Date currentDateTime = null;
  static int counter = 1;
  Timer myTimer = null;
  int tmpval = 0;
  int[][] move = new int[1024][1024];
  int position4 = -1;
  static int position = 4;
  static int position1 = 3;
  static int aposition4 = 0;
 
  // Default Constructor
  public MyTask(int maxCounter, Timer aTimer, int position4, int[][] amove) {
    super();
    maxNumberOfTimesToRun = maxCounter;
    myTimer = aTimer;
    // tmpval = aval;
    move = amove;
    // counter = 1;
    position4 = aposition4;
  }
 
  // Override the abstract method run()
  public void run() {
    if (MyTask.counter <= maxNumberOfTimesToRun) {
      String line = "";
     
      int val432 = 0;
      int trigger1 = 0; // trigger test, test if path exists in array
      int trigger2 = 0; 
     
      int trigger4 = 0;
      int trigger5 = 0;
      int trigger42 = -1; // trigger42 == c
     
      int trigger6 = 0;
      int trigger61 = 0;
      int trigger81 = 0;
      int trigger82 = 0;
      int trigger83 = 0;
      int c13 = 0;
     
      //tmp
      int trigger84 = 0;
      int i1 = 0;
     
     
      System.out.println("+                                +");
      for (int c = 0; c < 7; c ++) {
        line = " ";
       
       
       
        for (int c2 = 0; c2 < 15; c2 ++) {
          //for (int i1 = 0; i1 < 8; i1 ++) {
          //  val432 = 7-c;
          //  // fitting variable position y goes here ==> move[i1][1]
          //  if (move[i1][0] == val432 && move[i1][1] == c2)
          //    trigger61 = 1;
          //    //System.out.println("x = "+move[i1][1]+" y = "+move[i1][0]);
          //}
         
          //if (trigger61 == 0) {
          //  line += ".   ";
          //} else {
          //  line += ". * ";
          //}
         
          //trigger61 = 0;
         
          // TODO: trigger43 machen, und auch auf != x machen
          // fuer jeden aufruf von y .. position testen
          trigger42 = -1;
          //int i2 = 0;
         
          position += move[i1][0];
          position1 += move[i1][1];
         
           
          //if (c == position && position1 == c2) {
          //  trigger42 = 1;
          //}
         
         
         
          // while (trigger42 == -1) {
          //  if (i1 < 10)
          //    System.out.println("if (move[i1][0] --> "+move[i1][0]+" == "+c+" && move[i1][1] --> "+move[i1][1]+" == "+c2);
           
           
           
           
          //  if (move[i1][0] == c && move[i1][1] == c2) {
          //    trigger42 = 1;
             
          //  }
          //  if (i1 < 124000)
          //    trigger42 = 1;
           
          //  i1 ++;
            //i2 ++;
          //}
         
         
         
          //for (int i1 = 0; i1 < move.length; i1 ++) {  
          //  if (move[position4][0] == c) {
          //    for (int i2 = 0; i2 < move.length; i2 ++) {
               
          //      //System.out.println(c2+" == "+move[i2][0]);
          //      if (c2 == move[position4][1])
          //        trigger42 = 1;
          //        line += ". * ";
               
          //      } else {
          //        //line += ".   ";
          //    }
        //      }
          //  }
          //}
         
         
          if (position == c && position1 == c2) {
            line += ". 0 ";
          } else {
            line += ".   ";
           
          }
         
          trigger42 = 0;
          i1 ++;
        } 
       
       
        line += "\n";
        System.out.println(line);
      }
      System.out.println("");
      System.out.println("+                                +");
      System.out.println("\n\n");
     
      //position += x;
      //position += y;
     
     
     
      position4 ++;
     
      // Katze4_7.setCtimer1(ctimer2); // set counter timer 1 ... timer
      // katze display
     
      currentDateTime = new Date(System.currentTimeMillis());
      MyTask.counter++;
    } else {
      // Since we reached the counter max, cancel the task
      cancel();
      // Also cancel the timer since I'm the only one using it.
      // This might not be true in all cases
      myTimer.cancel();
    }
  }
  */
  /*
  // --
  private static Document getDocument(String name)
    { 
    try 
      { 
      DocumentBuilderFactory factory = 
      DocumentBuilderFactory.newInstance(); 
      factory.setIgnoringComments(true); 
      factory.setIgnoringElementContentWhitespace(true); 
      factory.setValidating(true); 
      DocumentBuilder builder = 
      factory.newDocumentBuilder(); 
      return builder.parse(new InputSource(name)); 
      } 
    catch (Exception e) 
      { 
      System.out.println(e.getMessage()); 
      } 
    return null; 
    }

  private static Movie getMovie(Element e)
    { 
    // get the year attribute 
    String yearString = e.getAttribute("year"); 
    int year = Integer.parseInt(yearString); 
    // get the Title element
    Element tElement = (Element)e.getFirstChild();
    String title = getTextValue(tElement).trim();
    // get the Price element
    Element pElement =
    (Element)tElement.getNextSibling();
    String pString = getTextValue(pElement).trim();
    double price = Double.parseDouble(pString);
    return new Movie(title, year, price);
    }
 
  private static String getTextValue(Node n) 
    { 
    return n.getFirstChild().getNodeValue(); 
    }
 
  public void Movie(String title, int year, double price)
  {
    this.title = title;
    this.year = year;
    this.price = price;
  }
*/
/*
}
*/
/* private static class Movie
  { 
    public String title; 
    public int year; 
    public double price; 
  }
*/

   







/*
    for (int i = 0; i < 3; i ++) {
      // randomposition0 --> rechts, ... 1= x, 2= y-position
      //double val32 = Math.random() * 3;
      //val32 = Math.round(val32);
        int triggeri1 = 0;
        for (int c2 = 0; c2 < 4; c2++) {
          if (position+c2 < 15 && position1+c2 < 7) {
            move[c3][0] = 1;
            move[c3][1] = 0;
            c3 ++;
          } else {
            triggeri1 ++;
          }
        }
        for (int c4 = 0; c4 < 4 - triggeri1; c4 ++) {
          position41 += 1;
          position42 += 0;
        }
        int triggeri1 = 0;
        for (int c2 = 0; c2 < 4; c2++) {
          if (position+c2 < 15 && position1+c2 < 7) {
            move[c3][0] = 0;
            move[c3][1] = -1;
            c3 ++;
          } else {
            triggeri1 ++;
          }
        }
        for (int c4 = 0; c4 < 4 - triggeri1; c4 ++) {
          position41 += 0;
          position42 += -1;
        }
        int triggeri1 = 0;
        for (int c2 = 0; c2 < 4; c2++) {
          if (position-c2 > 0 && position1-c2 > 0) {
            move[c3][0] = -1;
            move[c3][1] = 0;
            c3 ++;
          } else {
            triggeri1 ++;
          }
        }
        for (int c4 = 0; c4 < 4 - triggeri1; c4 ++) {
          position41 += -1;
          position42 += 0;
        }
        int triggeri1 = 0;
        for (int c2 = 0; c2 < 4; c2++) {
          if (position-c2 > 0 && position1-c2 > 0) {
            move[c3][0] = 0;
            move[c3][1] = -1;
            c3 ++;
          } else {
            triggeri1 ++;
          }
        }
        for (int c4 = 0; c4 < 4 - triggeri1; c4 ++) {
          position41 += 0;
          position42 += -1;
        }
    }
*/
[/I][/I][/I][/I][/I][/I][/I][/I][/I][/I]
 
Zuletzt bearbeitet von einem Moderator:
VfL_Freak

VfL_Freak

Top Contributor
Moin,
mal ganz davon abgesehen, dass man Code IMMER in Code-Tags postet (siehe meine Signatur) :
Den Code werde ich mir nicht anschauen!!
Da sind ja (gefühlt) hunderte Zeilen auskommentiert - haben also mit Deiner Frage wenig zu tun!
Da gibt es keine 'sprechenden' Variablennamen!

Mal ehrlich - blickst Du da selbst noch durch??
Reduziere mal den Code auf die relevanten Teile, poste ihn in vernünftiger Form ... und stell Deine Eingangsfrage neu und so, das man auch versteht, was genau Dein Problem !

Danke :rolleyes:
VG Klaus
 
mihe7

mihe7

Top Contributor
Indem Du im Konstruktor von MyTask Deine statischen Variablen nicht hinter lokalen versteckst. Das spielt aber bei dem Code eh keine Rolle mehr.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
N Operatoren Schreibtischtest der Reihen-Suche nach Aufschluss in die Basics Java Basics - Anfänger-Themen 1
D Ich suche nach einer Möglickeit den Webseiten Inhalt per Java zu analysieren Automatisch Java Basics - Anfänger-Themen 3
B String: suche nach Wörter und in List<String> speichern Java Basics - Anfänger-Themen 3
D Suche nach der Anzahl von Zonen zwischen zwei Punkten Java Basics - Anfänger-Themen 2
J Variablen Auf der suche nach einem Befehl Java Basics - Anfänger-Themen 2
S Erste Schritte Suche nach einem guten JAVA-Buch (Definition im Thread) Java Basics - Anfänger-Themen 6
G Erste Schritte Suche nach Zeichenkette Java Basics - Anfänger-Themen 26
S suche nach eclipse plug-in Java Basics - Anfänger-Themen 3
S Suche nach einem Programm Java Basics - Anfänger-Themen 7
A rekrusive Suche nach directories, dir Java Basics - Anfänger-Themen 10
S regular expression - suche nach | Java Basics - Anfänger-Themen 10
W Suche nach strings zwischen eckigen Klammern mittels regulärer Ausdrücke Java Basics - Anfänger-Themen 3
X Suche nach Zeichenketten Java Basics - Anfänger-Themen 9
D Suche in JList nach dem ersten Buchstaben Java Basics - Anfänger-Themen 2
V suche nach nsis script für java applikation Java Basics - Anfänger-Themen 2
A String Array: Suche nach Name -> Wert? Java Basics - Anfänger-Themen 3
S Suche nach einer bestimmten Komponente . Java Basics - Anfänger-Themen 6
Z Suche nach Liste? Java Basics - Anfänger-Themen 4
L Gezielte Infos aus Datei holen - Suche nach Position/Wort Java Basics - Anfänger-Themen 22
D hashcontains: Suche nach Objekten Java Basics - Anfänger-Themen 9
F Auf der Suche in π Java Basics - Anfänger-Themen 13
C Suche Nachhilfe in Java Java Basics - Anfänger-Themen 5
T Binärbaum-Suche Implementation Java Basics - Anfänger-Themen 6
A suche dringend Hilfe!! Java Basics - Anfänger-Themen 6
B Suche free SVN Hosting Java Basics - Anfänger-Themen 12
S Binäre-Suche Algorithmus Java Basics - Anfänger-Themen 1
S Java Lineare-Suche Zeitmessung Java Basics - Anfänger-Themen 5
S Java Lineare Suche Java Basics - Anfänger-Themen 1
S Binäre-Suche bei unsortierten Daten Java Basics - Anfänger-Themen 7
E Die richtige Suche in der API Java Basics - Anfänger-Themen 1
E Weg-Suche-Problem rekursiv Java Basics - Anfänger-Themen 12
B Suche Programme mit Fehlern Java Basics - Anfänger-Themen 9
jaleda100 Component für Suche Java Basics - Anfänger-Themen 4
L Suche ein sampel Projekt Java Basics - Anfänger-Themen 2
P Suche Aufwandsgenerator (o-notation) Java Basics - Anfänger-Themen 1
S Suche aktuelles 2D Grafik Tutorial Java Basics - Anfänger-Themen 5
M Suche hilfe bei Array Java Basics - Anfänger-Themen 4
L Binäre Suche mit Comparator Java Basics - Anfänger-Themen 5
J Methoden Suche effiziente Implementierung für eine Methode Java Basics - Anfänger-Themen 3
D Erste Schritte Suche Quelltext Java Basics - Anfänger-Themen 7
M Rekursion Minimums Suche Java Basics - Anfänger-Themen 12
J Suche Hilfestellung Java Basics - Anfänger-Themen 10
G Erste Schritte Suche Java Programmierer für kleines Projekt Java Basics - Anfänger-Themen 1
J Suche die Emailadresse Java Basics - Anfänger-Themen 6
H Suche in Text und Markierung Java Basics - Anfänger-Themen 14
H Suche in einem Text Java Basics - Anfänger-Themen 17
H Erste Schritte Binäre Suche Java Basics - Anfänger-Themen 37
J Suche simples Beispiel für die EOFException Java Basics - Anfänger-Themen 1
H Rekursion Binäre Suche Java Basics - Anfänger-Themen 2
L Binäre Suche Java Basics - Anfänger-Themen 2
L Linerae Suche in einem sortierten Array Java Basics - Anfänger-Themen 2
N Array, lineare Suche, binäre Suche, Programm bleibt unerwartet stehen... Java Basics - Anfänger-Themen 6
I Innerhalb einer Methode suchen und hinzufügen. Neues Objekt in Suche dann? Java Basics - Anfänger-Themen 8
B Binäre Suche - Junit Test Java Basics - Anfänger-Themen 6
L Einfache Lineare Suche Java Basics - Anfänger-Themen 7
J Binäre Suche eines Array Java Basics - Anfänger-Themen 5
M Methoden Binäre Suche als rekursive Variante Java Basics - Anfänger-Themen 5
M Benutzerdefinierte Suche in einem String - outofbounds Java Basics - Anfänger-Themen 7
X Best Practice SUCHE ein gutes Javabuch! (kein Anfang von 0) Java Basics - Anfänger-Themen 5
B Binäre Suche in einem String Array Java Basics - Anfänger-Themen 10
A Heap Space Error bei rekursiver Suche in Dateien trotz nur einer Zeile im Speicher Java Basics - Anfänger-Themen 26
M Rekursive Suche in einem Feld Java Basics - Anfänger-Themen 11
S Suche richtigen Typ für Variabel mit den Werten (neu, gebraucht, beschädigt) Java Basics - Anfänger-Themen 7
M Best Practice Programmierstil Graphen-A*-Suche Java Basics - Anfänger-Themen 5
M Suche Hilfe bei sehr kleinen Quelltexten Java Basics - Anfänger-Themen 2
E Suche Klasse die eine Bedinung prüft und einen von zwei Auswahlwerten zurückgibt... Java Basics - Anfänger-Themen 6
D Erste Schritte suche hilfe für db-anbindung Java Basics - Anfänger-Themen 36
S Java Servlet - Suche Java Basics - Anfänger-Themen 1
P Hashing suche Java Basics - Anfänger-Themen 4
K Suche Hilfe bei einfachem Java Code ( Debuggen ) Java Basics - Anfänger-Themen 1
M Binäre Suche Fehler überall =( Java Basics - Anfänger-Themen 2
Farbenfroh Suche Übungsaufgaben: BinaryTree, Stack Java Basics - Anfänger-Themen 0
D Binärbaum Suche Java Basics - Anfänger-Themen 5
U Vererbung Suche Hilfe anhand eines Bsp. Java Basics - Anfänger-Themen 1
L Suche Programmier-Projekt mit Anleitung Java Basics - Anfänger-Themen 3
A Suche Programmierer für Android App Java Basics - Anfänger-Themen 1
H Suche Vergleichstabelle für die Klassen String und StringBuilder Java Basics - Anfänger-Themen 1
X [SUCHE]Mitentwickler Java Basics - Anfänger-Themen 10
P Methoden suche funktion die char wert ausgibt wenn man numerischen wert und radix angibt Java Basics - Anfänger-Themen 1
D Binare Suche Java Basics - Anfänger-Themen 1
C Erste Schritte Bereich angeben bzw Fehler Suche Java Basics - Anfänger-Themen 6
L Suche in dreidimensionalen Arrays Java Basics - Anfänger-Themen 3
P Lineare Suche im Array Java Basics - Anfänger-Themen 5
X verschachtelte suche Java Basics - Anfänger-Themen 8
T Sortieren/Suche klappt nicht ganz (String Array) Java Basics - Anfänger-Themen 2
G suche den Begriff & wie programmiere ich sowas (ich ändere den Titel dann) Java Basics - Anfänger-Themen 2
M suche/brauche Links über rein GUI Beispielprogramme Java Basics - Anfänger-Themen 4
I Suche Component welches Map ähnelt Java Basics - Anfänger-Themen 11
D Binäre Suche für Integerarray in rekursiver Funktion Java Basics - Anfänger-Themen 5
steffomio Suche brauchbares I18N Lib Java Basics - Anfänger-Themen 4
J Suche Tipps zum erstellen von Algorithmen Java Basics - Anfänger-Themen 5
D Artikel-Suche implementieren Java Basics - Anfänger-Themen 7
W Compiler-Fehler Binäre Suche Java Basics - Anfänger-Themen 2
R Suche Regex Ausdruck für HTML Java Basics - Anfänger-Themen 11
K Suche geeignete Code-Beispiele Java Basics - Anfänger-Themen 4
P Suche Java Programme mit gutem/anfängertauglichem Quellcode Java Basics - Anfänger-Themen 8
I Suche Compiler in Java SDK Java Basics - Anfänger-Themen 5
R String in Strig Suche Java Basics - Anfänger-Themen 2
M Suche Beispiel-Spiel Java Basics - Anfänger-Themen 3
B Lineare Suche Java Basics - Anfänger-Themen 5

Ähnliche Java Themen

Anzeige

Neue Themen


Oben