Im getting side of the rectangle correct in and are always 90 degrees but the scaling of the width is not correct and cant really figure out how to solve that.

Any hint?

void setup() {
  size(500, 500, P2D); 
  background(255);
  //noCursor();
}

void draw() {
  background(255);
  gradientRectangle(); 
}

void gradientRectangle() {
  int rectWidth = 25; 
  float x1 = mouseX;
  float y1 = mouseY;
  float x2 = 250;
  float y2 = 250;
  color from = color(255, 0, 0);
  color to = color(0);

  // calculate the theta
  float adjecent = x2-x1;
  float opposite = y2-y1;

  float tanValue = opposite / adjecent;
  float theta = atan(tanValue); // in radians
  float angle = degrees(theta); // in degrees
  println("theta: "+ theta + " tanValue " + tanValue + " angle: " + angle);

  // calculate the change of the side of the second triangle
  float opposite2 = tan(theta) * rectWidth;
  println("opposite2: " + opposite2);

  // draw the shape
  beginShape();
  noStroke();  
  strokeWeight(5);

  fill(from);   
  vertex(x2, y2);  // övre till höger
  fill(to);
  vertex(x1, y1); // övre vänstra
  fill(to);
  vertex(x1+opposite2, y1-rectWidth); // undre vänstra
  fill(from);
  vertex(x2+opposite2, y2-rectWidth); // undre till höger
  endShape();
}

Heres the draw and setup

Player p;
int x = 100;
int y = 100;
int grids = 100;
int enemyCount = 1;
int bulletCount = 1;

float dEnemy;

boolean wait;
boolean isLeft, isRight, isUp, isDown;

ArrayList shootBullet = new ArrayList();
ArrayList enemies = new ArrayList();

void setup() {
  //fullScreen(P3D);
  size(750, 500, P3D);
  p = new Player();

  for(int i = 0; i < 2; i++) {
    enemies.add(new enemy());
  }
}

void draw() {
  background(100);
  stroke(255);

  for(int i = 0; i < 41; i++) {
    line(0 + (i * 100), 0, 0 + (i * 100), 4000);
  }

  for(int i = 0; i < 41; i++) {
    line(0, 0 + (i * 100), 4000, 0 + (i * 100));
  }


  if(mousePressed && wait == false) {
    for(int i = 0; i < bulletCount; i++) {
      wait = true;
      shootBullet.add(new shoot());
    }
  } else {
    if(mousePressed == false) {
      wait = false;
    }
  }

  for(int i = 0; i < shootBullet.size(); i++) {    
    shoot s = (shoot) shootBullet.get(i);
    s.display();
  }

  for(int i = 0; i < enemies.size(); i++) {
    enemy e = (enemy) enemies.get(i);
    e.display();
  }

  p.display();
  p.movement();
}

void keyPressed() {
  setMove(keyCode, true);
}

void keyReleased() {
  setMove(keyCode, false);
}

boolean setMove(int k, boolean b) {
  switch (k) {
    case UP:
    return isUp = b;

    case DOWN:
    return isDown = b;

    case LEFT:
    return isLeft = b;

    case RIGHT:
    return isRight = b;

    default:
    return b;
  }
}

Heres my Enemy class (The one that I want to check intersection between the enemies so they stop moving when they hit Eachother)

class enemy {
  PVector location;
  PVector velocity;
  float a;
  float speed = random(1, 10);
  float r = 50;
  float dPlayer;

  enemy() {
    location = new PVector(random(0, 4000), random(0, 4000));
    velocity = new PVector();
  }

  void display() {
    a = atan2(p.location.y - location.y, p.location.x - location.x);
    dPlayer = dist(location.x, location.y, p.location.x, p.location.y);

    velocity.x = cos(a);
    velocity.y = sin(a);

    velocity.x *= speed;
    velocity.y *= speed;

    if(dPlayer >= p.r) {
      location.x = location.x + velocity.x;
      location.y = location.y + velocity.y;
    }

    ellipse(location.x, location.y, r, r);
  }
}

Heres my Player class

class Player {
  PVector location;
  PVector velocity;
  float frict = 0.96;
  int r = 50;

  Player() {
    location = new PVector(2000, 2000);
    velocity = new PVector(0, 0);
  }

