# Vektor2f Slick2d



## gerredtor (24. Nov 2016)

Hallo, ich benutze in LWJGL die Vektor2f class von Slick2d, mit den daten von x und y lass ich ein bild rändern aber wenn ich ein projektil auf das image abfeuere ist x und y plötlich ganz wo anders von dem vektor.

Entity.java


```
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package com.fourthfloorproductions.TowerDefense.Entity;

import com.fourthfloorproductions.TowerDefense.Engine.Frame;
import com.fourthfloorproductions.TowerDefense.Engine.FrameImage;
import com.fourthfloorproductions.TowerDefense.Engine.Laufllienien;
import com.fourthfloorproductions.TowerDefense.Engine.Weglinie;
import com.fourthfloorproductions.TowerDefense.Game;
import java.util.ArrayList;
import org.newdawn.slick.geom.Point;
import org.newdawn.slick.geom.Vector2f;
/**
*
* @author Christoph
*/
public abstract class Entity {
  
    private int live;
    private int damage;
  
    private Vector2f pos;
    private Vector2f speed;
  
    private int x,y;
    private FrameImage image;
    private Laufllienien lauflienien;
    private int aktWeg;
    private boolean Living = true;
  
    float lastX, lastY;
  
    float rx, ry;
  
    public Entity(ArrayList<Weglinie> weglinie)
    {
        this.image = new FrameImage("src/res/Downloads.png", 60,60);
      
        this.aktWeg = 0;
        this.lauflienien = new Laufllienien(weglinie);
      
        this.x = lauflienien.getWege().get(0).fromX;
        this.y = lauflienien.getWege().get(0).fromY;
      
        this.pos = new Vector2f(x,y);
        this.speed = new Vector2f(lauflienien.getWege().get(aktWeg).toX,lauflienien.getWege().get(aktWeg).toY);
        this.speed.setTheta(getAngle(new Point(lauflienien.getWege().get(aktWeg).toX, lauflienien.getWege().get(aktWeg).toY)));
    }
  
    public void draw(Frame f)
    {
        if(Living)
        {
            f.drawImage(image,pos.getX()-30,pos.getY()-30);
            rx=pos.copy().getX()-30;
            ry=pos.copy().getY()-30;
            f.drawLine(pos.getX(), pos.getY(), pos.getX()+30, pos.getY()+30);
        }
    }
      
    public final float getAngle(Point target) {
        float angle = (float) Math.toDegrees(Math.atan2(target.getY() - y, target.getX() - x));

        if(angle < 0){
            angle += 360;
        }

        return angle;
    }
  
    public boolean isFinal()
    {
        boolean f = false;
      
        int finalPosX = lauflienien.getWege().get(aktWeg).toX;
        int finalPosY = lauflienien.getWege().get(aktWeg).toY;
      
        if((finalPosX < lastX && finalPosX > pos.getX()) || (finalPosX > lastX && finalPosX < pos.getX()))
        {
           if((finalPosY < lastY && finalPosY > pos.getY()) || (finalPosY > lastY && finalPosY < pos.getY()))
           {
               f = true;
           }
        }
      
        return f;
    }
  
    public void update(int delta)
    {      

        if(isFinal())
        {
            if(aktWeg == lauflienien.getWege().size()-1)
            {
                Game.live -= damage;
                Living = false;
            }else{
                aktWeg += 1;
              
                this.x = lauflienien.getWege().get(aktWeg).fromX;
                this.y = lauflienien.getWege().get(aktWeg).fromY;
              
                this.pos = new Vector2f(x,y);
                this.speed = new Vector2f(lauflienien.getWege().get(aktWeg).toX,lauflienien.getWege().get(aktWeg).toY);
                this.speed.setTheta(getAngle(new Point(lauflienien.getWege().get(aktWeg).toX, lauflienien.getWege().get(aktWeg).toY)));
            } 
        }else{
            lastX = pos.getX();
            lastY = pos.getY();
          
            Vector2f realSpeed = speed;
            realSpeed.normalise();
            realSpeed.scale(0.1f*delta);

            pos.add(realSpeed);
        }      
    }
  
    public float getX()
    {
        return this.rx;
    }
  
    public float getY()
    {
        return this.ry;
    }
  
    public Vector2f getVector()
    {
        return this.pos;
    }
}
```

Tower.java


