bool RigSegmentCollides(const Rig& targetRig, const CCPoint& newVertex, const CCPoint& oldVertex) { if(targetRig.size() < 3) { return false; } for(int v = 0; v < targetRig.size(); v++) { CCPoint edgeStart = targetRig[v]; CCPoint edgeEnd = targetRig[ (v+1) % targetRig.size() ]; if(edgeStart.equals(oldVertex) || edgeEnd.equals(oldVertex)) { continue; } if(ccpSegmentIntersect(edgeStart, edgeEnd, newVertex, oldVertex)) { return true; } } return false; }
void ItemFireString::collision() { if (_mario->_dead) return; // »ñÈ¡fireStringÏ߶Πstruct Line { CCPoint pt1; CCPoint pt2; } lineFireString; CCRect rcItem = boundingBox(); int angle = getRotation(); angle %= 360; if (angle > 270) { lineFireString.pt1 = ccp(rcItem.getMinX(), rcItem.getMinY()); lineFireString.pt2 = ccp(rcItem.getMaxX(), rcItem.getMaxY()); } else if (angle > 180) { lineFireString.pt1 = ccp(rcItem.getMinX(), rcItem.getMaxY()); lineFireString.pt2 = ccp(rcItem.getMaxX(), rcItem.getMinY()); } else if (angle > 90) { lineFireString.pt1 = ccp(rcItem.getMinX(), rcItem.getMinY()); lineFireString.pt2 = ccp(rcItem.getMaxX(), rcItem.getMaxY()); } else { lineFireString.pt1 = ccp(rcItem.getMinX(), rcItem.getMaxY()); lineFireString.pt2 = ccp(rcItem.getMaxX(), rcItem.getMinY()); } // MarioÏ߶ΠLine lineMario[2]; CCRect rcMario = _mario->boundingBox(); lineMario[0].pt1 = ccp(rcMario.getMinX(), rcMario.getMinY()); lineMario[0].pt2 = ccp(rcMario.getMaxX(), rcMario.getMaxY()); lineMario[1].pt1 = ccp(rcMario.getMaxX(), rcMario.getMinY()); lineMario[1].pt2 = ccp(rcMario.getMinX(), rcMario.getMaxY()); for (int i = 0; i < 2; ++i) { if (ccpSegmentIntersect(lineMario[i].pt1, lineMario[i].pt2, lineFireString.pt1, lineFireString.pt2)) _mario->Die(false); } }
void RigRandom(Rig& targetRig, int vertexes) { //Other implementations can be found at: //http://pastebin.com/wdKmSrL3 //Let's create the goal polygon first. //Due to preventing intersections, one more vertex maybe created that stated over here. unsigned int vertexNum = vertexes; //Now that we have the number of vertexes, let's create the number of angles needed. std::vector<float> angles; angles.reserve(vertexNum); for(int angleIter = 0; angleIter < vertexNum; angleIter++) { //angles.push_back(angleIter * (angleSize + CCRANDOM_0_1())); angles.push_back(GetRandomAngle()); } std::sort(angles.begin(), angles.end()); //Iterate over the angles, create a vertexes stack. targetRig.reserve(vertexNum); for(std::vector<float>::iterator iter = angles.begin(); iter != angles.end(); iter++) { float angle = (*iter); CCPoint highPoint = ccp(0, RIG_MIN_RADIUS() + (RIG_MAX_RADIUS()-RIG_MIN_RADIUS()) * CCRANDOM_0_1()); targetRig.push_back(ccpRotateByAngle(highPoint, CCPointZero, angle)); } //Make sure the first and last point doesn't intersect. for(int i = 0; i < targetRig.size()-1; i++) { CCPoint startPoint = targetRig[i]; CCPoint endPoint = targetRig[i+1]; if(ccpSegmentIntersect(startPoint, endPoint, targetRig.front(), targetRig.back())) { targetRig.push_back(CCPointZero); break; } } }
bool RigSplit(const CCPoint& startPoint, const CCPoint& endPoint, const Rig& originalRig, std::vector<Rig>& finalRigs) { std::vector<std::pair<Rig, CCPoint> > splitPolygons; std::pair<Rig, CCPoint>* currentRig = NULL; Rig intersections; Rig ignoreIntersections; CCPoint lastVert = originalRig[originalRig.size()-1]; for(int i = 0; i < originalRig.size(); i++) { CCPoint intersectPoint = ccpIntersectPoint(startPoint, endPoint, lastVert, originalRig[i]); if( ccpSegmentIntersect(startPoint, endPoint, lastVert, originalRig[i]) ) { intersections.push_back(intersectPoint); } lastVert = originalRig[i]; } std::sort(intersections.begin(), intersections.end(), PositionSort(startPoint)); //Check if the split line is valid. if(intersections.size() < 2) { return false; } if(RigCheckPoint(originalRig, startPoint)) { ignoreIntersections.push_back(intersections[0]); intersections.erase(intersections.begin()); } if(intersections.size() % 2 != 0) { ignoreIntersections.push_back(intersections[intersections.size()-1]); intersections.pop_back(); } std::vector<std::pair<CCPoint, CCPoint> > intersectionPairs; intersectionPairs.reserve(intersections.size() / 2); for(int i = 0; i < intersections.size(); i += 2) { intersectionPairs.push_back(std::make_pair(intersections[i], intersections[i+1])); } splitPolygons.push_back(std::make_pair(Rig(), CCPoint())); currentRig = &splitPolygons[0]; for(int y = 0; y < originalRig.size(); y++) { CCPoint edgeStart = originalRig[y]; CCPoint edgeEnd = originalRig[ (y+1) % originalRig.size()]; if(!RigContain(currentRig->first, edgeStart)) { currentRig->first.push_back(edgeStart); } //Check for intersections with the split line: bool intersects = ccpSegmentIntersect(startPoint, endPoint, edgeStart, edgeEnd); if(intersects) { CCPoint intersectionPoint = ccpIntersectPoint(startPoint, endPoint, edgeStart, edgeEnd); //These points should be ignored. if(RigContain(ignoreIntersections, intersectionPoint)) { continue; } //Add the intersection point to the current polygon. if(!RigContain(currentRig->first, intersectionPoint)) { currentRig->first.push_back(intersectionPoint); } CCPoint pairs; //Find the intersction point in the intersection pairs. for(int f = 0; f < intersectionPairs.size(); f ++) { if(intersectionPairs[f].first.equals(intersectionPoint)) { pairs = intersectionPairs[f].second; break; } if(intersectionPairs[f].second.equals(intersectionPoint)) { pairs = intersectionPairs[f].first; break; } } assert(!pairs.equals(CCPointZero)); if(!RigContain(currentRig->first, pairs)) { currentRig->first.push_back(pairs); } //Set its partner as the crossback point for the current polygon. currentRig->second = pairs; bool found = false; for(int x = 0; x < splitPolygons.size(); x ++) { //If there is an existing polygon with a crossback for this edge if(&splitPolygons[x] != currentRig && (splitPolygons[x].second.equals(pairs) || splitPolygons[x].second.equals(intersectionPoint)) ) { //Set the current polygon to be that polygon currentRig = &splitPolygons[x]; found = true; break; } } //Else if(!found) { //Append a new polygon and new crossback point to the output lists and make it current splitPolygons.push_back(std::make_pair(Rig(), CCPoint())); currentRig = &splitPolygons[splitPolygons.size()-1]; } if(!RigContain(currentRig->first, edgeEnd)) { currentRig->first.push_back(edgeEnd); } } } for(int i = 0; i < splitPolygons.size(); i++) { Rig rig = splitPolygons[i].first; finalRigs.push_back(rig); } return true; }