  void display() {
    //pushMatrix();
    colorMode(RGB);
    fill(255);
    camera(location.x, location.y, (height/2.0) / tan(PI*30.0 / 180.0), location.x, location.y, 0, 0, 1, 0); 
    ellipse(location.x, location.y, r, 50r);
    //popMatrix();
  }

  void movement() {
    location.x = location.x + velocity.x; 
    location.y = location.y + velocity.y;
    if (isLeft) velocity.x = velocity.x - frict/2;
    if (isRight) velocity.x = velocity.x + frict/2;
    if (isDown) velocity.y = velocity.y + frict/2;
    if (isUp) velocity.y  = velocity.y - frict/2;
    velocity.y = velocity.y * frict;
    velocity.x = velocity.x * frict;
    velocity.x = constrain(velocity.x, -5, 5);
    velocity.y = constrain(velocity.y, -5, 5);
  }
}

Heres my Shoot class

class shoot {
  PVector velocity;
  PVector location;

  shoot() {
    velocity = new PVector();
    location = new PVector();
    location.x = p.location.x;
    location.y = p.location.y;
    float a = atan2(mouseY - height/2, mouseX - width/2);
    velocity.x = cos(a);
    velocity.y = sin(a);
    velocity.x *= 10;
    velocity.y *= 10;
  }

  void display() {
    println(mouseY - height/2);
    println(mouseX - height/2);
    location.x += velocity.x;
    location.y += velocity.y;
    ellipse(location.x, location.y, 10, 10);
  }
}

Calculates the angle (in radians) from a specified point to the coordinate origin as measured from the positive x-axis.

However, I would like to calculate the angle between a set of points other than the origin. Is there any way to do this, and if so, can I get a pointer towards the right track? Thanks in advance! :)

Here is my code

PImage biker;

int x = 100;
int y = 100;

void setup()
{
  size(1500,1000);
}


void draw()
{
  background(0);
  biker = loadImage("biker.png");

  bikerMovement();
  bikerThrowKnife();
}


void bikerMovement()
{

  rotate(atan2(mouseY-y,mouseX-x));
  image(biker, x, y);



}

void bikerThrowKnife()
{





}


void keyPressed()
{

  if(key == 'w')
  {

    y-=7;

  }
  else if(key == 'w' && key == 'a')
  {

    x-=7;
    y-=7;
  }



  if(key == 's')
  {

    y+=7;

  }
  if(key == 'a')
  {

    x-=7;

  }
  if(key == 'd')
  {

    x+=7;

  }

}

There’s a PImage which has to follow the coordinates of the mouse, without moving. This gif is pretty much what i’d like to do

Could anyone help me out? also, I've attached the code below

int x, y;
float current_ship;
float target_ship;

void setup() { 
  fullScreen(); 
  ellipseMode(CENTER); 
} 


void draw() { 
  background(255); 
  ellipse(width/2, height/2, 200, 200); 

  target_ship = atan2(mouseY - height/2, mouseX - width/2);

  if(target_ship > current_ship) current_ship += 0.05;
  if(target_ship < current_ship) current_ship -= 0.05;

  x = int(width/2+165*cos(current_ship)); 
  y = int(height/2+165*sin(current_ship)); 

  pushMatrix(); 
  translate(x, y); 
  rotate(atan2( mouseY - height/2, mouseX - width/2)-PI/2); 
  triangle(-30, -10, 0, +50, +30, -10); 
  popMatrix(); 
} 

the added code for arcs is below

`// Calculate the angle the current point makes with the circle center int angle = (int) degrees(atan2(y, x)); //int(degrees(atan2(mouseY-(height/2),mouseX-(width/2))));

// draw the circle points as long as they lie in the range specified if (x < y) {

// draw point in range 0 to 45 degrees
if ( -90 + angle >= startAngle &&  -90 + angle <= endAngle) {
  point(centerX + y, centerY - x);
}

//// draw point in range 45 to 90 degrees
if (-angle >= startAngle && -angle <= endAngle) {
  point(centerX + x, centerY - y);
}

//// draw point in range 90 to 135 degrees
if (-180 + angle >= startAngle && -180 + angle <= endAngle) {
  point(centerX - x, centerY - y);
}

//// draw point in range 135 to 180 degrees
if ((-90 + -angle >= (startAngle) && -90 + -angle <= (endAngle))) {
  point(centerX - y, centerY - x);
}

// draw point in range 180 to 225 degrees
if (90 + (angle) >= (startAngle) && 90 + (angle) <= (endAngle)) {
  point(centerX - y, centerY + x);

  System.out.println("angle " + (90 + (angle)));
}

// draw point in range 225 to 270 degrees
if (180 + -angle >= startAngle && 180 + -angle <= endAngle) {
  point(centerX - x, centerY + y);
}

// draw point in range 270 to 315 degrees
if (angle >= startAngle && angle <= endAngle) {
  point(centerX + x, centerY + y);
}

// draw point in range 315 to 360 degrees
if (-angle + 90 >= startAngle && -angle + 90 <= endAngle) {
  point(centerX + y, centerY + x);
}

} } `

