//子弹和怪物碰撞
bool GameLayer:: iscollision(Sprite *sprite1, Sprite *sprite2){
auto rect1 = sprite1->getBoundingBox();//子弹
auto rect2 = sprite2->getBoundingBox();//怪物
return !(rect1.getMaxX() < rect2.getMinX() ||
rect2.getMaxX() < rect1.getMinX() ||
rect1.getMaxY() < rect2.getMinY() ||
rect2.getMaxY() <rect1.getMinY());
}
bool isOverlapping(const Rectangle& rect) const
{
/* Ugly, but correct. FIXME */
return
(insideInterval(rect.getMinX(), getMinX(), getMaxX()) ||
insideInterval(rect.getMaxX(), getMinX(), getMaxX()) ||
insideInterval(getMinX(), rect.getMinX(), rect.getMaxX()) ||
insideInterval(getMaxX(), rect.getMinX(), rect.getMaxX())) &&
(insideInterval(rect.getMinY(), getMinY(), getMaxY()) ||
insideInterval(rect.getMaxY(), getMinY(), getMaxY()) ||
insideInterval(getMinY(), rect.getMinY(), rect.getMaxY()) ||
insideInterval(getMaxY(), rect.getMinY(), rect.getMaxY()));
}
PreconditionWidget::PreconditionWidget(UMLScene * scene, ObjectWidget* a, Uml::IDType id )
: UMLWidget(scene, WidgetBase::wt_Precondition, id)
{
init();
m_pOw = a;
int y = getY();
m_nY = y;
//updateResizability();
// calculateWidget();
y = y < getMinY() ? getMinY() : y;
y = y > getMaxY() ? getMaxY() : y;
m_nY = y;
this->activate();
}
PreconditionWidget::PreconditionWidget(UMLView * view, ObjectWidget* a, Uml::IDType id )
: UMLWidget(view, id)
{
init();
m_pOw = a;
int y = getY();
m_nY = y;
//updateResizability();
updateComponentSize();
// calculateWidget();
y = y < getMinY() ? getMinY() : y;
y = y > getMaxY() ? getMaxY() : y;
m_nY = y;
this->activate();
}
bool Bonus::isCollidePlayer()
{
auto player = GameScene::getTankM()->getPlayerTank();
if (player == nullptr)
{
return false;
}
auto boundingBox1 = player->getBoundingBox();
auto boundingBox2 = this->getBoundingBox();
/* 不使用intersectsRect，因为边缘重合的时候并不算 */
return !(boundingBox1.getMaxX() <= boundingBox2.getMinX() ||
boundingBox2.getMaxX() <= boundingBox1.getMinX() ||
boundingBox1.getMaxY() <= boundingBox2.getMinY() ||
boundingBox2.getMaxY() <= boundingBox1.getMinY());
}
/*** This should be called when Objects colided. If 1/2 of the object height is > the other objects minY
it will hurt the other object with damage dmg.***/
void EnemyObject::simpleWalkerHurt(GameObject* pPlayer, const uint32_t otherType) {
auto player = pPlayer->getHitbox();
auto rThis = getHitbox();
if (rThis->getMidY() > player->getMinY()) {
pPlayer->hurt(dmg, Vec2(getVelocityX(), fSimpleHurtForce));
}
}
/*public*/
void
Envelope::translate(double transX, double transY)
{
if (isNull()) return;
init(getMinX() + transX, getMaxX() + transX,
getMinY() + transY, getMaxY() + transY);
}
bool OctreeProjectedPolygon::pointInside(const glm::vec2& point, bool* matchesVertex) const {
OctreeProjectedPolygon::pointInside_calls++;
// first check the bounding boxes, the point must be fully within the boounding box of this polygon
if ((point.x > getMaxX()) ||
(point.y > getMaxY()) ||
(point.x < getMinX()) ||
(point.y < getMinY())) {
return false;
}
// consider each edge of this polygon as a potential separating axis
// check the point against each edge
for (int i = 0; i < getVertexCount(); i++) {
glm::vec2 start = getVertex(i);
glm::vec2 end = getVertex((i + 1) % getVertexCount());
float a = start.y - end.y;
float b = end.x - start.x;
float c = a * start.x + b * start.y;
if (a * point.x + b * point.y < c) {
return false;
}
}
return true;
}
bool DRect::intersectsRect(const DRect& rect) const
{
return !( getMaxX() < rect.getMinX()
|| rect.getMaxX() < getMinX()
|| getMaxY() < rect.getMinY()
|| rect.getMaxY() < getMinY());
}
bool VoxelProjectedPolygon::pointInside(const glm::vec2& point) const {
// first check the bounding boxes, the point must be fully within the boounding box of this shadow
if ((point.x > getMaxX()) ||
(point.y > getMaxY()) ||
(point.x < getMinX()) ||
(point.y < getMinY())) {
return false;
}
float e = (getMaxX() - getMinX()) / 100.0f; // some epsilon
// We need to have one ray that goes from a known outside position to the point in question. We'll pick a
// start point just outside of our min X
glm::vec2 r1p1(getMinX() - e, point.y);
glm::vec2 r1p2(point);
glm::vec2 r2p1(getVertex(getVertexCount()-1)); // start with last vertex to first vertex
glm::vec2 r2p2;
// Test the ray against all sides
int intersections = 0;
for (int i = 0; i < getVertexCount(); i++) {
r2p2 = getVertex(i);
if (doLineSegmentsIntersect(r1p1, r1p2, r2p1, r2p2)) {
intersections++;
}
r2p1 = r2p2; // set up for next side
}
// If odd number of intersections, we're inside
return ((intersections & 1) == 1);
}
bool VoxelProjectedPolygon::occludes(const VoxelProjectedPolygon& occludee, bool checkAllInView) const {
// if we are completely out of view, then we definitely don't occlude!
// if the occludee is completely out of view, then we also don't occlude it
//
// this is true, but unfortunately, we're not quite handling projects in the
// case when SOME points are in view and others are not. So, we will not consider
// occlusion for any shadows that are partially in view.
if (checkAllInView && (!getAllInView() || !occludee.getAllInView())) {
return false;
}
// first check the bounding boxes, the occludee must be fully within the boounding box of this shadow
if ((occludee.getMaxX() > getMaxX()) ||
(occludee.getMaxY() > getMaxY()) ||
(occludee.getMinX() < getMinX()) ||
(occludee.getMinY() < getMinY())) {
return false;
}
// if we got this far, then check each vertex of the occludee, if all those points
// are inside our polygon, then the tested occludee is fully occluded
for(int i = 0; i < occludee.getVertexCount(); i++) {
if (!pointInside(occludee.getVertex(i))) {
return false;
}
}
// if we got this far, then indeed the occludee is fully occluded by us
return true;
}
bool Boundingbox::CollideBox(Boundingbox* _Box)
{
if (getMinX() > _Box->getMaxX()) return false;
if (getMaxX() < _Box->getMinX()) return false;
if (getMinY() > _Box->getMaxY()) return false;
if (getMaxY() < _Box->getMinY()) return false;
return true;
}
/*public*/
bool
Envelope::centre(Coordinate& centre) const
{
if (isNull()) return false;
centre.x=(getMinX() + getMaxX()) / 2.0;
centre.y=(getMinY() + getMaxY()) / 2.0;
return true;
}
/* Get the rectangle which is big enough to hold both rectangles */
Rectangle getUnion(const Rectangle& rect) const
{
return Rectangle(
std::min(getMinX(), rect.getMinX()),
std::max(getMaxX(), rect.getMaxX()),
std::min(getMinY(), rect.getMinY()),
std::max(getMaxY(), rect.getMaxY()));
}
// can be optimized with new pointInside()
bool OctreeProjectedPolygon::occludes(const OctreeProjectedPolygon& occludee, bool checkAllInView) const {
OctreeProjectedPolygon::occludes_calls++;
// if we are completely out of view, then we definitely don't occlude!
// if the occludee is completely out of view, then we also don't occlude it
//
// this is true, but unfortunately, we're not quite handling projects in the
// case when SOME points are in view and others are not. So, we will not consider
// occlusion for any shadows that are partially in view.
if (checkAllInView && (!getAllInView() || !occludee.getAllInView())) {
return false;
}
// first check the bounding boxes, the occludee must be fully within the boounding box of this shadow
if ((occludee.getMaxX() > getMaxX()) ||
(occludee.getMaxY() > getMaxY()) ||
(occludee.getMinX() < getMinX()) ||
(occludee.getMinY() < getMinY())) {
return false;
}
// we need to test for identity as well, because in the case of identity, none of the points
// will be "inside" but we don't want to bail early on the first non-inside point
bool potentialIdenity = false;
if ((occludee.getVertexCount() == getVertexCount()) && (getBoundingBox().contains(occludee.getBoundingBox())) ) {
potentialIdenity = true;
}
// if we got this far, then check each vertex of the occludee, if all those points
// are inside our polygon, then the tested occludee is fully occluded
int pointsInside = 0;
for(int i = 0; i < occludee.getVertexCount(); i++) {
bool vertexMatched = false;
if (!pointInside(occludee.getVertex(i), &vertexMatched)) {
// so the point we just tested isn't inside, but it might have matched a vertex
// if it didn't match a vertext, then we bail because we can't be an identity
// or if we're not expecting identity, then we also bail early, no matter what
if (!potentialIdenity || !vertexMatched) {
return false;
}
} else {
pointsInside++;
}
}
// we're only here if all points are inside matched and/or we had a potentialIdentity we need to check
if (pointsInside == occludee.getVertexCount()) {
return true;
}
// If we have the potential for identity, then test to see if we match, if we match, we occlude
if (potentialIdenity) {
return matches(occludee);
}
return false; // if we got this far, then we're not occluded
}
//----------------------------------------------------------
void ofRectangle::growToInclude(const ofRectangle& rect){
float x0 = MIN(getMinX(),rect.getMinX());
float x1 = MAX(getMaxX(),rect.getMaxX());
float y0 = MIN(getMinY(),rect.getMinY());
float y1 = MAX(getMaxY(),rect.getMaxY());
float w = x1 - x0;
float h = y1 - y0;
set(x0,y0,w,h);
}
//----------------------------------------------------------
void ofRectangle::growToInclude(const ofPoint& p){
float x0 = MIN(getMinX(),p.x);
float x1 = MAX(getMaxX(),p.x);
float y0 = MIN(getMinY(),p.y);
float y1 = MAX(getMaxY(),p.y);
float w = x1 - x0;
float h = y1 - y0;
set(x0,y0,w,h);
}
void PreconditionWidget::slotWidgetMoved(Uml::IDType id)
{
const Uml::IDType idA = m_pOw->localID();
if (idA != id ) {
uDebug() << "id=" << ID2STR(id) << ": ignoring for idA=" << ID2STR(idA);
return;
}
m_nY = getY();
if (m_nY < getMinY())
m_nY = getMinY();
if (m_nY > getMaxY())
m_nY = getMaxY();
calculateDimensions();
if (m_scene->getSelectCount(true) > 1)
return;
}
bool EnemyPlane::isStillOnScreen()
{
auto boundings = getParent()->getBoundingBox();
bool planeIsOnScreen = ( this->getPositionX()-19 < boundings.getMaxX() && this->getPositionX()-19 > boundings.getMinX() &&
this->getPositionY()-19 < boundings.getMaxY() && this->getPositionY()-19 > boundings.getMinY());
return planeIsOnScreen;
}
void VoxelProjectedPolygon::printDebugDetails() const {
printf("VoxelProjectedPolygon...");
printf(" minX=%f maxX=%f minY=%f maxY=%f\n", getMinX(), getMaxX(), getMinY(), getMaxY());
printf(" vertex count=%d distance=%f\n", getVertexCount(), getDistance());
for (int i = 0; i < getVertexCount(); i++) {
glm::vec2 point = getVertex(i);
printf(" vertex[%d] = %f, %f \n", i, point.x, point.y);
}
}
bool Sphere::isIntersects(Vec3 p)
{
if (getMaxX() > p.getX() && getMinX() < p.getX())
return true;
if (getMaxY() > p.getY() && getMinY() < p.getY())
return true;
if (getMaxZ() > p.getZ() && getMinZ() < p.getZ())
return true;
return false;
}
bool CCRect::containsPoint(const CCPoint& point) const
{
bool bRet = false;
if (point.x >= getMinX() && point.x <= getMaxX()
&& point.y >= getMinY() && point.y <= getMaxY())
{
bRet = true;
}
return bRet;
}
/**
* Constructs a MessageWidget.
*
* This method is used for creation, synchronous and synchronous message types.
*
* @param scene The parent to this class.
* @param a The role A widget for this message.
* @param b The role B widget for this message.
* @param y The vertical position to display this message.
* @param sequenceMessageType Whether synchronous or asynchronous
* @param id A unique id used for deleting this object cleanly.
* The default (-1) will prompt generation of a new ID.
*/
MessageWidget::MessageWidget(UMLScene * scene, ObjectWidget* a, ObjectWidget* b,
int y, Uml::SequenceMessage::Enum sequenceMessageType,
Uml::ID::Type id /* = Uml::id_None */)
: UMLWidget(scene, WidgetBase::wt_Message, id)
{
init();
m_pOw[Uml::RoleType::A] = a;
m_pOw[Uml::RoleType::B] = b;
m_sequenceMessageType = sequenceMessageType;
if (m_sequenceMessageType == Uml::SequenceMessage::Creation) {
y -= m_pOw[Uml::RoleType::B]->height() / 2;
m_pOw[Uml::RoleType::B]->setY(y);
}
updateResizability();
calculateWidget();
y = y < getMinY() ? getMinY() : y;
y = y > getMaxY() ? getMaxY() : y;
setY(y);
this->activate();
}
void HexaGridMap::updateTrajectory() {
((DrawNode*)this->trajectoryCanvas)->clear();
Point* ptsToDraw = new Point[this->trajectory.size()];
for (int i = 0; i < this->trajectory.size(); i++) {
auto name = Utils::generateNameByPoint(this->trajectory.at(i));
auto box = this->getChildByName<HexaGridMapUnit*>(name)->getBoundingBox();
ptsToDraw[i] = Point(box.getMinX()+box.getMaxX(), box.getMinY()+box.getMaxY())/2;
}
for (int i = 1; i < this->trajectory.size(); i++) {
((DrawNode*)this->trajectoryCanvas)->drawSegment(ptsToDraw[i-1], ptsToDraw[i], 4, Color4F(.5, .25, .25, 1));
}
}
/**
* Constrains the FloatingTextWidget X and Y values supplied.
* Overrides operation from LinkWidget.
*
* @param textX candidate X value (may be modified by the constraint)
* @param textY candidate Y value (may be modified by the constraint)
* @param textWidth width of the text
* @param textHeight height of the text
* @param tr Uml::TextRole::Enum of the text
*/
void MessageWidget::constrainTextPos(qreal &textX, qreal &textY, qreal textWidth, qreal textHeight,
Uml::TextRole::Enum tr)
{
textX = constrainX(textX, textWidth, tr);
// Constrain Y.
const qreal minTextY = getMinY();
const qreal maxTextY = getMaxY() - textHeight - 5;
if (textY < minTextY)
textY = minTextY;
else if (textY > maxTextY)
textY = maxTextY;
// setY(textY + textHeight); // NB: side effect
}
void MessageWidget::slotWidgetMoved(Uml::ID::Type id)
{
const Uml::ID::Type idA = m_pOw[Uml::RoleType::A]->localID();
const Uml::ID::Type idB = m_pOw[Uml::RoleType::B]->localID();
if (idA != id && idB != id) {
DEBUG(DBG_SRC) << "id=" << Uml::ID::toString(id) << ": ignoring for idA=" << Uml::ID::toString(idA)
<< ", idB=" << Uml::ID::toString(idB);
return;
}
qreal y = this->y();
if (y < getMinY())
y = getMinY();
if (y > getMaxY())
y = getMaxY();
setPos(x(), y);
calculateWidget();
if(!m_pFText)
return;
if (m_scene->selectedCount(true) > 1)
return;
setTextPosition();
}
/**
* Constructs a Lost or Found MessageWidget.
*
* @param scene The parent to this class.
* @param a The role A widget for this message.
* @param xclick The horizontal position clicked by the user
* @param yclick The vertical position clicked by the user
* @param sequenceMessageType Whether lost or found
* @param id The ID to assign (-1 will prompt a new ID.)
*/
MessageWidget::MessageWidget(UMLScene * scene, ObjectWidget* a, int xclick, int yclick,
Uml::SequenceMessage::Enum sequenceMessageType,
Uml::ID::Type id /*= Uml::id_None*/)
: UMLWidget(scene, WidgetBase::wt_Message, id)
{
init();
m_pOw[Uml::RoleType::A] = a;
m_pOw[Uml::RoleType::B] = a;
m_sequenceMessageType = sequenceMessageType;
m_xclicked = xclick;
m_yclicked = yclick;
updateResizability();
calculateWidget();
yclick = yclick < getMinY() ? getMinY() : yclick;
yclick = yclick > getMaxY() ? getMaxY() : yclick;
setY(yclick);
m_yclicked = yclick;
this->activate();
}
bool KeyboardPaddle::collideWithBall(Ball* ball) {
auto paddleBBox = getBoundingBox();
auto ballBBox = ball->getBoundingBox();
float bLeft = ballBBox.getMinX();
float bHigh = ballBBox.getMaxY();
float bLow = ballBBox.getMinY();
float pRight = paddleBBox.getMaxX();
float pHigh = paddleBBox.getMaxY();
float pLow = paddleBBox.getMinY();
if (bLeft <= pRight) {
if (bHigh <= pHigh
&& bHigh >= pLow) {
return true;
} else if (bLow <= pHigh
&& bLow >= pLow) {
return true;
}
}
return false;
}
/**
* Constrains the vertical position of the message widget so it doesn't go
* upper than the bottom side of the lower object.
* The height of the floating text widget in the message is taken in account
* if there is any and isn't empty.
*
* @param diffY The difference between current Y position and new Y position.
* @return The new Y position, constrained.
*/
qreal MessageWidget::constrainPositionY(qreal diffY)
{
qreal newY = y() + diffY;
qreal minY = getMinY();
if (m_pFText && !m_pFText->displayText().isEmpty()) {
minY += m_pFText->height();
}
if (newY < minY) {
newY = minY;
}
return newY;
}
bool ZoneImplementation::isWithinBoundaries(const Vector3& position) {
//Remove 1/16th of the size to match client limits. NOTE: it has not been verified to work like this in the client.
//Normal zone size is 8192, 1/16th of that is 512 resulting in 7680 as the boundary value.
float maxX = getMaxX() * 15 / 16;
float minX = getMinX() * 15 / 16;
float maxY = getMaxY() * 15 / 16;
float minY = getMinY() * 15 / 16;
if (maxX >= position.getX() && minX <= position.getX() &&
maxY >= position.getY() && minY <= position.getY()) {
return true;
} else {
return false;
}
}
