calculate moving object inside box - php

Question

I have an object that has:
start location: (X0,Y0)
and speed: (Vx, Vy)
it is trapped inside a box: boxWidth, boxHeight
when the object hits the border of the box it will flip direction.
ie:
object has speed: (1,3)
now it hits the top of the box
now it's speed will be: (1,-3)
now lets say it hitted the right of the box
and it's speed will be: (-1, -3)
I already made a sekeleton for the point class.
I would need a function that I will give it an "n" time and t will return me the current object location after that time:
my class:
class Point {
protected $x0;
protected $y0;
protected $vx;
protected $vy;
protected $currentX;
protected $currentY;
protected $blockWide;
protected $blockHeight;
public function __construct($x0, $y0, $vx, $vy, $blockHeight, $blockWide) {
$this->x0 = $x0;
$this->y0 = $y0;
$this->vx = $vx;
$this->vy = $vy;
$this->blockHeight = $blockHeight;
$this->blockWide = $blockWide;
$this->currentX = $x0;
$this->currentY = $y0;
}
public function getLoc($time) {
$this->currentX = $this->getLocX($time);
$this->currentY = $this->getLocY($time);
}
protected function getLocX($time) {
$direction = 1;
$flips = 0;
$distance = $this->vx * $time;
if ( $this->blockWide - $this->x0)
return 1;
}
protected function getLocY($time) {
return 0;
}
public function printAsPoint() {
echo '(',$this->currentX,',',$this->currentY,')';
}
}
I simply dont have an idea on how to calculate it with the starting location, speed, and speed flips that will happen each time the point will reach the borders.
some code from your posts:
protected function getLocX($time) {
$corPos = $this->x0 + $time * $this->vx;
$modulo = $corPos%(2*$this->blockWide);
if($modulo > $this->blockWide)
$corPos = 2*$this->blockWide - $modulo;
if($modulo < $this->blockWide)
$corPos = $modulo;
if($modulo == $this->blockWide)
$corPos = $modulo;
return $corPos;
}

Answer 1

If we take only the x - direction, then the object returns to the same state (same position and same velocity) after (2*boxWidth/Vx) time.
So keep subtracting the above quantity from the time till the value of time is greater than this quantity. If you are working with integers, then you can apply the remainder operator also.
Once you get the final time figure, it will be simple to deal with it. You just have to check for one bounce at the maximum.
xFinal = xInitial + Vx * t.
if xFinal > boxWidth || xFinal < 0 it means there is a bounce and proceed accordingly.
Similarly for y direction.

Answer 2

Consider your problem as looking for the X and then for the Y,
considering X0 the initial position, VX the walking step
(i assume this doesn't change in absolute) ,
WX the width of your object and boxWidth the width of the box
simplifications:
- you can consider your object to be 0 width in a box of (boxWidth-WX)
- you can consider your object running at the speed of 1
in a box of (boxWidth-WX)/VX width
- Since your object changes direction each time it hits a border, we can consider it
runs in same direction into a twice bigger box (boxWidth-WX)*2/VX
- finally, the new position after n moves shall be calculated on the base of :
(X0+n) mod (boxWidth-WX)*2/VX which gives you the position in a twice as big box,
and checking if the position is bigger than boxWidth the real position
will be boxWidth-foundPosition

Answer 3

Pretend there are no borders, then imagine there are!
d = s * t
No borders: actual d = d
With borders: actual d =
If moving to the right:
1. Subtract the distance to the right border from d.
2. Divide result by box-width. If the quotient is odd, the remainder
indicates how far you bounced back from the left border; if the quotient
is even, the remainder shows how far you bounced back from the right
border. (or something like that...perhaps you or others can correct me.)
If moving to the left:
Reverse the ideas from 1.
Since from your comments it seems that the positive-motion idea may be working for you, here's an example with motion in the opposite direction:
Let us say s is -1 unit/sec (that is, moving to the left),
t is 6 seconds,
the object is 1 unit from the left border,
and the box width is 2 units.
Total distance then is 1 * 6 = 6. We subtract 1 unit to get to the left border
and have 5 units left.
How many times do we bounce back and forth? We divide 5 by the box width:
the quotient is 2, which means the ball went once all the way to the right, then
back again to the left border. Since the quotient is even, we know we are back
to the left border (if the quotient was odd we would be at the right border).
Any remainder indicates the last distance bouncing back, in this case from the
left border, but not bouncing as far as the right border. Our remainder in this
case is 1, meaning we bounced back from the left border 1 unit, and that's our
current location!