I have tried placing the rotate command before the scale command, and that seems to do the trick, although the dimensions of the rectangle are wrong whenever the window is stretched horizontally or vertically.

If anyone could shed some light on why the line is offset, I would greatly appreciate it.

void draw() {
  background(255);
  translate(width/2, height/2);

  float scaleX = width / 1280.0;
  float scaleY = height / 800.0;

  scale(scaleX, scaleY);
  rotate(atan2((mouseY - height/2), mouseX - width/2));
  rect(-40, -20, 80, 40);
  line(0, 0, 500, 0);
}

Example 1 Example 2

I have a problem with a sketch in witch I need to make some cubes face a certain coordinate in P3D it works for the Z axis just like 2D with atan2() but when it comes to the X and Y axis it doesn't work :/

here is the code I have for now:

import peasy.*;

PeasyCam cam;


float x;
float y;
float z;

void setup() {
  size(500,500,P3D);
  cam = new PeasyCam(this, 100);
}

void draw() {
  background(50);

  //the angles
  float angleZ = atan2(-x,y); //-x,y
  float angleX = atan2(0,z);
  float angleY = atan2(-z,x);

  //Cube that need to face the target
  pushMatrix();
  rotateZ(angleZ);
  rotateX(angleX);
  //rotateY(angleY);
  translate(0,0,0);
  box(100);
  line(0,0,0,0,1000,0);
  popMatrix();

  //Cube that need to face the target
  pushMatrix();
  translate(1000,1000,1000);
  rotateZ(atan2(-x+1000,y-1000));
  //rotateX(atan2(y+100,-z-100));
  box(100);
  line(0,0,0,0,1000,0);
  popMatrix();

  //to control the little cube (target)
  if(keyPressed) {
   if(keyCode==UP) {
      y+=4;
    }
    if(keyCode==DOWN) {
      y-=4;
    }
    if(keyCode==LEFT) {
      x+=4;
    }
    if(keyCode==RIGHT) {
      x-=4;
    }
    if(key==' ') {
      z+=4;
    }
    if(keyCode==SHIFT) {
      z-=4;
    }
  }

  //little cube (taget)
  pushMatrix();
  translate(x,y,z);
  box(50);
  popMatrix();
}

I used the peasyCam so its easier to see and control

float x,y,z are the targets to face, you can control them with Arrows Space and Shift

thanks !

        point1x = pos_1.x+(pos_2.x-pos_1.x)/4*3;
        point1y = pos_1.y+(pos_2.y-pos_1.y)/4*3;
        var toy = point1y;
        var fromy = pos_1.y;
        var tox = point1x;
        var fromx = pos_1.x;

        var angle = Math.atan2(toy-fromy,tox-fromx);

        var pointBx = tox-(headlen+30)*Math.cos(angle+Math.PI/6);
        var pointBy = toy-(headlen+30)*Math.sin(angle+Math.PI/6);

        var point2x = tox-headlen*Math.cos(angle-Math.PI/6);
        var point2y = toy-headlen*Math.sin(angle-Math.PI/6);
        var point3x = tox-headlen*Math.cos(angle+Math.PI/6);
        var point3y = toy-headlen*Math.sin(angle+Math.PI/6);

        noFill();
        bezier(pos_1.x, pos_1.y, pointBx,  pointBy, point3x, point3y, pos_2.x, pos_2.y);
        stroke(myColor);
        strokeWeight(weight);
        line(pos_1.x, pos_1.y, pos_2.x, pos_2.y);

        fill(myColor);
        triangle(point1x, point1y, point2x, point2y, point3x, point3y);

