void Ball::collideWithPaddle(Paddle* paddle)
{
auto paddleRect = paddle->getRect();
paddleRect.origin.x += paddle->getPosition().x;
paddleRect.origin.y += paddle->getPosition().y;
float lowY = paddleRect.getMinY();
float midY = paddleRect.getMidY();
float highY = paddleRect.getMaxY();
float leftX = paddleRect.getMinX();
float rightX = paddleRect.getMaxX();
if (getPosition().x > leftX && getPosition().x < rightX) {
bool hit = false;
float angleOffset = 0.0f;
if (getPosition().y > midY && getPosition().y <= highY + radius())
{
setPosition( Point(getPosition().x, highY + radius()) );
hit = true;
angleOffset = KD_PI_F / 2;
}
else if (getPosition().y < midY && getPosition().y >= lowY - radius())
{
setPosition( Point(getPosition().x, lowY - radius()) );
hit = true;
angleOffset = -KD_PI_F / 2;
}
if (hit)
{
float hitAngle = (paddle->getPosition() - getPosition()).getAngle() + angleOffset;
float scalarVelocity = _velocity.getLength() * 1.05f;
float velocityAngle = -_velocity.getAngle() + 0.5f * hitAngle;
_velocity = Point::forAngle(velocityAngle) * scalarVelocity;
}
}
}
bool PhysicsObject::containsPoint(float x, float y) const {
return getMinX() < x && x < getMaxX() &&
getMinY() < y && y < getMaxY();
}
//----------------------------------------------------------
bool ofRectangle::intersects(const ofRectangle& rect) const {
return (getMinX() < rect.getMaxX() && getMaxX() > rect.getMinX() &&
getMinY() < rect.getMaxY() && getMaxY() > rect.getMinY());
}
//----------------------------------------------------------
ofPoint ofRectangle::getMax() const {
return ofPoint(getMaxX(),getMaxY());
}
void fillConstants(){
xmin = getMinX();
xdomain=getMaxX()-xmin;
ymax = getMaxY();
yrange=ymax-getMinY();
}
//----------------------------------------------------------
bool ofRectangle::inside(const ofPoint& p) const {
return p.x > getMinX() && p.y > getMinY() &&
p.x < getMaxX() && p.y < getMaxY();
}
//----------------------------------------------------------
float ofRectangle::getBottom() const {
return getMaxY();
}
//----------------------------------------------------------
glm::vec3 glmRectangle::getMax() const {
return glm::vec3(getMaxX(),getMaxY(),0.);
}
bool Rect::containsPoint( const Point& point ) const
{
return (point.x >= getMinX() && point.x <= getMaxX()
&& point.y >= getMinY() && point.y <= getMaxY());
}
void CubeProjectedPolygon::printDebugDetails() const {
qCDebug(shared, "CubeProjectedPolygon..."
" minX=%f maxX=%f minY=%f maxY=%f", (double)getMinX(), (double)getMaxX(), (double)getMinY(), (double)getMaxY());
qCDebug(shared, " vertex count=%d distance=%f", getVertexCount(), (double)getDistance());
for (int i = 0; i < getVertexCount(); i++) {
glm::vec2 point = getVertex(i);
qCDebug(shared, " vertex[%d] = %f, %f ", i, (double)point.x, (double)point.y);
}
}
DECLARE_DEBUG_DRAWING("representation:BodyContour:maxY", "drawingOnImage");
COMPLEX_DRAWING("representation:BodyContour",
{
for(std::vector<Line>::const_iterator i = lines.begin(); i != lines.end(); ++i)
LINE("representation:BodyContour", i->p1.x, i->p1.y, i->p2.x, i->p2.y, 1,
Drawings::ps_solid, ColorRGBA(255, 0, 255));
for(int x = 0; x < cameraResolution.x; x += 10)
{
int y = cameraResolution.y;
clipBottom(x, y);
LINE("representation:BodyContour", x, y, x, cameraResolution.y, 1,
Drawings::ps_solid, ColorRGBA(255, 0, 255));
}
});
int maxY = getMaxY();
LINE("representation:BodyContour:maxY", 0, maxY, cameraResolution.x - 1, maxY,
1, Drawings::ps_solid, ColorRGBA(255, 0, 255));
}
int BodyContour::getMaxY() const
{
int y = cameraResolution.y - 1;
clipBottom(0, y);
clipBottom(cameraResolution.x - 1, y);
if(y < 0)
{//no need to continue
return 0;
}
bool RunnerSprite::isCollisionWithTop(cocos2d::Rect box){
auto manBox = mRunner->boundingBox();
Vec2 manPoint = Vec2(manBox.getMidX(),manBox.getMaxY());
return box.containsPoint(manPoint);
}
//CCPoint centerpoint;
//CCPoint centerpoint2;
//if (_player->getScaleX()>0)
//{
// centerpoint= datapoint;
// centerpoint2=ccpAdd(centerpoint,ccp(wi,0));
//}
//else
//{
// centerpoint2=datapoint;
// centerpoint=ccpAdd(centerpoint2,ccp(-wi,0));
//}
//dataRect.origin= centerpoint;
//dataRect.size=CCSizeMake(wi,he);
dataRect=_player->nailuorect();
ccDrawRect(dataRect.origin,ccp(dataRect.getMaxX(),dataRect.getMaxY()));
CCPoint points[] = {ccpAdd(_player->GetCenterPoint(),ccp(_player->getScaleX()>0?50:-50,0)) };
ccPointSize(10);
ccDrawColor4B(0,255,255,255);
ccDrawPoints(points,1);
}
void GGameLayerBase::onEnter()
{
CCLayer::onEnter();
this->scheduleUpdate();
CCObject *obj1=NULL;
CCNotificationCenter::sharedNotificationCenter()->addObserver(this,
callfuncO_selector(GGameLayerBase::heroSmitten),SMITTENCB,obj1);
bool PhysicsObject::boundingBoxCollides(const PhysicsObject& other) const {
// http://stackoverflow.com/questions/306316/determine-if-two-rectangles-overlap-each-other
return getMinX() < other.getMaxX() && getMaxX() > other.getMinX() &&
getMinY() < other.getMaxY() && getMaxY() > other.getMinY();
}
void centerScrollingOnPlayer(void)
{
/* Nouveau scrolling à sous-boîte limite :
Pour éviter les effets de saccades dus à une caméra qui se centre
automatiquement et constamment
sur le joueur, on crée
une "boîte" imaginaire autour du joueur.
Quand on dépasse un de ses bords (en haut, en bas, à gauche ou à
droite), on scrolle.
Mais là encore, au lieu de centrer sur le joueur, on déplace
simplement la caméra jusqu'à arriver au joueur.
On a choisi la valeur de 3 pixels pour pouvoir avoir le plaisir
d'aller plus vite que le cameraman
On accélère aussi la vitesse de la caméra
en cas de chute rapide (pour ne pas
perdre le joueur de vue non plus. */
int cxperso = player.x + player.w / 2;
int cyperso = player.y + player.h / 2;
int xlimmin = getStartX() + LIMITE_X;
int xlimmax = xlimmin + LIMITE_W;
int ylimmin = getStartY() + LIMITE_Y;
int ylimmax = ylimmin + LIMITE_H;
/* Effet de retour en arrière quand on est mort :
Si on est très loin de la caméra, plus loin que le bord
de la map, on accélère le scrolling : */
if(cxperso < getStartX()) setStartX(getStartX() - 30);
/* Si on dépasse par la gauche, on recule la caméra de 3 pixels (vous
pouvez modifier cette valeur) */
if(cxperso < xlimmin) setStartX(getStartX() - 3);
/* Effet de retour en avant quand on est mort (au
cas où le joueur s'amuse à faire le niveau à rebours
après une checkpoint) :
Si on est très loin de la caméra, plus loin que le bord
de la map, on accélère le scrolling : */
if(cxperso > getStartX() + SCREEN_WIDTH) setStartX(getStartX() + 30);
/* Si on dépasse par la droite, on avance la caméra de 3 pixels (vous
pouvez modifier cette valeur) */
if(cxperso > xlimmax) setStartX(getStartX() + 3);
/*Si on arrive au bout de la map à gauche, on stoppe le scrolling */
if(getStartX() < 0) setStartX(0);
/* Si on arrive au bout de la map à droite, on stoppe le scrolling à la
valeur Max de la map - la moitié d'un écran (pour ne pas afficher du noir). */
else if(getStartX() + SCREEN_WIDTH >= getMaxX())
setStartX(getMaxX() - SCREEN_WIDTH);
/* Si on dépasse par le haut, on remonte la caméra de 3 pixels (vous
pouvez modifier cette valeur) */
if(cyperso < ylimmin) setStartY(getStartY() - 3);
/* Si on dépasse par le bas, on descend la caméra de 3 pixels (vous
pouvez modifier cette valeur) */
if(cyperso > ylimmax) setStartY(getStartY() + 3);
/*Si on arrive au bout de la map en haut, on stoppe le scrolling */
if (getStartY() < 0) setStartY(0);
/*Si on arrive au bout de la map en bas, on stoppe le scrolling à la
valeur Max de la map - la moitié d'un écran (pour ne pas afficher du noir). */
else if (getStartY() + SCREEN_HEIGHT >= getMaxY())
setStartY(getMaxY() - SCREEN_HEIGHT);
}
bool Field::isInFieldY(int y)
{
return y >= getMinY() && y <= getMaxY();
}
//----------------------------------------------------------
bool glmRectangle::inside(const glm::vec3& p) const {
return p.x > getMinX() && p.y > getMinY() &&
p.x < getMaxX() && p.y < getMaxY();
}
