//<editor-fold defaultstate="collapsed" desc="package Zuweisung & Importe [NICHT NÖTIG]">
package GUI;
import Klassen.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.AffineTransform;
import java.awt.image.*;
import java.io.*;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;
import javax.imageio.*;
import javax.swing.*;
import java.util.*;
import javax.swing.filechooser.FileNameExtensionFilter;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import java.util.Timer;
//</editor-fold>
public class Main extends javax.swing.JFrame implements MouseListener,ChangeListener {
//<editor-fold defaultstate="collapsed" desc="public Main() [Ivo, ALLES]">
public Main() {
initComponents();
// JFrame zentriert zur Bildschirmmitte, also JFrame in der Mitte des Bildschirms positionieren:
setLocationRelativeTo(null);
this.addWindowListener(new WindowListener () {
@Override
public void windowClosing(WindowEvent e) {
//if (lastSave + 3000 != System.currentTimeMillis()) { new Main().saveOnExit();}
}
//<editor-fold defaultstate="collapsed" desc="Unnötige Funktionen">
@Override
public void windowOpened(WindowEvent e) {}
@Override
public void windowClosed(WindowEvent e) {}
@Override
public void windowIconified(WindowEvent e) {}
@Override
public void windowDeiconified(WindowEvent e) {}
@Override
public void windowActivated(WindowEvent e) {}
@Override
public void windowDeactivated(WindowEvent e) {}
//</editor-fold>
});
this.initFunctions();
}
//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Globale Variablen [ALLES]">
private Simulation Instance; //Thread der die Simulation ausführt
boolean geschw = false;
private T_Paint paint = this.intPaint();
private String object = ""; // "object" speichert den Elementnamen des aktuell zu erstellen Elements (Strasse, Kreuzung, Brücke, nichts).
// "position" speichert, ob Strassen & Brücken vertikal (VK) oder horizontal (HO) erstellt werden sollen
private final int s=12;
private int ix,iy,ax,ay,StrIDZuwei;
// "ix" & "iy" sind jeweils die Koordinaten des letzten Klicks, "ax" & "ay" die des Punktes, zu dem die Maus gedrückt gehalten bewegt wurde
// "s" ist die Breite der Straßen, Brücken & Kreuzungen, "StrIDZuwei" ist ist für die Zuweisung der StraßenID notwendig. Da diese Funktion rekursiv aufgerufen wird muss die Variable global sein.
private double kreuv;
//Die Normgeschwindigkeit in der Kreuzung.Da die Normalgröße einer Kreuzung 6 betragen sollte stimmt diese Bei der einer größe von 6m mit 20 km/h überein.
//Aber für den Fall eines anderen Größenverhältnisses ist diese Formel vorhanden.
private BufferedImage roadVK = null, roadHO=null, crT_0=null, crT_90=null, crT_180=null, crT_270=null, cr4=null, corner_0=null, corner_90=null, corner_180=null, corner_270=null, turn_0=null , turn_90=null, turn_270=null , turn_180=null;
private BufferedImage car[] = new BufferedImage[10];
// Horizontale & Vertikale Strassen & Brücken sowie T- und Vierer-Kreuzungen
private MML_Draw listen;
// MouseMotionListener zum erfassen der Mausbewegung zwecks Drag & Drop und dem "ziehen" von Straßen.
private ObjL Auto = new ObjL(); // Objektliste für die Autos die auf den Straßen fahren
private ObjL Strasse= new ObjL(); // Objektliste für die Strassen, rechte und linke Fahrspur getrennt
private ObjL NormStrasse=new ObjL();// Objektliste für die Strassen, rechte und linke Fahrspur nicht getrennt zweck der Brechnung von Schnittpunkten
private ObjL Kreuzung=new ObjL(); // Objektliste für die Kreuzungen
private ObjL Autoweg[];
//Listenarray für den Autoweg (jedes Auto eine Liste/Nutzung der Kreuzungsknoten)/Listenarray für die Geschwindigkeit und die Beschleunigung und(Nutzung der Autoknoten.)
private ObjL Acceleration[];
//Listenarray für die Hindernisse (jedes Kreuzung eine Liste)
private StrK akt;
public JPanel aTab;
int count = 0;
private double Koordinaten[][];
//</editor-fold>
// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
private void initComponents() {
tp_main = new javax.swing.JTabbedPane();
jPanel1 = new javax.swing.JPanel();
jPanel2 = new javax.swing.JPanel();
jPanel3 = new javax.swing.JPanel();
l_title = new javax.swing.JLabel();
l_developers = new javax.swing.JLabel();
l_Editor = new javax.swing.JLabel();
l_map = new javax.swing.JLabel();
b_mapImport = new javax.swing.JButton();
b_mapExport = new javax.swing.JButton();
b_addRoad = new javax.swing.JButton();
b_addCrossroad = new javax.swing.JButton();
b_addBridge = new javax.swing.JButton();
l_notifications = new javax.swing.JLabel();
b_addCar = new javax.swing.JButton();
j_CarNumber = new javax.swing.JTextField();
b_start = new javax.swing.JButton();
b_pause = new javax.swing.JButton();
b_cancel = new javax.swing.JButton();
b_del = new javax.swing.JButton();
jButtongeschw = new javax.swing.JButton();
jLabel1 = new javax.swing.JLabel();
l_carCount = new javax.swing.JLabel();
b_clear = new javax.swing.JButton();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
jPanel1.setBackground(new java.awt.Color(255, 255, 255));
jPanel1.setForeground(new java.awt.Color(255, 255, 255));
javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1);
jPanel1.setLayout(jPanel1Layout);
jPanel1Layout.setHorizontalGroup(
jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 829, Short.MAX_VALUE)
);
jPanel1Layout.setVerticalGroup(
jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 453, Short.MAX_VALUE)
);
tp_main.addTab("TestTab 1", jPanel1);
javax.swing.GroupLayout jPanel2Layout = new javax.swing.GroupLayout(jPanel2);
jPanel2.setLayout(jPanel2Layout);
jPanel2Layout.setHorizontalGroup(
jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 829, Short.MAX_VALUE)
);
jPanel2Layout.setVerticalGroup(
jPanel2Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 453, Short.MAX_VALUE)
);
tp_main.addTab("TestTab 2", jPanel2);
javax.swing.GroupLayout jPanel3Layout = new javax.swing.GroupLayout(jPanel3);
jPanel3.setLayout(jPanel3Layout);
jPanel3Layout.setHorizontalGroup(
jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 829, Short.MAX_VALUE)
);
jPanel3Layout.setVerticalGroup(
jPanel3Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 453, Short.MAX_VALUE)
);
tp_main.addTab("TestTab 3", jPanel3);
l_title.setFont(new java.awt.Font("Open Sans", 0, 36)); // NOI18N
l_title.setText("Perfect Traffic");
l_developers.setFont(new java.awt.Font("Open Sans", 0, 14)); // NOI18N
l_developers.setText("developed by Remo Raabe and Ivo Berger");
l_Editor.setFont(new java.awt.Font("Open Sans", 0, 18)); // NOI18N
l_Editor.setText("Editor");
l_map.setFont(new java.awt.Font("Open Sans", 0, 18)); // NOI18N
l_map.setText("Karten");
b_mapImport.setText("Import");
b_mapImport.setCursor(new java.awt.Cursor(java.awt.Cursor.HAND_CURSOR));
b_mapImport.setPreferredSize(new java.awt.Dimension(121, 23));
b_mapImport.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
b_mapImportMouseClicked(evt);
}
});
b_mapExport.setText("Export / Speichern");
b_mapExport.setCursor(new java.awt.Cursor(java.awt.Cursor.HAND_CURSOR));
b_mapExport.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
b_mapExportMouseClicked(evt);
}
});
b_addRoad.setText("Straße");
b_addRoad.setCursor(new java.awt.Cursor(java.awt.Cursor.HAND_CURSOR));
b_addRoad.setPreferredSize(new java.awt.Dimension(121, 23));
b_addRoad.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
b_addRoadMouseClicked(evt);
}
});
b_addCrossroad.setText("Kreuzung");
b_addCrossroad.setCursor(new java.awt.Cursor(java.awt.Cursor.HAND_CURSOR));
b_addCrossroad.setEnabled(false);
b_addCrossroad.setPreferredSize(new java.awt.Dimension(121, 23));
b_addCrossroad.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
b_addCrossroadMouseClicked(evt);
}
});
b_addBridge.setText("Brücke");
b_addBridge.setCursor(new java.awt.Cursor(java.awt.Cursor.HAND_CURSOR));
b_addBridge.setEnabled(false);
b_addBridge.setPreferredSize(new java.awt.Dimension(121, 23));
b_addBridge.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
b_addBridgeMouseClicked(evt);
}
});
b_addCar.setText("Autos hinzufuegen");
b_addCar.setCursor(new java.awt.Cursor(java.awt.Cursor.HAND_CURSOR));
b_addCar.setPreferredSize(new java.awt.Dimension(121, 23));
b_addCar.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
b_addCarMouseClicked(evt);
}
});
j_CarNumber.setHorizontalAlignment(javax.swing.JTextField.CENTER);
j_CarNumber.setText("5");
j_CarNumber.setToolTipText("");
b_start.setText("Simulation starten");
b_start.setCursor(new java.awt.Cursor(java.awt.Cursor.HAND_CURSOR));
b_start.setPreferredSize(new java.awt.Dimension(121, 23));
b_start.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
b_startMouseClicked(evt);
}
});
b_pause.setText("Simulation pausieren");
b_pause.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
b_pauseMouseClicked(evt);
}
});
b_cancel.setText("Simulation beenden");
b_cancel.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
b_cancelMouseClicked(evt);
}
});
b_del.setText("Löschen");
b_del.setCursor(new java.awt.Cursor(java.awt.Cursor.HAND_CURSOR));
b_del.setPreferredSize(new java.awt.Dimension(121, 23));
b_del.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
b_delMouseClicked(evt);
}
});
jButtongeschw.setText("versch. Vmax");
jButtongeschw.setToolTipText("");
jButtongeschw.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
jButtongeschwMouseClicked(evt);
}
});
jLabel1.setText("Anzahl Autos: ");
l_carCount.setText("0");
b_clear.setText("Zurücksetzen");
b_clear.addMouseListener(new java.awt.event.MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent evt) {
b_clearMouseClicked(evt);
}
});
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(l_map)
.addComponent(l_Editor)
.addGroup(layout.createSequentialGroup()
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING, false)
.addComponent(b_clear, javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(jButtongeschw, javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(b_del, javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(b_mapImport, javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(b_mapExport, javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(b_addRoad, javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(b_addCrossroad, javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(b_addBridge, javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(j_CarNumber, javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(b_start, javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(b_addCar, javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(b_pause, javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addComponent(b_cancel, javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(l_notifications)))
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addComponent(tp_main))
.addGroup(layout.createSequentialGroup()
.addComponent(l_title)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
.addComponent(l_developers)
.addGroup(layout.createSequentialGroup()
.addComponent(jLabel1)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(l_carCount, javax.swing.GroupLayout.PREFERRED_SIZE, 60, javax.swing.GroupLayout.PREFERRED_SIZE)))))
.addContainerGap())
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
.addContainerGap()
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(l_title)
.addComponent(jLabel1)
.addComponent(l_carCount))
.addComponent(l_developers))
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addComponent(l_map)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addComponent(b_mapImport, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(b_mapExport)
.addGap(18, 18, 18)
.addComponent(l_Editor)
.addGap(18, 18, 18)
.addComponent(b_addRoad, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(b_addCrossroad, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(b_addBridge, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(b_del, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(jButtongeschw)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addGap(91, 91, 91)
.addComponent(l_notifications, javax.swing.GroupLayout.PREFERRED_SIZE, 100, javax.swing.GroupLayout.PREFERRED_SIZE))
.addGroup(layout.createSequentialGroup()
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addComponent(b_clear)
.addGap(10, 10, 10)
.addComponent(j_CarNumber, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(b_addCar, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
.addComponent(b_start, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(b_pause)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(b_cancel))))
.addComponent(tp_main, javax.swing.GroupLayout.PREFERRED_SIZE, 0, Short.MAX_VALUE))
.addContainerGap())
);
pack();
}// </editor-fold>//GEN-END:initComponents
//<editor-fold defaultstate="collapsed" desc="Button-Click-Event-Listener [Remo & Ivo, ALLES]">
//<editor-fold defaultstate="collapsed" desc="Import & Export [Ivo, ALLES]">
private void b_mapImportMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_b_mapImportMouseClicked
// TODO add your handling code here: IMPORT MAP
//Chooser = "Öffnen" Dialog
JFileChooser chooser = new JFileChooser(System.getProperty("user.home") + "/Documents/Schule/Informatik/Lernleistung");
FileNameExtensionFilter plainFilter = new FileNameExtensionFilter(
"Karte / Simluation: .map, .sim", "map", "sim");
chooser.removeChoosableFileFilter(chooser.getAcceptAllFileFilter());
chooser.setFileFilter(plainFilter);
chooser.setDialogTitle("Karte / Simulation öffnen");
if (chooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
if (chooser.getSelectedFile().getName().endsWith(".map")) {
this.reset();
this.importData(chooser.getSelectedFile().getPath(), this.NormStrasse, this.Kreuzung);
} else if (chooser.getSelectedFile().getName().endsWith(".sim")) {
this.reset();
//Simulation einspeisen
}
}
// Hier wird mit Hilfe eines Öffnen Dialogs ein Pfad zum Öffnen ermittelt
// Anschließend wird anhand der Dateiendung ermittelt, ob eine Karte oder eine Sim vorliegt
// importData wird mit diesem Pfad aufgerufen
if (!paint.started) new Timer().schedule(paint, (long) 0.0000001, paint.timeSlice);
paint.started = true;
}//GEN-LAST:event_b_mapImportMouseClicked
private void b_mapExportMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_b_mapExportMouseClicked
// TODO add your handling code here: EXPORT/SAVE MAP
JFileChooser chooser = new JFileChooser(System.getProperty("user.home") + "/Documents/Schule/Informatik/Lernleistung");
FileNameExtensionFilter plainFilter = new FileNameExtensionFilter(
"Karte / Simluation: .map, .sim", "map", "sim");
chooser.removeChoosableFileFilter(chooser.getAcceptAllFileFilter());
chooser.setFileFilter(plainFilter);
chooser.setDialogTitle("Karte / Simulation speichern");
if (chooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
if (chooser.getSelectedFile().getName().endsWith(".map")) {
try (FileWriter out = new FileWriter(chooser.getSelectedFile().getPath())) {
this.export(out, NormStrasse, Kreuzung);
} catch (IOException ex) { System.err.println(ex); }
} else if (chooser.getSelectedFile().getName().endsWith(".sim")) {
try (FileWriter out = new FileWriter(chooser.getSelectedFile().getPath())) {
} catch (IOException ex) { System.err.println(ex); }
} else {
String tmp = chooser.getSelectedFile().getPath() + ".map";
try (FileWriter out = new FileWriter(tmp)) {
this.export(out, NormStrasse, Kreuzung);
} catch (IOException ex) { System.err.println(ex); }
}
}
// Hier wird mit Hilfe eines Speichern unter Dialogs ein Pfad zum Speichern ermittelt
// Anschließend wird anhand der Dateiendung ermittelt, ob eine Karte oder eine Sim gespeichert werden soll
// exportData wird mit diesem Pfad aufgerufen
}//GEN-LAST:event_b_mapExportMouseClicked
//</editor-fold>
private void b_addRoadMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_b_addRoadMouseClicked
//PAINT ROAD
if(!"road".equals(this.object)){
this.object="road";
this.aTab.setFocusable(true); //Fokus auf das Zeichen-Panel ziehen, damit der KeyListener reagiert
this.aTab.requestFocusInWindow();
} else {
this.object="";
}
if (!paint.started) new Timer().schedule(paint, (long) 0.0000001, paint.timeSlice);
paint.started = true;
}//GEN-LAST:event_b_addRoadMouseClicked
private void b_addCrossroadMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_b_addCrossroadMouseClicked
//PLACE CROSSROAD
if(!"crossroad".equals(this.object)){
this.object="crossroad";
this.aTab.setFocusable(true); //Fokus auf das Zeichen-Panel ziehen, damit der KeyListener reagiert
this.aTab.requestFocusInWindow();
}
else{
this.object="";
}
}//GEN-LAST:event_b_addCrossroadMouseClicked
private void b_addBridgeMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_b_addBridgeMouseClicked
//PLACE BRIDGE
if(!"bridge".equals(this.object)){
this.object="bridge";
this.aTab.setFocusable(true); //Fokus auf das Zeichen-Panel ziehen, damit der KeyListener reagiert
this.aTab.requestFocusInWindow();
}
else{
this.object="";
}
}//GEN-LAST:event_b_addBridgeMouseClicked
private void b_addCarMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_b_addCarMouseClicked
paint.pause = true;
kreuv=5;
for(int i=0;i<Integer.parseInt(j_CarNumber.getText());i++){ //Hinzufügen von Autos in der in j_CarNumber angebeben Anzahl
System.out.println(i);
Autohinz();
}
Koordinaten=new double[Auto.getAnzAu()][4];
int i=0;
for(AuK aA=Auto.getAnfAu();aA!=null;aA=aA.getNF()){
Koordinaten[i][0]=aA.getx();
Koordinaten[i][1]=aA.gety();
Koordinaten[i][2]=aA.getxziel();
Koordinaten[i][3]=aA.getyziel();
i++;
}
this.l_carCount.setText(String.valueOf(Auto.getAnzAu()));
paint.pause = false;
}//GEN-LAST:event_b_addCarMouseClicked
private void b_startMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_b_startMouseClicked
Autoweg=new ObjL[Auto.getAnzAu()]; //Initialisierung aller benötigten Variablen & starten der Simulation
Acceleration=new ObjL[Kreuzung.getAnzKreu()];
for(int i=0;i<Auto.getAnzAu();i++){
Autoweg[i]=new ObjL();
}
for(int i=0;i<Kreuzung.getAnzKreu();i++){
Acceleration[i]=new ObjL();
}
for(int i=1;i<=Auto.getAnzAu();i++){
Autokreuzhinzufuegen(i);
}
kreuv=5;
this.startSimulation();
}//GEN-LAST:event_b_startMouseClicked
private void b_pauseMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_b_pauseMouseClicked
// TODO add your handling code here:
if (Instance != null) {
if (Instance.pause) {
resumeSimulation();
this.b_pause.setText("Simulation pausieren");
} else {
suspendSimulation();
this.b_pause.setText("Simulation fortsetzen");
}
}
}//GEN-LAST:event_b_pauseMouseClicked
private void b_cancelMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_b_cancelMouseClicked
// TODO add your handling code here:
if (Instance != null && !Instance.started) terminateSimulation();
}//GEN-LAST:event_b_cancelMouseClicked
private void b_delMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_b_delMouseClicked
if(!"del".equals(this.object)){
this.object="del";
this.aTab.setFocusable(true); //Fokus auf das Zeichen-Panel ziehen, damit der KeyListener reagiert
this.aTab.requestFocusInWindow();
}
else{
this.object="";
}
}//GEN-LAST:event_b_delMouseClicked
private void jButtongeschwMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_jButtongeschwMouseClicked
geschw=true;
System.out.println("geschw=true");
}//GEN-LAST:event_jButtongeschwMouseClicked
private void b_clearMouseClicked(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_b_clearMouseClicked
// TODO add your handling code here:
this.reset();
}//GEN-LAST:event_b_clearMouseClicked
//</editor-fold>
//Überprüfen:Alle IDs sollten mit 1 anfangen, damit man nicht durcheinander kommt.-->Schon gemacht
//Es müssen noch die Höchstgeschwindigkeit hinzugefügt werden.Je nach Länge?-->Vorerst alle eine Geschwindigkeit.
//<editor-fold defaultstate="collapsed" desc="Funktionen, die etwas hinzufüegen z.B. Straßen, Autos und Kreuzungen[REMO, ALLES,AUSSER KreuzungsID]">
//<editor-fold defaultstate="collapsed" desc="Verallgemeinerte, zu komplizierte Funktionen[Remo,Rechnung Schriftlich auf Blatt vorhanden]">
//<editor-fold defaultstate="collapsed" desc="Autos hinzufuegen unfertig, zu kompliziert[Remo,Rechnung Schriftlich auf Blatt vorhanden]">
private void AutohinzKom(double v,double z){
StrK kleinster=null;
double klein=100;
for(StrK aktuell=this.NormStrasse.getAnfStr();aktuell.getNF()==null;aktuell=aktuell.getNF()){
double x=aktuell.getX();
double y=aktuell.getY();
double dx=aktuell.getX2()-aktuell.getX();
double dy=aktuell.getY2()-aktuell.getY();
double r=(v-x+y*(dx/dy)-z*(dx/dy))/(dy/Math.sqrt(dy*dy+dx*dx)+dx/Math.pow(((dy*dy)/dx),2)+dy);
if(kleinster==null || r<klein){
kleinster=aktuell;
klein=r;
}
}
int i=1;
StrK aktuell=Strasse.getAnfStr();
if(i!=aktuell.getID()){
for(i=2;i<kleinster.getID();i++){
aktuell=aktuell.getNF().getNF();
}
}
StrK klein1=aktuell;
StrK klein2=aktuell.getNF();
}//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Hinzufügen einer Kreuzung: Berechnung ob sie nötig ist und wenn ja, wo [Remo], zu kompliziert Erklärung:KreuzAdd.docx">
private void KreuzAddKom(StrK Anf,StrK Aufhoe,StrK End){
if(this.NormStrasse.getAnzStr()>1){
double v1=End.getX();
boolean ueberp=false;
double v2=End.getX2();
double z1=End.getY();
double z2=End.getY2();
StrK aktuell=Anf;
do{
double x1=aktuell.getX();
double x2=aktuell.getX2();
double y1=aktuell.getY();
double y2=aktuell.getY2();
double r=(v2-v1)/(x2-x1);
double s=(z2-z1)/(y2-y1);
if(r==s){aktuell.setID(StrIDZuwei);StrIDZuwei=StrIDZuwei+1;}
else{
s=(-z1/(y2-y1)+y1/(y2-y1)+v1/(x2-x1)-x1/(x2-x1))/((z2-z1)/(y2-y1)-(v2-v1)/(x2-x1));
r=(z1+s*(z2-z1)-y1)/(y2-y1);
if(s<=1 && r<=1){
KreuK Kreuz=new KreuK();
int ID= Kreuzung.getAnzKreu()+1;
StrK adde=new StrK();
StrK adde2=new StrK();
Kreuzung.addKreuzung(Kreuz, v1+s*(v2-v1), z1+s*(z2-z1),ID);
if(r!=0 && r!=1){
StrIDZuwei=StrIDZuwei+2;this.NormStrasse.splitStrasse(aktuell,adde,adde2,x1,y1,x2,y2,v1+s*(v2-v1),z1+s*(z2-z1),aktuell.getID(),aktuell.getID()+1);
}
else{
aktuell.setID(StrIDZuwei);
StrIDZuwei=StrIDZuwei+1;
}
adde=new StrK();
StrK adde3=new StrK();
if(s!=0 && s!=1){
this.NormStrasse.splitStrasse(End,adde,adde3, v1, z1,v2,z2, v1+s*(v2-v1), z1+s*(z2-z1), this.NormStrasse.getAnzStr(),this.NormStrasse.getAnzStr()+1);
if(this.NormStrasse.getAnzStr()>2){
KreuzAddKom(adde2.getNF(),this.NormStrasse.getVG(adde),adde);
KreuzAddKom(adde2.getNF(),this.NormStrasse.getVG(adde),adde3);
}
}
else{
if(r!=0 && r!=1){
KreuzAddKom(adde2.getNF(),Aufhoe,End);
}
else{
KreuzAddKom(aktuell.getNF(),Aufhoe,End);
}
}
ueberp=true;
}
else{aktuell.setID(StrIDZuwei);StrIDZuwei=StrIDZuwei+1;}
}
aktuell=aktuell.getNF();
}while(aktuell!=Aufhoe && aktuell!=Aufhoe.getNF() && ueberp!=true);
}
}
//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Ändert die Straße von der Mittellinie zu den Seitenstreifen, zu kompliziert[Remo, NICHTS Rechnung schriftlich auf Blatt vorhanden]">
private void StrAddKom(){
Strasse.setAnfangStrasse(null);
StrK aktuell=this.NormStrasse.getAnfStr();
while(aktuell.getNF()!=null){
double x=aktuell.getX();
double y=aktuell.getY();
double x2=aktuell.getX2();
double y2=aktuell.getY2();
double[] Koo=new double[8];
Koo[0]=x+s/4*(-y2+y)/Math.sqrt(Math.pow((-y2+y),2)+Math.pow((-x2+x),2));
Koo[1]=y+s/4*(-x2+x)/Math.sqrt(Math.pow((-y2+y),2)+Math.pow((-x2+x),2));
Koo[2]=x2+s/4*(-y2+y)/Math.sqrt(Math.pow((-y2+y),2)+Math.pow((-x2+x),2));
Koo[3]=y2+s/4*(-x2+x)/Math.sqrt(Math.pow((-y2+y),2)+Math.pow((-x2+x),2));
Koo[4]=x-s/4*(-y2+y)/Math.sqrt(Math.pow((-y2+y),2)+Math.pow((-x2+x),2));
Koo[5]=y-s/4*(-x2+x)/Math.sqrt(Math.pow((-y2+y),2)+Math.pow((-x2+x),2));
Koo[6]=x2-s/4*(-y2+y)/Math.sqrt(Math.pow((-y2+y),2)+Math.pow((-x2+x),2));
Koo[7]=y2-s/4*(-x2+x)/Math.sqrt(Math.pow((-y2+y),2)+Math.pow((-x2+x),2));
StrK road_locale= new StrK();
this.Strasse.addStrasse(road_locale,Koo[0],Koo[1],Koo[2],Koo[3],Strasse.getAnzStr()+1);
road_locale= new StrK();
this.Strasse.addStrasse(road_locale,Koo[6],Koo[7],Koo[4],Koo[5],Strasse.getAnzStr()+1);
aktuell=aktuell.getNF();
}
double x=aktuell.getX();
double y=aktuell.getY();
double x2=aktuell.getX2();
double y2=aktuell.getY2();
double[] Koo=new double[8];
Koo[0]=x+s/4*(-y2+y)/Math.sqrt(Math.pow((-y2+y),2)+Math.pow((-x2+x),2));
Koo[1]=y+s/4*(-x2+x)/Math.sqrt(Math.pow((-y2+y),2)+Math.pow((-x2+x),2));
Koo[2]=x2+s/4*(-y2+y)/Math.sqrt(Math.pow((-y2+y),2)+Math.pow((-x2+x),2));
Koo[3]=y2+s/4*(-x2+x)/Math.sqrt(Math.pow((-y2+y),2)+Math.pow((-x2+x),2));
Koo[4]=x-s/4*(-y2+y)/Math.sqrt(Math.pow((-y2+y),2)+Math.pow((-x2+x),2));
Koo[5]=y-s/4*(-x2+x)/Math.sqrt(Math.pow((-y2+y),2)+Math.pow((-x2+x),2));
Koo[6]=x2-s/4*(-y2+y)/Math.sqrt(Math.pow((-y2+y),2)+Math.pow((-x2+x),2));
Koo[7]=y2-s/4*(-x2+x)/Math.sqrt(Math.pow((-y2+y),2)+Math.pow((-x2+x),2));
StrK road_locale= new StrK();
this.Strasse.addStrasse(road_locale,Koo[0],Koo[1],Koo[2],Koo[3],Strasse.getAnzStr()+1);
road_locale= new StrK();
this.Strasse.addStrasse(road_locale,Koo[6],Koo[7],Koo[4],Koo[5],Strasse.getAnzStr()+1);
/*
x+r*(x2-x)
y+r*(y2-y)
Diesee Gerade zu 1,5 Meter (s/2m ist ein Fahrstreifen breit) parallel zu dieser Gerade umrechnen. Sozusagen nur den Stützvektor (x|y) jeweils verändern.
Richtungsvektor hoch -1:
(-y2+y)
(-x2+x)
Jetzt den Einheitsvektor*1,5 davon nehmen.
(-y2+y)
1,5* /Wurzel((-y2+y)²+(-x2+x²))
(-x2+x)
Diesen nun auf dem Stützvektor rechnen
x+1,5*(-y2+y) /Wurzel((-y2+y)²+(-x2+x)²)
y+1,5*(-x2+x) /Wurzel((-y2+y)²+(-x2+x)²)
bzw.
x-1,5*(-y2+y) /Wurzel((-y2+y)²+(-x2+x)²)
y-1,5*(-x2+x) /Wurzel((-y2+y)²+(-x2+x)²)
*/
}
//</editor-fold>
//</editor-fold>
//Bei Kreuz Add sich überlappende Straßen zusammen fügen.
//Momentan noch nicht rechnerich möglich Straßen zu verschieben.
//<editor-fold defaultstate="collapsed" desc="Hinzufügen einer neuen Straße mit berechnung möglicher Kreuzungen[Remo, ALLES]">
private void KreuzAdd(StrK Anf,StrK Stop,StrK NewStrk){ //Dies zeigt die Knoten an, mit denen Angefangen wird(Anf), mit dem Aufgehört wird(Stop)und mit dem es überprüft wird(Check)
//alle Straßen sind senkrecht oder wagerecht zur x-Achse. Daher fuktioniert diese Funktion
//Strasse geht bis zum Rand der Kreuzung PS.: Die Kreuzung wird größer als die Straße. Doppelt so groß.
StrK aktuell=Anf; //setzt eine Variable als Anf ein [muss man sowas wirklich hinschreiben?]
int i=1;
if(this.NormStrasse.getAnzStr()>1 && Anf!=Stop.getNF()) {
Boolean check=false; //Boolean zum Canceln der Schleife bei Treffern
double X1=NewStrk.getX()+s/2;
double X2=NewStrk.getX2()-s/2;
double Y1=NewStrk.getY()+s/2;
double Y2=NewStrk.getY2()-s/2; //Variablen der zu überprüfenden Straße werden gespeichert
if(aktuell!=this.NormStrasse.getAnfStr()){
StrIDZuwei=this.NormStrasse.getVG(aktuell).getID()+1; //Die ID-Zuweisung der Straße wird aktuallisiert, fall die Funktion rekursiv aufgerufen wurde.
}
do {
double x1=aktuell.getX()+s/2;
double x2=aktuell.getX2()-s/2;
double y1=aktuell.getY()+s/2;
double y2=aktuell.getY2()-s/2; //Variablen der Aktuellen Straße werden zwischen gespeichert
aktuell.setID(StrIDZuwei);StrIDZuwei=StrIDZuwei+1; //Die StrassenID wird gesetzt.
if((X2-X1>0 && x2-x1>0) || (Y2-Y1>0 && y2-y1>0)){
//Überschneidung von Straßen --> zwei Straßen zu einer Straße zusammenfügen
} //Parallelität der Straßen
else { //Keine Parallelität der Straßen
if(X2-X1>0) { //Parallel zur x-Achse(End)
if(x1<=X2 && x1>=X1 && Y1<=y2 && Y1>=y1) { //Bedingungen zum Treffen der 2 Straßen
KreuK Kreuz=new KreuK(); //Initialisierung eines neuen Kreuzknotens
int ID= Kreuzung.getAnzKreu()+1; //Neue ID des Kreuzes
StrK adde=new StrK();
StrK adde2=new StrK(); //Zwei neue Straßen werden initialisiert(falls die Straßen sich überschneiden, da jede Straße von Kreuzung zu Kreuzung geht)
Kreuzung.addKreuzung(Kreuz, x1, Y1,ID); //Hinzufügen des neuen Kreuzes
if(x1==X2 || x1==X1){ //Wenn die Straße genau an einem Ende der Aktuell-Straße ist.
if(Y1==y2 || Y1==y1){ //Wenn die andere Straße dort auch ein Ende hat(End)
}
else { //Kein doppeltes Ende(kein Ende an der End-Straße)
this.NormStrasse.splitStrasse(aktuell,adde,adde2,x1,y1,x2,y2,x1,Y1, this.NormStrasse.getAnzStr(),this.NormStrasse.getAnzStr()+1);//Diese Funktion teilt die End-Straße an der Kreuzung in zwei Straßen auf
KreuzAdd(aktuell.getNF(),akt,NewStrk);//Mit jeder Teil-Endstraße wird die Funktion fortgeführt.
}
} else { //die Straße stößt an keinen Ende der Aktuell-Straße zusammen.
if(Y1==y2 || Y1==y1){ //An einem Ende der End Straße
if(akt.getNF()==NewStrk)i=2;
this.NormStrasse.splitStrasse(NewStrk,adde,adde2,X1,Y1,X2,Y2,x1,Y1,aktuell.getID(),aktuell.getID()+1);//Die Straße Aktuell-Straße wird in zwei Straßen aufgeteilt
if(i==2)akt=NormStrasse.getVG(adde);
KreuzAdd(aktuell.getNF(),akt,adde);
KreuzAdd(aktuell.getNF(),akt,adde2);//Mit jeder Teil-Endstraße wird die Funktion fortgeführt.
}
else { //Straßen überkreuzen sich komplett
this.NormStrasse.splitStrasse(aktuell,adde,adde2,x1,y1,x2,y2,x1,Y1,aktuell.getID(),aktuell.getID()+1);//Die Straße Aktuell-Straße wird in zwei Straßen aufgeteilt
StrK adde3=new StrK();
StrK adde4=new StrK();//Zwei neue Straßen werden initialisiert
if(akt.getNF()==NewStrk)i=2;
this.NormStrasse.splitStrasse(NewStrk,adde3,adde4,X1,Y1,X2,Y2,x1,Y1, this.NormStrasse.getAnzStr(),this.NormStrasse.getAnzStr()+1);// Die End-Straße wird auch aufgeteilt
if(i==2)akt=NormStrasse.getVG(adde3);
KreuzAdd(adde2.getNF(),akt,adde3);
KreuzAdd(adde2.getNF(),akt,adde4); //Die Funktion wird mit jeder Endstraße fortgesetzt
}
}
check=true; //Wenn zwei Straßen sich getroffen haben, wird check true
}
}
else { //Parallel zur y-Achse (End)
if(X1<=x2 && X1>=x1 && y1<=Y2 && y1>=Y1){ //Bedingungen zum Treffen der 2 Straßen
KreuK Kreuz=new KreuK(); //Initialisierung eines neuen Kreuzknotens
int ID= Kreuzung.getAnzKreu()+1; //Mit dazugehöeriger ID
StrK adde=new StrK();
StrK adde2=new StrK(); //Initialisierung zweier Straßenknoten
Kreuzung.addKreuzung(Kreuz, X1, y1,ID); //Hinzufügen der Kreuzung
if(X1==x2 || X1==x1) { //Wenn sich die Straßen an einem Ende der End-Straße kreuzen.
if (y1==Y2 || y1==Y1) { //Wenn dort auch das Ende von der Aktuell-Straße ist
} else { //Kein Ende von der Aktuell-Straße
if(akt.getNF()==NewStrk)i=2;
this.NormStrasse.splitStrasse(NewStrk,adde,adde2,X1,Y1,X2,Y2,X1,y1,aktuell.getID(),aktuell.getID()+1);//Die Straße Aktuell-Straße wird in zwei Straßen aufgeteilt
if(i==2)akt=NormStrasse.getVG(adde);
KreuzAdd(aktuell.getNF(),akt,adde);
KreuzAdd(aktuell.getNF(),akt,adde2);//Mit jeder Teil-Endstraße wird die Funktion fortgeführt.
}
} else{ //Kein Ende der End-Straße
if(y1==Y2 || y1==Y1) { //Wenn dort auch das Ende von der Aktuell-Straße ist
this.NormStrasse.splitStrasse(aktuell,adde,adde2,x1,y1,x2,y2,X1,y1,this.NormStrasse.getAnzStr(),this.NormStrasse.getAnzStr()+1);//Diese Funktion teilt die End-Straße an der Kreuzung in zwei Straßen auf
KreuzAdd(adde2.getNF(),akt,NewStrk);
} else {
this.NormStrasse.splitStrasse(aktuell,adde,adde2,x1,y1,x2,y2,X1,y1,aktuell.getID(),aktuell.getID()+1);//Die Straße Aktuell-Straße wird in zwei Straßen aufgeteilt
StrK adde3=new StrK();
StrK adde4=new StrK();
if(akt.getNF()==NewStrk)i=2;
this.NormStrasse.splitStrasse(NewStrk,adde3,adde4,X1,Y1,X2,Y2,X1,y1, this.NormStrasse.getAnzStr(),this.NormStrasse.getAnzStr()+1);// Die End-Straße wird auch aufgeteilt
if(i==2)akt=NormStrasse.getVG(adde3);
KreuzAdd(adde2.getNF(),akt,adde3);
KreuzAdd(adde2.getNF(),akt,adde4); //Die Funktion wird mit jeder Endstraße fortgesetzt
}
}
check=true; //Wenn zwei Straßen sich getroffen haben, wird überprüfung true
}
}
}
aktuell=aktuell.getNF(); //Aktuell-Straße wird auf die nächsteStraße gesetzt
} while(aktuell!=Stop.getNF() && aktuell!=Stop.getNF().getNF() && check!=true);//Die Funktion wird abgebrochen, wenn Die Aktuelle Straße der Nachfolger der Aufhör-Straße ist, damit Stop auch überprüft wird oder eine Überprüfung stattgefunden hat.(Neues KreuzAdd wurde dann auch aufgerufen)
}
}
//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Ändert die Straße von der Mittellinie zu den Seitenstreifen[Remo, ALLES]">
private void StrAdd(){
//Info:Die Seitenstreifen gehen nur vom/bis zum Anfang der Kreuzung
Strasse.setAnfangStrasse(null);
StrK aktuell=this.NormStrasse.getAnfStr();
for(int i=0;i<this.NormStrasse.getAnzStr()*2;aktuell=aktuell.getNF()){//Die Funktion sorgt dafür, dass alles für jede Straße wiederhohlt wird(der Nachfolger wird zu aktuell). i wird bei jedem Seitenstreifen +1 gererechnet, daher solange i<Anzahl*2
double x=aktuell.getX()+s/2;
double y=aktuell.getY()+s/2;
double x2=aktuell.getX2()-s/2;
double y2=aktuell.getY2()-s/2;//Dies sind die Variablen der Straßenmittellinie
i++;
StrK Str=new StrK();
StrK Str2=new StrK();//Hier werden die zwei Seitenstreifen initialisiert
if(x2-x==0){//Überprüfung ob die Straße wagerecht oder Senkrecht zur x-Achse ist. Hier senkrecht
Strasse.addStrasse(Str, x+s/4, y+s/2, x2+s/4, y2-s/2, i);
//Da ein Seitenstreifen s/2m breit ist und die Straße senkrecht ist muss die Mittellinie nur 1,5m in der x Richtung verschoben werden,
//um die Mitte des Seitenstreifens zu haben.Hier wird nach rechts verschoben
//Die s/4 bei y sind dafür da, das die Straße vom Rand der Kreuzungen beginnt und nicht in der Mitte der Kreuzungen.
i++;
Strasse.addStrasse(Str2, x-s/4, y+s/2, x2-s/4, y2-s/2, i);//Hier wird dies in die andere Richtung gemacht(nach links)
}
else{//Hier ist die Straße wagerecht.
Strasse.addStrasse(Str, x+s/2, y+s/4, x2-s/2, y2+s/4, i);//Bei der Waagerechten wird die Straße nur in Richtung der y-Achse verschoben.(Hier nach unten)
i++;
Strasse.addStrasse(Str2, x+s/2, y-s/4, x2-s/2, y2-s/4, i);//Hier das gleiche nach oben
}
}
KreuzungsID();
if(false/*geschw=true*/){
for(StrK ausgabe=Strasse.getAnfStr();ausgabe!=null;ausgabe=ausgabe.getNF()){
System.out.println("Straße nummer "+ausgabe.getID()+" von x1: "+ausgabe.getX()+" bis x2: "+ausgabe.getX2()+" und von y1: "+ausgabe.getY()+" bis y2: "+ausgabe.getY2());
}
for(StrK aStr=Strasse.getAnfStr();aStr!=null;aStr=aStr.getNF()){
double A;
boolean ueber=false;
for(A=50;ueber==false&&A>5;A=A-5){
double a1=3,a2=-6;
double t1=(A-kreuv)/a1,t2=-A/a2,t3=A/a1,t4=(kreuv-A)/a2;
double s1=kreuv*t1+0.5*a1*t1*t1;
double s2=A*t2+0.5*a2*t2*t2;
double s3=0.5*a1*t3*t3;
double s4=A*t4+0.5*a2*t4*t4;
if(s1+s2+s3+s4<Math.abs(aStr.getX2()-aStr.getX())+Math.abs(aStr.getY2()-aStr.getY()))ueber=true;
}
if(A<20){
aStr.setmaxv(5);
double diff=Math.abs(aStr.getX2()-aStr.getX())+Math.abs(aStr.getY2()-aStr.getY());
double t3=diff/5;
aStr.setnormt(t3);
}
else{
aStr.setmaxv(15);
double t1,t2,s1,s2,t3=0;
double a1=-6;
double a2=3;
double memv=A;
double krms=kreuv;
t1=(krms-memv)/a1;
t2=(memv-kreuv)/a2;
s1=memv*t1+a1*t1*t1*0.5;
s2=kreuv*t2+a2*t2*t2*0.5;
double weite=Math.abs(aStr.getX2()-aStr.getX())+Math.abs(aStr.getY2()-aStr.getY());
double diff=weite-(s1+s2);
t3=diff/memv;
aStr.setnormt(t1+t2+t3);
}
}
}
else{
for(StrK aStr=Strasse.getAnfStr();aStr!=null;aStr=aStr.getNF()){
aStr.setmaxv(10);
}
}
}//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Fügt IDs der Kreuzungen und den Straßen hinzu[Remo, ALLES]">
private void KreuzungsID(){
/*Funktion funktioniert nicht richtig und es können dopplungen vorkommen und vermischungen von Norm-/Straße kommt vor
int i=0;
StrK Normaktuell=this.NormStrasse.getAnfStr();
for(KreuK lKreu=Kreuzung.getAnfKreu();lKreu.getNF()!=null;lKreu=lKreu.getNF()){
for(StrK aktuell=Strasse.getAnfStr();aktuell.getNF()!=null && ueberpr!=true;aktuell=aktuell.getNF()){
if(i==2){
i=0;
Normaktuell=Normaktuell.getNF();
}
i++;
if(aktuell.getX2()-aktuell.getX()==0){
if(i==1){
if(aktuell.getX()==lKreu.getX() && aktuell.getY()-s/4==lKreu.getY()){
aktuell.setKreuID(lKreu);
Kreuzung.setKreuzungID(lKreu, aktuell.getNF());
}
}
else{
if(aktuell.getX()==lKreu.getX() && aktuell.getY()+s/4==lKreu.getY()){
aktuell.setKreuID(lKreu);
Kreuzung.setKreuzungID(lKreu, this.NormStrasse.getVG(aktuell));
}
}
}
else{
if(i==1){
if(aktuell.getY()==lKreu.getY() && aktuell.getX()-s/4==lKreu.getX()){
aktuell.setKreuID(lKreu);
Kreuzung.setKreuzungID(lKreu, aktuell.getNF());
}
}
else{
if(aktuell.getY()==lKreu.getY() && aktuell.getX()+s/4==lKreu.getX()){
aktuell.setKreuID(lKreu);
Kreuzung.setKreuzungID(lKreu, this.NormStrasse.getVG(aktuell));
}
}
}
if(lKreu.getStrasse4()!=null)ueberpr=true;
}
ueberpr=false;
}*/
for(StrK aktuell=Strasse.getAnfStr(); aktuell!=null; aktuell=aktuell.getNF().getNF()){
boolean ueberpr=false;
boolean ueberp2=false;
for(KreuK aKreu=Kreuzung.getAnfKreu(); aKreu!=null; aKreu=aKreu.getNF()){//Jede zweite Straße wird mit jeder Kreuzung aufgerufen
if(aktuell.getX2()-aktuell.getX()==0){//Wenn die Straße senkrecht ist
if(aktuell.getX()==aKreu.getx()+s/4){//und die Kreuzung von der x-Koordinate her passen würde
if(aktuell.getY()==aKreu.gety()+s/2){//und die Kreuzung oben an die Straße anstöst(y-Koordinate stimmt)
aktuell.setKreuID(aKreu);//Dann wird die Kreuzung zu der die Straße führt abgespeichert.
Kreuzung.setKreuzungID(aKreu, aktuell.getNF());//und die Straße, die von der Kreuzung abgeht eingespeichert wird
//Dies ist mit Hilfe des NF möglich, weil immer zwei Straßen parralel sind(aktuell=rechter,aktuell.getNF()=linker Seitenstreifen)
ueberpr=true;
}
else{
if(aktuell.getY2()==aKreu.gety()-s/2){//und die Kreuzung unten an die Straße anstöst(y-Koordinate stimmt)
aktuell.getNF().setKreuID(aKreu);//Dann wird die Kreuzung zu der die parralele Straße führt abgespeichert.
Kreuzung.setKreuzungID(aKreu, aktuell);//und die Straße, die von der Kreuzung abgeht eingespeichert wird
ueberp2=true;
}
}
}
}
else{//Wenn die Straße waagerecht ist.
if(aktuell.getY()==aKreu.gety()+s/4){//und die Kreuzung von der y-Koordinate her passen würde
if(aktuell.getX()==aKreu.getx()+s/2){//und die Kreuzung links an die Straße anstöst(y-Koordinate stimmt)
aktuell.getNF().setKreuID(aKreu);//Dann wird die Kreuzung zu der die Straße führt abgespeichert.
Kreuzung.setKreuzungID(aKreu, aktuell);//und die Straße, die von der Kreuzung abgeht eingespeichert wird
//Dies ist mit Hilfe des NF möglich, weil immer zwei Straßen parralel sind(aktuell=unterer,aktuell.getNF()=oberer Seitenstreifen)
ueberpr=true;
}
else{
if(aktuell.getX2()==aKreu.getx()-s/2){//und die Kreuzung links an die Straße anstöst(y-Koordinate stimmt)
aktuell.setKreuID(aKreu);//Dann wird die Kreuzung zu der die Straße führt abgespeichert.
Kreuzung.setKreuzungID(aKreu, aktuell.getNF());//und die Straße, die von der Kreuzung abgeht eingespeichert wird
ueberp2=true;
}
}
}
}
}
if(ueberpr==false){//Wenn keine Kreuzung...
KreuK Kreu=new KreuK();
if(aktuell.getX2()-aktuell.getX()==0){//...oben gefunden wurde
Kreuzung.addKreuzung(Kreu, aktuell.getX()-s/4, aktuell.getY()-s/2, Kreuzung.getAnzKreu()+1);
aktuell.setKreuID(Kreu);
Kreuzung.setKreuzungID(Kreu, aktuell.getNF());
//Dann wird eine neue Kreuzung hinzugefügt, an der man umkehren kann.
}
else{//...links gefunden wurde
Kreuzung.addKreuzung(Kreu, aktuell.getX()-s/2, aktuell.getY()-s/4, Kreuzung.getAnzKreu()+1);
aktuell.getNF().setKreuID(Kreu);
Kreuzung.setKreuzungID(Kreu, aktuell);
//Dann wird eine neue Kreuzung hinzugefügt, an der man umkehren kann.
}
}
if(ueberp2==false){//Wenn keine Kreuzung...
KreuK Kreu=new KreuK();
if(aktuell.getX2()-aktuell.getX()==0){//...unten gefunden wurde
Kreuzung.addKreuzung(Kreu, aktuell.getX2()-s/4, aktuell.getY2()+s/2, Kreuzung.getAnzKreu()+1);
aktuell.getNF().setKreuID(Kreu);
Kreuzung.setKreuzungID(Kreu, aktuell);
//Dann wird eine neue Kreuzung hinzugefügt, an der man umkehren kann.
}
else{//...rechts gefunden wurde
Kreuzung.addKreuzung(Kreu, aktuell.getX2()+s/2, aktuell.getY2()-s/4, Kreuzung.getAnzKreu()+1);
aktuell.setKreuID(Kreu);
Kreuzung.setKreuzungID(Kreu, aktuell.getNF());
//Dann wird eine neue Kreuzung hinzugefügt, an der man umkehren kann.
}
}
}
for(KreuK aKreu=Kreuzung.getAnfKreu();
aKreu.getNF()!=null;
aKreu=aKreu.getNF()){
for(KreuK bKreu=aKreu.getNF();bKreu!=null;bKreu=bKreu.getNF()){
if(aKreu.getx()==bKreu.getx()&&aKreu.gety()==bKreu.gety()){
for(StrK aStr=Strasse.getAnfStr();aStr!=null;aStr=aStr.getNF()){
if(aStr.getKreuID()==bKreu){
aStr.setKreuID(aKreu);
}
}
if(bKreu.getStrasse1()!=null){
Kreuzung.setKreuzungID(aKreu, bKreu.getStrasse1());
if(bKreu.getStrasse2()!=null){
Kreuzung.setKreuzungID(aKreu, bKreu.getStrasse2());
if(bKreu.getStrasse3()!=null){
Kreuzung.setKreuzungID(aKreu, bKreu.getStrasse3());
if(bKreu.getStrasse4()!=null){
Kreuzung.setKreuzungID(aKreu, bKreu.getStrasse4());
}
}
}
}
Kreuzung.delKreu(bKreu);
aKreu=Kreuzung.getAnfKreu();
}
}
}
int i=1;
for(KreuK aKreu=Kreuzung.getAnfKreu();aKreu!=null;aKreu=aKreu.getNF()){
aKreu.setID(i);
i++;
System.err.println("Kreuzung "+aKreu.getID()+" x: "+aKreu.getx()+" y: "+aKreu.gety());
}
}//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Wenn Straßen parallel sind.[Remo, ALLES]">
private void Strhinz(){
StrK bStr;
for(StrK aStr=NormStrasse.getAnfStr(); aStr!=null && aStr.getNF()!=null; aStr=aStr.getNF()){
for(bStr=aStr.getNF(); bStr!=null; bStr=bStr.getNF()){
if(aStr!=bStr){
StrK cStr;
if(aStr.getX()>bStr.getX() || aStr.getY()>bStr.getY()){
cStr=aStr;
aStr=bStr;
bStr=cStr;
}
double aSx1=aStr.getX()+s/2;
double bSx1=bStr.getX()+s/2;
double aSy1=aStr.getY()+s/2;
double bSy1=bStr.getY()+s/2;
double aSx2=aStr.getX2()-s/2;
double bSx2=bStr.getX2()-s/2;
double aSy2=aStr.getY2()-s/2;
double bSy2=bStr.getY2()-s/2;
if(aSx2-aSx1==0 && bSx2-bSx1==0 && aSx1==bSx1){
if(aSy2>=bSy1&&aSy1<=bSy1){
if(bSy2>aSy2){
aStr.setY2(bStr.getY2());
}
NormStrasse.delStrassen(bStr);
aStr=NormStrasse.getAnfStr();
bStr=NormStrasse.getAnfStr();
}
}
else{
if(aSy2-aSy1==0&&bSy2-bSy1==0&&aSy1==bSy1){
if(aSx2>=bSx1&&aSx1<=bSx1){
if(bSx2>aSx2){
aStr.setX2(bStr.getX2());
}
NormStrasse.delStrassen(bStr);
aStr=NormStrasse.getAnfStr();
bStr=NormStrasse.getAnfStr();
}
}
}
}
}
}
StrK temp=akt;
if(this.NormStrasse.getLetzterStrasse()!=this.NormStrasse.getAnfStr()){
for(StrK aStr=NormStrasse.getAnfStr().getNF();aStr!=null;aStr=aStr.getNF()){
akt=this.NormStrasse.getVG(aStr);
KreuzAdd(this.NormStrasse.getAnfStr(),akt,aStr);
}
}
StrK aktuell=this.NormStrasse.getAnfStr(); //Nun wird wieder die Anfangsstraße aufgerufen
for(int i=1;i<=this.NormStrasse.getAnzStr();aktuell=aktuell.getNF()){ //und für jede Straße
aktuell.setID(i); //die richtige ID eingesetzt
i++;
}
akt=temp;
StrAdd();
sortKreuK(Kreuzung);
}//</editor-fold>
//Werden die Autos per Zufall hinzugefügt?Funktion mit zufallszahlen aufrufen-->Wird momentan gemacht
//Was passiert, wenn schon ein Auto dort vorhanden ist?-->Mom. gar nichts
//Werden die Anzahlen der Autos vorbestimmt? Oder werden alle Autos gleichzeitig hinzugefügt?-->beste Lösung
//<editor-fold defaultstate="collapsed" desc="Autos hinzufuegen[Remo, ALLES]">
private void Autohinz(){
int lrou=2;//Hilfsvariable für den Richtungsvektor
double v,z,abs;
int xy;
double weite=0,s1,s2;
do{
if(weite!=0){
weite=0;Auto.delAuto(Auto.getLetzterAuto());
}
do{
Random generator=new Random();
v=generator.nextInt(this.aTab.getWidth())+1;
z=generator.nextInt(this.aTab.getHeight())+1;//Mittelpunkt des Autos(v|z)
lrou=2;
xy=2;//Eine Hilfsvariable, die später anzeigt ob die Straße senkrecht oder wagerecht zur x-Achse ist.
abs=0;//Diese Variable zeigt den Abstand zwischen Auto(wo hingeklickt wurde un Straße an)
for(StrK aktuell=Strasse.getAnfStr(); aktuell!=null; aktuell=aktuell.getNF()){//Sorgt dafür, dass jede Straße durchgelaufen wird
double x=aktuell.getX();
double y=aktuell.getY();
double x2=aktuell.getX2();
double y2=aktuell.getY2();//Koordinaten der Straße
if((z>y && z<y2) || (v>x && v<x2)){//sorgt dafür, dass nur Straßen genommen werden, die senkrecht oder wagerecht zum Ursprung vom Auto aus sind.
if(x2-x==0){//Senkrecht?
if(xy==2 || Math.abs(v-x)<Math.abs(abs)){//Wenn bisher noch nichts gespeichert wurde oder der Abstand kleiner ist als vorher
abs=v-x;//Neuer Abstand wird gespeichert
xy=0;//Art der Straße wird gespeichert(senk.)
if(aktuell.getX()-aktuell.getKreuID().getx()==s/4){lrou=0;}//Wenn die Straße rechts ist (das Auto nach oben fährt)ist lrou 0
else{lrou=1;}//Wenn das Auto nach unten fährt ist lrou 1
}
}
else{//Waagerecht?
if(xy==2 || Math.abs(z-y)<Math.abs(abs)){//Wenn bisher noch nichts gespeichert wurde oder der Abstand kleiner ist als vorher
abs=z-y;//Neuer Abstand wird gespeichert
xy=1;//Art der Straße wird gespeichert(waag.)
if(aktuell.getY()-aktuell.getKreuID().gety()==s/4){lrou=0;}//Wenn die Straße unten ist (das Auto nach rechts fährt)ist lrou 0
else{lrou=1;}//Wenn das Auto nach links fährt ist lrou 1
}
}
}
}
if(Auto.getAnfAu()!=null){//Überprüfung ob es sich mit einem anderen Auto überschneidet
for(AuK aA=Auto.getAnfAu();aA.getNF()!=null;aA=aA.getNF()){
if(xy==1){
if(aA.getxrichtung()==0){
if(aA.getx()==v-abs){
if(aA.gety()-aA.getlaenge()/2<=z+aA.getlaenge()/2 && aA.gety()+aA.getlaenge()/2>=z-aA.getlaenge()/2){
lrou=2;
}
}
}
}
else{
if(aA.getyrichtung()==0){
if(aA.gety()==z-abs){
if(aA.getx()-aA.getlaenge()/2<=v+aA.getlaenge()/2 && aA.getx()+aA.getlaenge()/2>=v-aA.getlaenge()/2){
lrou=2;
}
}
}
}
}
}
}
while(lrou==2);//Wenn oben, links,recht oder unten keine Strase sich befindet, wird der Algorithmus wiederholt.
AuK Autos=new AuK(s);//Initialisierung eines neuen Autoknotens
if(xy==0){
Auto.addAuto(Autos,v-abs,z);//Projektion des Autos auf die Senkrechte Straße
if(lrou==0){//Überprüft in welche Richtung das Auto fährt und speichert anhand dessen den Richungsvektor des Autos
Auto.getLetzterAuto().setxrichtung(0);
Auto.getLetzterAuto().setyrichtung(-1);
}
else{
Auto.getLetzterAuto().setxrichtung(0);
Auto.getLetzterAuto().setyrichtung(1);
}
}
if(xy==1){
Auto.addAuto(Autos,v,z-abs);//Projektion auf die wagerechte Straße
if(lrou==0){//Überprüft in welche Richtung das Auto fährt und speichert anhand dessen den Richungsvektor des Autos
Auto.getLetzterAuto().setxrichtung(1);
Auto.getLetzterAuto().setyrichtung(0);
}
else{
Auto.getLetzterAuto().setxrichtung(-1);
Auto.getLetzterAuto().setyrichtung(0);
}
}
AuK aA=Auto.getLetzterAuto();
aA.setbeschlanf();
aA.setbeschlbrem();
aA.setv(0);
boolean check=false;//Variable zur Überprüfung
StrK aStr;
for(aStr=Strasse.getAnfStr();check==false;aStr=aStr.getNF()){
if(aStr.getX2()-aStr.getX()==0){//Wenn die Straße senkrecht ist
if(aA.getx()==aStr.getX() && aA.gety()<=aStr.getY2() && aA.gety()>=aStr.getY()){
//Wenn die x-Variable des Autos gleich der Straße ist und die y-Variable des Autos innerhalb der Straße liegt, färt das Auto auf der Straße.
//Die Zugehörigkeit wird eingetragen,check true gesetzt, damit nicht jede Weitere Straße überprüft wird.
aA.setMemShip(aStr.getID());check=true;
}
}
else{//Wenn die Straße wagerecht ist.
if(aA.gety()==aStr.getY() && aA.getx()<=aStr.getX2() && aA.getx()>=aStr.getX()){
//Wenn die y-Variable des Autos gleich der Straße ist und die x-Variable des Autos innerhalb der Straße liegt, färt das Auto auf der Straße.
//Die Zugehörigkeit wird eingetragen,check true gesetzt, damit nicht jede Weitere Straße überprüft wird.
aA.setMemShip(aStr.getID());check=true;
}
}
}
if(aStr==null)aStr=Strasse.getLetzterStrasse();
else aStr=Strasse.getVG(aStr);
double a2=aA.getbeschlanf();
double krms=kreuv;
double t2=krms/a2;
s2=a2*t2*t2*0.5;
if(aA.getxrichtung()>0||aA.getyrichtung()>0)weite=aStr.getX2()-aA.getx()+aStr.getY2()-aA.gety();
else weite=aA.getx()-aStr.getX()+aA.gety()-aStr.getY();
}
while(weite<s2);
Autozeichnen(Auto.getLetzterAuto().getx(),Auto.getLetzterAuto().gety());
Auto_setzeZiel(Auto.getLetzterAuto());
}
//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Setzt dem Auto ein neues Ziel [Remo, ALLES]">
public void Auto_setzeZiel(AuK aA) {
double xz,yz;
do{
int zufall=Strasse.getAnzStr();
Random generator = new Random();
zufall=generator.nextInt(zufall)+1;//Nimmt eine Zufallszahl, die innerhalb von 0 bis zu der Anzahl der Straßen
xz=(Strasse.getbestStrasse(zufall,Strasse.getAnfStr()).getX2()-Strasse.getbestStrasse(zufall,Strasse.getAnfStr()).getX())/2+Strasse.getbestStrasse(zufall,Strasse.getAnfStr()).getX();
yz=(Strasse.getbestStrasse(zufall,Strasse.getAnfStr()).getY2()-Strasse.getbestStrasse(zufall,Strasse.getAnfStr()).getY())/2+Strasse.getbestStrasse(zufall,Strasse.getAnfStr()).getY();
}
while(aA.getxziel()==xz && aA.getyziel()==yz);
aA.setxziel(xz);
aA.setyziel(yz);
//Als neues Ziel wird die Mitte der Strasse, dessen ID der Zufallszahl übereinstimmt.
}//</editor-fold>
//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Funktionen, die Zeitabhängig aufgerufen werden[Remo,FAST ALLES], nicht alle Funktionen fertig und vollständig">
//<editor-fold defaultstate="collapsed" desc="Check, aber zu kompliziert[Remo,ALLES]">
private void checkKom(double dt){
if(Strasse.getAnfStr()==null || Auto.getAnfAu()==null){}
else{
AuK aA; //Definition der Variable in der Autoliste
StrK aStr; //Definition der Variable in der Strassenliste
int i=0;//Hilfsvariable für den Autoweg(zeigt das Auto an)
//Zugehoerigkeit: //Diese Formeln beachten noch nicht, dass die Autos nicht in der Mitte der Fahrbahn, sondern in der Mitte eines Fahrstreifen fahren.
boolean check=false;
for(aA=Auto.getAnfAu();aA!=null;aA=aA.getNF()){//Hiermit wird das für jedes Auto auf jeder Strasse wiederholt
check=false;//Variable zur Überprüfung
aStr=Strasse.getAnfStr();//Straßenvariable
if(aStr.getX2()-aStr.getX()==0){//Wenn die Straße senkrecht ist
if(aA.getx()==aStr.getX() && aA.gety()<=aStr.getY2() && aA.gety()>=aStr.getY()){
//Wenn die x-Variable des Autos gleich der Straße ist und die y-Variable des Autos innerhalb der Straße liegt, färt das Auto auf der Straße.
//Die Zugehörigkeit wird eingetragen,check true gesetzt, damit nicht jede Weitere Straße überprüft wird.
aA.setMemShip(aStr.getID());check=true;
}
}
else{//Wenn die Straße wagerecht ist.
if(aA.gety()==aStr.getY() && aA.getx()<=aStr.getX2() && aA.getx()>=aStr.getX()){
//Wenn die y-Variable des Autos gleich der Straße ist und die x-Variable des Autos innerhalb der Straße liegt, färt das Auto auf der Straße.
//Die Zugehörigkeit wird eingetragen,check true gesetzt, damit nicht jede Weitere Straße überprüft wird.
aA.setMemShip(aStr.getID());check=true;
}
}
do {
aStr=aStr.getNF();//Die Nächste Straße wird genommen
//und das ganze wird wiederholt, bis ein Treffer vorkam.
if(aStr.getX2()-aStr.getX()==0){//Wenn die Straße senkrecht ist
if(aA.getx()==aStr.getX() && aA.gety()<=aStr.getY2() && aA.gety()>=aStr.getY()){
//Wenn die x-Variable des Autos gleich der Straße ist und die y-Variable des Autos innerhalb der Straße liegt, färt das Auto auf der Straße.
//Die Zugehörigkeit wird eingetragen,check true gesetzt, damit nicht jede Weitere Straße überprüft wird.
aA.setMemShip(aStr.getID());check=true;
}
}
else{//Wenn die Straße wagerecht ist.
if(aA.gety()==aStr.getY() && aA.getx()<=aStr.getX2() && aA.getx()>=aStr.getX()){
//Wenn die y-Variable des Autos gleich der Straße ist und die x-Variable des Autos innerhalb der Straße liegt, färt das Auto auf der Straße.
//Die Zugehörigkeit wird eingetragen,check true gesetzt, damit nicht jede Weitere Straße überprüft wird.
aA.setMemShip(aStr.getID());check=true;
}
}
}
/*verallgemeinerte Funktion:(enthält Rundungen)
r=Math.round(((aA.getX()-aStr.getX())/(aStr.getX2()-aStr.getX()))*100)/100;//Mit hilfe der Verktorrechnung den Wert fur r, mit den man den Richtungsvektor der Strasse bestimmt.
s=Math.round(((aA.getY()-aStr.getY())/(aStr.getY2()-aStr.getY()))*100)/100; //Mit hilfe der Verktorrechnung den Wert fur s, mit den man den Richtungsvektor der Strasse bestimmt.
if(s==r){aA.setMemShip(aStr.getID());check=true;} //Einspeichern der Daten falls sie übereinstimmen(Wenn das Auto auf der Straße ist)
do{ //Hier wird das gleiche für jede Strasse gemacht.
aStr=aStr.getNF();
r=Math.round(((aA.getX()-aStr.getX())/(aStr.getX2()-aStr.getX()))*100)/100;//Mit hilfe der Verktorrechnung den Wert fur r, mit den man den Richtungsvektor der Strasse bestimmt.
s=Math.round(((aA.getY()-aStr.getY())/(aStr.getY2()-aStr.getY()))*100)/100; //Mit hilfe der Verktorrechnung den Wert fur s, mit den man den Richtungsvektor der Strasse bestimmt.
if(s==r){aA.setMemShip(aStr.getID());check=true;} //Einspeichern der Daten falls sie übereinstimmen(Wenn das Auto auf der Straße ist)
}*/
while(aStr.getNF()!=null && check==false); //Die Anweisung wird abgebrochen sobald es einen Treffer gibt,da nur eines möglich ist.
if(check==false){aA.setMemShip(0);}//Wenn Check immer noch False ist, ist das Auto auf einer Kreuzung.
i++;//Das Auto wird eins hoch gesetzt
}
//Wegberechnung(dt);
for(AuK cA=Auto.getAnfAu();cA!=null;cA=cA.getNF()){
if(Autoweg[Auto.getAnzAu(cA)-1].getAnfAu()==null&&cA.getMemShip()!=0){//Wenn keine Daten zu fahren gespeichert sind, soll es die Funktion getHindernis()aufrufen.
getHindernis();
}
Autofahrenzeichnen(dt,cA);
}
//Stehende Autos, Autos auf Strasse und Strassenauslastung:
/*
int[] MemShip=new int[Strasse.getAnzStr()+1]; ////////////Noch zu beachten: Identifikation muss bei 0 anfangen, da dies das Array auch tut
int[] stehend=new int[Strasse.getAnzStr()+1]; //Diese 2 Arrays sind zählen die der stehenden Autos für jede Strasse(i und j)
int j;
for(aA=Auto.getAnfAu();
aA.getNF() != null;
aA = aA.getNF()){//die sorgt dafür, das es mit allen Autos gemacht wird
i=aA.getMemShip(); //Hier wird i als die Strasse des Autos definiert
if(aA.getv()==0){
//Hier wird das gleiche gemacht mit den Autos, die 0kmh fahren
stehend[i]=stehend[i]+1;//Dies wird jetzt in den Array gespeichert
}
MemShip[i]=MemShip[i]+1; //""
aA=aA.getNF();
}
i=aA.getMemShip(); //Das gleiche nochmal, weil dies in der Schleife nicht mit inbegriffen ist.
if(aA.getv()==0){
stehend[i]=stehend[i]+1;
}
MemShip[i]=MemShip[i]+1;
for(aStr=Strasse.getAnfStr();aStr.getNF()!=null;aStr=aStr.getNF()){ //Hier werden die Informationen für jede Straße in der Liste gespeichert
aStr.setAuStr(MemShip[aStr.getID()]);
aStr.setSteAu(stehend[aStr.getID()]);
aStr.setStrAus(); //Die Strassenauslastung wird aus den Autos und der Länge der Strasse ausgerechnet
}*/
}
}//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Ruft die einzelnen Funktionen auf, wenn nötig[Remo,ALLES]">
private void check(double dt){
/*for(AuK cA=Auto.getAnfAu();cA!=null;cA=cA.getNF()){
if(Autoweg[Auto.getAnzAu(cA)-1].getAnfKreu()==null||cA.getnaechste_strasse().equals("")){
Wegberechnung(cA);
}
}
boolean check=false;
for(AuK cA=Auto.getAnfAu();cA!=null&&check==false;cA=cA.getNF()){
if(Autoweg[Auto.getAnzAu(cA)-1].getAnfAu()==null&&cA.getMemShip()!=0){//Wenn keine Daten zu fahren gespeichert sind, soll es die Funktion getHindernis()aufrufen.
getHindernis();
check=true;
}
}*/
for(AuK cA=Auto.getAnfAu();cA!=null;cA=cA.getNF()){
Autofahrenzeichnen(dt,cA);
}
//Stehende Autos, Autos auf Strasse und Strassenauslastung:
/*
int[] MemShip=new int[Strasse.getAnzStr()+1]; ////////////Noch zu beachten: Identifikation muss bei 0 anfangen, da dies das Array auch tut
int[] stehend=new int[Strasse.getAnzStr()+1]; //Diese 2 Arrays sind zählen die der stehenden Autos für jede Strasse(i und j)
int j;
for(aA=Auto.getAnfAu();
aA.getNF() != null;
aA = aA.getNF()){//die sorgt dafür, das es mit allen Autos gemacht wird
i=aA.getMemShip(); //Hier wird i als die Strasse des Autos definiert
if(aA.getv()==0){
//Hier wird das gleiche gemacht mit den Autos, die 0kmh fahren
stehend[i]=stehend[i]+1;//Dies wird jetzt in den Array gespeichert
}
MemShip[i]=MemShip[i]+1; //""
aA=aA.getNF();
}
i=aA.getMemShip(); //Das gleiche nochmal, weil dies in der Schleife nicht mit inbegriffen ist.
if(aA.getv()==0){
stehend[i]=stehend[i]+1;
}
MemShip[i]=MemShip[i]+1;
for(aStr=Strasse.getAnfStr();aStr.getNF()!=null;aStr=aStr.getNF()){ //Hier werden die Informationen für jede Straße in der Liste gespeichert
aStr.setAuStr(MemShip[aStr.getID()]);
aStr.setSteAu(stehend[aStr.getID()]);
aStr.setStrAus(); //Die Strassenauslastung wird aus den Autos und der Länge der Strasse ausgerechnet
}*/
}//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Auto fahren vollständig geradeaus[Remo, ALLES]">
private void Autofahrenzeichnen(double dt,AuK aktuell){
int i=Auto.getAnzAu(aktuell)-1;
double dt2=dt+aktuell.getdt();//Ist die Zeit, mit der das Auto bis jetzt mit der Beschleunigung a fährt
aktuell.setdt(dt2);//Die neue Zeit wird eingespeichert
AuK Fahr=Autoweg[i].getAnfAu();//In fahr(Autoweg) ist die Beschleunigung und die Dauer der Beschleunigung, sowie die momentane Geschwindigkeit beschrieben.
boolean pruefung;//Für den Fall ,dass sich die Beschleunigung ändert
double xneu=aktuell.getx();
double yneu=aktuell.gety();//Die Koordinaten an denen das Auto momentan ist.
double xrichtung=aktuell.getxrichtung();
double yrichtung=aktuell.getyrichtung();//Richtung, in die das Auto fährt
double v=aktuell.getv();//Die Geschwindigkeit zu Anfang der Beschleunigung.
if(Autoweg[i].getAnfAu().getnaechste_strasse().equals("")){//Wenn das Auto auf keiner Kreuzung ist
double a=Fahr.getbeschleunigung();//Die momentane Beschleunigung des Autos
double a2=a;
if(xrichtung!=0){//Wenn das Auto in die x-Richtung fährt
do {
pruefung=false;//Prüfung wird auf false gesetzt
if(Fahr.getdt()<=aktuell.getdt()){//Wenn innerhalb der Zeit, die das Auto noch fährt das Auto die Beschleunigung ändert
dt2=Fahr.getdt();//Wird die Zeit bis zur änderung gespeichert und dt2 ist nun die Zeit bis sich a ändert.
xneu=xneu+xrichtung*dt2*v+xrichtung*0.5*a*dt2*dt2;//dann wird das x mithilfe der kmh und dieser Zeit errechnet
v=v+a*dt2;//sowie auch die Geschwindigkeit die es nach es an der Beschleunigungsänderung hat.
Autoweg[i].delAuto(Fahr);//und nach der Beschleunigungsänderung wird die vorherige Beschleunigung usw. gelöscht
aktuell.setv(v);//Die neue Geschwindigkeit wird nach der Beschleunigungsänderung eingespeichert.
a=0;//Beschleunigung wird vorerst 0 gesetzt.
aktuell.setdt(aktuell.getdt()-dt2);//Die Zeit, die das Auto noch nicht gefahren ist(noch übrig)
dt2=aktuell.getdt();//dt2 ist nun die Restzeit, die das Auto noch nicht gefahren ist.
aktuell.setx(xneu);
Fahr=null;
if(Autoweg[i].getAnfAu()!=null){
//Wenn das es eine weitere Beschleunigung auf der Straße gibt, also das Auto noch nicht das Ende der Straße erreicht hat
Fahr=Autoweg[i].getAnfAu();//Dann wird das nachfolgende Fahr eingespeichert.
a=Fahr.getbeschleunigung();//und die nue Beschleunigung
pruefung=true;//Prüfung wird auf true gesetzt(Eine Beschleunigungsänderung hat stattgefunden)
Fahr.sety(yneu);Fahr.setx(xneu);//und die neuen Koordinaten werden in Fahr eingespeichert.
}
if(Fahr!=null&&Fahr.getnaechste_strasse()!=null)pruefung=false;
if(Fahr!=null&&Fahr.getnaechste_strasse().equals(""))pruefung=false;
}
} while(pruefung==true);//Dies macht es so lange bis keine Beschleunigungsänderung mehr stattgefunden hat
xneu=xneu+xrichtung*dt2*v+xrichtung*0.5*a*dt2*dt2;//dann wird das x mithilfe der Geschwindigkeit, der Beschleunigung und der Zeit errechnet.
if(Fahr!=null&&Fahr.getnaechste_strasse().equals("")){
//Wenn das Auto während der ganzen Zeit auf der Straße bleibt,dann wird das neu x eingespeichert.
Fahr.setv(v+a*dt2);//Die aktuelle Geschwindigkeit wird errechnet und eingespeichert.
Fahr.setx(xneu);//Das neue x wird eingespeichert.
Koordinaten[i][0]=Autoweg[i].getAnfAu().getx();
Koordinaten[i][1]=Autoweg[i].getAnfAu().gety();//Das Auto wird mit den neuen Koordinaten eingespeichert
}
else{
//Wenn das Auto innerhalb dieser Zeit auf die Kreuzung kommt,wird die Zeit berechnet,
//ab der es auf der Kreuzung ist und der Weg auf der Kreuzung von der Kreuzungsfunktion gefahren.
aktuell.setMemShip(0);
Autofahrenkurve(aktuell,dt);//Aufrufen der Funktion, die die Autos auf der Kreuzung fahren lässt.
}
}
else{//Wenn das Auto in die y-Richtung fährt
do{
pruefung=false;//Prüfung wird auf false gesetzt
if(Fahr.getdt()<=aktuell.getdt()){//Wenn innerhalb der Zeit, die das Auto noch fährt das Auto die Beschleunigung ändert
dt2=Fahr.getdt();//Wird die Zeit bis zur änderung gespeichert und dt2 ist nun die Zeit bis sich a ändert.
yneu=yneu+yrichtung*dt2*v+yrichtung*0.5*a*dt2*dt2;//dann wird das y mithilfe der kmh und dieser Zeit errechnet
v=v+a*dt2;//sowie auch die Geschwindigkeit die es nach es an der Beschleunigungsänderung hat.
Autoweg[i].delAuto(Fahr);//und nach der Beschleunigungsänderung wird die vorherige Beschleunigung usw. gelöscht
aktuell.setv(v);//Die neue Geschwindigkeit wird nach der Beschleunigungsänderung eingespeichert.
a=0;//Beschleunigung wird vorerst 0 gesetzt.
aktuell.setdt(aktuell.getdt()-dt2);//Die Zeit, die das Auto noch nicht gefahren ist(noch übrig)
dt2=aktuell.getdt();//dt2 ist nun die Restzeit, die das Auto noch nicht gefahren ist.
aktuell.sety(yneu);
Fahr=null;
if(Autoweg[i].getAnfAu()!=null){
//Wenn das es eine weitere Beschleunigung auf der Straße gibt, also das Auto noch nicht das Ende der Straße erreicht hat
Fahr=Autoweg[i].getAnfAu();//Dann wird das nachfolgende Fahr eingespeichert.
a=Fahr.getbeschleunigung();//und die nue Beschleunigung
pruefung=true;//Prüfung wird auf true gesetzt(Eine Beschleunigungsänderung hat stattgefunden)
Fahr.sety(yneu);Fahr.setx(xneu);//und die neuen Koordinaten werden in Fahr eingespeichert.
}
if(Fahr!=null&&Fahr.getnaechste_strasse()!=null)pruefung=false;
if(Fahr!=null&&Fahr.getnaechste_strasse()!="")pruefung=false;
}
}
while(pruefung==true);//Dies macht es so lange bis keine Beschleunigungsänderung mehr stattgefunden hat
yneu=yneu+yrichtung*dt2*v+yrichtung*0.5*a*dt2*dt2;//dann wird das y mithilfe der Geschwindigkeit, der Beschleunigung und der Zeit errechnet.
if(Fahr!=null&&Fahr.getnaechste_strasse()==""){
//Wenn das Auto während der ganzen Zeit auf der Straße bleibt,dann wird das neu y eingespeichert.
Fahr.setv(v+a*dt2);//Die aktuelle Geschwindigkeit wird errechnet und eingespeichert.
Fahr.sety(yneu);//Das neue y wird eingespeichert.
Koordinaten[i][0]=Autoweg[i].getAnfAu().getx();
Koordinaten[i][1]=Autoweg[i].getAnfAu().gety();//Das Auto wird mit den neuen Koordinaten eingespeichert
}
else{
//Wenn das Auto innerhalb dieser Zeit auf die Kreuzung kommt,wird die Zeit berechnet,
//ab der es auf der Kreuzung ist und der Weg auf der Kreuzung von der Kreuzungsfunktion gefahren.
aktuell.setMemShip(0);
Autofahrenkurve(aktuell,dt);//Aufrufen der Funktion, die die Autos auf der Kreuzung fahren lässt.
}
}
}
else{
System.err.println("Mem==0");
Autofahrenkurve(aktuell,dt);
}
}
//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Auto fahren vollständig in der Kreuzung[Remo, ALLES]">
private void Autofahrenkurve(AuK aktuell,double dt){
//Das Auto fährt an der Kreuzung nicht geradeaus
double x=aktuell.getx();
double r;
double dtl;
StrK aStr;
int i=Auto.getAnzAu(aktuell)-1;
if(Autoweg[i].getAnfAu()==null)aktuell.setdt(dt+aktuell.getdt());
double y=aktuell.gety();
double xrichtung=aktuell.getxrichtung();
double yrichtung=aktuell.getyrichtung();
//double v=aktuell.getv();
double v=kreuv;//Variablen die benötigten werden, werden gespeichert, damit sie nicht immer abgerufen werden.
if(Autoweg[i].getAnfAu()!=null){
//System.out.println(Autoweg[i].getAnfAu().getnaechste_strasse());
//System.out.println("id Kreu: "+Autoweg[i].getAnfKreu().getID()+"id Kreu nächste: "+Autoweg[i].getAnfKreu().getNF().getID());
if(Autoweg[i].getAnfAu().getnaechste_strasse().equals("geradeaus")){//Wenn das Auto geradeaus
if(xrichtung!=0){//in die x/-x-Richtung fährt,
x=x+xrichtung*v*aktuell.getdt();//wird für das Auto der neue x-Wert gespeichert
Koordinaten[i][0]=x;
Koordinaten[i][1]=y;
if(Math.abs(x-aktuell.getx())>=s){
aktuell.setx(aktuell.getx()+xrichtung*s);
Koordinaten[i][0]=x+xrichtung*s;
Koordinaten[i][1]=y;
dtl=aktuell.getdt()-s/v;
aktuell.setdt(0);
aktuell.setnaechste_strasse("");
if(xrichtung>0)aktuell.setMemShip(Kreuzung.getbestKreu(Autoweg[i].getAnfKreu().getID(),Kreuzung.getAnfKreu()).getStrasse2().getID());
else aktuell.setMemShip(Kreuzung.getbestKreu(Autoweg[i].getAnfKreu().getID(),Kreuzung.getAnfKreu()).getStrasse4().getID());
Autoweg[i].delAuto(Autoweg[i].getAnfAu());
Autoweg[i].delKreu(Autoweg[i].getAnfKreu());
Autoweg[i].getAnfAu().sety(Koordinaten[i][1]);
Autoweg[i].getAnfAu().setx(Koordinaten[i][0]);
Autofahrenzeichnen(dtl,aktuell);
//getHindernis();
}
}
else{//in die y/-y-Richtung fährt,
y=y+yrichtung*v*aktuell.getdt();//wird für das Auto der neue y-Wert gespeichert
Koordinaten[i][0]=x;
Koordinaten[i][1]=y;
if(Math.abs(y-aktuell.gety())>=s){
aktuell.sety(aktuell.gety()+yrichtung*s);
Koordinaten[i][0]=x;
Koordinaten[i][1]=y+yrichtung*s;
dtl=aktuell.getdt()-s/v;
aktuell.setdt(0);
aktuell.setnaechste_strasse("");
if(yrichtung>0)aktuell.setMemShip(Kreuzung.getbestKreu(Autoweg[i].getAnfKreu().getID(),Kreuzung.getAnfKreu()).getStrasse3().getID());
else aktuell.setMemShip(Kreuzung.getbestKreu(Autoweg[i].getAnfKreu().getID(),Kreuzung.getAnfKreu()).getStrasse1().getID());
Autoweg[i].delAuto(Autoweg[i].getAnfAu());
Autoweg[i].delKreu(Autoweg[i].getAnfKreu());
Autoweg[i].getAnfAu().sety(Koordinaten[i][1]);
Autoweg[i].getAnfAu().setx(Koordinaten[i][0]);
Autofahrenzeichnen(dtl,aktuell);
//getHindernis();
}
}
}
else{
if(Autoweg[i].getAnfAu().getnaechste_strasse().equals("rechts")){//Wenn das Auto nach rechts abbiegt
r=s/4;
if(yrichtung!=0){//es in/gegen die y-Richtung fährt
double kreu=aktuell.getdt()*v;
//Berechnet mit Hilfe der Zeit im Kreuz und der Geschwindigkeit den Weg, den es im Kreuz zurückgelegt hat.
double alpha=(360*kreu)/(2*Math.PI*r);
Koordinaten[i][0]=x-yrichtung*Math.sin(Math.toRadians(alpha))*r;
Koordinaten[i][1]=y+yrichtung*Math.cos(90-Math.toRadians(alpha))*r;
//Berechnet mit Hilfe dem Weg und den Radius der Kurve den Winkel den es gefahren ist
//Speichert das Auto an der Kreisbahn ein.sinuns und cosinus ist wegen dem Kreisbogen.
//Die Berechnung hier ist mithilfe des Einheitskreises und der y-Richtung möglich.
if(alpha>=90){
aktuell.setx(x-yrichtung*r);//Die x-Werte werden zum Anfang der neuen Straße gesetzt.
aktuell.sety(y+yrichtung*r);//Das gleiche passiert mit den y-Koordinaten
Koordinaten[i][0]=x-yrichtung*r;
Koordinaten[i][1]=y+yrichtung*r;
dtl=aktuell.getdt()-(90*2*Math.PI*r)/(360*v);
aktuell.setdt(0);//Die Zeit, die in der Kreuzung verbracht wurde wird auf 0 gesetzt.
aktuell.setnaechste_strasse("");
aktuell.setyrichtung(0);
aktuell.setxrichtung(-yrichtung*1);//Aktualisiert die Richtung in die das Auto fährt.
if(yrichtung>0)aktuell.setMemShip(Kreuzung.getbestKreu(Autoweg[i].getAnfKreu().getID(),Kreuzung.getAnfKreu()).getStrasse4().getID());
else aktuell.setMemShip(Kreuzung.getbestKreu(Autoweg[i].getAnfKreu().getID(),Kreuzung.getAnfKreu()).getStrasse2().getID());
Autoweg[i].delAuto(Autoweg[i].getAnfAu());
Autoweg[i].delKreu(Autoweg[i].getAnfKreu());
Autoweg[i].getAnfAu().sety(Koordinaten[i][1]);
Autoweg[i].getAnfAu().setx(Koordinaten[i][0]);
Autofahrenzeichnen(dtl,aktuell);
//getHindernis();
}
}
else{
if(xrichtung!=0){//in/gegen die x-Richtung fährt. Im Grunde das gleiche, aber mit der x-richtung
double kreu=aktuell.getdt()*v;
double alpha=(360*kreu)/(2*Math.PI*r);
Koordinaten[i][0]=x+xrichtung*Math.sin(Math.toRadians(alpha))*r;
Koordinaten[i][1]=y+xrichtung*Math.cos(90-Math.toRadians(alpha))*r;
if(alpha>=90){
aktuell.setx(x+xrichtung*r);
aktuell.sety(y+xrichtung*r);
Koordinaten[i][0]=x+xrichtung*r;
Koordinaten[i][1]=y+xrichtung*r;
dtl=aktuell.getdt()-(90*2*Math.PI*r)/(360*v);
aktuell.setdt(0);//Die Zeit, die in der Kreuzung verbracht wurde wird auf 0 gesetzt.
aktuell.setnaechste_strasse("");
aktuell.setyrichtung(xrichtung*1);
aktuell.setxrichtung(0);
if(xrichtung>0)aktuell.setMemShip(Kreuzung.getbestKreu(Autoweg[i].getAnfKreu().getID(),Kreuzung.getAnfKreu()).getStrasse3().getID());
else aktuell.setMemShip(Kreuzung.getbestKreu(Autoweg[i].getAnfKreu().getID(),Kreuzung.getAnfKreu()).getStrasse1().getID());
Autoweg[i].delAuto(Autoweg[i].getAnfAu());
Autoweg[i].delKreu(Autoweg[i].getAnfKreu());
Autoweg[i].getAnfAu().sety(Koordinaten[i][1]);
Autoweg[i].getAnfAu().setx(Koordinaten[i][0]);
Autofahrenzeichnen(dtl,aktuell);
//getHindernis();
}
}
}
}
else{
if(Autoweg[i].getAnfAu().getnaechste_strasse().equals("links")){//Wenn das Auto in/gegen die yrichhtung fährt.
r=3*s/4;
if(yrichtung!=0){//und es von unten nach oben fährt
double kreu=aktuell.getdt()*v;
double alpha=(360*kreu)/(2*Math.PI*r);
Koordinaten[i][0]=x+yrichtung*Math.sin(Math.toRadians(alpha))*r;
Koordinaten[i][1]=y+yrichtung*Math.sin(Math.toRadians(alpha))*r;
if(alpha>=90){
aktuell.setx(x+yrichtung*r);
aktuell.sety(y+yrichtung*r);
Koordinaten[i][0]=x+yrichtung*r;
Koordinaten[i][1]=y+yrichtung*r;
dtl=aktuell.getdt()-(90*2*Math.PI*r)/(360*v);
aktuell.setdt(0);//Die Zeit, die in der Kreuzung verbracht wurde wird auf 0 gesetzt.
aktuell.setnaechste_strasse("");
aktuell.setyrichtung(0);
aktuell.setxrichtung(yrichtung*1);
if(yrichtung>0)aktuell.setMemShip(Kreuzung.getbestKreu(Autoweg[i].getAnfKreu().getID(),Kreuzung.getAnfKreu()).getStrasse2().getID());
else aktuell.setMemShip(Kreuzung.getbestKreu(Autoweg[i].getAnfKreu().getID(),Kreuzung.getAnfKreu()).getStrasse4().getID());
Autoweg[i].delAuto(Autoweg[i].getAnfAu());
Autoweg[i].delKreu(Autoweg[i].getAnfKreu());
Autoweg[i].getAnfAu().sety(Koordinaten[i][1]);
Autoweg[i].getAnfAu().setx(Koordinaten[i][0]);
Autofahrenzeichnen(dtl,aktuell);
//getHindernis();
}
}
else{//und es in/gegen die x-richtung fährt
double kreu=aktuell.getdt()*v;
double alpha=(360*kreu)/(2*Math.PI*r);
Koordinaten[i][0]=x+xrichtung*Math.sin(Math.toRadians(alpha))*r;
Koordinaten[i][1]=y-xrichtung*Math.cos(90-Math.toRadians(alpha))*r;
if(alpha>=90){
aktuell.setx(x+xrichtung*r);
aktuell.sety(y-xrichtung*r);
Koordinaten[i][0]=x+xrichtung*r;
Koordinaten[i][1]=y-xrichtung*r;
dtl=aktuell.getdt()-(90*2*Math.PI*r)/(360*v);
aktuell.setdt(0);//Die Zeit, die in der Kreuzung verbracht wurde wird auf 0 gesetzt.
aktuell.setnaechste_strasse("");
aktuell.setyrichtung(-xrichtung*1);
aktuell.setxrichtung(0);
if(xrichtung>0)aktuell.setMemShip(Kreuzung.getbestKreu(Autoweg[i].getAnfKreu().getID(),Kreuzung.getAnfKreu()).getStrasse1().getID());
else aktuell.setMemShip(Kreuzung.getbestKreu(Autoweg[i].getAnfKreu().getID(),Kreuzung.getAnfKreu()).getStrasse3().getID());
Autoweg[i].delAuto(Autoweg[i].getAnfAu());
Autoweg[i].delKreu(Autoweg[i].getAnfKreu());
Autoweg[i].getAnfAu().sety(Koordinaten[i][1]);
Autoweg[i].getAnfAu().setx(Koordinaten[i][0]);
Autofahrenzeichnen(dtl,aktuell);
//getHindernis();
}
}
}
else{
if(Autoweg[i].getAnfAu().getnaechste_strasse().equals("umkehren")){//Wenn das Auto umkehrt
r=s/4;
if(yrichtung!=0){//und es in/gegen die y-Richtung fährt
//Das umkehren ist im grunde auch wie das rechtsabbiegen, nur in die andere Richtung und bis 180°
double kreu=aktuell.getdt()*v;
double alpha=(360*kreu)/(2*Math.PI*r);
Koordinaten[i][1]=y+yrichtung*Math.cos(90-Math.toRadians(alpha))*r;
System.err.println(aktuell.getdt());
System.err.println(kreu);
System.err.println(alpha);
if(alpha>=90){
Koordinaten[i][0]=x+yrichtung*Math.sin(Math.toRadians(alpha)-90)*r+r*yrichtung;
}
else{
Koordinaten[i][0]=x+yrichtung*Math.sin(Math.toRadians(alpha))*r;
}
if(alpha>=180){
aktuell.setx(x+yrichtung*r*2);
aktuell.sety(y);
Koordinaten[i][0]=x+yrichtung*r*2;
Koordinaten[i][1]=y;
dtl=aktuell.getdt()-(180*2*Math.PI*r)/(360*v);
aktuell.setdt(0);//Die Zeit, die in der Kreuzung verbracht wurde wird auf 0 gesetzt.
aktuell.setnaechste_strasse("");
aktuell.setyrichtung(-yrichtung*1);
aktuell.setxrichtung(0);
if(yrichtung>0)aktuell.setMemShip(Kreuzung.getbestKreu(Autoweg[i].getAnfKreu().getID(),Kreuzung.getAnfKreu()).getStrasse1().getID());
else aktuell.setMemShip(Kreuzung.getbestKreu(Autoweg[i].getAnfKreu().getID(),Kreuzung.getAnfKreu()).getStrasse3().getID());
Autoweg[i].delAuto(Autoweg[i].getAnfAu());
Autoweg[i].delKreu(Autoweg[i].getAnfKreu());
Autoweg[i].getAnfAu().sety(Koordinaten[i][1]);
Autoweg[i].getAnfAu().setx(Koordinaten[i][0]);
Autofahrenzeichnen(dtl,aktuell);
//getHindernis();
}
}
else{//und es in/gegen die x-Richtung fährt
double kreu=aktuell.getdt()*v;
double alpha=(360*kreu)/(2*Math.PI*r);
System.err.println(aktuell.getdt());
System.err.println(kreu);
System.err.println(alpha);
Koordinaten[i][0]=x+xrichtung*Math.sin(Math.toRadians(alpha))*r;
if(alpha>=90){
Koordinaten[i][1]=y+xrichtung*Math.cos(Math.toRadians(alpha))*r-r*xrichtung;
}
else{
Koordinaten[i][1]=y-xrichtung*Math.cos(90-Math.toRadians(alpha))*r;
}
if(alpha>=180){
aktuell.setx(x);
aktuell.sety(y-xrichtung*r*2);
Koordinaten[i][0]=x;
Koordinaten[i][1]=y-xrichtung*r*2;
dtl=aktuell.getdt()-(180*2*Math.PI*r)/(360*v);
aktuell.setdt(0);//Die Zeit, die in der Kreuzung verbracht wurde wird auf 0 gesetzt.
aktuell.setnaechste_strasse("");
aktuell.setyrichtung(0);
aktuell.setxrichtung(-xrichtung*1);
if(xrichtung>0)aktuell.setMemShip(Kreuzung.getbestKreu(Autoweg[i].getAnfKreu().getID(),Kreuzung.getAnfKreu()).getStrasse4().getID());
else aktuell.setMemShip(Kreuzung.getbestKreu(Autoweg[i].getAnfKreu().getID(),Kreuzung.getAnfKreu()).getStrasse2().getID());
Autoweg[i].delAuto(Autoweg[i].getAnfAu());
Autoweg[i].delKreu(Autoweg[i].getAnfKreu());
Autoweg[i].getAnfAu().sety(Koordinaten[i][1]);
Autoweg[i].getAnfAu().setx(Koordinaten[i][0]);
Autofahrenzeichnen(dtl,aktuell);
//getHindernis();
}
}
}
}
}
}
}
else{
Autoweg[i].setAnfangKreuzung(null);//wird der Weg gelöscht(auf null gesetzt)
Autoweg[i].setAnfangAuto(null);
aktuell.setnaechste_strasse("");
aktuell.setv(0);
//Momentane Rundungen wegen Wurzeln etc.
System.err.println("Ziel erreicht: Auto "+i+" x: "+aktuell.getx()+" y: "+aktuell.gety());
System.err.println("Ziel erreicht: ziel x: "+aktuell.getxziel()+" y: "+aktuell.getyziel());
System.err.println("x-richtung: "+aktuell.getxrichtung()+" y-richtung: "+aktuell.getyrichtung());
System.err.println("Nächste Kreuzung: "+Strasse.getbestStrasse(aktuell.getMemShip(),Strasse.getAnfStr()).getKreuID().getID());
System.err.println("Momentane Straße: "+aktuell.getMemShip());
aktuell.setx(aktuell.getxziel());
aktuell.sety(aktuell.getyziel());
Koordinaten[i][0]=aktuell.getx();
Koordinaten[i][1]=aktuell.gety();
Auto_setzeZiel(aktuell);//und ein neues Ziel erstellt.
Koordinaten[i][2]=aktuell.getxziel();
Koordinaten[i][3]=aktuell.getyziel();
boolean check=false;//Variable zur Überprüfung
for(StrK bStr=Strasse.getAnfStr();check==false;bStr=bStr.getNF()){
if(bStr.getX2()-bStr.getX()==0){//Wenn die Straße senkrecht ist
if(aktuell.getx()==bStr.getX() && aktuell.gety()<=bStr.getY2() && aktuell.gety()>=bStr.getY()){
//Wenn die x-Variable des Autos gleich der Straße ist und die y-Variable des Autos innerhalb der Straße liegt, färt das Auto auf der Straße.
//Die Zugehörigkeit wird eingetragen,check true gesetzt, damit nicht jede Weitere Straße überprüft wird.
aktuell.setMemShip(bStr.getID());check=true;
}
}
else{//Wenn die Straße wagerecht ist.
if(aktuell.gety()==bStr.getY() && aktuell.getx()<=bStr.getX2() && aktuell.getx()>=bStr.getX()){
//Wenn die y-Variable des Autos gleich der Straße ist und die x-Variable des Autos innerhalb der Straße liegt, färt das Auto auf der Straße.
//Die Zugehörigkeit wird eingetragen,check true gesetzt, damit nicht jede Weitere Straße überprüft wird.
aktuell.setMemShip(bStr.getID());check=true;
}
}
}
System.err.println("Momentane Straße 2.Mal: "+aktuell.getMemShip());
Autokreuzhinzufuegen(i+1);
System.err.println("Anzshl Kreuzungen für den weg(schon -1 gerechnet): "+(Autoweg[i].getAnzKreu()-1));
}
}
//</editor-fold> //autofahrenkurve
//<editor-fold defaultstate="collapsed" desc="Auto fahren vollständig in der Kreuzung(a-Star)[Remo, ALLES]">
private void Autofahrenkurveastar(AuK aktuell,double dt){
//Das Auto fährt an der Kreuzung nicht geradeaus
int i=Auto.getAnzAu(aktuell)-1;
double x=Koordinaten[i][0];
double r;
double dtl;
StrK aStr;
aktuell.setdt(dt+aktuell.getdt());
double y=Koordinaten[i][1];
double xrichtung=aktuell.getxrichtung();
double yrichtung=aktuell.getyrichtung();
//double v=aktuell.getv();
double v=kreuv;//Variablen die benötigten werden, werden gespeichert, damit sie nicht immer abgerufen werden.
if(aktuell.getnaechste_strasse().equals("geradeaus")){//Wenn das Auto geradeaus
if(xrichtung!=0){//in die x/-x-Richtung fährt,
x=x+xrichtung*v*aktuell.getdt();//wird für das Auto der neue x-Wert gespeichert
aktuell.setx(x);
aktuell.sety(y);
if(Math.abs(x-aktuell.getx())>=s){
aktuell.setx(aktuell.getx()+xrichtung*s);
Koordinaten[i][0]=x+xrichtung*s;
Koordinaten[i][1]=y;
dtl=aktuell.getdt()-s/v;
aktuell.setdt(0);
aktuell.setnaechste_strasse("");
}
} else {//in die y/-y-Richtung fährt,
y=y+yrichtung*v*aktuell.getdt();//wird für das Auto der neue y-Wert gespeichert
aktuell.setx(x);
aktuell.sety(y);
if(Math.abs(y-aktuell.gety())>=s){
aktuell.sety(aktuell.gety()+yrichtung*s);
Koordinaten[i][0]=x;
Koordinaten[i][1]=y+yrichtung*s;
dtl=aktuell.getdt()-s/v;
aktuell.setdt(0);
aktuell.setnaechste_strasse("");
}
}
} else {
if(aktuell.getnaechste_strasse().equals("rechts")) {//Wenn das Auto nach rechts abbiegt
r=s/4;
if(yrichtung!=0) { //es in/gegen die y-Richtung fährt
double kreu=aktuell.getdt()*v;
//Berechnet mit Hilfe der Zeit im Kreuz und der Geschwindigkeit den Weg, den es im Kreuz zurückgelegt hat.
double alpha=(360*kreu)/(2*Math.PI*r);
aktuell.setx(x-yrichtung*Math.sin(Math.toRadians(alpha))*r);
aktuell.sety(y+yrichtung*Math.cos(90-Math.toRadians(alpha))*r);
//Berechnet mit Hilfe dem Weg und den Radius der Kurve den Winkel den es gefahren ist
//Speichert das Auto an der Kreisbahn ein.sinuns und cosinus ist wegen dem Kreisbogen.
//Die Berechnung hier ist mithilfe des Einheitskreises und der y-Richtung möglich.
if(alpha>=90){
aktuell.setx(x-yrichtung*r);//Die x-Werte werden zum Anfang der neuen Straße gesetzt.
aktuell.sety(y+yrichtung*r);//Das gleiche passiert mit den y-Koordinaten
Koordinaten[i][0]=x-yrichtung*r;
Koordinaten[i][1]=y+yrichtung*r;
dtl=aktuell.getdt()-(90*2*Math.PI*r)/(360*v);
aktuell.setdt(0);//Die Zeit, die in der Kreuzung verbracht wurde wird auf 0 gesetzt.
aktuell.setnaechste_strasse("");
aktuell.setyrichtung(0);
aktuell.setxrichtung(-yrichtung*1);//Aktualisiert die Richtung in die das Auto fährt.
}
} else {
if(xrichtung!=0){//in/gegen die x-Richtung fährt. Im Grunde das gleiche, aber mit der x-richtung
double kreu=aktuell.getdt()*v;
double alpha=(360*kreu)/(2*Math.PI*r);
aktuell.setx(x+xrichtung*Math.sin(Math.toRadians(alpha))*r);
aktuell.sety(y+xrichtung*Math.cos(90-Math.toRadians(alpha))*r);
if(alpha>=90){
aktuell.setx(x+xrichtung*r);
aktuell.sety(y+xrichtung*r);
Koordinaten[i][0]=x+xrichtung*r;
Koordinaten[i][1]=y+xrichtung*r;
dtl=aktuell.getdt()-(90*2*Math.PI*r)/(360*v);
aktuell.setdt(0);//Die Zeit, die in der Kreuzung verbracht wurde wird auf 0 gesetzt.
aktuell.setnaechste_strasse("");
aktuell.setyrichtung(xrichtung*1);
aktuell.setxrichtung(0);
}
}
}
}
else{
if(aktuell.getnaechste_strasse().equals("links")){//Wenn das Auto in/gegen die yrichhtung fährt.
r=3*s/4;
if(yrichtung!=0){//und es von unten nach oben fährt
double kreu=aktuell.getdt()*v;
double alpha=(360*kreu)/(2*Math.PI*r);
aktuell.setx(x+yrichtung*Math.sin(Math.toRadians(alpha))*r);
aktuell.sety(y+yrichtung*Math.cos(90-Math.toRadians(alpha))*r);
if(alpha>=90){
aktuell.setx(x+yrichtung*r);
aktuell.sety(y+yrichtung*r);
Koordinaten[i][0]=x+yrichtung*r;
Koordinaten[i][1]=y+yrichtung*r;
dtl=aktuell.getdt()-(90*2*Math.PI*r)/(360*v);
aktuell.setdt(0);//Die Zeit, die in der Kreuzung verbracht wurde wird auf 0 gesetzt.
aktuell.setnaechste_strasse("");
aktuell.setyrichtung(0);
aktuell.setxrichtung(yrichtung*1);
}
}
else{//und es in/gegen die x-richtung fährt
double kreu=aktuell.getdt()*v;
double alpha=(360*kreu)/(2*Math.PI*r);
aktuell.setx(x+xrichtung*Math.sin(Math.toRadians(alpha))*r);
aktuell.sety(y-xrichtung*Math.cos(90-Math.toRadians(alpha))*r);
if(alpha>=90){
aktuell.setx(x+xrichtung*r);
aktuell.sety(y-xrichtung*r);
Koordinaten[i][0]=x+xrichtung*r;
Koordinaten[i][1]=y-xrichtung*r;
dtl=aktuell.getdt()-(90*2*Math.PI*r)/(360*v);
aktuell.setdt(0);//Die Zeit, die in der Kreuzung verbracht wurde wird auf 0 gesetzt.
aktuell.setnaechste_strasse("");
aktuell.setyrichtung(-xrichtung*1);
aktuell.setxrichtung(0);
}
}
}
else{
if(aktuell.getnaechste_strasse().equals("umkehren")){//Wenn das Auto umkehrt
r=s/4;
if(yrichtung!=0){//und es in/gegen die y-Richtung fährt
//Das umkehren ist im grunde auch wie das rechtsabbiegen, nur in die andere Richtung und bis 180°
double kreu=aktuell.getdt()*v;
double alpha=(360*kreu)/(2*Math.PI*r);
aktuell.sety(y+yrichtung*Math.cos(90-Math.toRadians(alpha))*r);
if(alpha>=90){
aktuell.setx(x+yrichtung*Math.sin(Math.toRadians(alpha)-90)*r+r*yrichtung);
}
else{
aktuell.setx(x+yrichtung*Math.sin(Math.toRadians(alpha))*r);
}
if(alpha>=180){
aktuell.setx(x+yrichtung*r*2);
aktuell.sety(y);
Koordinaten[i][0]=x+yrichtung*r*2;
Koordinaten[i][1]=y;
dtl=aktuell.getdt()-(180*2*Math.PI*r)/(360*v);
aktuell.setdt(0);//Die Zeit, die in der Kreuzung verbracht wurde wird auf 0 gesetzt.
aktuell.setnaechste_strasse("");
aktuell.setyrichtung(-yrichtung*1);
aktuell.setxrichtung(0);
}
}
else{//und es in/gegen die x-Richtung fährt
double kreu=aktuell.getdt()*v;
double alpha=(360*kreu)/(2*Math.PI*r);
aktuell.setx(x+xrichtung*Math.sin(Math.toRadians(alpha))*r);
if(alpha>=90){
aktuell.sety(y+xrichtung*Math.cos(Math.toRadians(alpha))*r-r*xrichtung);
}
else{
aktuell.sety(y-xrichtung*Math.cos(90-Math.toRadians(alpha))*r);
}
if(alpha>=180){
aktuell.setx(x);
aktuell.sety(y-xrichtung*r*2);
Koordinaten[i][0]=x;
Koordinaten[i][1]=y-xrichtung*r*2;
dtl=aktuell.getdt()-(180*2*Math.PI*r)/(360*v);
aktuell.setdt(0);//Die Zeit, die in der Kreuzung verbracht wurde wird auf 0 gesetzt.
aktuell.setnaechste_strasse("");
aktuell.setyrichtung(0);
aktuell.setxrichtung(-xrichtung*1);
}
}
}
}
}
}
}
//</editor-fold> //autofahrenkurve
//<editor-fold defaultstate="collapsed" desc="Autos werden vorerst als Punkte gezeichnet,[Remo, noch NICHTS]">
private void Autozeichnen(double x, double y) {
java.awt.Graphics J = this.aTab.getGraphics();
int r=2;
x=Math.round(x);
int s=(int)x;
y=Math.round(y);
int t=(int)y;
J.setColor(Color.YELLOW);
J.fillOval(s-r,t-r,r*2,r*2);
}//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Wegberechnung[Remo, ALLES]">
private void Wegberechnung(AuK aA){
//Kürzester Weg:
int i=Auto.getAnzAu(aA)-1;//Hilfsvariable für die Liste Autoweg
double xZielAuto=aA.getxziel();
double yZielAuto=aA.getyziel();//Die Zielkoordinaten werden gespeichert
StrK Mem=null;
KreuK EndKreuzung;
boolean check=false;
StrK aStr;
for(aStr=Strasse.getAnfStr();check==false; aStr=aStr.getNF()){
//Diese Funktion sorgt dafür, dass in Mem die Straße,auf der das Ziel des Autos ist eingespeichert wird.
if(aStr.getX2()-aStr.getX()==0){
if(xZielAuto==aStr.getX() && yZielAuto<aStr.getY2() && yZielAuto>aStr.getY()){Mem=aStr;check=true;}
}
else{
if(yZielAuto==aStr.getY() && xZielAuto<aStr.getX2() && xZielAuto>aStr.getX()){Mem=aStr;check=true;}
}
}
boolean stop=false;
int k=0;
for(EndKreuzung=Kreuzung.getAnfKreu();stop==false;EndKreuzung=EndKreuzung.getNF()){
if(EndKreuzung.getStrasse1()==Mem || EndKreuzung.getStrasse2()==Mem || EndKreuzung.getStrasse3()==Mem || EndKreuzung.getStrasse4()==Mem){
k=EndKreuzung.getID();
stop=true;
}
}
EndKreuzung=Kreuzung.getbestKreu(k, Kreuzung.getAnfKreu());
//Diese for-Funktion sorgt dafür, dass die Kreuzung gefunden wird, die zu dem Endziel führt.(Eine Straße die von der Kreuzung abgeht muss mit Mem übereinstimmen)
KreuK abc=new KreuK();
Autoweg[i].setlaenge();
//Setzt die Länge des schnellsten Weges auf 0
Autoweg[i].setAnfangKreuzung(null);
Autoweg[i].addKreuzung(abc,Strasse.getbestStrasse(aA.getMemShip(),Strasse.getAnfStr()).getKreuID().getx(),Strasse.getbestStrasse(aA.getMemShip(),Strasse.getAnfStr()).getKreuID().gety(), Strasse.getbestStrasse(aA.getMemShip(),Strasse.getAnfStr()).getKreuID().getID());
//Es wird für das i.te Auto die erste Kreuzung eingespeichert, auf die das Auto momentan zufährt.
Autoweg[i].getAnfKreu().setZahl(Math.abs(Autoweg[i].getAnfKreu().getx()-aA.getx())+Math.abs(Autoweg[i].getAnfKreu().gety()-aA.gety())-s/2);
//Hier wird als Zahl der Abstand zur nächsten Kreuzung gespeichert
if(Autoweg[i].getAnfKreu().getID()!=EndKreuzung.getID()){
Autoweg[i].Autoweghin(Strasse.getbestStrasse(aA.getMemShip(),Strasse.getAnfStr()),abc,EndKreuzung);
//Hier wird die Funktion Autoweghin aufgerufen mit den Variablen der nächsten Kreuzung und der ersten Variable aus der Liste
Autoweg[i].WegNF(Autoweg[i].getweg());
//Hier wird der beste Weg so abgespeichert, dass man ihn mithilfe des ersten Nachfolgers verfolgen kann.
}
KreuK def=Autoweg[i].getLetzterKreu();
abc=new KreuK();
Autoweg[i].addKreuzung(abc,Mem.getKreuID().getx(),Mem.getKreuID().gety(),Mem.getKreuID().getID());
Autoweg[i].getLetzterKreu().setVG(def);
Autoweg[i].getLetzterKreu().setZahl((((Mem.getX2()-Mem.getX())+(Mem.getY2()-Mem.getY()))/2+Autoweg[i].getLetzterKreu().getVG().getzahl()));
/*if(Autoweg[i].getAnfKreu().getID()==Autoweg[i].getLetzterKreu().getID() &&
((Mem.getX2()-Mem.getX())+(Mem.getY2()-Mem.getY()))/2<Math.abs(aA.getx()-Mem.getX2())+Math.abs(aA.gety()-Mem.getY2())){
Autoweg[i].setAnfangKreuzung(null);
Autoweg[i].addKreuzung(abc,Mem.getKreuID().getx(),Mem.getKreuID().gety(),Mem.getKreuID().getID());
}*/
double xrichtung=aA.getxrichtung();
double yrichtung=aA.getyrichtung();
String abcd="";
System.out.println(Autoweg[i].getAnfKreu().getzahl());
for(KreuK dKreu=Autoweg[i].getAnfKreu();dKreu.getNF()!=null;dKreu=dKreu.getNF()){
abcd=nextStr(dKreu,xrichtung,yrichtung,1);
System.out.println(abcd);
System.out.println(dKreu.getNF().getzahl()-dKreu.getzahl());
xrichtung=Double.parseDouble(nextStr(dKreu,xrichtung,yrichtung,2));
yrichtung=Double.parseDouble(nextStr(dKreu,xrichtung,yrichtung,3));
}
/*
if(Autoweg[i].getAnfKreu().getNF() != null && aA.getnaechste_strasse().equals("")) {
aA.setnaechste_strasse(nextStr(Autoweg[i].getAnfKreu(),aA.getxrichtung(),aA.getyrichtung(),1));
}*/
}//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Wegberechnung A* [Remo, ALLES]">
private void Wegberechnung_a_Star(AuK aA){
//Kürzester Weg:
StrK Mem=null;
KreuK EndKreuzung;
boolean check;
int i=Auto.getAnzAu(aA)-1;//Hilfsvariable für die Liste Autoweg
do{
double xZielAuto=aA.getxziel();
double yZielAuto=aA.getyziel();//Die Zielkoordinaten werden gespeichert
Mem=null;
check=false;
StrK aStr;
for(aStr=Strasse.getAnfStr();check==false; aStr=aStr.getNF()){
//Diese Funktion sorgt dafür, dass in Mem die Straße,auf der das Ziel des Autos ist eingespeichert wird.
if(aStr.getX2()-aStr.getX()==0){
if(xZielAuto==aStr.getX() && yZielAuto<aStr.getY2() && yZielAuto>aStr.getY()){Mem=aStr;check=true;}
}
else{
if(yZielAuto==aStr.getY() && xZielAuto<aStr.getX2() && xZielAuto>aStr.getX()){Mem=aStr;check=true;}
}
}
boolean stop=false;
int k=0;
for(EndKreuzung=Kreuzung.getAnfKreu();stop==false;EndKreuzung=EndKreuzung.getNF()){
if(EndKreuzung.getStrasse1()==Mem || EndKreuzung.getStrasse2()==Mem || EndKreuzung.getStrasse3()==Mem || EndKreuzung.getStrasse4()==Mem){
k=EndKreuzung.getID();
stop=true;
}
}
EndKreuzung=Kreuzung.getbestKreu(k, Kreuzung.getAnfKreu());
KreuK abc=Strasse.getbestStrasse(aA.getMemShip(),Strasse.getAnfStr()).getKreuID();
//Diese for-Funktion sorgt dafür, dass die Kreuzung gefunden wird, die zu dem Endziel führt.(Eine Straße die von der Kreuzung abgeht muss mit Mem übereinstimmen)
Autoweg[i].setlaenge();
//Setzt die Länge des schnellsten Weges auf 0
Autoweg[i].setAnfangKreuzung(null);
Autoweg[i].addKreuzung(abc,abc.getx(),abc.gety(), abc.getID());
//Es wird für das i.te Auto die erste Kreuzung eingespeichert, auf die das Auto momentan zufährt.
ObjL closedList=new ObjL();
ObjL openList=new ObjL();
openList.addKreuzung(abc);
abc.g=(int)(Math.abs(Autoweg[i].getAnfKreu().getx()-aA.getx())+Math.abs(Autoweg[i].getAnfKreu().gety()-aA.gety())-s/2);
abc.h=(int) (Math.abs(EndKreuzung.getx()-abc.getx())+Math.abs(EndKreuzung.gety()-abc.gety()));
abc.f=abc.g+abc.h;
if(Autoweg[i].getAnfKreu().getID()!=EndKreuzung.getID()){
KreuK qwert=Kreuzung.getLetzterKreu();
qwert.setNF(Kreuzung.getAnfKreu());
Autoweg[i].aStarini(abc,EndKreuzung,openList.getAnfKreu(),closedList.getAnfKreu());
//Hier wird die Funktion Autoweghin aufgerufen mit den Variablen der nächsten Kreuzung und der ersten Variable aus der Liste
qwert.setNF(null);
System.out.println("25");
}
if(Autoweg[i].getweg()==null)Auto_setzeZiel(aA);
}while(Autoweg[i].getweg()==null);
KreuK abc=new KreuK();
abc.setID(Autoweg[i].getAnfKreu().getID());
abc.setx(Autoweg[i].getAnfKreu().getx());
abc.sety(Autoweg[i].getAnfKreu().gety());
KreuK alt=abc;
System.out.println("26");
for(KreuK aendern=Autoweg[i].getAnfKreu().getNF1();aendern!=null;aendern=aendern.getNF1()){
KreuK def=new KreuK();
def.setID(aendern.getID());
def.setx(aendern.getx());
def.sety(aendern.gety());
aendern.setVG(null);
alt.setNF(def);
alt=def;
System.out.println("27");
}
Autoweg[i].setAnfangKreuzung(abc);
abc=Kreuzung.getAnfKreu();
while(abc!=null){
abc.setVG(null);
abc.setVG2(null);
abc.setNF1(null);
abc.setNF2(null);
abc.setNF3(null);
abc.setNF4(null);
abc=abc.getNF();
System.out.println("28");
}
KreuK def=Autoweg[i].getLetzterKreu();
abc=new KreuK();
Autoweg[i].addKreuzung(abc,Mem.getKreuID().getx(),Mem.getKreuID().gety(),Mem.getKreuID().getID());
double xrichtung=aA.getxrichtung();
double yrichtung=aA.getyrichtung();
String abcd="";
System.out.println(Autoweg[i].getAnfKreu().g);
for(KreuK dKreu=Autoweg[i].getAnfKreu();dKreu.getNF()!=null;dKreu=dKreu.getNF()){
abcd=nextStr(dKreu,xrichtung,yrichtung,1);
System.out.println(abcd);
xrichtung=Double.parseDouble(nextStr(dKreu,xrichtung,yrichtung,2));
yrichtung=Double.parseDouble(nextStr(dKreu,xrichtung,yrichtung,3));
}
System.out.println("Anzahl Kreuzungen gesamt: "+Kreuzung.getAnzKreu());
}//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Gibt die Richtung an der nächsten Kreuzung an oder die richtungsänderung[Remo, ALLES]">
private String nextStr(KreuK aK,double xrichtung, double yrichtung,int i){
String nStr="";
if(aK.getNF().getx()-aK.getx()==0){//Wenn der Weg zwischen den Kreuzungen senkrecht ist
if(xrichtung==1){//Wenn das Auto von links nach rechts fährt
if(aK.getNF().gety()-aK.gety()>0)//und wenn die nächste Kreuzung unter der jetzigen liegt
{
nStr="rechts";//dann biegt das Auto nach rechts ab
xrichtung=0;
yrichtung=1;
}
else{//und wenn die nächste Kreuzung über der jetzigen Kreuzung liegt
nStr="links";//dann biegt das Auto nach links ab
xrichtung=0;
yrichtung=-1;
}
}
else{
if(xrichtung==-1){//Wenn das Auto von rechts nach links fährt
if(aK.getNF().gety()-aK.gety()>0){//und wenn die nächste Kreuzung unter der jetzigen liegt
nStr="links";//dann biegt das Auto nach links ab
xrichtung=0;
yrichtung=1;
}
else{//und wenn die nächste Kreuzung über der jetzigen Kreuzung liegt
nStr="rechts";//dann biegt das Auto nach rechts ab
xrichtung=0;
yrichtung=-1;
}
}
else{
if(yrichtung==1){//Wenn das Auto von oben nach unten fährt
if(aK.getNF().gety()-aK.gety()>0)//und wenn die nächste Kreuzung unter der jetzigen liegt
{
nStr="geradeaus";//dann fährt das Auto geradeaus weiter
}
else{//und wenn die nächste Kreuzung über der jetzigen Kreuzung liegt
nStr="umkehren";//dann kehrt das Auto um
yrichtung=-1;
}
}
else{//Wenn das Auto von unten nach oben fährt
if(aK.getNF().gety()-aK.gety()>0){//und wenn die nächste Kreuzung unter der jetzigen liegt
nStr="umkehren";//dann kehrt das Auto um
yrichtung=1;
}
else{//und wenn die nächste Kreuzung über der jetzigen Kreuzung liegt
nStr="geradeaus";//dann fährt das Auto geradeaus weiter
}
}
}
}
}
else{
if(yrichtung==1){//Wenn das Auto von oben nach unten fährt
if(aK.getNF().getx()-aK.getx()>0)//und wenn die nächste Kreuzung rechts von der jetzigen liegt
{
nStr="links";//dann biegt das Auto nach rechts ab
xrichtung=1;
yrichtung=0;
}
else{//und wenn die nächste Kreuzung links von der jetzigen Kreuzung liegt
nStr="rechts";//dann biegt das Auto nach links ab
xrichtung=-1;
yrichtung=0;
}
}
else{
if(yrichtung==-1){//Wenn das Auto von unten nach oben fährt
if(aK.getNF().getx()-aK.getx()>0){//und wenn die nächste Kreuzung rechts von der jetzigen liegt
nStr="rechts";//dann biegt das Auto nach links
xrichtung=1;
yrichtung=0;
}
else{//und wenn die nächste Kreuzung links von der jetzigen Kreuzung liegt ab
nStr="links";//dann biegt das Auto nach rechts ab
xrichtung=-1;
yrichtung=0;
}
}
else{
if(xrichtung==1){//Wenn das Auto von links nach rechts fährt
if(aK.getNF().getx()-aK.getx()>0)//und wenn die nächste Kreuzung rechts von der jetzigen liegt
{
nStr="geradeaus";//dann fährt das Auto geradeaus weiter
}
else{//und wenn die nächste Kreuzung links von der jetzigen Kreuzung liegt
nStr="umkehren";//dann kehrt das Auto um
xrichtung=-1;
}
}
else{//Wenn das Auto von rechts nach links fährt
if(aK.getNF().getx()-aK.getx()>0){//und wenn die nächste Kreuzung rechts von der jetzigen liegt
nStr="umkehren";//dann kehrt das Auto um
xrichtung=1;
}
else{//und wenn die nächste Kreuzung links von der jetzigen Kreuzung liegt
nStr="geradeaus";//dann fährt das Auto geradeaus weiter
}
}
}
}
}
if(i==1){
return(nStr);
}
else{
if(i==2){
return(String.valueOf(xrichtung));
}
else{
return(String.valueOf(yrichtung));
}
}
}//</editor-fold>
//Fehlt noch die Koordination mit den anderen Autos. Autolänge und Breite, wann anhalten?-->gerade in Bearbeitung
//<editor-fold defaultstate="collapsed" desc="Hindernissuche,[Remo, Teil Hier und Word-Dokument Geschwindigkeitsregulierung]">
public void getHindernis(){
//Speichert die Geschwindigkeitsänderung und den Abstand zum nächsten Hindernis
//Schwierigkeit:Wann treffen sich die Autos auf den Kreuzungen
//Ansäte:
//Jedes Auto schaut auf seine Umgebung(x-y-Liste)(Ganz andere Umsetzung als jetzt.)
//Beste Lösung:Wer fährt zur gleichen Kreuzung, dann diese Vergleichen.(Und wer von diesen fährt auf der selben Straße)
//Liste??? Welche??-->Neue Autoliste
//Oder direkt in dieser Funktion die Geschwindigkeit regulieren.
//Beachte: Länge der Autos
for(KreuK K=Kreuzung.getAnfKreu();K!=null;K=K.getNF()){Acceleration[K.getID()-1].setAnfangAuto(null);}
for(int j=1;j!=3;j++){
int i=0;
for(AuK aA=Auto.getAnfAu();i<Auto.getAnzAu();aA=aA.getNF()){//Speichert für jede Kreuzung die Autos, die zu dieser fahren.(Beachten:Autos auf Kreuzungen.)
if(aA.getMemShip()!=0){
Autoweg[i].setAnfangAuto(null);
StrK mem=Strasse.getbestStrasse(aA.getMemShip(),Strasse.getAnfStr());
AuK bA;
double Av=aA.getv();
//bA=aA;
/*Acceleration[mem.getKreuID().getID()-1].addAuto(bA);
Acceleration[mem.getKreuID().getID()-1].getAnfAu().setNF(null);
Acceleration[mem.getKreuID().getID()-1].getLetzterAuto().setmHin(Math.abs(aA.getX()-Strasse.getbestStrasse(aA.getMemShip(),Strasse.getAnfStr()).getKreuID().getX())+Math.abs(aA.getY()-Strasse.getbestStrasse(aA.getMemShip(),Strasse.getAnfStr()).getKreuID().getY()));*/
bA=new AuK(s);
Autoweg[i].addAuto(bA);//Der Autoweg speichert die Beschleunigung und die Zeit ein.
//Erklärung siehe word-Dokument
double t1, t2,s1,s2;
//double y=Acceleration[mem.getKreuID().getID()-1].getLetzterAuto().getmHin();//y muss noch verkleinert werden wenn das Auto sonst an ein anderes stößt.
double y=Math.abs(aA.getx()-mem.getKreuID().getx())+Math.abs(aA.gety()-mem.getKreuID().gety())-3*s/4;
if(j==2&&Acceleration[mem.getKreuID().getID()-1].getbestAu(i, Acceleration[mem.getKreuID().getID()-1].getAnfAu()).getdt()!=0&&Autoweg[i].getAnfKreu().getNF()!=null){
y=y-aA.getdt()*kreuv;
}
double a1=aA.getbeschlbrem();
double a2=aA.getbeschlanf();
double memv=mem.getmaxv();
double krms=kreuv;
System.out.println(Autoweg[i].getAnfKreu());
System.err.println(Autoweg[i].getAnfKreu().getNF());
if(Autoweg[i].getAnfKreu().getNF()==null){
y=Math.abs(aA.getx()-aA.getxziel())+Math.abs(aA.gety()-aA.getyziel());
krms=0;
//Ziel wird trotzem noch wie Kreuz behandelt, da die Funktion aufgerufen wird, bevor das Kreuz erkannt wird.
}
t1=(krms-memv)/a1;
t2=(memv-Av)/a2;
s1=memv*t1+a1*t1*t1*0.5;
s2=Av*t2+a2*t2*t2*0.5;
if(s2+s1>=y){
double x1,konst,konst2;
konst=(2*a1*kreuv+2*a2*kreuv)/a1;
konst2=((kreuv*kreuv*(3*a2-a1))/(2*a1*a2)-y)/(1/(2*a1)+1/(2*a2));
x1=-konst+Math.sqrt(konst*konst-konst2);
if(-konst-Math.sqrt(konst*konst-konst2)>=0&&-konst-Math.sqrt(konst*konst-konst2)<x1)x1=-konst-Math.sqrt(konst*konst-konst2);
t1=(kreuv-x1)/a1;
t2=(x1-kreuv)/a2;
if(Av<=kreuv){
double t0=(kreuv-Av)/a2;
Autoweg[i].getAnfAu().setdt(t2+t0);
Autoweg[i].getAnfAu().setbeschleunigung(a2);
Autoweg[i].getAnfAu().setx(aA.getx());
Autoweg[i].getAnfAu().sety(aA.gety());
bA=new AuK(s);
Autoweg[i].addAuto(bA);
Autoweg[i].getLetzterAuto().setdt(t1);
Autoweg[i].getLetzterAuto().setbeschleunigung(a1);
}
else{
double t0=(Av-kreuv)/a2;
Autoweg[i].getAnfAu().setdt(t2-t0);
Autoweg[i].getAnfAu().setbeschleunigung(a2);
Autoweg[i].getAnfAu().setx(aA.getx());
Autoweg[i].getAnfAu().sety(aA.gety());
bA=new AuK(s);
Autoweg[i].addAuto(bA);
Autoweg[i].getLetzterAuto().setdt(t1);
Autoweg[i].getLetzterAuto().setbeschleunigung(a1);
}
System.out.println("konst: " + konst);
System.out.println("konst2: " + konst2);
System.out.println("x1: " + x1);
System.out.println("t1 " + t2+" s1: "+s2);
System.out.println("t3: " + t1+" s3: "+s1);
System.err.println("gesweg: "+y);
}
else{
double diff=y-(s1+s2);
double t3=diff/memv;
Autoweg[i].getAnfAu().setdt(t2);
Autoweg[i].getAnfAu().setbeschleunigung(a2);
Autoweg[i].getAnfAu().setx(aA.getx());
Autoweg[i].getAnfAu().sety(aA.gety());
bA=new AuK(s);
Autoweg[i].addAuto(bA);
Autoweg[i].getLetzterAuto().setdt(t3);
Autoweg[i].getLetzterAuto().setbeschleunigung(0);
bA=new AuK(s);
Autoweg[i].addAuto(bA);
Autoweg[i].getLetzterAuto().setdt(t1);
Autoweg[i].getLetzterAuto().setbeschleunigung(a1);
}
/*if(y<Acceleration[mem.getKreuID().getID()-1].getLetzterAuto().getmHin()){
bA=new AuK(s);
Autoweg[i].addAuto(bA);
Autoweg[i].getLetzterAuto().setdt((Acceleration[mem.getKreuID().getID()-1].getLetzterAuto().getmHin()-y)/krms);
Autoweg[i].getLetzterAuto().setbeschleunigung(0);
}*/
if(j==2&&Acceleration[mem.getKreuID().getID()-1].getbestAu(i, Acceleration[mem.getKreuID().getID()-1].getAnfAu()).getdt()!=0&&Autoweg[i].getAnfKreu().getNF()!=null){
double diff=aA.getdt()*kreuv;
double t4=diff/kreuv;
bA=new AuK(s);
Autoweg[i].addAuto(bA);
Autoweg[i].getLetzterAuto().setdt(t4);
Autoweg[i].getLetzterAuto().setbeschleunigung(0);
}
if(Autoweg[i].getAnfKreu().getNF()!=null){
if(j==1){
Acceleration[mem.getKreuID().getID()-1].addAuto(new AuK(s));
Acceleration[mem.getKreuID().getID()-1].getLetzterAuto().setMemShip(i);
double dt=0;
for(AuK a=Autoweg[i].getAnfAu();a!=null;a=a.getNF()){dt=dt+a.getdt();}
Acceleration[mem.getKreuID().getID()-1].getLetzterAuto().setdt(dt);
}
}
}
System.out.println("Auto "+(i+1));
for(AuK cA=Autoweg[i].getAnfAu();cA!=null;cA=cA.getNF()){
System.out.println("a: "+cA.getbeschleunigung()+" dt: "+cA.getdt());
}
i++;
}
if(j==1){
for(KreuK K=Kreuzung.getAnfKreu();K!=null;K=K.getNF()){
bubble_sort(Acceleration[K.getID()-1].getAnzAu(),K.getID()-1);
if(Acceleration[K.getID()-1].getAnzAu()>1)Autokoordination(Acceleration[K.getID()-1],K);
}
}
}
}//</editor-fold>
double lasttimediff=0;
//Fehlt noch die Änderung bei den Kurven
//<editor-fold defaultstate="collapsed" desc="Setzt den einzelnen Autos die Beschleunigung mit zeit,[Remo, Teil Hier und Word-Dokument Geschwindigkeitsregulierung]">
public void Autokreuzhinzufuegen(int i){//i zeigt das Auto an
for(int k=0;k<Kreuzung.getAnzKreu();k++){
if(Acceleration[k].getAnfAu()!=null){
for(AuK gAuto=Acceleration[k].getAnfAu();gAuto!=null;gAuto=gAuto.getNF()){
gAuto.setdt(gAuto.getdt()-(abcde-lasttimediff)*timediff);
if(gAuto.getdt()<=0){
Acceleration[k].delAuto(gAuto);
}
}
}
}
lasttimediff=abcde;
AuK aA=Auto.getntesAu(i);
//Wegberechnung(aA);
Wegberechnung_a_Star(aA);
KreuK aKreu=Autoweg[i-1].getAnfKreu();
double weite;
double mpros=aA.getv();
double dauer=0;
double xrichtung=aA.getxrichtung();
double yrichtung=aA.getyrichtung();
double Av=aA.getv();
if(aKreu.getNF()==null){
weite=Math.abs(aA.getxziel()-aA.getx())+Math.abs(aA.getyziel()-aA.gety());
}
else{
weite=Math.abs(aA.getx()-aKreu.getx())+Math.abs(aA.gety()-aKreu.gety())-3*s/4;
}
for(aKreu=aKreu;aKreu!=null;aKreu=aKreu.getNF()){//Für nachfolgendes sollte auch eine Funktion eingebaut werden.(Für den Fall wenn man etwas beim späteren hinzufügen änderns sollte)
double t1,t2,s1,s2,t3=0;
StrK mem=Strasse.getbestStrasse(aA.getMemShip(),Strasse.getAnfStr());
double a1=aA.getbeschlbrem();
double a2=aA.getbeschlanf();
double memv=mem.getmaxv();
double krms=kreuv;
t1=(krms-memv)/a1;
t2=(memv-Av)/a2;
s1=memv*t1+a1*t1*t1*0.5;
s2=Av*t2+a2*t2*t2*0.5;
if(s2+s1>=weite){
double x1=Math.sqrt(-(((kreuv*kreuv*a2-kreuv*kreuv*a1)/(2*a1*a2)-weite)/(((a1-a2))/(2*a1*a2))));
t1=(kreuv-x1)/a1;
t2=(x1-kreuv)/a2;
System.out.println(x1);
if(Av<=kreuv){
double t0=(kreuv-Av)/a2;
t2=t2+t0;
}
else{
double t0=(Av-kreuv)/a2;
t2=t2-t0;
}
}
else{
double diff=weite-(s1+s2);
t3=diff/memv;
}
AuK bA=new AuK(s);
Autoweg[i-1].addAuto(bA);
Autoweg[i-1].getLetzterAuto().setdt(t2);
Autoweg[i-1].getLetzterAuto().setbeschleunigung(a2);
bA=new AuK(s);
Autoweg[i-1].addAuto(bA);
Autoweg[i-1].getLetzterAuto().setdt(t3);
Autoweg[i-1].getLetzterAuto().setbeschleunigung(0);
bA=new AuK(s);
dauer=dauer+t1+t2+t3;
Autoweg[i-1].addAuto(bA);
Autoweg[i-1].getLetzterAuto().setdt(t1);
Autoweg[i-1].getLetzterAuto().setbeschleunigung(a1);
Autoweg[i-1].getLetzterAuto().setxrichtung(xrichtung);
Autoweg[i-1].getLetzterAuto().setyrichtung(yrichtung);
Autoweg[i-1].getLetzterAuto().setlaenge(t1+t2+t3);
Autoweg[i-1].getLetzterAuto().setdms(weite);
Autoweg[i-1].getLetzterAuto().setMemShip(i);
if(aKreu.getNF()!=null){
bA=new AuK(s);
Autoweg[i-1].addAuto(bA);
Autoweg[i-1].getLetzterAuto().setdt(tKreu(nextStr(aKreu,xrichtung,yrichtung,1)));
Autoweg[i-1].getLetzterAuto().setbeschleunigung(0);
Autoweg[i-1].getLetzterAuto().setnaechste_strasse(nextStr(aKreu,xrichtung,yrichtung,1));
Autoweg[i-1].getLetzterAuto().setMemShip(i);
Acceleration[aKreu.getID()-1].addAuto(new AuK(s), i, dauer,xrichtung,yrichtung);
xrichtung=Double.parseDouble(nextStr(aKreu,xrichtung,yrichtung,2));
yrichtung=Double.parseDouble(nextStr(aKreu,xrichtung,yrichtung,3));
Av=kreuv;
if(aKreu.getNF().getNF()==null){
weite=Math.abs(aA.getxziel()-aKreu.getx())+Math.abs(aA.getyziel()-aKreu.gety())-3*s/4;
}
else{
weite=Math.abs(aKreu.getNF().getx()-aKreu.getx())+Math.abs(aKreu.getNF().gety()-aKreu.gety())-s;
}
}
}
if(Autoweg[i-1].getAnfKreu().getNF()!=null)hinterschieben(Autoweg[i-1].getAnfAu(),Autoweg[i-1].getAnfKreu());//Achtung eine inverse Funktion(Vielleicht sogar neue Aufstellung.wird eine ürsprüngliche Zeit und aktuelle eit benötigt)
Autoweg[i-1].getAnfAu().sety(Koordinaten[i-1][1]);
Autoweg[i-1].getAnfAu().setx(Koordinaten[i-1][0]);
}//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Gibt die Zeit in der Kreuzung aus.[Remo, Nichts]">
public double tKreu(String richtung){
double zeit=1;
if(richtung=="links"){
zeit=(90*2*Math.PI*3*s/4)/(360*kreuv);
}
else{
if(richtung=="rechts"){
zeit=(90*2*Math.PI*s/4)/(360*kreuv);
}
else{
if(richtung=="geradeaus"){
zeit=s/kreuv;
}
else{
zeit=(180*2*Math.PI*s/4)/(360*kreuv);
}
}
}
return(zeit);
}//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Reiht das Auto in die Kreuzungen ein.[Remo, Teil Hier und Word-Dokument Geschwindigkeitsregulierung]">
public void hinterschieben(AuK bA,KreuK aKreu){//i zeigt das Auto an
for(aKreu=aKreu;aKreu.getNF()!=null;aKreu=aKreu.getNF()){//Für nachfolgendes sollte auch eine Funktion eingebaut werden.(Für den Fall wenn man etwas beim späteren hinzufügen änderns sollte)
while(bA.getNF().getnaechste_strasse().equals("")){
bA=bA.getNF();
}
System.out.println("Auto1.: "+bA.getMemShip());
AuK bAuto=Acceleration[aKreu.getID()-1].getbestAu(bA.getMemShip(), Acceleration[aKreu.getID()-1].getAnfAu());
if(Acceleration[aKreu.getID()-1].getAnfAu()!=bAuto &&
bAuto.getdt()-Acceleration[aKreu.getID()-1].getVG(bAuto).getdt()<tKreu(nextStr(aKreu,Acceleration[aKreu.getID()-1].getVG(bAuto).getxrichtung(),Acceleration[aKreu.getID()-1].getVG(bAuto).getyrichtung(),1))){
//Obige Formel sollte verbessert werden.
System.out.println("es macht hier etwas");
double t4=tKreu(nextStr(aKreu,Acceleration[aKreu.getID()-1].getVG(bAuto).getxrichtung(),Acceleration[aKreu.getID()-1].getVG(bAuto).getyrichtung(),1))-(bAuto.getdt()-Acceleration[aKreu.getID()-1].getVG(bAuto).getdt());
zeitveränderung(bA,t4,aKreu);//Verlangerung von bA um t4
KreuK bKreu=aKreu;
AuK dA=bA;
Acceleration[bKreu.getID()-1].getbestAu(dA.getMemShip(), Acceleration[bKreu.getID()-1].getAnfAu()).setdt(t4+Acceleration[bKreu.getID()-1].getbestAu(dA.getMemShip(), Acceleration[bKreu.getID()-1].getAnfAu()).getdt());
bubble_sort(Acceleration[bKreu.getID()-1].getAnzAu(),bKreu.getID()-1);
dA=bA.getNF();
bKreu=bKreu.getNF();
while(bKreu.getNF()!=null){
while(dA.getNF().getnaechste_strasse().equals("")){
dA=dA.getNF();
}
Acceleration[bKreu.getID()-1].getbestAu(dA.getMemShip(), Acceleration[bKreu.getID()-1].getAnfAu()).setdt(t4+Acceleration[bKreu.getID()-1].getbestAu(dA.getMemShip(), Acceleration[bKreu.getID()-1].getAnfAu()).getdt());
bubble_sort(Acceleration[bKreu.getID()-1].getAnzAu(),bKreu.getID()-1);
bKreu=bKreu.getNF();
}
}
if(bAuto.getNF()!=null&&bAuto.getNF().getdt()-bAuto.getdt()<tKreu(nextStr(aKreu,bA.getxrichtung(),bA.getyrichtung(),1))){
System.out.println("Zeiten: 1: "+bAuto.getdt()+" 2: "+bAuto.getNF().getdt()+"not. Diff: "+ tKreu(nextStr(aKreu,bA.getxrichtung(),bA.getyrichtung(),1)));
System.out.println("asd"+Autoweg[bAuto.getNF().getMemShip()-1].getbestAutKreu(Autoweg[bAuto.getNF().getMemShip()-1].getAnfAu(),Autoweg[bAuto.getNF().getMemShip()-1].getAnfKreu(),aKreu));
hinterschieben(Autoweg[bAuto.getNF().getMemShip()-1].getbestAutKreu(Autoweg[bAuto.getNF().getMemShip()-1].getAnfAu(),Autoweg[bAuto.getNF().getMemShip()-1].getAnfKreu(),aKreu),Autoweg[bA.getMemShip()-1].getbestKreu(aKreu.getID(),Autoweg[bA.getMemShip()-1].getAnfKreu()));//
}
bA=bA.getNF();
}
}//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Verlängert den Autoweg um eine bestimmte Zeit.[Remo, Teil Hier und Word-Dokument Geschwindigkeitsregulierung]">
public void zeitveränderung(AuK bA,double t4,KreuK aKreu){
int j=0;
int i=bA.getMemShip();
System.out.println("Auto2.: "+i);
System.out.println(i);
double weite=bA.getdmsHin();
double laenge=bA.getlaenge();
while(Autoweg[i-1].getVG(bA)!=bA&&Autoweg[i-1].getVG(bA).getnaechste_strasse().equals("")){
bA=Autoweg[i-1].getVG(bA);
j++;
}
boolean ueb=false;
StrK mem;
for(mem=Strasse.getAnfStr();ueb==false;mem=mem.getNF()){
if(mem.getID()==aKreu.getID())ueb=true;
}
if(mem==null)mem=Strasse.getLetzterStrasse();
else mem=Strasse.getVG(mem);
double Av;
AuK aA=Auto.getntesAu(i);
if(Autoweg[i-1].getVG(bA)==null)Av=Auto.getntesAu(Autoweg[i-1].getVG(bA).getMemShip()).getv();
else Av=kreuv;
double t1,t2,s1,s2,t3=0;
double a1=aA.getbeschlbrem();
double a2=aA.getbeschlanf();
double memv=mem.getmaxv();
double krms=kreuv;
t1=(krms-memv)/a1;
t2=(memv-Av)/a2;
s1=memv*t1+a1*t1*t1*0.5;
s2=Av*t2+a2*t2*t2*0.5;
if(s2+s1>=weite){ //Für das else noch keine Funktion gefunden(kommt auch selten vor)
t4=0;
double x1=Math.sqrt(-(((kreuv*kreuv*a2-kreuv*kreuv*a1)/(2*a1*a2)-weite)/(((a1-a2))/(2*a1*a2))));
t1=(kreuv-x1)/a1;
t2=(x1-kreuv)/a2;
if(Av<=kreuv){
double t0=(kreuv-Av)/a2;
t2=t2+t0;
}
else{
double t0=(Av-kreuv)/a2;
t2=t2-t0;
}
}
else{
double diff=weite-(s1+s2);
t3=diff/memv;
t3=(memv*laenge+memv*t4-diff)/(memv-kreuv);
t4=laenge+t4-t3;
}
bA=bA.getNF();
AuK dA=bA;
while(dA.getnaechste_strasse()==""){
dA=dA.getNF();
}
double xrichtung=dA.getxrichtung();
double yrichtung=dA.getyrichtung();
AuK cA=new AuK(s);
if(Autoweg[i-1].getVG(bA)==bA) bA=cA;
else Autoweg[i-1].getVG(bA).setNF(cA);
cA.setdt(t2);
cA.setbeschleunigung(a2);
bA=bA.getNF();
cA=new AuK(s);
bA.setNF(cA);
cA.setdt(t3);
cA.setbeschleunigung(0);
bA=bA.getNF();
cA=new AuK(s);
bA.setNF(cA);
cA.setdt(t1);
cA.setbeschleunigung(a1);
bA=bA.getNF();
cA=new AuK(s);
bA.setNF(cA);
cA.setdt(t4);
cA.setbeschleunigung(0);
cA.setxrichtung(xrichtung);
cA.setyrichtung(yrichtung);
cA.setlaenge(t1+t2+t3+t4);
cA.setdms(weite);
cA.setMemShip(i);
cA.setNF(dA);
}//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Koordiniert die Autos(damit sie sich nicht auf der Kreuzung treffen)[Remo, noch NICHTS]">
private void Autokoordination(ObjL Liste,KreuK nK) {//Liste ist die Kreuzungsliste, zu der die Autos fahren.
double warten=Liste.getAnfAu().getdt();//Zeigt die Zeit zur Kreuzung an(wenn die Zeit verlängert wird, wird warten auch verlängert.)
AuK aA=Liste.getAnfAu();
aA.setdt(0);
if(aA!=null&&aA.getNF()!=null){
for(aA=aA;aA.getNF()!=null;aA=aA.getNF()){
if(aA.getNF().getdt()-warten>=1.007){//Wenn die Zeitdifferenz großer ist als der größte Zeitwert (ca. 1.007), wird nichts gemacht.
warten=aA.getNF().getdt();
aA.getNF().setdt(0);
}
else{
double diff=1.077;
if(Autoweg[aA.getMemShip()].getAnfKreu().getNF()!=null){warten=aA.getNF().getdt()+diff-(aA.getNF().getdt()-warten);aA.getNF().setdt(diff-(aA.getNF().getdt()-aA.getdt()));}
else warten=aA.getNF().getdt();aA.getNF().setdt(0);
// double diff=dtkreu(aA,nK);//Für diff wird der Wert ausgerechnet, die das nachfolgende Auto später ankommen muss.
// if(aA.getNF().getdt()-aA.getdt()>=diff){//Wenn die Zeitdifferenz größer ist als ein Wert, der für die Autos ausgerechnet wird.
// aA.getNF().setdt(0);
// }
// else{
// aA.getNF().setdt(diff-(aA.getNF().getdt()-aA.getdt()));//Die Zeit die das Auto zur Kreuzung fährt muss um diesen Wert verlängert werden.
// }
}
}
}
}//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Rechnet die Zeitdifferenz der Autos aus(damit sie sich nicht auf der Kreuzung treffen)[Remo, noch NICHTS]">
private double dtkreu(AuK aA, KreuK nK) {//Auto, das mit dem nachfolgende Auto überprüft werden soll.(fehlt noch die mom. Kreuzung, auf die das Auto zufährt, damit man weiter vorrausberechnen kann.)
double dt=0;
double xrich=aA.getxrichtung()+aA.getNF().getxrichtung();
double yrich=aA.getyrichtung()+aA.getNF().getyrichtung();
if(yrich==2||yrich==-2||xrich==2||xrich==-2){//Die Autos fahren aufeinander zu
dt=((aA.getlaenge()/2)+(aA.getNF().getlaenge()/2))/kreuv;
}
else{
String nextStr=nextStr(Autoweg[Auto.getAnzAu(aA)-1].getbestKreu(nK.getID(), Autoweg[Auto.getAnzAu(aA)-1].getAnfKreu()),aA.getxrichtung(),aA.getyrichtung(),1);
String nextStrNF=nextStr(Autoweg[Auto.getAnzAu(aA.getNF())-1].getbestKreu(nK.getID(), Autoweg[Auto.getAnzAu(aA.getNF())-1].getAnfKreu()),aA.getNF().getxrichtung(),aA.getNF().getyrichtung(),1);
if(yrich==0&&xrich==0){
if(nextStr=="links"||nextStrNF=="links"){
}
else{
dt=0;
}
}
else{
if(xrich*yrich==1){//Die beiden Autos fahren im90°Winkel(beide -1 oder 1 von der Richtung her)
if(aA.getxrichtung()!=0){//aA(das erste Auto) fährt rechts von dem anderen
if(nextStrNF=="rechts"){//Wenn sich die Autos nicht treffen
dt=0;
}
else{
}
}
else{//aA ist links von dem nachfolgenden
if(nextStr=="rechts"){
dt=0;
}
}
}
}
}
return(dt);
}//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Bubble_Sort,Sortiert die Autos(nach Zeitabstand zur Kreuzung), die zu der gleichen Kreuzung fahren.[Remo, noch NICHTS]">
private void bubble_sort(int n,int ID) {//ID ist die Kreuzungs-ID
int i=1;
boolean tausch=true;
while((i<n) && (tausch==true)){
tausch=false;
for(int j=1;j<n;j++){
if(Acceleration[ID].getntesAu(j).getdt()>Acceleration[ID].getntesAu(j+1).getdt()){
//Dreieckstausch
Acceleration[ID].Autotausch(Acceleration[ID].getntesAu(j));
tausch=true;
}
}
i++;
}
}//</editor-fold>
//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="THREAD: Starten, Pausieren, Wiederaufnehmen, Beenden [IVO, NICHTS/UNNÖTIG]">
int abcde=0;
double timediff=0.2;
public void startSimulation(){
if (Instance == null || this.Instance.started) {
for(AuK aA=Auto.getAnfAu();aA!=null;aA=aA.getNF()){
Koordinaten[Auto.getAnzAu(aA)-1][2]=aA.getxziel();
Koordinaten[Auto.getAnzAu(aA)-1][3]=aA.getyziel();
System.err.println("x-richtung: "+aA.getxrichtung());
System.err.println("y-richtung: "+aA.getyrichtung());
}
this.Instance = new Simulation() {
@Override
public void doSimulation(){
check(timediff);
abcde++;
}
};
// Deaktivieren aller Buttons
this.b_addBridge.setEnabled(false);
this.b_addRoad.setEnabled(false);
this.b_addCrossroad.setEnabled(false);
this.b_del.setEnabled(false);
this.b_mapImport.setEnabled(false);
this.b_mapExport.setEnabled(false);
Timer Sim = new Timer();
Sim.scheduleAtFixedRate(Instance, (long) 0.0000000001, Instance.timeSlice);
Instance.started = true;
Instance.running = true;
}
else Instance.pause = false;
}
public void suspendSimulation() {
this.Instance.pause = true;
this.b_mapExport.setEnabled(true);
}
public void resumeSimulation() {
this.Instance.pause = false;
this.b_mapExport.setEnabled(false);
}
public void terminateSimulation() {
this.Instance.cancel();
//Reaktivierung aller Buttons
this.b_addBridge.setEnabled(true);
this.b_addRoad.setEnabled(true);
this.b_addCrossroad.setEnabled(true);
this.b_del.setEnabled(true);
this.b_mapImport.setEnabled(true);
this.b_mapExport.setEnabled(true);
}
//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="main-Funktion, Deklaration der swing-Felder [NetBeans,NICHT NOETIG]">
public static void main(String args[]) {
/* Set the Nimbus look and feel */
//<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
/* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.
* For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
*
try {
for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {
java.util.logging.Logger.getLogger(Main.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {
java.util.logging.Logger.getLogger(Main.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (IllegalAccessException ex) {
java.util.logging.Logger.getLogger(Main.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {
java.util.logging.Logger.getLogger(Main.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
}*/
//</editor-fold>
/* Create and display the form */
java.awt.EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
new Main().setVisible(true);
}
});
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JButton b_addBridge;
private javax.swing.JButton b_addCar;
private javax.swing.JButton b_addCrossroad;
private javax.swing.JButton b_addRoad;
private javax.swing.JButton b_cancel;
private javax.swing.JButton b_clear;
private javax.swing.JButton b_del;
private javax.swing.JButton b_mapExport;
private javax.swing.JButton b_mapImport;
private javax.swing.JButton b_pause;
private javax.swing.JButton b_start;
private javax.swing.JButton jButtongeschw;
private javax.swing.JLabel jLabel1;
private javax.swing.JPanel jPanel1;
private javax.swing.JPanel jPanel2;
private javax.swing.JPanel jPanel3;
private javax.swing.JTextField j_CarNumber;
private javax.swing.JLabel l_Editor;
private javax.swing.JLabel l_carCount;
private javax.swing.JLabel l_developers;
private javax.swing.JLabel l_map;
private javax.swing.JLabel l_notifications;
private javax.swing.JLabel l_title;
private javax.swing.JTabbedPane tp_main;
// End of variables declaration//GEN-END:variables
//</editor-fold>
//<editor-fold desc="public void reset(): Löscht alles [Ivo, ALLES]" defaultstate="collapsed">
public void reset() {
// Diese Funktion setzt alle Variablen auf ihren Originalzustand zurück und beendet die Threads
// sodass man einen weiteren Simulationdurchlauf starten kann, ohne das ganze Programm neu starten zu müssen
if (Instance != null && Instance.started) Instance.cancel();
if (paint != null && paint.started) paint.cancel();
Instance = null;
geschw = false;
paint = intPaint();
ix = iy = ax = ay = StrIDZuwei = count = 0;
kreuv = 0;
roadVK = null;
roadHO=null;
crT_0=null;
crT_90=null;
crT_180=null;
crT_270=null;
cr4=null;
corner_0=null;
corner_90=null;
corner_180=null;
corner_270=null;
turn_0=null;
turn_90=null;
turn_270=null;
turn_180=null;
car = new BufferedImage[10];
listen = null;
Auto = new ObjL();
Strasse= new ObjL();
NormStrasse=new ObjL();
Kreuzung=new ObjL();
Autoweg = Acceleration = null;
akt = null;
if (aTab != null) {
Graphics g = aTab.getGraphics();
g.setColor(Color.white);
g.fillRect(0, 0, aTab.getWidth(), aTab.getHeight());
}
this.aTab = (JPanel) tp_main.getSelectedComponent();
Koordinaten = null;
}
//</editor-fold>
//<editor-fold desc="public void sortKreuK (ObjL Kreu: sortiert die Strassen aller KreuK's von Kreu im Uhrzeigersinn [Remo, NICHTS]" defaultstate="collapsed">
public void sortKreuK (ObjL Kreu) {
if (Kreu.getAnfKreu() != null) {
for (KreuK a = Kreu.getAnfKreu(); a!=null; a=a.getNF()) {
int s_x, s_y;
int k_x = (int) (a.getx()-s/4);
int k_y = (int) (a.gety()-s/4);
StrK oben, rechts, unten, links;
oben=links=rechts=unten=null;
if (a.getStrasse1() != null) {
s_x = (int) a.getStrasse1().getX();
s_y = (int) a.getStrasse1().getY();
if (k_x == s_x) unten= a.getStrasse1();
else if (k_x+s/2 == s_x) oben = a.getStrasse1();
else if (k_y == s_y) links = a.getStrasse1();
else if (k_y+s/2==s_y) rechts = a.getStrasse1();
} if (a.getStrasse2() != null) {
s_x = (int) a.getStrasse2().getX();
s_y = (int) a.getStrasse2().getY();
if (k_x == s_x) unten= a.getStrasse2();
else if (k_x+s/2 == s_x) oben = a.getStrasse2();
else if (k_y == s_y) links = a.getStrasse2();
else if (k_y+s/2==s_y) rechts = a.getStrasse2();
} if (a.getStrasse3() != null) {
s_x = (int) a.getStrasse3().getX();
s_y = (int) a.getStrasse3().getY();
if (k_x == s_x) unten= a.getStrasse3();
else if (k_x+s/2 == s_x) oben = a.getStrasse3();
else if (k_y == s_y) links = a.getStrasse3();
else if (k_y+s/2==s_y) rechts = a.getStrasse3();
} if (a.getStrasse4() != null) {
s_x = (int) a.getStrasse4().getX();
s_y = (int) a.getStrasse4().getY();
if (k_x == s_x) unten= a.getStrasse4();
else if (k_x+s/2 == s_x) oben = a.getStrasse4();
else if (k_y == s_y) links = a.getStrasse4();
else if (k_y+s/2==s_y) rechts = a.getStrasse4();
} if (oben!=null) {
oben.kU = a;
oben.kO = oben.getKreuID();
} if (unten!=null) {
unten.kO = a;
unten.kU = unten.getKreuID();
} if (rechts!=null) {
rechts.kL = a;
rechts.kR = rechts.getKreuID();
} if (links!=null){
links.kR = a;
links.kL = links.getKreuID();
}
a.setStrasse1(oben);
a.setStrasse2(rechts);
a.setStrasse3(unten);
a.setStrasse4(links);
}
}
}
//</editor-fold>
//<editor-fold desc="private void initFunctions(): initialisiert Mouse + Change Listener und lädt die Texturen in den Speicher [Ivo, Nicht Nötig]" defaultstate="collapsed">
private void initFunctions() {
this.aTab = (JPanel) tp_main.getSelectedComponent();
this.aTab.addMouseListener(this);
this.tp_main.addChangeListener(this);
LoadImages tmp = LoadIMG();
tmp.start();
}
//</editor-fold>
//<editor-fold desc="Daten Im- & Export [Ivo]" defaultstate="collapsed">
//<editor-fold desc="public void importData (String path, ObjL Strasse, ObjL Kreu): importiert Strasse und Kreu von path [Ivo, ALLES]" defaultstate="collapsed">
public void importData (String path, ObjL Strasse, ObjL Kreu) {
String [] splitString = null;
try {
byte[] encoded = Files.readAllBytes(Paths.get(path));
splitString = Charset.defaultCharset().decode(ByteBuffer.wrap(encoded)).toString().split(";");
} catch (IOException ex) { System.err.println(ex); }
if (splitString == null || splitString[0].equals("")) splitString = new String[0];
int [] splitInt = new int[splitString.length];
for (int i = 0; i<splitString.length; i++) {
splitInt[i] = Integer.parseInt(splitString[i]);
}
// Hier wird zunächst die gesamte Datei ausgelesen und an Semikolon aufgeteilt und in ein String-Array gespeichert
// Anschließend werden die Strings in Integer konvertiert
Strasse.setAnfangStrasse(null);
Kreu.setAnfangKreuzung(null);
Strasse.setAnfangStrasse(null);
int i;
for (i = 0; splitInt[i]!=-1; i=i+4) {
Strasse.addStrasse(new StrK(), splitInt[i], splitInt[i+1], splitInt[i+2], splitInt[i+3], Strasse.getAnzStr()+1);
}
for (i++; i<splitInt.length; i = i+2 ) {
Kreu.addKreuzung(new KreuK(), splitInt[i], splitInt[i+1], Kreu.getAnzKreu()+1);
}
// Hier werden die Koordinaten aus dem boen erstellten Array ausgelesen und als StrK
// bzw. nach dem Trenner (-1) als KreuK gespeichert
Strhinz();
// Ausführungen von Strhinz zum errechnen aller Verknüpfungen
}
//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="public void export(FileWriter out, ObjL NStrasse, ObjL Kreu): speichert Die Daten aus NStrasse und Kreu nach out [Ivo, ALLES]">
public void export(FileWriter out, ObjL NStrasse, ObjL Kreu) throws IOException {
if (this.NormStrasse.getAnfStr()!=null) {
this.NormStrasse.setStr_aktuell(this.NormStrasse.getAnfStr());
while (this.NormStrasse.getStr_aktuell()!=null) {
StrK tmp = this.NormStrasse.getStr_aktuell();
out.write(String.valueOf((int) tmp.getX()) + ";");
out.write(String.valueOf((int) tmp.getY()) + ";");
out.write(String.valueOf((int) tmp.getX2()) + ";");
out.write(String.valueOf((int) tmp.getY2()) + ";");
this.NormStrasse.setStr_aktuell(this.NormStrasse.getStr_aktuell().getNF());
}
// Durchgehen & speichern aller Koords aller Straßen
out.write(-1 + ";");
// Trenner zwischen Straßen und Kreuzungen (-1 ist eine unmögliche Koordinate, kann daher nciht verwechselt werden)
}
if (this.Kreuzung.getAnfKreu()!=null) {
KreuK aktuell = this.Kreuzung.getAnfKreu();
while (aktuell!=null) {
KreuK tmp = aktuell;
out.write(String.valueOf((int) tmp.getx()) + ";");
out.write(String.valueOf((int) tmp.gety()) + ";");
aktuell = aktuell.getNF();
}// Durchgehen & speichern aller Koords aller Kreuzungen
}
}
//</editor-fold>
public void saveOnExit () {
this.b_mapExportMouseClicked(new MouseEvent(this,0,0,0,0,0,0,false));
for (int i = 0; i <= count; i++) {
if (new File("temp_" + i).exists()) new File("temp_" + i).delete();
}
// Das hier sollte eine Funktion werden, die beim Beenden des Programms fragt, ob man speichern möchte,
// wenn sich seit dem letzten Speichern etwas verändert hat
}
//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="Grafische Ausgabe">
//<editor-fold defaultstate="collapsed" desc="LOADIMG">
private LoadImages LoadIMG() {
LoadImages tmp = new LoadImages() {
@Override
public void load() {
try {
roadVK = ImageIO.read(Main.class.getResource("../Texturen/road_VK.png"));
} catch (IOException ex) { System.err.println(ex); }
try {
roadHO = ImageIO.read(Main.class.getResource("../Texturen/road_HO.png"));
} catch (IOException ex) { System.err.println(ex); }
try {
cr4 = ImageIO.read(Main.class.getResource("../Texturen/cr_4.png"));
} catch (IOException ex) { System.err.println(ex); }
try {
try {
corner_0 = ImageIO.read(Main.class.getResource("../Texturen/corner_0.png"));
} catch (IOException ex) { System.err.println(ex); }
corner_90 = ImageIO.read(Main.class.getResource("../Texturen/corner_90.png"));
} catch (IOException ex) { System.err.println(ex); }
try {
corner_180 = ImageIO.read(Main.class.getResource("../Texturen/corner_180.png"));
} catch (IOException ex) { System.err.println(ex); }
try {
corner_270 = ImageIO.read(Main.class.getResource("../Texturen/corner_270.png"));
} catch (IOException ex) { System.err.println(ex); }
try {
turn_0 = ImageIO.read(Main.class.getResource("../Texturen/turn_0.png"));
} catch (IOException ex) { System.err.println(ex); }
try {
turn_90 = ImageIO.read(Main.class.getResource("../Texturen/turn_90.png"));
} catch (IOException ex) { System.err.println(ex); }
try {
turn_180 = ImageIO.read(Main.class.getResource("../Texturen/turn_180.png"));
} catch (IOException ex) { System.err.println(ex); }
try {
turn_270 = ImageIO.read(Main.class.getResource("../Texturen/turn_270.png"));
} catch (IOException ex) { System.err.println(ex); }
try {
crT_0 = ImageIO.read(Main.class.getResource("../Texturen/cr_T_0.png"));
} catch (IOException ex) { System.err.println(ex); }
try {
crT_90 = ImageIO.read(Main.class.getResource("../Texturen/cr_T_90.png"));
} catch (IOException ex) { System.err.println(ex); }
try {
crT_180 = ImageIO.read(Main.class.getResource("../Texturen/cr_T_180.png"));
} catch (IOException ex) { System.err.println(ex); }
try {
crT_270 = ImageIO.read(Main.class.getResource("../Texturen/cr_T_270.png"));
} catch (IOException ex) { System.err.println(ex); }
}
};
return tmp;
}
//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="public BufferedImage rotateIMG (BufferedImage srcImage, int degrees): dreht srcImage um degrees und gibt es als rotatedImage zurück [Ivo, ALLES]">
public BufferedImage rotateIMG (BufferedImage srcImage, int degrees) {
BufferedImage rotatedImage = new BufferedImage(srcImage.getHeight(), srcImage.getWidth(), srcImage.getType());
AffineTransform affineTransform = AffineTransform.getRotateInstance(Math.toRadians(degrees), rotatedImage.getWidth() / 2d, srcImage.getHeight() / 2d);
Graphics2D g = (Graphics2D) rotatedImage.getGraphics();
g.setTransform(affineTransform);
g.drawImage(srcImage, 0, 0, null);
return rotatedImage;
// Hier wird mit Hilfe eines Transformers die Grafikebene um den mitgelieferten Wert gedreht
// Mit dem gedrehten Bild wird das alte Bild überschrieben und zurückgegeben
}
//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="public T_Paint intPaint(): Initialisiert die graphische Ausgabe der Simulation [Ivo, ALLES]">
public T_Paint intPaint () {
T_Paint tmp = new T_Paint() {
@Override
public void paint() {
Image preRender = createImage(aTab.getWidth(), aTab.getHeight()); //preRender ist die Ebene auf die zunächst gezeichnet wird
Graphics r = preRender.getGraphics(); //dafür werden dessen Graphics benötigt
r.setColor(Color.white);
r.fillRect(0, 0, aTab.getWidth(), aTab.getHeight());
// erstellen der Zwischenebene fürs DoubleBuffering
//<editor-fold desc="StrK toMove zeichnen" defaultstate="collapsed">
if (akt != null) {
int x = (int) akt.getX();
int y = (int) akt.getY();
int x2 = (int) akt.getX2();
int y2 = (int) akt.getY2();
if (y2-y == s) {
for (int i = x+s;i<x2-s;i=i+s) {
r.drawImage(roadHO, i, y, s, s, aTab);
}
} else {
for (int i = y+s;i<y2-s;i=i+s) {
r.drawImage(roadVK, x, i, s, s, aTab);
}
}
}
//</editor-fold>
//<editor-fold desc="Straßen zeichnen" defaultstate="collapsed">
// durchgehen der ObjL NormStrasse zum zeichen aller StrK
if (NormStrasse.getAnfStr() != null) {
for (StrK S_akt = NormStrasse.getAnfStr();
S_akt!=null;
S_akt = S_akt.getNF()) {
int x = (int) S_akt.getX();
int y = (int) S_akt.getY();
int x2 = (int) S_akt.getX2();
int y2 = (int) S_akt.getY2();
//Hier wird die Straße in Schritte der Größe s abgetastet und jeweils einmal die Textur gezeichnet
if (y2-y == s) {
for (int i = x+s;i<x2-s;i=i+s) {
r.drawImage(roadHO, i, y, s, s, aTab);
}
} else {
for (int i = y+s;i<y2-s;i=i+s) {
r.drawImage(roadVK, x, i, s, s, aTab);
}
}
}
}
//</editor-fold>
//<editor-fold desc="Kreuzungen zeichnen" defaultstate="collapsed">
if (Kreuzung.getAnfKreu() != null) {
for (KreuK K_akt = Kreuzung.getAnfKreu();
K_akt!=null;
K_akt = K_akt.getNF()) {
int k_x = (int) K_akt.getx();
int k_y = (int) K_akt.gety();
//<editor-fold desc="4er-Kreuzungen" defaultstate="collapsed">
// Eine 4er-Kreuzung soll nur dann gezeichnet werden, wenn auch 4 Straßen von der Kreuzung abgehen
if (K_akt.getStrasse1()!=null && K_akt.getStrasse2()!=null && K_akt.getStrasse3()!=null && K_akt.getStrasse4()!=null) {
r.drawImage(cr4, k_x-s, k_y-s, s*2, s*2, aTab);
//4er-Kreuzunge haben eine doppelt so große Textur wie Straßen
}//</editor-fold>
//<editor-fold desc="T-Kreuzungen" defaultstate="collapsed">
// Hier wird anhand der Anordnung der abgehenden Straßen ermittelt, welche Ausrichtung die T-Kreuzung haben muss
// und wird dann dementsprechend gezeichnet
else if (K_akt.getStrasse1()!=null && K_akt.getStrasse2()!=null && K_akt.getStrasse3()!=null && K_akt.getStrasse4()==null) {
r.drawImage(crT_180, k_x-s, k_y-s, s*2, s*2, aTab);
} else if (K_akt.getStrasse1()!=null && K_akt.getStrasse2()!=null && K_akt.getStrasse3()==null && K_akt.getStrasse4()!=null) {
r.drawImage(crT_90, k_x-s, k_y-s, s*2, s*2, aTab);
} else if (K_akt.getStrasse1()!=null && K_akt.getStrasse2()==null && K_akt.getStrasse3()!=null && K_akt.getStrasse4()!=null) {
r.drawImage(crT_0, k_x-s, k_y-s, s*2, s*2, aTab);
} else if (K_akt.getStrasse1()==null && K_akt.getStrasse2()!=null && K_akt.getStrasse3()!=null && K_akt.getStrasse4()!=null) {
r.drawImage(crT_270, k_x-s, k_y-s, s*2, s*2, aTab);
} //</editor-fold>
//<editor-fold desc="Ecken" defaultstate="collapsed">
// Hier wird anhand der Anordnung der abgehenden Straßen ermittelt, welche Ausrichtung die Ecke haben muss
// und wird dann dementsprechend gezeichnet
else if (K_akt.getStrasse1()!=null && K_akt.getStrasse2()!=null && K_akt.getStrasse3()==null && K_akt.getStrasse4()==null) {
r.drawImage(corner_180, k_x-s/2, k_y-s/2, s, s, aTab);
} else if (K_akt.getStrasse1()!=null && K_akt.getStrasse2()==null && K_akt.getStrasse3()==null && K_akt.getStrasse4()!=null) {
r.drawImage(corner_90, k_x-s/2, k_y-s/2, s, s, aTab);
} else if (K_akt.getStrasse1()==null && K_akt.getStrasse2()==null && K_akt.getStrasse3()!=null && K_akt.getStrasse4()!=null) {
r.drawImage(corner_0, k_x-s/2, k_y-s/2, s, s, aTab);
} else if (K_akt.getStrasse1()==null && K_akt.getStrasse2()!=null && K_akt.getStrasse3()!=null && K_akt.getStrasse4()==null) {
r.drawImage(corner_270, k_x-s/2, k_y-s/2, s, s, aTab);
} //</editor-fold>
//<editor-fold desc="Wendekreise" defaultstate="collapsed">
// Hier wird anhand der Platzierung der abgehenden Straße ermittelt, welche Ausrichtung der Wendekreis haben muss
// und wird dann dementsprechend gezeichnet
else if (K_akt.getStrasse1()!=null && K_akt.getStrasse2()==null && K_akt.getStrasse3()==null && K_akt.getStrasse4()==null) {
r.drawImage(turn_90, k_x-s, k_y-s, s*2, s*2, aTab);
} else if (K_akt.getStrasse1()==null && K_akt.getStrasse2()!=null && K_akt.getStrasse3()==null && K_akt.getStrasse4()==null) {
r.drawImage(turn_180, k_x-s, k_y-s, s*2, s*2, aTab);
} else if (K_akt.getStrasse1()==null && K_akt.getStrasse2()==null && K_akt.getStrasse3()!=null && K_akt.getStrasse4()==null) {
r.drawImage(turn_270, k_x-s, k_y-s, s*2, s*2, aTab);
} else if (K_akt.getStrasse1()==null && K_akt.getStrasse2()==null && K_akt.getStrasse3()==null && K_akt.getStrasse4()!=null) {
r.drawImage(turn_0, k_x-s, k_y-s, s*2, s*2, aTab);
} //</editor-fold>
}
}
//</editor-fold>
//<editor-fold desc="Autos zeichnen" defaultstate="collapsed">
if (Auto.getAnfAu() != null) {
Random carTex = new Random();
for (double[] Koordinaten1 : Koordinaten) {
int texNr = carTex.nextInt(10) + 1;
int x = (int) Koordinaten1[0];
int y = (int) Koordinaten1[1];
// if (car[texNr] == null) try {
// car[texNr] = ImageIO.read(new File(Main.class.getProtectionDomain().getCodeSource().getLocation().toURI().getPath() + "/../../textures/car_" + texNr + ".png"));
// } catch (IOException ex) { System.err.println(ex); } catch (URISyntaxException ex) {
// Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
// }
r.setColor(Color.YELLOW);
r.fillOval(x-2, y-2, 4, 4);
x = (int) Koordinaten1[2];
y = (int) Koordinaten1[3];
r.setColor(Color.GREEN);
r.fillOval(x-3, y-3, 6, 6);
}
}
//</editor-fold>
// Die eigentliche Anzeige des vorgerenderten Bildes erfolgt erst hier
aTab.getGraphics().drawImage(preRender, 0, 0, new Main());
}
};
return tmp;
}
//</editor-fold>
//</editor-fold>
//<editor-fold desc="MouseListener" defaultstate="collapsed">
//<editor-fold defaultstate="collapsed" desc="public boolean isHit(Point click): überprüft ob ein mitgelieferter Punkt ein Karten-Element trifft [Ivo, ALLES]">
public boolean isHit(Point c) {
if (this.NormStrasse.getAnfStr()!=null) { //Wenn keine Straße vorhanden ist, soll nicht passieren
//Str_aktuell auf den Anfang setzen um alle Straßen durchzugehen
for (this.NormStrasse.setStr_aktuell(this.NormStrasse.getAnfStr());
this.NormStrasse.getStr_aktuell()!=null;
this.NormStrasse.setStr_aktuell(this.NormStrasse.getStr_aktuell().getNF())) {
int x=(int) this.NormStrasse.getStr_aktuell().getX();
int y=(int) this.NormStrasse.getStr_aktuell().getY();
int x2=(int) this.NormStrasse.getStr_aktuell().getX2();
int y2=(int) this.NormStrasse.getStr_aktuell().getY2();
if (x<c.x && y<c.y && c.x<x2 && c.y<y2) {
return true;
//Wenn eine der Straßen durch click getroffen wird, soll die Funktion beendet und "true" zurückgegen werden
// getroffen wird sie, wenn die Koordinaten des MouseEvent zwischen oder auf denen der Straße liegen
}
}
}
return false;
}
//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="MouseListener [Ivo, ALLES]">
@Override
public void mousePressed(MouseEvent e) {
ix=e.getX();
iy=e.getY();
System.out.println("Pressed");
switch (this.object) { // Überprüfung ob eine Strasse, eine Kreuzung oder nichts erstellt werden soll
case "":
if (isHit(e.getPoint())) {
//<editor-fold defaultstate="collapsed" desc="Wenn keine Strasse, Kreuzung oder Brücke gezeichnet werden soll, wird überprüft ob ein bestehendes Element getroffem wurde">
this.listen = new MML_Draw(this.NormStrasse.getStr_aktuell());
this.aTab.addMouseMotionListener(listen);
//Wurde ein Element getroffen wird ein MML_Draw-Objekt erstellt um es per Drag & Drop zu bewegen
//</editor-fold>
}
break;
case "del":
isHit(e.getPoint());
// isHit wird ausgeführt, um den StrK aktuell innerhalb der ObjL Normstraße bis zur zu löschenden Straße zu bewegen
// Das eigentlich Löschen findet in MouseReleased statt.
break;
case "road":
//<editor-fold defaultstate="collapsed" desc="Raster mit Maschengröße s [Ivo, ALLES]">
while (iy%s!=0) {
iy--;
}
while (ix%s!=0) {
ix--;
}
//</editor-fold>
this.NormStrasse.addStrasse(new StrK(), ix, iy, 0, 0, this.NormStrasse.getAnzStr()+1);
// Hinzufügen einer neuen Straße, deren Koordinaten in MML_Draw an die UserEingabe angepasst werden.
listen = new MML_Draw(this.NormStrasse.getLetzterStrasse());
this.aTab.addMouseMotionListener(listen);
break;
case "crossroad":
break;
}
}
@Override
public void mouseReleased(MouseEvent e) {
this.aTab.removeMouseMotionListener(listen);
switch (this.object) {
case "":
if (this.NormStrasse.getAnfStr()!=null) {
Kreuzung.setAnfangKreuzung(null);
Strhinz(); //erneuern der Kreuzungen nach dem Verschieben
this.akt = null;
}
break;
case "del":
if(this.NormStrasse.getAnfStr()!=null){
NormStrasse.delStrassen(NormStrasse.getStr_aktuell());
StrIDZuwei=1; //s.o.
Kreuzung.setAnfangKreuzung(null);
if(this.NormStrasse.getAnfStr()!=null){
Strhinz(); //erneuern der Kreuzungen nach dem Löschen
}
}
this.object="";
break;
case "road":
//<editor-fold defaultstate="collapsed" desc="object=road: es wird eine Straße erstellt">
ax=(int) this.NormStrasse.getLetzterStrasse().getX();
ay=(int) this.NormStrasse.getLetzterStrasse().getY();
ix=(int) this.NormStrasse.getLetzterStrasse().getX2();
iy=(int) this.NormStrasse.getLetzterStrasse().getY2();
if(ax<ix){ //Sicherstellen, dass die a-Koords die untere rechte Ekc darstellen
int x3=ax;
ax=ix;
ix=x3;
}
if(ay<iy){
int y3=ay;
ay=iy;
iy=y3;
}
//<editor-fold defaultstate="collapsed" desc="Raster [Ivo, ALLES]">
while (iy%s!=0) {
iy--;
}
while (ix%s!=0) {
ix--;
}
while (ax%s!=0) {
ax--;
}
while (ay%s!=0) {
ay--;
}
//</editor-fold>
this.NormStrasse.getLetzterStrasse().setBounds(ix, iy, ax, ay);
// Finales einspeichern der Koordinaten
StrIDZuwei=1; //s.o.
Kreuzung.setAnfangKreuzung(null);
Strhinz(); //erneuern der Kreuzungen nach dem Erstellen der Straße
this.object="";
this.akt = null;
break;
//</editor-fold>
}
System.out.println("MouseReleased");
}
//<editor-fold defaultstate="collapsed" desc="Nicht benötigte Mouse-Listener Funktionen [NICHTS]">
@Override
public void mouseEntered(MouseEvent me) {}
@Override
public void mouseExited(MouseEvent me) {}
@Override
public void mouseClicked(MouseEvent me) {}
//</editor-fold>
//</editor-fold>
//<editor-fold defaultstate="collapsed" desc="MouseMotionListener [Ivo, ALLES]">
class MML_Draw implements MouseMotionListener {
int ux, uy;
StrK toMove;
public MML_Draw (StrK akt) {
this.ux = (int) akt.getX();
this.uy = (int) akt.getY();
this.toMove = akt;
}
@Override
public void mouseDragged(MouseEvent me) {
ax=me.getX();
ay=me.getY();
int x,y,w,h;
switch (object) { // Überprüfung der benötigten Funktion: es soll entweder ein Element verschoben werden oder eines erzeugt werden.
case "":
//<editor-fold defaultstate="collapsed" desc="object="": es wird eine Straße verschoben">
w = (int) (toMove.getX2() - toMove.getX());
h = (int) (toMove.getY2() - toMove.getY());
// Breite und Höhe ermittelt um die Maße beizubehalten
x = ax - ( ix - ux );
y = ay - ( iy - uy );
// Ermitteln, welcher Abstand der Straßenrand von Klick-Punkt hat,
// um relativ zum Klick verschieben zu können
//<editor-fold defaultstate="collapsed" desc="Raster [Ivo, ALLES]">
while (y%s!=0) {
y++;
}
while (x%s!=0) {
x++;
}
//</editor-fold>
toMove.setBounds(x, y, x+w, y+h);
break;
//</editor-fold>
case "road":
//<editor-fold defaultstate="collapsed" desc="object="road": es wird eine Straße erstellt">
if (Math.abs(ax-ix)>Math.abs(ay-iy)) {
y=iy; h=s;
if (ax-ix>0) {
x=ix;
if (ax-ix<s)w=s;
else w=ax-ix;
} else {
x=ax;
if (ix-ax<s)w=s;
else w=ix-ax;
}
} else {
x=ix; w=s;
if (ay-iy>0) {
y=iy;
if (ay-iy<s)h=s;
else h=ay-iy;
} else {
y=ay;
if (iy-ay<s)h=s;
else h=iy-ay;
}
}
// Hier wird jeweils ermittelt, welche Ausrichtung die Straße haben soll
// und nachfolgend wird die Breite bzw. Höhe ermittelt
//<editor-fold defaultstate="collapsed" desc="Raster [Ivo, ALLES]">
while (y%s!=0) {
y--;
}
while (x%s!=0) {
x--;
}
while (h%s!=0) {
h--;
}
while (w%s!=0) {
w--;
}
//</editor-fold>
toMove.setBounds(x, y, x+w, y+h);
break;
//</editor-fold>
}
}
@Override
public void mouseMoved(MouseEvent me) {}
}
//</editor-fold>
@Override
public void stateChanged(ChangeEvent e) {
// try {
// this.export(new FileWriter("temp_" + tp_main.getSelectedIndex()), NormStrasse, Kreuzung);
// } catch (IOException ex) { System.err.println(ex); }
// this.importData("temp_" + tp_main.getSelectedIndex(), Strasse, Auto);
// this.aTab=null;
// this.aTab = (JPanel) tp_main.getSelectedComponent();
// this.aTab.addMouseListener(this);
// Diese Funktion sollte einen Tabwechsel erkennen und entsprechend reagieren
}
//</editor-fold>
}