SHARE
TWEET

Untitled

a guest May 19th, 2019 87 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. package map;
  2.  
  3. import map.Casketjanlambeck7338116.typ;
  4.  
  5. public class Gridjanlambeck7338116 {
  6.  
  7.     Casketjanlambeck7338116 [][]grid=new Casketjanlambeck7338116[42][32]; // Grid mit Rand
  8.     public void intialisieregridjanlambeck7338116() {
  9.        
  10.         for(int j=31; j>-1; j--) {
  11.         for(int i=0; i<42; i++) {  
  12.            Casketjanlambeck7338116 dummy=new Casketjanlambeck7338116();
  13.            grid[i][j]=dummy;
  14.         }
  15.         }
  16.     }
  17.    
  18.     public void setdirectionJanLambeck7338116() {
  19.         for(int j=30; j>0; j--) {
  20.             for(int i=1; i<41; i++) {
  21.         if((grid[i-1][j].gett()==typ.s && grid[i][j+1].gett()!=typ.s)   ||
  22.            (grid[i-1][j].gett()==typ.s && grid[i-2][j].gett()==typ.s && grid[i-2][j+1].gett()!=typ.s && (grid[i][j-2].gett()==typ.s  ||  grid[i+1][j-1].gett()==typ.s )) ||
  23.            (grid[i-1][j].gett()==typ.s && grid[i-1][j+1].gett()!=typ.s)  ||
  24.            (grid[i-1][j].gett()==typ.s && grid[i+1][j+1].gett()!=typ.s  && grid[i+1][j].gett()==typ.s && grid[i-1][j-2].gett()==typ.s)
  25.              )
  26.         {
  27.             grid[i][j].setw(true);
  28.         }
  29.         if(( grid[i+1][j].gett()==typ.s && grid[i][j-1].gett()!=typ.s  )    ||
  30.             (grid[i+1][j].gett()==typ.s && grid[i+2][j].gett()==typ.s && grid[i+2][j-1].gett()!=typ.s && (grid[i][j+2].gett()==typ.s || grid[i-1][j+1].gett()==typ.s)) ||
  31.             (grid[i+1][j].gett()==typ.s && grid[i+1][j-1].gett()!=typ.s) ||
  32.             (grid[i+1][j].gett()==typ.s && grid[i-1][j-1].gett()!=typ.s  && grid[i-1][j].gett()==typ.s && grid[i+1][j+2].gett()==typ.s)
  33.             )
  34.             {
  35.                 grid[i][j].sete(true);
  36.             }
  37.         if((grid[i][j+1].gett()==typ.s && grid[i+1][j].gett()!=typ.s )  ||
  38.            (grid[i][j+1].gett()==typ.s && grid[i][j+2].gett()==typ.s && grid[i+1][j+2].gett()!=typ.s && (grid[i-2][j].gett()==typ.s || grid[i-1][j-1].gett()==typ.s)) ||
  39.            (grid[i][j+1].gett()==typ.s && grid[i+1][j+1].gett()!=typ.s) ||
  40.            (grid[i][j+1].gett()==typ.s && grid[i+1][j-1].gett()!=typ.s && grid[i][j-1].gett()==typ.s && grid[i-2][j+1].gett()==typ.s)
  41.             )
  42.             {
  43.                 grid[i][j].setn(true);
  44.             }
  45.         if(( grid[i][j-1].gett()==typ.s && grid[i-1][j].gett()!=typ.s ) ||
  46.             (grid[i][j-1].gett()==typ.s && grid[i][j-2].gett()==typ.s && grid[i-1][j-2].gett()!=typ.s && (grid[i+2][j].gett()==typ.s || grid[i+1][j+1].gett()==typ.s)) ||
  47.             (grid[i][j-1].gett()==typ.s && grid[i-1][j-1].gett()!=typ.s) ||
  48.             (grid[i][j-1].gett()==typ.s && grid[i-1][j+1].gett()!=typ.s && grid[i][j+1].gett()==typ.s && grid[i+2][j-1].gett()==typ.s)
  49.             )
  50.             {
  51.                 grid[i][j].sets(true);
  52.             }
  53.             }
  54.         }  
  55.     }
  56.    
  57.     public void buildstreetjanlambeck7338116(int x1, int y1, int x2, int y2, int spee) {
  58.         /**
  59.          * Methode mit der Strassen gebaut werden koennen
  60.          * Strassen sind bei mir die einzigen Instanzen, die in ihrer bauphase andere Gebaude einreissen duerfen
  61.          *  x1/y1 linkes unteres Ende der Strasse,
  62.          *  x2/y2 rechtes oberes Ende der Strasse
  63.          */
  64.                        
  65.         if (x2!=x1+1 && y2!=y1+1) {
  66.             System.out.println("Ungueltige Eingabe");    
  67.             return;
  68.         }
  69.        
  70.         if ( x1<1 || x1>39 || x2<2 || x2>40) {          
  71.             System.out.println("Ungueltige Eingabe");
  72.             return;
  73.         }
  74.        
  75.         if ( y1<1  || y1>29 || y2 <2 || y2>30 ) {
  76.             System.out.println("Ungueltige Eingabe");
  77.             return;
  78.         }
  79.        
  80.         if (x2==x1+1) {  //Nord-Sued Achse
  81.             for (int i=y1; i<y2+1; i++) {
  82.                 grid[x1][i].sp=spee;
  83.                 grid[x1][i].t=typ.s;
  84.                 grid[x2][i].sp=spee;
  85.                 grid[x2][i].t=typ.s;
  86.                }   
  87.             }
  88.         if(y2==y1+1) {          //Ost-West-Achse
  89.             for (int i=x1; i<x2+1; i++) {
  90.                 grid[i][y1].sp=spee;
  91.                 grid[i][y1].t=typ.s;
  92.                 grid[i][y2].sp=spee;
  93.                 grid[i][y2].t=typ.s;
  94.             }
  95.         }
  96.     }
  97.    
  98.     public void buildhospitaljanlambeck7338116(int x1, int y1, int x2, int y2) {
  99.         /**
  100.          * Methode mit der Krankenhauser gebaut werden koennen
  101.          *  x1/y1 linkes unteres Ende des Krankenhauses,
  102.          *  x2/y2 rechtes oberes Ende des Krankenhaus;
  103.          */
  104.                        
  105.         if (x2!=x1+1 || y2!=y1+1) {
  106.             System.out.println("Ungueltige Eingabe");    
  107.             return;
  108.         }
  109.        
  110.         if ( x1<1 || x1>39 || x2<2 || x2>40) {          
  111.             System.out.println("Ungueltige Eingabe");
  112.             return;
  113.         }
  114.        
  115.         if ( y1<1  || y1>29 || y2 <2 || y2>30 ) {
  116.             System.out.println("Ungueltige Eingabe");
  117.             return;
  118.         }
  119.        
  120.          
  121.             for (int i=y1; i<y2+1; i++) {
  122.                 if(grid[x1][i].gett()!=typ.w) {
  123.                     System.out.println("Bitte benutzen Sie unbebaute Grundstuecke zum Bauen ");
  124.                     return;
  125.                 }
  126.             }
  127.             for (int i=y1; i<y2+1; i++) {
  128.                 grid[x1][i].sett(typ.k);
  129.                 grid[x2][i].sett(typ.k);
  130.                
  131.             }
  132.            
  133.             /**
  134.              * hier entsteht ein Code, um Haeuser mit der Strasse zu verbinden, falls diese vorher keinen Strassenanschluss hatten
  135.              Code funktioniert schon ein bisschen
  136.              */
  137.             if(grid[x1-1][y1].gett()!=typ.s && grid[x1-1][y2].gett()!=typ.s && //links vom Gebaeude
  138.                grid[x1+2][y1].gett()!=typ.s && grid[x1+2][y2].gett()!=typ.s &&  //rechts vom Gebaude
  139.                grid[x1][y2+1].gett()!=typ.s && grid[x2][y2+1].gett()!=typ.s &&//oben vom Gebaeude
  140.                grid[x1][y2-2].gett()!=typ.s && grid[x2][y2-2].gett()!=typ.s
  141.                     ) {
  142.                 boolean end=true; //für Abbruch while-Schleife
  143.                 int it=1;         // Iterator  
  144.                 int xdl=0;          // x punkt links wo die Straße gebaut werden soll
  145.                 int ydl=0;          // y punkt unten "  "
  146.                 int xur=0;          // x punkt rechts  " "
  147.                 int yur=0;          // y punkt oben
  148.                 while(end==true){
  149.                     if(grid[x1-it][y1].gett()==typ.s && grid[x1-it][y2].gett()==typ.s) {  //nach westen 90 Grad Kreuzung finden
  150.                         xdl=x1-it+1;
  151.                         ydl=y1;
  152.                         xur=x1-1;
  153.                         yur=y2;
  154.                         end=false;
  155.                         break;
  156.                     }
  157.                     if(grid[x1-it][y1+2].gett()==typ.s && grid[x1-it-1][y1+2].gett()==typ.s &&
  158.                             grid[x1-it-2][y1].gett()!=typ.s && grid[x1-it-2][y2].gett()!=typ.s &&
  159.                             (grid[x1-it-1][y1-1].gett()!=typ.s || grid[x1-it][y1-1].gett()==typ.s )) {                                   //nach westen gehen im norden an Strasse andocken 4fach kreuzungen werden ausgeschlossen
  160.                         xdl=x1-it-1;
  161.                         ydl=y1;
  162.                         xur=x1-1;
  163.                         yur=y2;
  164.                         end=false;
  165.                         break;
  166.                     }
  167.                     if(grid[x1-it][y1-1].gett()==typ.s && grid[x1-it-1][y1-1].gett()==typ.s &&
  168.                        grid[x1-it-2][y1].gett()!=typ.s && grid[x1-it-2][y2].gett()!=typ.s &&   
  169.                        (grid[x1-it-1][y1+2].gett()!=typ.s || grid[x1-it][y1+2].gett()==typ.s)) {                                     //nach westen gehen im sueden an Strasse andocken
  170.                         xdl=x1-it-1;
  171.                         ydl=y1;
  172.                         xur=x1-1;
  173.                         yur=y2;
  174.                         end=false;
  175.                         break;
  176.                     }
  177.                    
  178.                     if(grid[x1][y2+it].gett()==typ.s && grid[x2][y2+it].gett()==typ.s) {  //nach norden 90 Grad Kreuzung finden
  179.                         xdl=x1;
  180.                         ydl=y2+1;
  181.                         xur=x2;
  182.                         yur=y2+it-1;
  183.                         end=false;
  184.                         break;
  185.                     }
  186.                     if(grid[x1-1][y2+it].gett()==typ.s && grid[x1-1][y2+it+1].gett()==typ.s &&  //nach norden gehen im westen an Strasse andocken
  187.                         grid[x1][y2+it+2].gett()!=typ.s && grid[x2][y2+it+2].gett()!=typ.s &&  
  188.                         (grid[x1+2][y2+it+1].gett()!=typ.s || grid[x1+2][y2+it].gett()==typ.s) )
  189.                     {
  190.                         xdl=x1;
  191.                         ydl=y2+1;
  192.                         xur=x2;
  193.                         yur=y2+it+1;
  194.                         end=false;
  195.                         break;
  196.                     }
  197.                     if(grid[x1+2][y2+it].gett()==typ.s && grid[x1+2][y2+it+1].gett()==typ.s && //nach norden gehen im osten an Strasse andocken
  198.                         grid[x1][y2+it+2].gett()!=typ.s && grid[x2][y2+it+2].gett()!=typ.s &&
  199.                         (grid[x1-1][y2+it+1].gett()!=typ.s || grid[x1-1][y2+it].gett()==typ.s )
  200.                             ) {
  201.                         xdl=x1;
  202.                         ydl=y2+1;
  203.                         xur=x2;
  204.                         yur=y2+it+1;
  205.                         end=false;
  206.                         break;
  207.                     }
  208.                     if(grid[x2+it][y1].gett()==typ.s && grid[x2+it][y2].gett()==typ.s) {  //nach osten 90 Grad Kreuzung finden
  209.                         xdl=x2+1;
  210.                         ydl=y1;
  211.                         xur=x2+it-1;
  212.                         yur=y2;
  213.                         end=false;
  214.                         break;
  215.                     }
  216.                     if(grid[x2+it][y1+2].gett()==typ.s && grid[x2+it+1][y1+2].gett()==typ.s &&
  217.                             grid[x2+it+2][y1].gett()!=typ.s && grid[x2+it+2][y2].gett()!=typ.s &&
  218.                             (grid[x2+it+1][y1-1].gett()!=typ.s || grid[x2+it][y1-1].gett()==typ.s )) {            //nach osten gehen im norden an Strasse andocken 4fach kreuzungen werden ausgeschlossen
  219.                         xdl=x2+1;
  220.                         ydl=y1;
  221.                         xur=x2+it+1;
  222.                         yur=y2;
  223.                         end=false;
  224.                         break;
  225.                     }
  226.                     if(grid[x2+it][y1-1].gett()==typ.s && grid[x2+it+1][y1-1].gett()==typ.s &&
  227.                        grid[x2+it+2][y1].gett()!=typ.s && grid[x2+it+2][y2].gett()!=typ.s &&   
  228.                        (grid[x2+it+1][y1+2].gett()!=typ.s || grid[x2+it][y1+2].gett()==typ.s)) {              //nach osten gehen im sueden an Strasse andocken
  229.                         xdl=x2+1;
  230.                         ydl=y1;
  231.                         xur=x2+it+1;
  232.                         yur=y2;
  233.                         end=false;
  234.                         break;
  235.                     }
  236.                     if(grid[x1][y1-it].gett()==typ.s && grid[x2][y1-it].gett()==typ.s) {  //nach sueden 90 Grad Kreuzung finden
  237.                         xdl=x1;
  238.                         ydl=y1-it+1;
  239.                         xur=x2;
  240.                         yur=y1-1;
  241.                         end=false;
  242.                         break;
  243.                     }
  244.                     if(grid[x1-1][y1-it].gett()==typ.s && grid[x1-1][y1-it-1].gett()==typ.s &&  //nach sueden gehen im westen an Strasse andocken
  245.                         grid[x1][y1-it-2].gett()!=typ.s && grid[x2][y1-it-2].gett()!=typ.s &&  
  246.                         (grid[x1+2][y1-it-1].gett()!=typ.s || grid[x1+2][y1-it].gett()==typ.s) )
  247.                     {
  248.                         xdl=x1;
  249.                         ydl=y1-it-1;
  250.                         xur=x2;
  251.                         yur=y1-1;
  252.                         end=false;
  253.                         break;
  254.                     }
  255.                     if(grid[x1+2][y1-it].gett()==typ.s && grid[x1+2][y1-it-1].gett()==typ.s && //nach sueden gehen im osten an Strasse andocken
  256.                         grid[x1][y1-it-2].gett()!=typ.s && grid[x2][y1-it-2].gett()!=typ.s &&
  257.                         (grid[x1-1][y1-it-1].gett()!=typ.s || grid[x1-1][y1-it].gett()==typ.s )
  258.                             ) {
  259.                         xdl=x1;
  260.                         ydl=y1-it-1;
  261.                         xur=x2;
  262.                         yur=y1-1;
  263.                         end=false;
  264.                         break;
  265.                     }
  266.                 }  
  267.                    
  268.                    
  269.                    
  270.                    
  271.                     if (xur==xdl+1) {  //Nord-Sued Achse
  272.                         for (int i=ydl; i<yur+1; i++) {
  273.                             grid[xdl][i].sp=30;           //geschwindigkeit wird als Standard 30 gesetzt
  274.                             grid[xdl][i].t=typ.s;
  275.                             grid[xur][i].sp=30;
  276.                             grid[xur][i].t=typ.s;
  277.                            }   
  278.                         }
  279.                     if(yur==ydl+1) {            //Ost-West-Achse
  280.                         for (int i=xdl; i<xur+1; i++) {
  281.                             grid[i][ydl].sp=30;
  282.                             grid[i][ydl].t=typ.s;
  283.                             grid[i][yur].sp=30;
  284.                             grid[i][yur].t=typ.s;
  285.                         }
  286.                     }
  287.                    
  288.                            
  289.             }
  290.            
  291.     }
  292.    
  293.     public void buildwaterjanlambeck7338116(int x1, int y1, int x2, int y2) {
  294.         /**
  295.          * Methode mit der wassertanks gebaut werden können
  296.          *  x1/y1 linkes unteres Ende des wassertanks,
  297.          *  x2/y2 rechtes oberes Ende des wassertanks;
  298.          */
  299.                        
  300.         if (x2!=x1+1 || y2!=y1+1) {
  301.             System.out.println("Ungueltige Eingabe");    
  302.             return;
  303.         }
  304.        
  305.         if ( x1<1 || x1>39 || x2<2 || x2>40) {          
  306.             System.out.println("Ungueltige Eingabe");
  307.             return;
  308.         }
  309.        
  310.         if ( y1<1  || y1>29 || y2 <2 || y2>30 ) {
  311.             System.out.println("Ungueltige Eingabe");
  312.             return;
  313.         }
  314.        
  315.          
  316.             for (int i=y1; i<y2+1; i++) {
  317.                 if(grid[x1][i].gett()!=typ.w) {
  318.                     System.out.println("Bitte benutzen Sie unbebaute Grundstuecke zum Bauen ");
  319.                     return;
  320.                 }
  321.             }
  322.             for (int i=y1; i<y2+1; i++) {
  323.                 grid[x1][i].sett(typ.wt);
  324.                 grid[x2][i].sett(typ.wt);
  325.                
  326.             }
  327.     }
  328.    
  329.     public void buildfirewakejanlambeck7338116(int x1, int y1, int x2, int y2) {
  330.         /**
  331.          * Methode mit der Feuerwachen gebaut werden können
  332.          *  x1/y1 linkes unteres Ende des Feuerwachen,
  333.          *  x2/y2 rechtes oberes Ende des Feuerwachen;
  334.          */
  335.                        
  336.         if (x2!=x1+1 || y2!=y1+1) {
  337.             System.out.println("Ungueltige Eingabe");    
  338.             return;
  339.         }
  340.        
  341.         if ( x1<1 || x1>39 || x2<2 || x2>40) {          
  342.             System.out.println("Ungueltige Eingabe");
  343.             return;
  344.         }
  345.        
  346.         if ( y1<1  || y1>29 || y2 <2 || y2>30 ) {
  347.             System.out.println("Ungueltige Eingabe");
  348.             return;
  349.         }
  350.        
  351.          
  352.             for (int i=y1; i<y2+1; i++) {
  353.                 if(grid[x1][i].gett()!=typ.w) {
  354.                     System.out.println("Bitte benutzen Sie unbebaute Grundstuecke zum Bauen ");
  355.                     return;
  356.                 }
  357.             }
  358.             for (int i=y1; i<y2+1; i++) {
  359.                 grid[x1][i].sett(typ.f);               
  360.                 grid[x2][i].sett(typ.f);
  361.                
  362.             }
  363.     }
  364.    
  365.     public void buildscrapjanlambeck7338116(int x1, int y1, int x2, int y2) {
  366.         /**
  367.          * Methode mit der Schrottplaetze gebaut werden koennen
  368.          *  x1/y1 linkes unteres Ende des Schrottplatzes
  369.          *  x2/y2 rechtes oberes Ende des schrottplatzes;
  370.          */
  371.                        
  372.         if (x2!=x1+1 || y2!=y1+1) {
  373.             System.out.println("Ungueltige Eingabe");    
  374.             return;
  375.         }
  376.        
  377.         if ( x1<1 || x1>39 || x2<2 || x2>40) {          
  378.             System.out.println("Ungueltige Eingabe");
  379.             return;
  380.         }
  381.        
  382.         if ( y1<1  || y1>29 || y2 <2 || y2>30 ) {
  383.             System.out.println("Ungueltige Eingabe");
  384.             return;
  385.         }
  386.        
  387.          
  388.             for (int i=y1; i<y2+1; i++) {
  389.                 if(grid[x1][i].gett()!=typ.w) {
  390.                     System.out.println("Bitte benutzen Sie unbebaute Grundstuecke zum Bauen ");
  391.                     return;
  392.                 }
  393.             }
  394.             for (int i=y1; i<y2+1; i++) {
  395.                 grid[x1][i].sett(typ.sc);              
  396.                 grid[x2][i].sett(typ.sc);
  397.                
  398.             }
  399.     }
  400.    
  401.     public void buildparkjanlambeck7338116(int x1, int y1, int x2, int y2) {
  402.         /**
  403.          * Methode mit der Parks gebaut werden können
  404.          *  x1/y1 linkes unteres Ende des Parks,
  405.          *  x2/y2 rechtes oberes Ende des Parks;
  406.          */
  407.                        
  408.         if (x2!=x1+1 || y2!=y1+1) {
  409.             System.out.println("Ungueltige Eingabe");    
  410.             return;
  411.         }
  412.        
  413.         if ( x1<1 || x1>39 || x2<2 || x2>40) {          
  414.             System.out.println("Ungueltige Eingabe");
  415.             return;
  416.         }
  417.        
  418.         if ( y1<1  || y1>29 || y2 <2 || y2>30 ) {
  419.             System.out.println("Ungueltige Eingabe");
  420.             return;
  421.         }
  422.        
  423.          
  424.             for (int i=y1; i<y2+1; i++) {
  425.                 if(grid[x1][i].gett()!=typ.w) {
  426.                     System.out.println("Bitte benutzen Sie unbebaute Grundstuecke zum Bauen ");
  427.                     return;
  428.                 }
  429.             }
  430.             for (int i=y1; i<y2+1; i++) {
  431.                 grid[x1][i].sett(typ.p);               
  432.                 grid[x2][i].sett(typ.p);
  433.                
  434.             }
  435.     }
  436.    
  437.     public void buildstandardbuildingjanlambeck7338116(int x1, int y1) {
  438.         /**
  439.          * Methode mit der Standardgebaeude gebaut werden können
  440.          *  x1/y1 linkes unteres Ende des Standardgebaeude,
  441.          *  x2/y2 rechtes oberes Ende des Standardgebaeude;
  442.          */
  443.         if ( x1<1 || x1>40 ||  y1<1  || y1>30) {          
  444.             System.out.println("Ungueltige Eingabe");
  445.             return;
  446.         }
  447.         if(grid[x1][y1].gett()!=typ.w) {
  448.             System.out.println("Bitte benutzen Sie unbebaute Grundstuecke zum Bauen ");
  449.             return;    
  450.         }
  451.         grid[x1][y1].sett(typ.st);             
  452.    
  453.     }
  454.    
  455.     public void buildpartyjanlambeck7338116(int x1, int y1) {
  456.         /**
  457.          * Methode mit der Festhallen gebaut werden koennen
  458.          *  x1/y1 linkes unteres Ende der Festhallen,
  459.          *  x2/y2 rechtes oberes Ende der Festhallen;
  460.          */
  461.         if ( x1<1 || x1>40 ||  y1<1  || y1>30) {          
  462.             System.out.println("Ungueltige Eingabe");
  463.             return;
  464.         }
  465.         if(grid[x1][y1].gett()!=typ.w) {
  466.             System.out.println("Bitte benutzen Sie unbebaute Grundstuecke zum Bauen ");
  467.             return;    
  468.         }
  469.         grid[x1][y1].sett(typ.fe);             
  470.    
  471.     }
  472.    
  473.     public void deleteparkjanlambeck7338116(int x1, int y1, int x2, int y2) {
  474.         /**
  475.          * Methode mit der Parks geloescht werden koennen
  476.          *  x1/y1 linkes unteres Ende des Parks,
  477.          *  x2/y2 rechtes oberes Ende des Parks;
  478.          */
  479.                        
  480.         if (x2!=x1+1 || y2!=y1+1) {
  481.             System.out.println("Ungueltige Eingabe");    
  482.             return;
  483.         }
  484.        
  485.         if ( x1<1 || x1>39 || x2<2 || x2>40) {          
  486.             System.out.println("Ungueltige Eingabe");
  487.             return;
  488.         }
  489.        
  490.         if ( y1<1  || y1>29 || y2 <2 || y2>30 ) {
  491.             System.out.println("Ungueltige Eingabe");
  492.             return;
  493.         }
  494.        
  495.          
  496.             for (int i=y1; i<y2+1; i++) {
  497.                 if(grid[x1][i].gett()!=typ.p) {
  498.                     System.out.println("Es befinden sich nicht nur Parks auf diesem Grundstueck, Loeschversuch deshalb fehlgeschlagen ");
  499.                     return;
  500.                 }
  501.             }
  502.             for (int i=y1; i<y2+1; i++) {
  503.                 grid[x1][i].sett(typ.w);               
  504.                 grid[x2][i].sett(typ.w);
  505.                
  506.             }
  507.     }
  508.    
  509.     public void deletefirewakejanlambeck7338116(int x1, int y1, int x2, int y2) {
  510.         /**
  511.          * Methode mit der Feuerwachen geloescht werden koennen
  512.          *  x1/y1 linkes unteres Ende der Feuerwache,
  513.          *  x2/y2 rechtes oberes Ende der Feuerwache;
  514.          */
  515.                        
  516.         if (x2!=x1+1 || y2!=y1+1) {
  517.             System.out.println("Ungueltige Eingabe");    
  518.             return;
  519.         }
  520.        
  521.         if ( x1<1 || x1>39 || x2<2 || x2>40) {          
  522.             System.out.println("Ungueltige Eingabe");
  523.             return;
  524.         }
  525.        
  526.         if ( y1<1  || y1>29 || y2 <2 || y2>30 ) {
  527.             System.out.println("Ungueltige Eingabe");
  528.             return;
  529.         }
  530.        
  531.          
  532.             for (int i=y1; i<y2+1; i++) {
  533.                 if(grid[x1][i].gett()!=typ.f) {
  534.                     System.out.println("Es befinden sich nicht nur Feuerwachen auf diesem Grundstueck, Loeschversuch deshalb fehlgeschlagen ");
  535.                     return;
  536.                 }
  537.             }
  538.             for (int i=y1; i<y2+1; i++) {
  539.                 grid[x1][i].sett(typ.w);               
  540.                 grid[x2][i].sett(typ.w);
  541.                
  542.             }
  543.     }
  544.    
  545.     public void deletescrapjanlambeck7338116(int x1, int y1, int x2, int y2) {
  546.         /**
  547.          * Methode mit der Schrottplaetze geloescht werden koennen
  548.          *  x1/y1 linkes unteres Ende des Schrottplatz,
  549.          *  x2/y2 rechtes oberes Ende des Schrottplatz;
  550.          */
  551.                        
  552.         if (x2!=x1+1 || y2!=y1+1) {
  553.             System.out.println("Ungueltige Eingabe");    
  554.             return;
  555.         }
  556.        
  557.         if ( x1<1 || x1>39 || x2<2 || x2>40) {          
  558.             System.out.println("Ungueltige Eingabe");
  559.             return;
  560.         }
  561.        
  562.         if ( y1<1  || y1>29 || y2 <2 || y2>30 ) {
  563.             System.out.println("Ungueltige Eingabe");
  564.             return;
  565.         }
  566.        
  567.          
  568.             for (int i=y1; i<y2+1; i++) {
  569.                 if(grid[x1][i].gett()!=typ.sc) {
  570.                     System.out.println("Es befinden sich nicht nur Schrottplaetze auf diesem Grundstueck, Loeschversuch deshalb fehlgeschlagen ");
  571.                     return;
  572.                 }
  573.             }
  574.             for (int i=y1; i<y2+1; i++) {
  575.                 grid[x1][i].sett(typ.w);               
  576.                 grid[x2][i].sett(typ.w);
  577.                
  578.             }
  579.     }
  580.    
  581.     public void deletehospitaljanlambeck7338116(int x1, int y1, int x2, int y2) {
  582.         /**
  583.          * Methode mit der Krankenhauser geloescht werden koennen
  584.          *  x1/y1 linkes unteres Ende des krankenhauses,
  585.          *  x2/y2 rechtes oberes Ende des krankenhauses;
  586.          */
  587.                        
  588.         if (x2!=x1+1 || y2!=y1+1) {
  589.             System.out.println("Ungueltige Eingabe");    
  590.             return;
  591.         }
  592.        
  593.         if ( x1<1 || x1>39 || x2<2 || x2>40) {          
  594.             System.out.println("Ungueltige Eingabe");
  595.             return;
  596.         }
  597.        
  598.         if ( y1<1  || y1>29 || y2 <2 || y2>30 ) {
  599.             System.out.println("Ungueltige Eingabe");
  600.             return;
  601.         }
  602.        
  603.          
  604.             for (int i=y1; i<y2+1; i++) {
  605.                 if(grid[x1][i].gett()!=typ.k) {
  606.                     System.out.println("Es befinden sich nicht nur Krankenhauser auf diesem Grundstueck, Loeschversuch deshalb fehlgeschlagen ");
  607.                     return;
  608.                 }
  609.             }
  610.             for (int i=y1; i<y2+1; i++) {
  611.                 grid[x1][i].sett(typ.w);               
  612.                 grid[x2][i].sett(typ.w);
  613.                
  614.             }
  615.     }
  616.    
  617.     public void deletewaterjanlambeck7338116(int x1, int y1, int x2, int y2) {
  618.         /**
  619.          * Methode mit der Wassertanks geloescht werden koennen
  620.          *  x1/y1 linkes unteres Ende des Wassertanks,
  621.          *  x2/y2 rechtes oberes Ende des Wassertanks;
  622.          */
  623.                        
  624.         if (x2!=x1+1 || y2!=y1+1) {
  625.             System.out.println("Ungueltige Eingabe");    
  626.             return;
  627.         }
  628.        
  629.         if ( x1<1 || x1>39 || x2<2 || x2>40) {          
  630.             System.out.println("Ungueltige Eingabe");
  631.             return;
  632.         }
  633.        
  634.         if ( y1<1  || y1>29 || y2 <2 || y2>30 ) {
  635.             System.out.println("Ungueltige Eingabe");
  636.             return;
  637.         }
  638.        
  639.          
  640.             for (int i=y1; i<y2+1; i++) {
  641.                 if(grid[x1][i].gett()!=typ.wt) {
  642.                     System.out.println("Es befinden sich nicht nur Wassertanks auf diesem Grundstueck, Loeschversuch deshalb fehlgeschlagen ");
  643.                     return;
  644.                 }
  645.             }
  646.             for (int i=y1; i<y2+1; i++) {
  647.                 grid[x1][i].sett(typ.w);               
  648.                 grid[x2][i].sett(typ.w);
  649.                
  650.             }
  651.     }
  652.    
  653.     public void deletepartyjanlambeck7338116(int x1, int y1) {
  654.         if ( x1<1 || x1>40 ||  y1<1  || y1>30) {          
  655.             System.out.println("Ungueltige Eingabe");
  656.             return;
  657.         }
  658.         if(grid[x1][y1].gett()!=typ.fe) {System.out.println("Hier hat vorher keine Festhalle existiert, Loeschversuch deshalb fehlgeschlagen");
  659.         return;        
  660.         }
  661.         grid[x1][y1].sett(typ.w);
  662.     }
  663.    
  664.     public void deletestandardbuildingjanlambeck7338116(int x1, int y1) {
  665.         if ( x1<1 || x1>40 ||  y1<1  || y1>30) {          
  666.             System.out.println("Ungueltige Eingabe");
  667.             return;}
  668.         if(grid[x1][y1].gett()!=typ.st) {System.out.println("Hier hat vorher kein Standardgebaeude existiert, Loeschversuch deshalb fehlgeschlagen");
  669.         return;        
  670.         }
  671.         grid[x1][y1].sett(typ.w);
  672.     }
  673.    
  674.    
  675.    
  676.     public void deletestreetjanlambeck7338116(int x1, int y1, int x2, int y2) {
  677.         if (x2!=x1+1 && y2!=y1+1) {
  678.             System.out.println("Ungueltige Eingabe");    
  679.             return;
  680.         }
  681.        
  682.         if ( x1<1 || x1>39 || x2<2 || x2>40) {          
  683.             System.out.println("Ungueltige Eingabe");
  684.             return;
  685.         }
  686.        
  687.         if ( y1<1  || y1>29 || y2 <2 || y2>30 ) {
  688.             System.out.println("Ungueltige Eingabe");
  689.             return;
  690.         }
  691.        
  692.         if (x2==x1+1) {  //Nord-Sued Achse
  693.             for (int i=y1; i<y2+1; i++) {
  694.                 if(grid[x1][i].gett()!=typ.s || grid[x2][i].gett()!=typ.s) {
  695.                     System.out.println("Hier hat vorher nicht überall eine Strasse existiert, Loeschversuch deshalb fehlgeschlagen");
  696.                     return;
  697.                 }
  698.             }
  699.             for (int i=y1; i<y2+1; i++) {
  700.                 grid[x1][i].setsp(0);
  701.                 grid[x1][i].sett(typ.w);
  702.                 grid[x1][i].setn(false);
  703.                 grid[x1][i].sets(false);
  704.                 grid[x1][i].setw(false);
  705.                 grid[x1][i].sete(false);
  706.                 grid[x2][i].setsp(0);
  707.                 grid[x2][i].sett(typ.w);
  708.                 grid[x2][i].setn(false);
  709.                 grid[x2][i].sets(false);
  710.                 grid[x2][i].setw(false);
  711.                 grid[x2][i].sete(false);
  712.                }   
  713.             }
  714.         if(y2==y1+1) {          //Ost-West-Achse
  715.             for (int i=x1; i<x2+1; i++) {
  716.                 if(grid[i][y1].gett()!=typ.s || grid[i][y2].gett()!=typ.s) {
  717.                     System.out.println("Hier hat vorher nicht überall eine Strasse existiert, Loeschversuch deshalb fehlgeschlagen");
  718.                     return;
  719.                 }
  720.             }
  721.             for (int i=x1; i<x2+1; i++) {
  722.                 grid[i][y1].setsp(0);
  723.                 grid[i][y1].sett(typ.w);
  724.                 grid[i][y1].setn(false);
  725.                 grid[i][y1].sets(false);
  726.                 grid[i][y1].setw(false);
  727.                 grid[i][y1].sete(false);
  728.                 grid[i][y2].setsp(0);
  729.                 grid[i][y2].sett(typ.w);
  730.                 grid[i][y2].setn(false);
  731.                 grid[i][y2].sets(false);
  732.                 grid[i][y2].setw(false);
  733.                 grid[i][y2].sete(false);
  734.             }
  735.         }
  736.     }
  737.    
  738.    
  739.     public void printspeedjanlambeck7338116(){  // Methode die das Array mittels der Geschhwindigkeit auf der Konsole ausgibt
  740.         for(int j=30; j>0; j--) {
  741.             for(int i=1; i<41; i++) {             // setze i=0 und i<42 und der Rand wird mit ausgegeben
  742.             if(grid[i][j].t==typ.w) {
  743.                     System.out.print("wi  ");  
  744.                 }
  745.             if(grid[i][j].t==typ.s) {
  746.                 if(grid[i][j].sp>99) {
  747.                     System.out.print(grid[i][j].sp+" ");
  748.                 }
  749.                 else
  750.                 System.out.print(grid[i][j].sp+"  ");
  751.             }
  752.             if(grid[i][j].t==typ.k) {
  753.                 System.out.print("k   ");  
  754.             }
  755.             if(grid[i][j].t==typ.p) {
  756.                 System.out.print("p   ");  
  757.             }
  758.             if(grid[i][j].t==typ.fe) {
  759.                 System.out.print("fe  ");  
  760.             }
  761.             if(grid[i][j].t==typ.sc) {
  762.                 System.out.print("sc  ");  
  763.             }
  764.             if(grid[i][j].t==typ.f) {
  765.                 System.out.print("f   ");  
  766.             }
  767.             if(grid[i][j].t==typ.wt) {
  768.                 System.out.print("wt  ");  
  769.             }
  770.             if(grid[i][j].t==typ.st) {
  771.                 System.out.print("st  ");  
  772.             }
  773.             //Baustelle muss noch
  774.         }
  775.             System.out.println();
  776.     }  
  777.     }      
  778.        
  779.         public void printdirjanlambeck7338116(){  // Methode die das Array mittels der Geschhwindigkeit auf der Konsole ausgibt
  780.             for(int j=30; j>0; j--) {
  781.                 for(int i=1; i<41; i++) {             // setze i=0 und i<42 und der Rand wird mit ausgegeben
  782.                 if(grid[i][j].t==typ.w) {
  783.                         System.out.print("wi    ");
  784.                     }
  785.                 if(grid[i][j].t==typ.s) {
  786.                     if(grid[i][j].n==true) {
  787.                         System.out.print("(n");
  788.                        
  789.                         }
  790.                     else System.out.print("( ");
  791.                         if(grid[i][j].s==true) {
  792.                             System.out.print("s");     
  793.                             }
  794.                         else System.out.print(" ");
  795.                         if(grid[i][j].e==true) {
  796.                             System.out.print("e");     
  797.                             }
  798.                         else System.out.print(" ");
  799.                         if(grid[i][j].w==true) {
  800.                                 System.out.print("w)");    
  801.                             }
  802.                         else System.out.print(" )");
  803.                 }  
  804.                 if(grid[i][j].t==typ.k) {
  805.                     System.out.print("k     ");
  806.                 }
  807.                 if(grid[i][j].t==typ.p) {
  808.                     System.out.print("p     ");
  809.                 }
  810.                 if(grid[i][j].t==typ.fe) {
  811.                     System.out.print("fe    ");
  812.                 }
  813.                 if(grid[i][j].t==typ.sc) {
  814.                     System.out.print("sc    ");
  815.                 }
  816.                 if(grid[i][j].t==typ.f) {
  817.                     System.out.print("f     ");
  818.                 }
  819.                 if(grid[i][j].t==typ.wt) {
  820.                     System.out.print("wt    ");
  821.                 }
  822.                 if(grid[i][j].t==typ.st) {
  823.                     System.out.print("st    ");
  824.                 }
  825.                 //Baustelle muss noch
  826.                
  827.             }  
  828.                 System.out.println();
  829.         }  
  830.         }  
  831.            
  832.        
  833.    
  834. /*public void bauestrassejanlambeck7338116(int x1, int y1, int x2, int y2, int spee) {
  835.     /**
  836.      * Methode mit der Strassen gebaut werden können
  837.      *  x1/y1 linkes unteres Ende der Strasse,
  838.      *  x2/y2 rechtes oberes Ende der Strasse
  839.      
  840.                    
  841.     if (x2!=x1+1 && y2!=y1+1) {
  842.         System.out.println("Ungültige Eingabe");     // Annahme Einbahnstraße nicht erlaubt
  843.         return;
  844.     }
  845.    
  846.     if ( x1<1 || x1>39 || x2<2 || x2>40) {          // Annhame Einbahnstraße nicht erlaubt
  847.         System.out.println("Ungültige Eingabe");
  848.         return;
  849.     }
  850.    
  851.     if ( y1<1  || y1>29 || y2 <2 || y2>30 ) {
  852.         System.out.println("Ungültige Eingabe");
  853.         return;
  854.     }
  855.    
  856.     if (x2==x1+1) {  //Nord-Süd Achse
  857.         for (int i=y1; i<y2+1; i++) {
  858.             // linke Seite der Straße
  859.            
  860.             if(grid[x1][i-1].t==typ.s) {
  861.                 // es sind
  862.                 grid[x1][i].s=true;
  863.             }  
  864.             if(grid[x1-1][i].t==typ.s && grid[x1-1][i+1].t!=typ.s) {
  865.                
  866.                 grid[x1][i].w=true;
  867.             }
  868.             if(grid[x1+2][i].t==typ.s && grid[x1+2][i+1].t==typ.s) {
  869.                 grid[x1][i].e=true;
  870.             }
  871.             grid[x1][i].sp=spee; //setze geschw
  872.             grid[x1][i].t=typ.s; //setze typ strasse
  873.             grid[x1][i+1].s=true; //setze
  874.            
  875.             if(grid[x1-1][i].t==typ.s && grid[x1-1][i+1].t==typ.s) {
  876.              grid[x1-1][i].e=true;
  877.             }
  878.             if(grid[x1+2][i].t==typ.s && grid[x1+2][i-1].t==typ.s) {
  879.              grid[x1][i].w=true;
  880.             }
  881.             // rechte Seite der Straße ab hier kein x1 mehr
  882.            
  883.             if(grid[x2][i+1].t==typ.s) {
  884.                
  885.                 grid[x2][i].n=true;
  886.             }  
  887.             if(grid[x2+1][i].t==typ.s && grid[x2+1][i-1].t!=typ.s) {
  888.                
  889.                 grid[x2][i].e=true;
  890.             }
  891.             if(grid[x2-2][i].t==typ.s && grid[x2-2][i-1].t==typ.s) {
  892.                 //bei typ.s liegt eventuell ein BUG Nordsetzen
  893.                 grid[x2][i].w=true;
  894.             }
  895.             grid[x2][i].sp=spee;
  896.             grid[x2][i].t=typ.s;
  897.             grid[x2][i-1].n=true;
  898.            
  899.              * Die östlichen/westlichen Angrenzfelder der straße werden einbezogen
  900.             *
  901.             if(grid[x2+1][i].t==typ.s && grid[x2+1][i-1].t==typ.s) {
  902.                  grid[x2+1][i].w=true;                
  903.                 }
  904.             if(grid[x2-2][i].t==typ.s && grid[x2-2][i+1].t==typ.s) {
  905.                 grid[x2-1][i].e=true;
  906.             }
  907.            
  908.         }
  909.         if(grid[x2+1][y2].t==typ.s && grid[x2-2][y2].t!=typ.s && grid[x2][y2+1].t!=typ.s) {
  910.                //damit bei rechtskurven nicht in den gegenverkehr gefahren wird
  911.                 grid[x2][y2-1].n=false;
  912.         }
  913.         if(grid[x1-1][y1].t==typ.s && grid[x1+2][y1].t!=typ.s && grid[x1][y1-1].t!=typ.s) {
  914.                //damit bei rechtskurven nicht in den gegenverkehr gefahren wird
  915.                 grid[x1][y1+1].s=false;
  916.         }
  917.         if(grid[x2][y2+2].t==typ.s) {
  918.             grid[x2][y2+2].s=true; //für Kurvensteuerung
  919.         }          
  920.         if(grid[x2-2][y2+1].t!=typ.s) {
  921.             grid[x2-1][y2+1].e=false;
  922.         }
  923.        
  924.     }
  925.     if(y2==y1+1) {
  926.         //Ost-West-Achse
  927.         for (int i=x1; i<x2+1; i++) {
  928.             // linke Seite der Straße
  929.            
  930.             if(grid[i+1][y1].t==typ.s) {
  931.                 // es sind
  932.                 grid[i][y1].e=true;
  933.             }  
  934.             if(grid[i][y1-1].t==typ.s && grid[i+1][y1-1].t!=typ.s) {
  935.                
  936.                 grid[i][y1].n=true;
  937.             }
  938.             if(grid[i][y1+2].t==typ.s && grid[i+1][y1+2].t==typ.s) {
  939.                 grid[i][y1].s=true;
  940.             }
  941.             grid[i][y1].sp=spee; //setze geschw
  942.             grid[i][y1].t=typ.s; //setze typ strasse
  943.             grid[i-1][y1].e=true; //setze
  944.            
  945.             if(grid[i][y1-1].t==typ.s && grid[i+1][y1-1].t==typ.s) {
  946.              grid[i][y1-1].s=true;
  947.             }
  948.             if(grid[i][y1+2].t==typ.s && grid[i-1][y1+2].t==typ.s) {
  949.              grid[i][y1].n=true;
  950.             }
  951. //rechte Seite der Straße ab hier kein y1 mehr
  952.            
  953.             if(grid[i-1][y2].t==typ.s) {
  954.                
  955.                 grid[i][y2].w=true;
  956.             }  
  957.             if(grid[i][y2+1].t==typ.s && grid[i-1][y2+1].t!=typ.s) {
  958.                
  959.                 grid[i][y2].s=true;
  960.             }
  961.             if(grid[i][y2-2].t==typ.s && grid[i-1][y2-2].t==typ.s) {
  962.                
  963.                 grid[i][y2].n=true;
  964.             }
  965.             grid[i][y2].sp=spee;
  966.             grid[i][y2].t=typ.s;
  967.             grid[i+1][y2].w=true;
  968.            
  969.              * Die östlichen/westlichen Angrenzfelder der straße werden einbezogen
  970.             *
  971.             if(grid[i][y2+1].t==typ.s && grid[i-1][y2+1].t==typ.s) {
  972.                  grid[i][y2+1].n=true;                
  973.                 }
  974.             if(grid[i][y2-2].t==typ.s && grid[i+1][y2-2].t==typ.s) {
  975.                 grid[i][y2-1].s=true;
  976.             }
  977.         }
  978.         if(grid[x2][y2+1].t==typ.s && grid[x2][y2-2].t!=typ.s && grid[x2+1][y2].t!=typ.s) {
  979.                //damit bei rechtskurven nicht in den gegenverkehr gefahren wird
  980.                 grid[x2-1][y2].w=false;
  981.         }
  982.         if(grid[x1][y1-1].t==typ.s && grid[x1][y1+2].t!=typ.s && grid[x1-1][y1].t!=typ.s) {
  983.                //damit bei rechtskurven nicht in den gegenverkehr gefahren wird
  984.                 grid[x1+1][y1].e=false;
  985.         }      
  986.         if(grid[x1-2][y1].t==typ.s) {
  987.             grid[x1-2][y1].e=true;
  988.         }
  989.         if(grid[x1-1][y1-1].t!=typ.s) {
  990.             grid[x1-1][y1].n=false;
  991.         }
  992.     }
  993. }*/
  994.  
  995. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top