arc(x1, y1, w1, h1, start1, stop1, PIE);
arc(x2, y2, w2, h2, start2, stop2, PIE);

... and I'd like to find out before I draw them if the arcs intersect/overlap/share pixels (using these terms synonymously). It's not enough to check the two ellipses because the ellipses can overlap long before the arcs overlap.

Would prefer some nice elegant math, but I do have one duct-tape idea:
Draw both arcs to some kind of off screen buffer using semi-transparent fill colors, then scan the buffer for pixels colored to reflect an overlap. Big buffer, so probably check the ellipses first, then just check pixels within the ellipses somehow.

Very grateful for any suggestions!

"ClassCastException: processing.core.PGraphics3D cannot be cast to processing.opengl.PGraphicsOpenGL"

Any help please????

/* OpenProcessing Tweak of *@*http://www.openprocessing.org/sketch/6742*@* */
/* !do not delete the line above, required for linking your tweak if you upload again */

      ////////////////////////////
      //                        //
      //        doodle 3        //
      //                        //
      ////////////////////////////

      // (c) Martin Schneider 2009
      import codeanticode.syphon.*;
      PGraphics canvas;
    SyphonServer server;

    int n = 1000;
    int maxage = 20;
    int rdodge = 30;
    int opacity = 40;
    float speed = .2;
    float zoom = .01;
    boolean crayons, soft, dodge = true;

    float[][] a = new float[n][2];
    int[] age = new int[n];
    float w, h, s;
    int t, c;


    void setup() {
      size(500, 500,P3D);
      canvas = createGraphics(500, 500, P3D);
        // Create syhpon server to send frames out.
    server = new SyphonServer(this, "Processing Syphon");
      w = width/2;
      h = height/2;
      colorMode(HSB, TWO_PI, 2, 1);
      smooth();
      reset();

    }


    void draw() {
      canvas.beginDraw();
      // create new particles
      int np = n / maxage;
      for(int i=0; i<np & c<n; i++, c++) newp(c);
      // draw particle traces
      for(int i=0; i<c; i++) {
        age[i]++;
        float[] p = a[i];
        if (age[i] > maxage) newp(i);
        else {
          float[] f = f(p[0], p[1]);     
          // opacity based on speed (soft mode) or age (hard mode) 
          int m = maxage/2;
          float o = soft ? mag(f[0], f[1]) * 2 * opacity : (m - abs(m - age[i])) * opacity/m;
          // hue based on direction
          float h =  atan2(f[0], f[1]) + PI;   
          canvas.stroke(h, crayons ? 1 : 0, crayons ? 1 : 0, o); 
          // draw line while updating position
          canvas.line(p[0], p[1], p[0] += s*f[0],  p[1] += s*f[1]);
        }
      }
      canvas.endDraw();
      image(canvas, 0, 0);
      server.sendImage(canvas);
    }


    // noise based flow field
    float[] f(float x, float y) {;
      return new float[] {
        noise(t, x * zoom, y * zoom)-.5,
        noise(t+1, x * zoom, y * zoom) - .5
      };
    }


    void newp(int p) {
      if(dodge) { 
        // particle inside a circle around the mouse position
        float r = random(rdodge), ang = random(TWO_PI);
        a[p] = new float[] { mouseX + r * cos(ang), mouseY + r *sin(ang) };  
      } else {  
        // particle anywhere on screen
        a[p] = new float[] { random(width), random(height) };
      }
      age[p] = 0;
    }


    void reset() {
      canvas.background(crayons ? 0 : #ffffff);
      s = speed / zoom;
      c = 0;
    }


    void keyPressed() { 
      switch(key) {
        case 's' : soft = !soft; break;
        case 'd' : dodge = !dodge; break;
        case 'f' : t++; break;
        case 'c' : crayons = !crayons; break;
        case '+' : zoom /= 1.1; break;
        case '-' : zoom *= 1.1; break;
        case ' ' : break;
        default: return;
      } 
      reset();
    }

Code:

var rectArray = [];

var mouseVector;

function setup() {
  createCanvas(windowWidth,windowHeight);

  for (i = 0;i < 100; i++) {
  rectArray.push(new Square(10*i,40));
  }
}

function draw() {

  for (i = 0; i < rectArray.length; i++) {
    rectArray[i].rotation();
    rectArray[i].update();
    rectArray[i].display();
  }

}

function Square(x,y) {
  this.x = x;
  this.y = y;
  this.size = 20;
  this.color = color(200);
  this.target = 0;
  this.rotationValue = 0;

  this.rotation = function() {
    push();
    translate(this.x,this.y);
    mouseVector = createVector(mouseX,mouseY);
    this.target = mouseVector.heading();
    this.rotationValue = this.target;
    pop();
  }

  this.update = function() {
    //this.x = this.x + 1;
  }

  this.display = function() {
    push();
    translate(this.x,this.y);
    rectMode(CENTER);
    rotate(this.rotationValue);
    fill(this.color);
    rect(0,0,this.size,this.size);
    pop();
  }
}

I can do this for quarter squares by saying if (mouseX < 300 & mouseY < 300) { rect ... }

but am unable to work out how to define the triangle from two corners to the centre - shown in my sketch as coloured red.

void draw() {
  background(145,180,70);

  if (mouseX < 300 & mouseY < 300) {
    triangle(0, 0, 0,600, 300,300); // Left
    fill(190,75,90);
    }

    if (mouseX > 300 & mouseY > 300){
    triangle(300, 300, 600,600, 600,0); // Left
    fill(190,75,90); // Right
  }
}

Can anyone point me in the right direction?

So, i tried converting radians to angles, constrain degrees and convert to radians again. But the result is the same.

a = radians(constrain(degrees(a), 90, 270));

Any clue?

I have tried to make a programm where a red cirlce (the leader as I call it) moves to the mouse position. Additionally to that several small traingles are supposed to follow the leader to a certain point next to the leader, which functions as I wanted but I tried to make the triangles point in the direction where they are heading. But i didnt manage to achieve that so i wanted to ask if someone can help me with that. Here is the follower class:

    class Follower
    {

      PVector followerSupposedPos = new PVector();            //Position of the follower which it should reach
      PVector followerPos         = new PVector();            // actual position of the follower
      PVector distance            = new PVector();            //distance (magnitude will be changed) between the followerPos and  followerSupposedPos
      PVector preFollower         = new PVector();            //position of the follower next to it(left)
      PVector leaderPos           = new PVector();            // position of the leader
      PVector realDistance        = new PVector();            //the real distance between the followerPos and  followerSupposedPos

      boolean numberOne;

      float speed;

      float angle;

      Follower(float speed_)
      {
        speed = speed_;
      }

      void run(PVector leaderPos_, boolean numberOne_, PVector preFollower_)
      {
        preFollower = preFollower_;
        numberOne   = numberOne_;
        leaderPos   = leaderPos_;

        if (numberOne_ == true)
        {
          followerSupposedPos.x = leaderPos.x - 100;
          followerSupposedPos.y = leaderPos.y + 20;
          fill(200, 100, 50);
        } else if (numberOne_ == false)
        {
          followerSupposedPos.x = preFollower.x + 13;
          followerSupposedPos.y = preFollower.y;
        }

        //points(); //the direction the follower points

        display();

        move();

      }


      PVector impart()  // needed for the preFollower position
      {
        return followerSupposedPos;
      }

      void display()
      {      
        fill(255, 0, 0, 100);
        ellipse(followerPos.x, followerPos.y, 5, 5);
        fill(200, 150, 10);
        triangle(followerPos.x, followerPos.y, followerPos.x - 5, 
        followerPos.y + 10, followerPos.x+ 5, followerPos.y + 10);
      }

      void move()
      {
        PVector distancePrint = new PVector(distance.x * 1000, distance.y * 1000);

        realDistance.x = followerSupposedPos.x - followerPos.x;
        realDistance.y = followerSupposedPos.y - followerPos.y;

        distance.x = realDistance.x * 0.007;
        distance.y = realDistance.y * 0.007;


        if (realDistance.mag() >= 4)
        {
          distance.setMag(5);

          followerPos.x += distance.x + speed;
          followerPos.y += distance.y + speed;
        } else
        {
          distance.setMag(0);
        }

        println(realDistance.mag());
      }

      void points()
      {
        angle = atan2(realDistance.y, realDistance.x);
      }

    }

and a programm where I managed to make a triangle point at the mouse without moving (didnt work in the programm above) :

float angle;
PVector d = new PVector();


void draw()
{  
  background(0);

  translate(width/2, height/2);

  d.x = mouseX - width/2;
  d.y = mouseY - height/2;

  angle = atan2(d.y, d.x);



  triangle_(angle);
}

void triangle_(float ang)
{
  pushMatrix();

  rotate(ang);
  triangle(0, 0, -50, -20, - 50, 20);
  popMatrix();
}

does somebody know how I can connect these two programms or a another way to achieve what i what?

I'd like to be able to display the relative degree position of the joystick cursor, such at at the top of the screen it would show 0 degrees, when in the 3 o'clock position it would be 90 degree, and 6 o'clock would show 180 degrees and a 9 o'clock it would show 270... and so on. I guess the max would be 359 deg after which the bearing would become 0 again. This is relative to the center of the screen, so the Y portion (width) should have no effect on the reading.

I suspect this is fairly trivial to do, but as a Processing noob, my best efforts have failed!

As last, the calculations should be fast! I tried some things with the cross and dot product but not sure if that is the right way to go.

Hope someone can help.

Here some code to get started, with my attempts removed.

PVector a, b, c;

void setup() {
  size(600, 600);

  a = new PVector(50, 50);
  b = new PVector(width/2, height/2);
  c = new PVector();

}

void draw() {
  c.set(mouseX, mouseY);

  background(0);
  beginShape();
  stroke(255);
  noFill();
  vertex(a.x, a.y);
  vertex(b.x, b.y);
  vertex(c.x, c.y);
  endShape();

  // magic...


}

So 0 stays 0. 11 becomes 1, 6 becomes 2, 10 becomes 3 etc. In other words, if the line would move clockwise then they get numbered in that order.

I have no idea how to make a Comparator for that. I hope someone can help.

O yeah, if you want to run you need eclipse or IntelliJ cause Processing will give a scope problem.

import processing.core.PApplet;
import processing.core.PVector;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;


public class CompareToAngle extends PApplet {

     public static void main(String[] args) {
         PApplet.main("CompareToAngle", args);
     }


    public void settings() {
        size(1024, 1024);

    }

    public void setup() {

    }


    public void draw() {
        background(255);

        PVector a = new PVector(width/2, height/2);
        PVector b = new PVector(mouseX, mouseY);

        line(a.x, a.y, b.x, b.y);

        // compare against this angle!!
        // compare against this angle!!
        // compare against this angle!!
        // compare against this angle!!
        // compare against this angle!!
        float angle = atan2(b.y-a.y, b.x-a.x);

        fill(0);
        text(angle, b.x, b.y);

        ArrayList<PVector> vecs = new ArrayList<PVector>();

        randomSeed(1);
        for (int i = 0; i < 15; i++ ) {
            PVector v = new PVector(random(50, width-50), random(50, height-50));
            vecs.add(v);
        }

        Collections.sort(vecs, new Comparator<PVector>() {

            @Override
            public int compare(PVector o1, PVector o2) {

                float angleO1 = atan2(b.y-o1.y, b.x-o1.x);
                float angleO2 = atan2(b.y-o2.y, b.x-o2.x);

                if (angleO1 > angleO2) {
                    if (angleO1 > angle) {
                        return 1;
                    }
                    if (angleO1 < angle) {
                        return -1;
                    }
                }
                else if (angleO1 < angleO2) {
                    if (angleO2 > angle) {
                        return 1;
                    }
                    if (angleO2 < angle) {
                        return -1;
                    }

                }

                return 0;
            }
        });

        int c = 0;
        for (PVector v : vecs) {
            ellipse(v.x, v.y, 5, 5);
            text(c++, v.x+20, v.y);
        }





    }

}

atan2()

Calculates the angle (in radians) from a specified point to the coordinate origin as measured from the positive x-axis. Values are returned as a float in the range from PI to -PI. The atan2() function is most often used for orienting geometry to the position of the cursor. Note: The y-coordinate of the point is the first parameter, and the x-coordinate is the second parameter, due the the structure of calculating the tangent

atan()

The inverse of tan(), returns the arc tangent of a value. This function expects the values in the range of -Infinity to Infinity (exclusive) and values are returned in the range -PI/2 to PI/2

I'm not too sure what the real difference is here though. I get that atan2() is generally used instead of atan() for movement, and I've seen it work better, but I don't really understand why this is.

Can anyone explain further please?

thanks