Hi tishan, thanks,

i´m looking at the two dimensional array at http://processing.org/learning/, the atracctor in nature code at http://www.shiffman.net/teaching/nature/forces/ , and the attraccion/repulsion at http://openprocessing.org/sketch/18798. And i have been trying to mix all of them in a grid but i´m kind of confused.



my equation for the potetial field is

Attracction force is = gravity * ((xsource - xtarget), (ysource - ytarget)
repulsion force is= repulsionForce* (( 1/sqrt (xsource - xobstacle)^2 + (ysource - yobstacle)^2) - 1/range of repulsion forces)

and the information that i need to put inside each part of tha greed is:  Attraction force + repulsion force / sqrt (Attraction force^2 + repulsion force^2)

Then i need to add a moving object  that´s attracted by a megnetic force.

These are my advances:

/* potentia fields
by: Joaku de Sotavento
 */

//const
Froces[][]  _forcesArray; //const of the equation
int _forcesSize = 10;



int rangeD1; //const of the equation
int gravity;
int rangeDo;
int repulsionN;

void setup() {
  size (800, 600); //size
  smooth();
  noStroke();
  background(255);
 
// im stop in this part
  //fill forces array with forces
 for (int i = 0; i < _forces.length; i++) {
  for (int j = 0; j < _froces.length; j++) {
    forces[i][j] = new Froces ();

  }
}
 
}

void draw(){
  frameRate (24);

 
}

///////////////////////////////////////////////////////////////////Froces
class Froces{

 PVector loc; //location vector
  PVector vel; //velocity vector
  PVector acc; //acceleration vector
  int sz;  //size of particle
  float gravity;  //gravity variable
  int rangeDo;  //range of repulsion force
  int velocityLimit = 10;  //the maximum velocity a particle can travel at
  float d;  //distance variable between particle and the target co-ordinates
 
  //constructor
 

 
}

//thanks for all.

Thanks asimes,

is really good have a digital support.

My question for you are the same that i hade made to tishan if you have some idea, please tell me.

Hey thanks, im reading the objects part, by other way u could mix the grid and the objects but, how i store the potential nodes in that grid?

please look at and tell me what you thing, i dont know if i´m working at wring way.

// sistema de atraccion
//int num = 1; //how many particles we'll have in the system. More particles = slower sketch.
//Particle[] particle = new Particle[num]; //Initialise array of particles of length "num"
//

Cell[][] _cellArray;
int _cellSize = 20;
int _numX, _numY;

//las cosntantes de los campor de repuslion y atraccion
int margenD1; //constantes de las ecuaciones de los campos potenciales
int necesidadE1;
int campoDo;
int repulsionN;

// el objeto y el atractor
Thing t;
Attractor a;
boolean showVectors = true;
void setup() {
  size(800, 600);
 
  // del sistema de atraccion
   smooth();  //turn on anti-aliasing
  noStroke();
  background(255);
 
  //vector de lu
PVector ac = new PVector(0.0,0.0);
  PVector ve = new PVector(0.0,1.0);
  PVector lo = new PVector(50,50);
 // Create new thing with some initial settings
  t = new Thing(ac,ve,lo,10);
  // Create an attractive body
  a = new Attractor(new PVector(width/2,height/2),20,0.4);
  _numX = floor(width/_cellSize);
  _numY = floor(height/_cellSize);
 matriz();

}

void matriz() {
  _cellArray = new Cell[_numX][_numY];
  for (int x = 0; x<_numX; x++) {
    for (int y = 0; y<_numY; y++) {
      Cell newCell = new Cell(x, y);
      _cellArray[x][y] = newCell;
    }
  }
}

void draw() {
  background(200);
  for (int x = 0; x < _numX; x++) {
    for (int y = 0; y < _numY; y++) {
     
    }
  }
  translate(_cellSize/2, _cellSize/2);
  for (int x = 0; x < _numX; x++) {
    for (int y = 0; y < _numY; y++) {
      _cellArray[x][y].drawMe();
    }
  }
 
a.rollover(mouseX,mouseY);
  a.go();

  // Calculate a force exerted by "attractor" on "thing"
  PVector f = a.calcGravForce(t);
  // Apply that force to the thing
  t.applyForce(f);
  // Update and render the positions of both objects
  t.go();

}

void mousePressed() {
  a.clicked(mouseX,mouseY);
}

void mouseReleased() {
  a.stopDragging();
}

void keyPressed() {
  showVectors = !showVectors;
}

// Renders a vector object 'v' as an arrow and a location 'loc'
void drawVector(PVector v, PVector loc, float scayl) {
  if (v.mag() > 0.0) {
    pushMatrix();
    float arrowsize = 4;
    // Translate to location to render vector
    translate(loc.x,loc.y);
    stroke(0);
    // Call vector heading function to get direction (note that pointing up is a heading of 0) and rotate
    rotate(v.heading2D());
    // Calculate length of vector & scale it to be bigger or smaller if necessary
    float len = v.mag()*scayl;
    // Draw three lines to make an arrow (draw pointing up since we've rotate to the proper direction)
    line(0,0,len,0);
    line(len,0,len-arrowsize,+arrowsize/2);
    line(len,0,len-arrowsize,-arrowsize/2);
    popMatrix();
  }
}


// Attraction
// Daniel Shiffman < http://www.shiffman.net>

// A class for a draggable attractive body in our world

class Attractor {
  float mass;    // Mass, tied to size
  float G;       // Gravitational Constant
  PVector loc;   // Location
  boolean dragging = false; // Is the object being dragged?
  boolean rollover = false; // Is the mouse over the ellipse?
  PVector drag;  // holds the offset for when object is clicked on

  Attractor(PVector l_,float m_, float g_) {
    loc = l_.get();
    mass = m_;
    G = g_;
    drag = new PVector(0.0,0.0);
  }

  void go() {
    render();
    drag();
  }

  PVector calcGravForce(Thing t) {
    PVector dir = PVector.sub(loc,t.getLoc());        // Calculate direction of force
    float d = dir.mag();                              // Distance between objects
    d = constrain(d,5.0,25.0);                        // Limiting the distance to eliminate "extreme" results for very close or very far objects
    dir.normalize();                                  // Normalize vector (distance doesn't matter here, we just want this vector for direction)
    float force = (G * mass * t.getMass()) / (d * d); // Calculate gravitional force magnitude
    dir.mult(force);                                  // Get force vector --> magnitude * direction
    return dir;
  }

  // Method to display
  void render() {
    ellipseMode(CENTER);
    stroke(0);
    if (dragging) fill (50);
    else if (rollover) fill(100);
    else fill(175,200);
    ellipse(loc.x,loc.y,mass*2,mass*2);
  }

  // The methods below are for mouse interaction
  void clicked(int mx, int my) {
    float d = dist(mx,my,loc.x,loc.y);
    if (d < mass) {
      dragging = true;
      drag.x = loc.x-mx;
      drag.y = loc.y-my;
    }
  }

  void rollover(int mx, int my) {
    float d = dist(mx,my,loc.x,loc.y);
    if (d < mass) {
      rollover = true;
    } else {
      rollover = false;
    }
  }

  void stopDragging() {
    dragging = false;
  }
 
 

  void drag() {
    if (dragging) {
      loc.x = mouseX + drag.x;
      loc.y = mouseY + drag.y;
    }
  }

}


// Attraction
// Daniel Shiffman < http://www.shiffman.net>

// A class to describe a thing in our world, has vectors for location, velocity, and acceleration
// Also includes scalar values for mass, maximum velocity, and elasticity

class Thing {
  PVector loc;
  PVector vel;
  PVector acc;
  float mass;
  float max_vel;
  float bounce = 1.0; // How "elastic" is the object
   
  Thing(PVector a, PVector v, PVector l, float m_) {
    acc = a.get();
    vel = v.get();
    loc = l.get();
    mass = m_;
    max_vel = 20.0;
  }
 
  PVector getLoc() {
    return loc;
  }

  PVector getVel() {
    return vel;
  }
  float getMass() {
    return mass;
  }

  void applyForce(PVector force) {
    force.div(mass);
    acc.add(force);
    if (showVectors) {
      drawVector(force,loc,1000);
    }   
  }

  // Main method to operate object
  void go() {
    update();
    render();
  }
 
  // Method to update location
  void update() {
    vel.add(acc);
    vel.limit(max_vel);
    loc.add(vel);
    // Multiplying by 0 sets the all the components to 0
    acc.mult(0);
  }
 
  // Method to display
  void render() {
    ellipseMode(CENTER);
    stroke(0);
    fill(175,100);
    ellipse(loc.x,loc.y,mass*2,mass*2);
    if (showVectors) {
      drawVector(vel,loc,20);
    }
  }
}


//================================= the grid
class Cell {
  float x, y;
  Cell(float ex, float why) {
    x = ex * _cellSize;
    y = why * _cellSize;
  }
    void drawMe() {
    stroke(0);
    fill(255);
    fill(255);
    rect(x, y, _cellSize, _cellSize);
  }
}

im building since the begining the code follow the object tutorial,

dont worry in fact, i will update the code with your sugestions.

the work looks clearly now

i´ll continue working and tay to construct the grid too.

Thanks keep in touch

now i finish the grid and the neutral ball, some idea about how can translate my equations at

1. Class PotentialNode{
2. float charge;
3. //to do methods
4. }

i´m reading the PVector http://www.processing.org/learning/pvector/  part of tutorial

please more help

Hellow Tishan, i have been working, i review the part of PVector and almost finish the code thanks to you to, the conclusion i earlier close

a frien of my helpme with the equations and i tried to imitate te form to one las equation but, by an unknow reason for my this part didn run.

if you could please take a look of it.

1. //this is the method for the atracction force between the destini and the robot or ball
   
2. PVector atraccion(Robot r, Attractor att){
       float d = dist(r.loc.x, r.loc.y, att.loc.x, att.loc.y); //this part is the distance between the robot and the destiny
       float fatx = 0;
       float faty = 0;
       if (d  <= r.deI){
         fatx = att.E * (r.loc.x - att.loc.x);
         faty = att.E * (r.loc.y - att.loc.y);
       } else{
         fatx = att.E * (r.loc.x - att.loc.x)/d;
         faty = att.E * (r.loc.y - att.loc.y)/d;
       }
       return new PVector(fatx,faty);
     }
    
    // this is the method bay the repulsive forces of the obstacle whit the component x and y, and multiple //obstacle
     PVector repulsion(Robot r, Obstacle[] obs){
      float d = 0;
      float rep = 0;
      float frepx = 0;
      float frepy = 0;
      
       for ( int i = 0; i < obs.length; i++){
          d = dist(r.loc.x, r.loc.y, obs[i].loc.x, obs[i].loc.y);
         if ( d <= obs[i].rangoO){
           rep = (-(obs[i].N) * ((1/d)- 1/obs[i].rangoO))/( sqrt(pow(pow((r.loc.x - obs[i].loc.x),2) + pow((r.loc.y - obs[i].loc.y),2),3)) );
          
         }else{
           rep = 0;
         }
         frepx = rep * (r.loc.x - obs[i].loc.x);
         frepy = rep * (r.loc.y - obs[i].loc.y);
       }
      return new PVector (frepx, frepy);
     }
    
     /////// this is the part where i´m stoping, i cant see what is wrong.
    
     PVector fuerzaT (Robot r, Attractor att, Obstacle[] obs){
          
      float fTotalx = ( (fatx + frepx) / (sqrt((pow(fatx)2)+(pow(frepx)2)));
      float fTotaly = ( (faty + frepy) / (sqrt((pow(faty)2)+(pow(frepy)2)));
      
       return new PVector fTotalx;
       return new PVector fTotaly;
     }