 # How do I change the position of the circle in macroquad

MY code:

``````// Importing crate
use macroquad::*;

//NEED
#[macroquad::main("BasicShapes")]
async fn main() {
// loop is essential for program
// NEED
loop {
clear_background(RED);

const RHO: f64 = 28.0;
const BETA: f64 = 8.0/3.0;
const SIGMA: f64 = 10.0;

let color = BLACK;

let x = 0.0;
let y = 0.1;
let z = 0.0;

let mut dx_dt = SIGMA * (y - x);
let mut dy_dt = x * (RHO - z) - y;
let mut _dz_dt = x * y - BETA * z;

draw_circle((dx_dt as f32) + 100.0, (dy_dt as f32) + 50.0, 10.0, color);

//NEED
next_frame().await
}
}
``````

So I am working on a 2D implementation of the lorenz attractor using the macroquad library
But the problem is when the circle is drawn it just drawn once but I have to draw it a lot of times run the program yourself and you will see just `on` circle.

So what should I do

And if you are asking why I am making it in 2d is because macroquad doesn't has good options for 3D things so I did 2d.

``Help_me("please", 'P');``

You mean the circle isn’t moving? That’s because the position you calculate is the same every single frame. If you do something like—I don’t know—maybe `let x = get_time();` instead of `let x = 0.0`, then you’ll see that stuff is happening.

Your x, y, and z are the same each loop.
If you send a number into your loop, you can use that number to modify your x, y, or z.
As an example, the variable "i" sent into this loop is 1 the first loop, 2 the second loop, and so on. Then you can use the "i" inside the loop to change x, y, or z. I use 'i" do modify "x" below.

``````// Importing crate
use macroquad::*;

//NEED
#[macroquad::main("BasicShapes")]
async fn main() {
// loop is essential for program
// NEED
for i in 0..1_000_000 {
clear_background(RED);

const RHO: f64 = 28.0;
const BETA: f64 = 8.0 / 3.0;
const SIGMA: f64 = 10.0;

let color = BLACK;

let x = (i as f64 / 13.0).sin();
let y = 0.1;
let z = 0.0;

let mut dx_dt = SIGMA * (y - x);
let mut dy_dt = x * (RHO - z) - y;
let mut _dz_dt = x * y - BETA * z;

draw_circle((dx_dt as f32) + 100.0, (dy_dt as f32) + 50.0, 10.0, color);

//NEED
next_frame().await
}
}

``````

Oh no I meant that the circle stays at one position but I need many circles not move the singular circles but have plural circles

and is there any library made for animation??

I cam up with another code but that jut draws a damn line.

``````use macroquad::*;

fn canvas() -> Vec<i64>{
let mut can: Vec<i64> = Vec::new();
for i in 1..401 {
can.push(i)
}
return can;
}

fn code () -> Vec<[f64;3]>{

let mut x = 0.01;
let mut y = 0.0;
let mut z = 0.0;

let canv = canvas();
let sigma = 10.0;
let rho = 28.0;
let bet: f64 = 8.0 / 3.0;

// Lorenz equations

// let mut row = Vec::new();
let dx_dt = sigma * (y - x);
let dy_dt = x * (rho - z) - y;
let dz_dt = x * y - bet * z;

let mut res: Vec<[f64;3]> = Vec::new();
for i in 0..1301 {

x += dx_dt;
y+=dy_dt;
z+=dz_dt;
// derivatives as vec
res.push([x,y,z]);

}

res
}
//NEED
#[macroquad::main("BasicShapes")]
async fn main() {
// loop is essential for program
// NEED
clear_background(BLACK);
loop {
let lor = code();
for i in lor  {

let x = i;
let y = i;

draw_circle(x as f32 + 200.0, y as f32 + 100.0, 3.0,RED);

// println!("x: {}, y: {}",x,y);

}
//NEED
next_frame().await
}
}
``````

PLease tell me what is wrong

I haven't tested this code, but I would believe that your line is probably just a lot of circles arranged in a line with small offsets. I don't think that you have any problems with the library but instead that your code just doesn't produce the thing you want.

I haven't got the time to give any detailed advice right now, but you might want to look into how to solve differential equations numerically or what kind of Rust libraries/crates might already exist for this. As for existing crates, I've searched a bit and found for example this one - no idea how easy to use that is though.

hmmmmm ??