float k=800/600;
print(k);

After I run this code I get 1.0 instead of 1.333333. Why?

Hi, guys! I'm trying to recreate an old game. You need to move the player by pressing arrows on keyboard and move the blocks. But sometimes when one block falls on top of another and you try to push it aside - it doesn't fall to the ground.
When there are only 6 blocks it works fine, but when there are more of them this bug appears.
Functions that detect vertical collisions between blocks are named:

collisionDetection, BBcols, ybarCheck.

Thanks in advance!

1. Player player;

   Block[] block=new Block[10];

   int time=0;

   void setup() {

   size(300, 500);

   smooth();

   player=new Player();

   for (int i=0; i<block.length; i++) {

   block[i] = new Block();

   }

   }

   boolean jumped=false;

   void draw() {

   background(255);

   managePlayer();

   blockGenerator();

   collisionDetection();

   }

   void blockGenerator() {

   int i=0;

   for(int t=0; t<millis(); t+=2000){

   if(t/2000<block.length){

   block[i].fall();

   block[i].display();

   i++;

   }

   }

   }

   void collisionDetection() {

   for (int i=0; i<block.length; i++) {

   detectPBCollisions(player, block[i]);

   }

   for (int i=0; i<block.length; i++) {

   for (int j=0; j<block.length; j++) {

   BBcols(block[i], block[j], i);

   }

   }

   }

   void managePlayer() {

   if (jumped) {

   player.jumpRange=50;

   }

   else {

   player.jumpRange=30;

   }

   player.move();

   player.display();

   checkLevel();

   }

   void BBcols(Block b1, Block b2, int index) {

   //println(dist(b1.loc.x+b1.bw.x/2, b1.loc.y+b1.bw.y/2, b2.loc.x+b2.bw.x/2, b2.loc.y+b2.bw.y/2));

   //Horizontal

   if (dist(b1.loc.x+b1.bw.x/2, b1.loc.y+b1.bw.y/2, b2.loc.x+b2.bw.x/2, b2.loc.y+b2.bw.y/2) < b1.bw.x/2+b2.bw.x/2 && b1.loc.y>1 && b2.loc.y>1) {

   if (((b1.loc.x+b1.bw.x>=b2.loc.x && b1.loc.x+b1.bw.x<b2.loc.x+b2.bw.x/2))) {

   b1.xfree=false;

   b2.xfree=false;

   }

   }

   //Vertical

   if (b1.loc.y>1 && b2.loc.y>1) {

   if (b1.loc.y+b1.bw.y>=b2.loc.y && b1.loc.y+b1.bw.y<b2.loc.y+b2.bw.y/2) {

   if (ybarCheck(b1,index)) {

   b1.ybar=height-b1.bw.y;

   } else

   if (b1.loc.x>b2.loc.x-b1.bw.x&&b1.loc.x+b1.bw.x<b2.loc.x+b2.bw.x+b1.bw.x) {

   b1.ybar=b2.loc.y-b1.bw.y-1;

   }

   //else if (b1.loc.x<b2.loc.x-b1.bw.x || b1.loc.x+b1.bw.x>b2.loc.x+b2.bw.x+b1.bw.x) {

   }

   }

   }

   boolean ybarCheck(Block b, int exeption){

   for(int i=0; i<block.length; i++){

   if(i==exeption){} else

   if (b.loc.x<block[i].loc.x-block[i].bw.x || b.loc.x+b.bw.x>block[i].loc.x+block[i].bw.x+b.bw.x) {} else {return false;}

   }

   return true;

   }

   void detectPBCollisions(Player p, Block b) {

   //Vertical

   if (p.location.x+p.pw.x>b.loc.x &&

   p.location.x<b.loc.x+20) {

   if (p.location.y+p.pw.y<b.loc.y+1) {

   //p.jumpRange=50;

   jumped=true;

   }

   if (p.location.y<b.loc.y+20  && b.inAir) {

   noLoop();

   }

   }

   //Horizontal

   if (p.location.y+p.pw.y>b.loc.y && b.loc.y+20>p.location.y ) {

   if (p.location.x<b.loc.x+20 && p.location.x>b.loc.x+10){

   if(b.xfree) {

   b.loc.x=p.location.x-b.bw.x;

   } else if(!b.xfree){ p.Lfree=false; p.location.x=b.loc.x+b.bw.x;}

   }

   if (p.location.x+p.pw.x>b.loc.x && p.location.x+p.pw.x<b.loc.x+10){

   if(b.xfree) {

   b.loc.x=p.location.x+p.pw.x;

   } else if(!b.xfree){ p.Rfree=false; p.location.x=b.loc.x-p.pw.x;}

   }

   }

   //println((p.location.x+p.pw.x)+" "+b.loc.x+" id: "+b.id+" mX: "+mouseX );

   if(!b.xfree){

   if(((p.location.x+p.pw.x<b.loc.x && p.location.x+p.pw.x>b.loc.x-p.pw.x) || p.location.y+p.pw.y<b.loc.y)&&!p.Rfree){ p.Rfree=true; }

   if(((p.location.x>b.loc.x+b.bw.x && p.location.x<b.loc.x+b.bw.x+p.pw.x)|| p.location.y+p.pw.y<b.loc.y)&&!p.Lfree){ p.Lfree=true; }

   }

   //println("Rfree: "+p.Rfree+" "+"Lfree: "+p.Lfree+" "+"Bloc");

   }

   class Player {

   int jumpRange=30;

   PVector location;

   PVector pw;

   float maxUP,maxDOWN;

   int force=2;

   boolean air;

   boolean Rfree=true;

   boolean Lfree=true;

   Player(){

   pw=new PVector(10,20);

   location=new PVector(width/2, height-(pw.y/2));

   MnMreset();

   }

   void display(){

   fill(0);

   rect(location.x,location.y,pw.x,pw.y);

   }

   void move(){

   MnMreset();

   if(keyPressed){

   if(keyCode==RIGHT && Rfree){ location.x+=force; }

   if(keyCode==LEFT && Lfree){ location.x-=force; }

   if(keyCode==UP && location.y>maxUP && !air){ location.y-=6; if(location.y==maxUP){

   air=true;}

   }

   }

   location.x=constrain(location.x,0,width-pw.x);

   if(location.y==maxDOWN){ air=false; }

   location.y=constrain(location.y,maxUP,maxDOWN);

   location.y+=force/2;

   }

   void MnMreset(){

   maxUP=height-(pw.y)-jumpRange;

   maxDOWN=height-(pw.y)-jumpRange+30;

   }

   }

   class Block{

   float id=random(0,1);

   PVector bw=new PVector(20,20);

   PVector loc=new PVector(random(0,width-bw.x),0);

   PVector vel=new PVector(0,1);

   boolean inAir=true;

   boolean yfree=true;

   boolean xfree=true;

   float ybar=height-bw.y;

   color c = color(random(0,255),random(0,255),random(0,255));

   void fall(){

   fill(c);

   loc.y=constrain(loc.y,0,ybar);

   //loc.x=constrain(loc.x,0,width-bw.x);

   if(loc.x<=0-1 || loc.x+bw.x>=width){xfree=false;}

   loc.add(vel);

   if(loc.y>=player.location.y-player.pw.y){inAir=false; }

   }

   void display(){

   rect(loc.x,loc.y,bw.x,bw.y);

   //println(loc.y);

   }

   }

   int resetJR(Player p, Block b) {

   if (p.location.x+p.pw.x>b.loc.x &&

   p.location.x<b.loc.x+20) {

   if (p.location.y+p.pw.y<b.loc.y+1) {

   return 1;

   }}

   return 0;

   }

   void checkLevel(){

   int j=0;

   for (int i=0; i<block.length; i++) {

   j+=resetJR(player,block[i]);

   }

   if(j==0){ jumped=false;}

   }