```
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package com.fourthfloorproductions.TowerDefense.Tower;

import com.fourthfloorproductions.TowerDefense.Engine.Frame;
import com.fourthfloorproductions.TowerDefense.Entity.Entity;
import com.fourthfloorproductions.TowerDefense.Projectile.Arrow;
import com.fourthfloorproductions.TowerDefense.Projectile.Projectile;
import java.util.ArrayList;
import org.newdawn.slick.geom.Vector2f;

/**
*
* @author Christoph
*/
public abstract class Tower {
  
    private int radius = 120;
    private int x = 1000;
    private int y = 1000;
    private boolean fiered = false;
    private ArrayList<Projectile> projectiles = new ArrayList<>();
    private ArrayList<Entity> entites;
  
    public Tower()
    {
      
    }
  
    public void update(int delta, ArrayList<Entity> entites)
    {
        this.entites = entites;
      
        for(Entity e : entites)
        {
            float xDistance = x - e.getX();
            float yDistance = y - e.getY();
         
            double dis = Math.toDegrees(Math.atan2(xDistance, yDistance));
            System.out.println(dis);
        }
      
        if(!fiered)
        {
            if(entites.size() > 0)
            {
                for(Entity e : entites)
                {
                    projectiles.add(new Arrow(entites, e, new Vector2f(x,y), new Vector2f(e.getX(), e.getY())));
                }
              
                fiered = true;
            }
        }
      
        if(projectiles == null || projectiles.isEmpty())
        {
            return;
        }
      
        for(Projectile e : projectiles)
        {
            e.update(delta, this.entites);
        }
    }
  
    public void draw(Frame f)
    {
        if(projectiles == null || projectiles.size() == 0)
        {
            return;
        }
      
        for(Projectile e : projectiles)
        {
            e.draw(f);
        }      
    }
  
}
```

Projectile.java


```
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package com.fourthfloorproductions.TowerDefense.Projectile;

import com.fourthfloorproductions.TowerDefense.Engine.Frame;
import com.fourthfloorproductions.TowerDefense.Engine.FrameImage;
import com.fourthfloorproductions.TowerDefense.Entity.Entity;
import java.util.ArrayList;
import org.newdawn.slick.geom.Point;
import org.newdawn.slick.geom.Vector2f;

/**
*
* @author Gerredtor
*/
public class Projectile {
  
    private Vector2f pos;
    private Vector2f speed;
    private FrameImage image;
    private Entity e;
    private float lastX;
    private float lastY;
    private int ListID;
  
    public Projectile(ArrayList<Entity> entites, Entity e, Vector2f pos, Vector2f speed) {
        this.pos = pos;
        this.speed = speed;
      
        this.image = new FrameImage("src/res/Downloads.png",20,20);
      
        ListID = entites.indexOf(e);
      
        this.speed.setTheta(getAngle(new Point(e.getX(), e.getY())));
    }
  
    public final float getAngle(Point target) {
        float angle = (float) Math.toDegrees(Math.atan2(target.getY() - pos.getY(), target.getX() - pos.getX()));

        if(angle < 0){
            angle += 360;
        }

        return angle;
    }
  
    public void update(int delta, ArrayList<Entity> entites)
    {
      
        lastX = pos.getX();
        lastY = pos.getY();
      
        e = entites.get(ListID);
              
        speed = new Vector2f(e.getVector());
        this.speed.setTheta(getAngle(new Point(e.getX(), e.getY())));
      
        Vector2f realSpeed = speed;
        realSpeed.normalise();
        realSpeed.scale(0.4f*delta);

        pos.add(realSpeed);
    }
  
    public void draw(Frame f)
    {
        f.drawImage(image, pos.getX(), pos.getX());
    }
  
  
  
}
```


----------



## Major_Sauce (24. Nov 2016)

Ich muss sagen ich kenne mich nicht unbeding mit LWJGL oder Slick aus, daher gebe ich hierzu mal kein Statement ab.
Generell ist mir aber etwas aufgefallen:
Du hast einen Vektor der "pos" heißt. Wenn du dir mal die Definition von "Vektor" anschaust, wirst du relativ schnell rausfinden dass ein Vektor frei im Raum beweglich ist, ein Vektor besitzt normalerweise keine Position, nur eine Richtung.


----------



## InfectedBytes (24. Nov 2016)

Major_Sauce hat gesagt.:


> Du hast einen Vektor der "pos" heißt. Wenn du dir mal die Definition von "Vektor" anschaust, wirst du relativ schnell rausfinden dass ein Vektor frei im Raum beweglich ist, ein Vektor besitzt normalerweise keine Position, nur eine Richtung.


Bei Game Frameworks/Engines sind Vektoren typischerweise nichts weiter als einfache Bündel aus x/y/z/... Komponenten und werden immer sowohl für Positionen, Richtungen, Geschwindigkeiten, etc. verwendet. Es gibt also keine Unterscheidung in Ortsvektoren und Richtungsvektoren.


----------