Just wanna make sure if my function does what I think it does. 

If I had some code like this:

Few more problems with minim. 

Hi! I want to move an image slowly and smoothly. I am not sure why this doesn't work, but I suppose that it's because image changes it's position after image() converts it to integer.

2. PImage img;
3. float x;
4. void setup(){
5.  size(500,500);
6.  img=loadImage("song cover.png"); 
7. }
8. 
   
9. void draw(){
10.  background(255);
11.  image(img,x,0,500,500);
12.  x+=0.01;
13. }

Hi! Just downloaded new version of Processing. I tried to add javascript mode, but got this error:

Hi, guys! I've been making a game and I wanna add pause function to it. But unfortunately there was a bug.

What my code does: it plays an audio file when mouse is pressed and stops when it's released. 

I made a game with a lot of graphics. It has 2 arrays of objects and each of them contains an image. So basically there are images falling from the top of the screen and you need to catch them with your mouse.

I need to be able to send midi signal from a DAW (Reaper, Pro Tools, Garage Band) to Arduino. I didn't find info that would help me, so I thought that I could receive it using a processing sketch using a midi library (midibus, proMidi) and then send info to Arduino via Serial Communication. 

I want a user to be able to browse for a file to import to "data" directory of my app. Maybe there's a library for it...

Hello, guys! I've been trying to fix a bug for the whole day and I finally found it. I have a two-dimensional array named "presets[][]" and another array named "dummy[]". I needed to set "dummy" to "presets[]". I tried to do it like this:

Hi, guys. I'm new to Processing. I use it to communicate with Arduino and receive messages from serial port.