void create()
{
resize(1000, 233);
gridLayout = new QGridLayout(this);
treeWidget = new QTreeWidget(this);
gridLayout->addWidget(treeWidget, 0, 0, 2, 1);
spinPrecision = new QSpinBox(this);
gridLayout->addWidget(spinPrecision, 0, 1, 1, 1);
verticalSpacer = new QSpacerItem(20, 20, QSizePolicy::Minimum, QSizePolicy::Expanding);
gridLayout->addItem(verticalSpacer, 1, 1, 1, 1);
QStringList itemInfo("Col1");
itemInfo.append("Col2");
itemInfo.append("Col3");
itemInfo.append("Dummy");
// Developer no. could also have been social security number og some other id.
treeWidget->setHeaderLabels(itemInfo);
QStringList sl1("This is Root Item");
sl1.append("i");
QTreeWidgetItem *rootitem = new QTreeWidgetItem(treeWidget, sl1);
QStringList sl2("This is Child1 Item");
sl2.append("WW");
QTreeWidgetItem *child1 = new QTreeWidgetItem(rootitem, sl2);
QString ii = QString::fromLatin1("ii");
QStringList is;
const int rowCount = 3000;
spinPrecision->setMinimum(-1);
spinPrecision->setMaximum(rowCount + 5);
for (int u = 0; u < rowCount; ++u) {
if (u % 25 == 0)
ii += QString::fromLatin1("i");
else
ii[ii.length() - 1] = QChar::fromLatin1('a' + (u % 25));
ii[ii.length() - 2] = QChar::fromLatin1('i');
is.append(ii);
}
for (int u = 0; u < rowCount - 2; ++u) { // -2 since we have rootitem and child1
QString col1;
col1 = QString::fromLatin1("This is child item %1").arg(u + 2);
QStringList sl(col1);
sl.append(is[u]);
sl.append(is[rowCount - u - 1]);
if (u > 500)
new QTreeWidgetItem(rootitem, sl);
else
new QTreeWidgetItem(child1, sl);
}
treeWidget->header()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
treeWidget->header()->setSectionResizeMode(1, QHeaderView::ResizeToContents);
treeWidget->header()->setSectionResizeMode(2, QHeaderView::ResizeToContents);
spinPrecision->setValue(treeWidget->header()->resizeContentsPrecision());
connect(spinPrecision, SIGNAL(valueChanged(int)), this, SLOT(slotValueChanged(int)));
} // setupUi
bool strings_similar(const char* str1, const char* str2, const char* delims)
{
StringList sl1(str1, delims);
StringList sl2(str2, delims);
return sl1.number() == sl2.number() &&
sl1.contains_list(sl2, false) &&
sl2.contains_list(sl1, false);
}
void *fetchNextBuffer() {
tbb::spin_mutex::scoped_lock sl1(buffer_mutex);
for(size_t icnt = 0; icnt < n_buffers; ++icnt) {
if(buf_available[icnt]) {
buf_available[icnt] = false;
return buffers[icnt];
}
}
ASSERT(0, "Ran out of buffers");
return 0;
}
void UiTestApp::startup()
{
ui->enable();
ui->rootView->layer->backgroundColor(clearColor);
ui->rootView->layer->name = "root";
LayerPtr sl1(new Layer);
sl1->rect(Rect(50,50,50,50));
sl1->backgroundColor(greenColor);
sl1->name = "green";
sl1->cornerRadius(4);
LayerPtr sl2(new Layer);
sl2->rect(Rect(75,100,30,40));
sl2->backgroundColor(yellowColor);
sl2->name = "yellow";
sl2->cornerRadius(12);
LayerPtr sl3(new Layer);
sl3->rect(Rect(0,0,90,10));
sl3->backgroundColor(blueColor);
sl3->name = "blue";
sl3->cornerRadius(4);
LayerPtr sl4(new Layer);
sl4->rect(Rect(100,50,50,50));
sl4->backgroundColor(whiteColor);
sl4->name = "reddy";
sl4->cornerRadius(20);
sl4->borderColor(blueColor);
sl4->borderWidth(1);
LayerPtr sl5(new Layer);
sl5->rect(Rect(130,130,165,165));
sl5->backgroundColor(whiteColor);
sl5->name = "arrow";
sl5->backgroundImage(resourceManager->image("resources/images/arrow.png"));
sl5->backgroundImage()->orientation = ImageOrientationUp;
ui->rootView->layer->addSublayer(sl1);
ui->rootView->layer->addSublayer(sl2);
sl2->addSublayer(sl3);
ui->rootView->layer->addSublayer(sl4);
ui->rootView->layer->addSublayer(sl5);
DOUT("root Z:"<<ui->rootView->layer->z(););
void SDTestObject::test<3>()
// construction via scalar values
// tests both constructor and initialize forms
{
SDCleanupCheck check;
LLSD b1(true); ensureTypeAndValue("construct boolean", b1, true);
LLSD b2 = true; ensureTypeAndValue("initialize boolean", b2, true);
LLSD i1(42); ensureTypeAndValue("construct int", i1, 42);
LLSD i2 =42; ensureTypeAndValue("initialize int", i2, 42);
LLSD d1(1.2); ensureTypeAndValue("construct double", d1, 1.2);
LLSD d2 = 1.2; ensureTypeAndValue("initialize double", d2, 1.2);
LLUUID newUUID;
newUUID.generate();
LLSD u1(newUUID);
ensureTypeAndValue("construct UUID", u1, newUUID);
LLSD u2 = newUUID;
ensureTypeAndValue("initialize UUID", u2, newUUID);
LLSD ss1(std::string("abc"));
ensureTypeAndValue("construct std::string", ss1, "abc");
LLSD ss2 = std::string("abc");
ensureTypeAndValue("initialize std::string",ss2, "abc");
LLSD sl1(std::string("def"));
ensureTypeAndValue("construct std::string", sl1, "def");
LLSD sl2 = std::string("def");
ensureTypeAndValue("initialize std::string", sl2, "def");
LLSD sc1("ghi");
ensureTypeAndValue("construct const char*", sc1, "ghi");
LLSD sc2 = "ghi";
ensureTypeAndValue("initialize const char*",sc2, "ghi");
LLDate aDay("2001-10-22T10:11:12.00Z");
LLSD t1(aDay); ensureTypeAndValue("construct LLDate", t1, aDay);
LLSD t2 = aDay; ensureTypeAndValue("initialize LLDate", t2, aDay);
LLURI path("http://slurl.com/secondlife/Ambleside/57/104/26/");
LLSD p1(path); ensureTypeAndValue("construct LLURI", p1, path);
LLSD p2 = path; ensureTypeAndValue("initialize LLURI", p2, path);
const char source[] = "once in a blue moon";
std::vector<U8> data;
copy(&source[0], &source[sizeof(source)], back_inserter(data));
LLSD x1(data); ensureTypeAndValue("construct vector<U8>", x1, data);
LLSD x2 = data; ensureTypeAndValue("initialize vector<U8>", x2, data);
}
void FAGeneral::calculateSlope(double* xm,double* ngroup,NumericVector xv,
std::string weights, double gamma, NumericMatrix W){
double sign;
double sum1=0,sum2=0;
double N = 0;
for (int i=0; i<K; i++){
N += ngroup[i]; // number of individuals in all groups
}
if (weights=="default"){ // easiest
if (N==K){ //slopes are known (clusterpath case)
for (int i =0; i<K; i++){
sl.push_back(K-1-2*i);
}
}else{ // nk.nl weights (O(n) calculation)
for (int i=1;i<K;i++){
sum1 += ngroup[i];
}
sl.push_back(sum1);
for (int i =0; i<(K-1);i++){
sl.push_back(sl[i]-ngroup[i]-ngroup[i+1]);
}
}
}else if (weights == "laplace"){ // O(n) calculation
sum1 = 0;
sum2 = 0;
vector<double> sl1(K),sl2(K);
for (int i=K-1;i>0;i--){
sum1 += ngroup[i]*exp(-gamma * xm[i]);
sl1[i-1] = sum1;
}
sl1[K-1] =0;
for (int i=1;i<K;i++){
sum2 += ngroup[i-1]*exp(gamma * xm[i-1]);
sl2[i] = sum2;
}
sl2[0] =0;
for (int i=0;i<K;i++){
sl.push_back(sl1[i]*exp(gamma * xm[i])- sl2[i]*exp(-gamma * xm[i]));
}
// O(n2) calculation for all the rest
// gaussian and adaptive trick : summing starting by the smallest element for each line
// the smallest are the one away from the "diagonal"
// create two vectors of sum and then add them
}else if (weights == "gaussian"){
// calculate the positive part
for(int i=0;i<(K-1);i++){
sum1=0;
for(int j =K-1;j>i;j--){
sum1 += ngroup[j] * exp(-gamma* square(xm[i]-xm[j]));
}
sl.push_back(sum1);
}
sl.push_back(0);
// calculate the negative part
for(int i=1;i<K;i++){
sum2=0;
for (int j = 0;j<i ;j++){
sum2 += ngroup[j] * exp(-gamma* square(xm[i]-xm[j]));
}
sl[i]-=sum2;
}
}else if (weights == "adaptive"){
// calculate the positive part
for(int i=0;i<(K-1);i++){
sum1=0;
for(int j =K-1;j>i;j--){
sum1 += ngroup[j] /pow(fabs(xm[i]-xm[j]),gamma);
}
sl.push_back(sum1);
}
sl.push_back(0);
// calculate the negative part
for(int i=1;i<K;i++){
sum2=0;
for (int j = 0;j<i ;j++){
sum2 += ngroup[j] /pow(fabs(xm[i]-xm[j]),gamma);
}
sl[i]-=sum2;
}
}else if (weights == "naivettest"){
for (int i=0; i<K; i++){
sum1 = 0;
sign = -1.0;
for (int j=0; j<K; j++){
if (i==j){
sign= 1.0;
}else{
sum1+= sign / sqrt(1/ngroup[i]+1/ngroup[j]) ;
}
}
sl.push_back(sum1/ ngroup[i]);
}
}else if (weights == "ttest"){
for (int i=0; i<K; i++){
sum1 = 0;
sign = -1.0;
for (int j=0; j<K; j++){
if (i==j){
sign= 1.0;
}else{
sum1+= sign * sqrt(((ngroup[i]-1)*xv[i] + (ngroup[j]-1)*xv[j])/(ngroup[i]+ngroup[j]-2)) /sqrt(1/ngroup[i]+1/ngroup[j]) ;
}
}
sl.push_back(sum1/ ngroup[i]);
}
}else if (weights == "welch"){
for (int i=0; i<K; i++){
sum1 = 0;
sign = -1.0;
for (int j=0; j<K; j++){
if (i==j){
sign= 1.0;
}else{
sum1+= sign * sqrt(xv[i]/ngroup[i]+xv[j]/ngroup[j])/(1/ngroup[i]+1/ngroup[j]) ;
}
}
sl.push_back(sum1/ngroup[i]);
}
}else if (weights == "personal"){
for (int i=0; i<K; i++){
sum1 = 0;
sign = -1.0;
for (int j=0; j<K; j++){
if (i==j){
sign= 1.0;
}else{
sum1 += sign * W(i,j);
}
}
sl.push_back(sum1/ngroup[i]);
}
}
}
int screen_1::Run(sf::RenderWindow &App)
{
hop.setBuffer(hopFile);
trucked.setBuffer(truckedFile);
dunked.setBuffer(dunkedFile);
// Clock
sf:: Clock clock;
sf::Time time;
sf::Time delay;
// Plays Intro
intro.play();
delay = intro.getDuration();
time = clock.getElapsedTime();
// Music
while ( clock.getElapsedTime() <= delay )
{
//cout << "NO";
}
froggerTheme.setVolume(50);
froggerTheme.play();
clock.restart();
sf::Event Event;
bool Running = true;
int sum = 0;// for log testing purposes
int sum2 = 0;
int sum3 = 0;
int sum4 = 0;
int sum5 = 0;
int sum6 = 0;
int sum7 = 0;
int sum8 = 0;
int sum9 = 0;
int sum10 = 0;
while (Running)
{
// Timer Rect and Clock
double time = clock.getElapsedTime().asSeconds();
if(time >= 1.5)
{
timeRect.width = timeRect.width - 2.383;
timer.setTextureRect(timeRect);
clock.restart();
}
if(timeRect.width <= 0)
{
frogOnLily1 = false;
frogOnLily2 = false;
frogOnLily3 = false;
frogOnLily4 = false;
frogOnLily5 = false;
mainPlayer.setNumLives(3);
rectSource.width = 115;
life.setTextureRect(rectSource);
occupied1.setPosition(-100, -100);
occupied2.setPosition(-100, -100);
occupied3.setPosition(-100, -100);
occupied4.setPosition(-100, -100);
occupied5.setPosition(-100, -100);
froggerTheme.pause();
clock.restart();
timeRect.width = 143;
timer.setTextureRect(timeRect);
frogger.setPosition(320, 605);
return 2;
}
// *********************************************************************
// Creating the objects of Object class for continuous movement
//
// Object(double posX, double posY, double speed)
// *********************************************************************
// Trucks
Object t1(130, 420,0.2 );
Object t2(550, 290, 0.2);
// Cars
Object c1(-50, 420, 0.3);
Object c2(280, 289, 0.2);
Object c3(0, 289, 0.2);
// Short Logs
Object sl1(0, 125, 0.2);
Object sl2(200, 61, 0.3);
Object sl3(300, 8, 0.4);
// Long Logs
Object l1(799, 8.3, 0.4);
Object l2(500, 125, 0.2);
// Sets object's direction
t1.moveRight(truck);
t2.moveLeft(truck2);
c1.moveRight(car);
c2.moveLeft(car2);
c3.moveLeft(car3);
sl1.moveRight(shortLog);
sl2.moveLeft(shortLog2);
sl3.moveRight(shortLog3);
l1.moveRight(longLog);
l2.moveRight(longLog2);
// *********************************************************************
// The following rectangles are for collision detection
// *********************************************************************
// Frog
sf::RectangleShape rect;
// Trucks
sf::RectangleShape rect2;
sf::RectangleShape rect3;
// Cars
sf::RectangleShape rect4;
sf::RectangleShape rect5;
sf::RectangleShape rect6;
// Short Logs
sf::RectangleShape rect7;
sf::RectangleShape rect8;
sf::RectangleShape rect9;
// Long Logs
sf::RectangleShape rect10;
sf::RectangleShape rect11;
// River
sf::RectangleShape rect12;
// Lilypads
sf::RectangleShape rect13;
sf::RectangleShape rect14;
sf::RectangleShape rect15;
sf::RectangleShape rect16;
sf::RectangleShape rect17;
// *********************************************************************
// Setting size of rectangles aka size(width, height)
// *********************************************************************
// Frog
sf::Vector2f size(40, 40);
// Truck
sf::Vector2f size2(120, 70);
sf::Vector2f size3(120, 70);
sf::Vector2f size4(95, 70);
// Cars
sf::Vector2f size5(95, 70);
sf::Vector2f size6(95, 70);
// Short Logs
sf::Vector2f size7(85, 35);
sf::Vector2f size8(85, 35);
sf::Vector2f size9(85, 35);
// Long Log
sf::Vector2f size10(135, 35);
sf::Vector2f size11(135, 35);
// River
sf::Vector2f size12(800, 230);
// Lilypads
sf::Vector2f size13(60, 60);
sf::Vector2f size14(60, 60);
sf::Vector2f size15(60, 60);
sf::Vector2f size16(60, 60);
sf::Vector2f size17(60, 60);
// *********************************************************************
// Get pos of every object
// *********************************************************************
// Trucks
sf::Vector2f objectPos = truck.getPosition();
sf::Vector2f objectPos2 = truck2.getPosition();
// Cars
sf::Vector2f objectPos3 = car.getPosition();
sf::Vector2f objectPos4 = car2.getPosition();
sf::Vector2f objectPos5 = car3.getPosition();
// Short Logs
sf::Vector2f objectPos6 = shortLog.getPosition();
sf::Vector2f objectPos7 = shortLog2.getPosition();
sf::Vector2f objectPos8 = shortLog3.getPosition();
// Long Logs
sf::Vector2f objectPos9 = longLog.getPosition();
sf::Vector2f objectPos10 = longLog2.getPosition();
// Lilypad
sf::Vector2f objectPos11 = lillypad.getPosition();
sf::Vector2f objectPos12 = lillypad2.getPosition();
sf::Vector2f objectPos13 = lillypad3.getPosition();
sf::Vector2f objectPos14 = lillypad4.getPosition();
sf::Vector2f objectPos15 = lillypad5.getPosition();
// *********************************************************************
// Sets boundary settings
// *********************************************************************
sf::Vector2f pos = frogger.getPosition();
// Frog
rect.setPosition(pos.x + 30 , pos.y +10);
rect.setSize(size);
rect.setFillColor(sf::Color::Transparent);
rect.setOutlineColor(sf::Color::Red);
rect.setOutlineThickness(5);
// Trucks
rect2.setPosition(objectPos.x + 40, objectPos.y + 20);
rect2.setSize(size2);
rect2.setFillColor(sf::Color::Transparent);
rect2.setOutlineColor(sf::Color::Red);
rect2.setOutlineThickness(5);
rect3.setPosition(objectPos2.x + 40, objectPos2.y + 60);
rect3.setSize(size3);
rect3.setFillColor(sf::Color::Transparent);
rect3.setOutlineColor(sf::Color::Red);
rect3.setOutlineThickness(5);
// Cars
rect4.setPosition(objectPos3.x + 45, objectPos3.y + 70);
rect4.setSize(size4);
rect4.setFillColor(sf::Color::Transparent);
rect4.setOutlineColor(sf::Color::Red);
rect4.setOutlineThickness(5);
rect5.setPosition(objectPos4.x + 50, objectPos4.y + 70);
rect5.setSize(size5);
rect5.setFillColor(sf::Color::Transparent);
rect5.setOutlineColor(sf::Color::Red);
rect5.setOutlineThickness(5);
rect6.setPosition(objectPos5.x + 50, objectPos5.y + 70);
rect6.setSize(size6);
rect6.setFillColor(sf::Color::Transparent);
rect6.setOutlineColor(sf::Color::Red);
rect6.setOutlineThickness(5);
// Short Logs
rect7.setPosition(objectPos6.x + 30, objectPos6.y + 80);
rect7.setSize(size7);
rect7.setFillColor(sf::Color::Transparent);
rect7.setOutlineColor(sf::Color::Red);
rect7.setOutlineThickness(5);
rect8.setPosition(objectPos7.x + 30, objectPos7.y + 80);
rect8.setSize(size8);
rect8.setFillColor(sf::Color::Transparent);
rect8.setOutlineColor(sf::Color::Red);
rect8.setOutlineThickness(5);
rect9.setPosition(objectPos8.x + 30, objectPos8.y + 80);
rect9.setSize(size9);
rect9.setFillColor(sf::Color::Transparent);
rect9.setOutlineColor(sf::Color::Red);
rect9.setOutlineThickness(5);
// Long Logs
rect10.setPosition(objectPos9.x + 35, objectPos9.y + 70);
rect10.setSize(size10);
rect10.setFillColor(sf::Color::Transparent);
rect10.setOutlineColor(sf::Color::Red);
rect10.setOutlineThickness(5);
rect11.setPosition(objectPos10.x + 35, objectPos10.y + 70);
rect11.setSize(size11);
rect11.setFillColor(sf::Color::Transparent);
rect11.setOutlineColor(sf::Color::Red);
rect11.setOutlineThickness(5);
// River
rect12.setPosition(0, 0);
rect12.setSize(size12);
rect12.setFillColor(sf::Color::Transparent);
rect12.setOutlineColor(sf::Color::Red);
rect12.setOutlineThickness(5);
// Lilypads
rect13.setPosition(objectPos11.x + 30, objectPos11.y+40);
rect13.setSize(size13);
rect13.setFillColor(sf::Color::Transparent);
rect13.setOutlineColor(sf::Color::Red);
rect13.setOutlineThickness(5);
rect14.setPosition(objectPos12.x + 30 , objectPos12.y+40);
rect14.setSize(size14);
rect14.setFillColor(sf::Color::Transparent);
rect14.setOutlineColor(sf::Color::Red);
rect14.setOutlineThickness(5);
rect15.setPosition(objectPos13.x + 30, objectPos13.y+40);
rect15.setSize(size15);
rect15.setFillColor(sf::Color::Transparent);
rect15.setOutlineColor(sf::Color::Red);
rect15.setOutlineThickness(5);
rect16.setPosition(objectPos14.x + 30 , objectPos14.y+40);
rect16.setSize(size16);
rect16.setFillColor(sf::Color::Transparent);
rect16.setOutlineColor(sf::Color::Red);
rect16.setOutlineThickness(5);
rect17.setPosition(objectPos15.x + 30 , objectPos15.y+40);
rect17.setSize(size17);
rect17.setFillColor(sf::Color::Transparent);
rect17.setOutlineColor(sf::Color::Red);
rect17.setOutlineThickness(5);
// *********************************************************************
// Frogger Hit Truck 1
// *********************************************************************
if (rect.getGlobalBounds().intersects(rect2.getGlobalBounds()))
{
froggerTheme.pause();
trucked.play();
lives = mainPlayer.getNumLives();
mainPlayer.setNumLives(lives - 1);
mainPlayer.setIsHit(true);
rectSource.width -= 38.3;
life.setTextureRect(rectSource);
froggerTheme.play();
//death.setPosition(-100,-100);
}
// *********************************************************************
// Frogger Hit Truck 2
// *********************************************************************
if (rect.getGlobalBounds().intersects(rect3.getGlobalBounds()))
{
froggerTheme.pause();
trucked.play();
lives = mainPlayer.getNumLives();
mainPlayer.setNumLives(lives - 1);
mainPlayer.setIsHit(true);
rectSource.width -= 38.3;
life.setTextureRect(rectSource);
sf::Vector2f pos = frogger.getPosition();
death.setPosition(pos);
froggerTheme.play();
death.setPosition(-100,-100);
}
// *********************************************************************
// Frogger Hit Car 1
// *********************************************************************
if (rect.getGlobalBounds().intersects(rect4.getGlobalBounds()))
{
froggerTheme.pause();
trucked.play();
lives = mainPlayer.getNumLives();
mainPlayer.setNumLives(lives - 1);
mainPlayer.setIsHit(true);
rectSource.width -= 38.3;
life.setTextureRect(rectSource);
sf::Vector2f pos = frogger.getPosition();
death.setPosition(pos);
froggerTheme.play();
death.setPosition(-100,-100);
}
// *********************************************************************
// Frogger Hit Car 2
// *********************************************************************
if (rect.getGlobalBounds().intersects(rect5.getGlobalBounds()))
{
froggerTheme.pause();
trucked.play();
lives = mainPlayer.getNumLives();
mainPlayer.setNumLives(lives - 1);
mainPlayer.setIsHit(true);
rectSource.width -= 38.3;
life.setTextureRect(rectSource);
sf::Vector2f pos = frogger.getPosition();
death.setPosition(pos);
froggerTheme.play();
death.setPosition(-100,-100);
}
// *********************************************************************
// Frogger Hit Car 3
// *********************************************************************
if (rect.getGlobalBounds().intersects(rect6.getGlobalBounds()))
{
froggerTheme.pause();
trucked.play();
lives = mainPlayer.getNumLives();
mainPlayer.setNumLives(lives - 1);
mainPlayer.setIsHit(true);
rectSource.width -= 38.3;
life.setTextureRect(rectSource);
sf::Vector2f pos = frogger.getPosition();
death.setPosition(pos);
froggerTheme.play();
death.setPosition(-100,-100);
}
// *********************************************************************
// Below this line will be log collision checking
// *********************************************************************
if (rect.getGlobalBounds().intersects(rect7.getGlobalBounds()))
{
frogger.setPosition(objectPos6.x + 45 + sum2 , objectPos6.y + 80 + sum);
isOnLog = true;
}
else
{
isOnLog = false;
sum = 0;
sum2 = 0;
}
if (rect.getGlobalBounds().intersects(rect8.getGlobalBounds()))
{
frogger.setPosition(objectPos7.x + 45 + sum4, objectPos7.y + 80 + sum3);
isOnLog2 = true;
}
else
{
isOnLog2 = false;
sum3 = 0;
sum4 = 0;
}
if (rect.getGlobalBounds().intersects(rect9.getGlobalBounds()))
{
frogger.setPosition(objectPos8.x + 45+sum6, objectPos8.y + 80+sum5);
isOnLog3 = true;
}
else
{
isOnLog3 = false;
sum5 = 0;
sum6 = 0;
}
if (rect.getGlobalBounds().intersects(rect10.getGlobalBounds()))
{
frogger.setPosition(objectPos9.x + 45 + sum8, objectPos9.y + 70+ sum7);
isOnLog4 = true;
}
else
{
isOnLog4 = false;
sum7 = 0;
sum8 = 0;
}
if (rect.getGlobalBounds().intersects(rect11.getGlobalBounds()))
{
frogger.setPosition(objectPos10.x + 45+ sum10, objectPos10.y + 70+sum9);
isOnLog5 = true;
}
else
{
isOnLog5 = false;
sum9 = 0;
sum10 = 0;
}
// *********************************************************************
// Below this line will be lily collision checking
// *********************************************************************
if (rect.getGlobalBounds().intersects(rect13.getGlobalBounds()))
{
isOnLily = true;
if (frogOnLily1 == false)
{
score += 50;
}
frogOnLily1 = true;
sf::Vector2f lilyPos = rect13.getPosition();
occupied1.setPosition(lilyPos);
}
if (rect.getGlobalBounds().intersects(rect14.getGlobalBounds()))
{
isOnLily = true;
if (frogOnLily2 == false)
{
score += 50;
}
frogOnLily2 = true;
sf::Vector2f lilyPos = rect14.getPosition();
occupied2.setPosition(lilyPos);
}
if (rect.getGlobalBounds().intersects(rect15.getGlobalBounds()))
{
isOnLily = true;
if (frogOnLily3 == false)
{
score += 50;
}
frogOnLily3 = true;
sf::Vector2f lilyPos = rect15.getPosition();
occupied3.setPosition(lilyPos);
}
if (rect.getGlobalBounds().intersects(rect16.getGlobalBounds()))
{
isOnLily = true;
if (frogOnLily4 == false)
{
score += 50;
}
frogOnLily4 = true;
sf::Vector2f lilyPos = rect16.getPosition();
occupied4.setPosition(lilyPos);
}
if (rect.getGlobalBounds().intersects(rect17.getGlobalBounds()))
{
isOnLily = true;
if (frogOnLily5 == false)
{
score += 50;
}
frogOnLily5 = true;
sf::Vector2f lilyPos = rect17.getPosition();
occupied5.setPosition(lilyPos);
}
// *********************************************************************
// Checks if frogger is on log AND goes outside screen boundaries
// if so frogger dies
// *********************************************************************
sf::Vector2f location = frogger.getPosition();
// Checks if frogger went out of bounds
if (rect.getGlobalBounds().intersects(rect12.getGlobalBounds()))
{
if ((isOnLog || isOnLog2 || isOnLog3 || isOnLog4 || isOnLog5) && (location.x >= 740 || location.x < -40))
{
mainPlayer.setIsHit(true);
lives = mainPlayer.getNumLives();
mainPlayer.setNumLives(lives - 1);
rectSource.width -= 38.3;
life.setTextureRect(rectSource);
}
}
// Checks if frogger is on the logs not the water
if (rect.getGlobalBounds().intersects(rect12.getGlobalBounds()))
{
if (isOnLog || isOnLog2 || isOnLog3 || isOnLog4 || isOnLog5)
{
//this frogger is on the logs not the water
}
else
{
froggerTheme.pause();
dunked.play();
froggerTheme.play();
mainPlayer.setIsHit(true);
lives = mainPlayer.getNumLives();
mainPlayer.setNumLives(lives - 1);
rectSource.width -= 38.3;
life.setTextureRect(rectSource);
}
}
// Checks if the frog has landed on a lilypad
if (isOnLily || isOnLily2 || isOnLily3 || isOnLily4 || isOnLily5)
{
// the frog has landed on the lily pad
froggerLanded = true;
}
// *********************************************************************
// Checks if the frog has landed on all 5 lilypads if so you win
// *********************************************************************
if (frogOnLily1 && frogOnLily2 && frogOnLily3 && frogOnLily4 && frogOnLily5)
{
score += 10000;
frogOnLily1 = false;
frogOnLily2 = false;
frogOnLily3 = false;
frogOnLily4 = false;
frogOnLily5 = false;
mainPlayer.setNumLives(3);
rectSource.width = 115;
life.setTextureRect(rectSource);
occupied1.setPosition(-100, -100);
occupied2.setPosition(-100, -100);
occupied3.setPosition(-100, -100);
occupied4.setPosition(-100, -100);
occupied5.setPosition(-100, -100);
froggerTheme.pause();
clock.restart();
timeRect.width = 143;
timer.setTextureRect(timeRect);
frogger.setPosition(320, 605);
return 2;
}
while (App.pollEvent(Event))
{
// Window closed
if (Event.type == sf::Event::Closed)
{
return (-1);
}
// *********************************************************************
// LEFT
// *********************************************************************
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left))
{
if (isOnLog)
{
sum2 = (sum2 + (20 * -1));
}
if (isOnLog2)
{
sum4 = (sum4 + (20 * -1));
}
if (isOnLog3)
{
sum6 = (sum6 + (20 * -1));
}
if (isOnLog4)
{
sum8 = (sum8 + (20 * -1));
}
if (isOnLog5)
{
sum10 = (sum10 + (20 * -1));
}
sf::Vector2f pos = frogger.getPosition();
if (pos.x < 0)
{
frogger.move(0, 0);
}
else
{
if (rectSourceSprite.left != 216)
{
rectSourceSprite.left = 216;
rectSourceSprite.width = 55;
frogger.setTextureRect(rectSourceSprite);
}
score += 10;
froggerTheme.setVolume(0);
hop.play();
frogger.move(-40, 0);
froggerTheme.setVolume(50);
}
}
// *********************************************************************
// RIGHT
// *********************************************************************
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right))
{
if (isOnLog)
{
sum2 = (sum2 + (20));
}
if (isOnLog2)
{
sum4 = (sum4 + (20));
}
if (isOnLog3)
{
sum6 = (sum6 + (20));
}
if (isOnLog4)
{
sum8 = (sum8 + (20));
}
if (isOnLog5)
{
sum10 = (sum10 + (20));
}
sf::Vector2f pos = frogger.getPosition();
if (pos.x >= 640)
{
frogger.move(0, 0);
}
else
{
if (rectSourceSprite.left != 89)
{
rectSourceSprite.left = 89;
rectSourceSprite.width = 60;
frogger.setTextureRect(rectSourceSprite);
}
score += 10;
froggerTheme.setVolume(0);
hop.play();
frogger.move(40, 0);
froggerTheme.setVolume(50);
}
}
// *********************************************************************
// UP
// *********************************************************************
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up))
{
if (isOnLog)
{
sum = (sum + (20 * -1));
}
if (isOnLog2)
{
sum3 = (sum3 + (20 * -1));
}
if (isOnLog3)
{
sum5 = (sum5 + (20 * -1));
}
if (isOnLog4)
{
sum7 = (sum7 + (20 * -1));
}
if (isOnLog5)
{
sum9 = (sum9 + (20 * -1));
}
if (pos.y <= -35)
{
frogger.move(0, 0);
}
else
{
if (rectSourceSprite.left != 0)
{
rectSourceSprite.left = 0;
rectSourceSprite.width = 89;
frogger.setTextureRect(rectSourceSprite);
}
score += 10;
froggerTheme.setVolume(0);
hop.play();
frogger.move(0, -40);
froggerTheme.setVolume(50);
}
}
// *********************************************************************
// DOWN
// *********************************************************************
if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down))
{
if (isOnLog)
{
sum = (sum + 20);
}
if (isOnLog2)
{
sum3 = (sum3 + 20);
}
if (isOnLog3)
{
sum5 = (sum5 + 20);
}
if (isOnLog4)
{
sum7 = (sum7 + 20);
}
if (isOnLog5)
{
sum9 = (sum9 + 20);
}
sf::Vector2f pos = frogger.getPosition();
if (pos.y >= 650)
{
frogger.move(0, 0);
}
else
{
if (rectSourceSprite.left != 149)
{
rectSourceSprite.left = 149;
rectSourceSprite.width = 67;
frogger.setTextureRect(rectSourceSprite);
}
score += 10;
froggerTheme.setVolume(0);
hop.play();
frogger.move(0, 40);
froggerTheme.setVolume(50);
}
}
}
// *********************************************************************
// Checks if player has been hit
// *********************************************************************
if (mainPlayer.getIsHit() == true)
{
cout << " Number of lives" << mainPlayer.getNumLives() << endl;
mainPlayer.setIsHit(false);
rectSourceSprite.left = 0;
rectSourceSprite.width = 89;
frogger.setTextureRect(rectSourceSprite);
frogger.setPosition(320, 605);
}
// *********************************************************************
// Checks if player landed on lily
// *********************************************************************
if (froggerLanded == true)
{
froggerLanded = false;
rectSourceSprite.left = 0;
rectSourceSprite.width = 89;
frogger.setTextureRect(rectSourceSprite);
frogger.setPosition(320, 605);
isOnLily = false;
isOnLily2 = false;
isOnLily3 = false;
isOnLily4 = false;
isOnLily5 = false;
}
// *********************************************************************
// Checks if player has run out of lives
// *********************************************************************
if (mainPlayer.getNumLives() < 1)
{
frogOnLily1 = false;
frogOnLily2 = false;
frogOnLily3 = false;
frogOnLily4 = false;
frogOnLily5 = false;
mainPlayer.setNumLives(3);
rectSource.width = 115;
life.setTextureRect(rectSource);
occupied1.setPosition(-100, -100);
occupied2.setPosition(-100, -100);
occupied3.setPosition(-100, -100);
occupied4.setPosition(-100, -100);
occupied5.setPosition(-100, -100);
froggerTheme.pause();
clock.restart();
timeRect.width = 143;
timer.setTextureRect(timeRect);
frogger.setPosition(320, 605);
return 2;
}
App.clear(sf::Color(0, 0, 0, 0));
//Drawing
App.draw(background);
App.draw(car2);
App.draw(car3);
App.draw(truck2);
App.draw(truck);
App.draw(car);
App.draw(longLog);
App.draw(longLog2);
App.draw(shortLog);
App.draw(shortLog2);
App.draw(shortLog3);
App.draw(lillypad);
App.draw(lillypad2);
App.draw(lillypad3);
App.draw(lillypad4);
App.draw(lillypad5);
App.draw(life);
App.draw(timer);
App.draw(frogger);
App.draw(occupied1);
App.draw(occupied2);
App.draw(occupied3);
App.draw(occupied4);
App.draw(occupied5);
// *********************************************************************
// The following are for testing purposes only
// Draws the boundary box
// *********************************************************************
App.draw(rect);
App.draw(rect2);
App.draw(rect3);
App.draw(rect4);
App.draw(rect5);
App.draw(rect6);
App.draw(rect7);
App.draw(rect8);
App.draw(rect9);
App.draw(rect10);
App.draw(rect11);
App.draw(rect12);
App.draw(rect13);
App.draw(rect14);
App.draw(rect15);
App.draw(rect16);
App.draw(rect17);
App.display();
}
//Never reaching this point normally, but just in case, exit the application
return -1;
}
list<tuple<string,double>> TaskManager :: Timing ()
{
/*
list<tuple<string,double>>timings;
double time =
RunTiming
( [&] ()
{
ParallelJob ( [] (TaskInfo ti) { ; } ,
TasksPerThread(1) );
});
timings.push_back (make_tuple("parallel job with 1 task per thread", time*1e9));
time =
RunTiming
( [&] ()
{
ParallelJob ( [] (TaskInfo ti) { ; } ,
TasksPerThread(10) );
});
timings.push_back (make_tuple("parallel job with 10 tasks per thread", time*1e9));
time =
RunTiming
( [&] ()
{
ParallelJob ( [] (TaskInfo ti) { ; } ,
TasksPerThread(100) );
});
timings.push_back (make_tuple("parallel job with 100 tasks per thread", time*1e9));
return timings;
*/
// this is the old function moved from the py-interface:
list<tuple<string,double>>timings;
double starttime, time;
double maxtime = 0.5;
size_t steps;
starttime = WallTime();
steps = 0;
do
{
for (size_t i = 0; i < 1000; i++)
ParallelJob ( [] (TaskInfo ti) { ; },
TasksPerThread(1));
steps += 1000;
time = WallTime()-starttime;
}
while (time < maxtime);
timings.push_back(make_tuple("ParallelJob 1 task/thread", time/steps*1e9));
starttime = WallTime();
steps = 0;
do
{
for (size_t i = 0; i < 1000; i++)
ParallelJob ( [] (TaskInfo ti) { ; },
TasksPerThread(100));
steps += 1000;
time = WallTime()-starttime;
}
while (time < maxtime);
timings.push_back(make_tuple("ParallelJob 100 task/thread", time/steps*1e9));
starttime = WallTime();
steps = 0;
do
{
for (int k = 0; k < 10000; k++)
{
SharedLoop2 sl(1000);
steps += 1;
}
time = WallTime()-starttime;
}
while (time < maxtime);
timings.push_back(make_tuple("SharedLoop init", time/steps*1e9));
starttime = WallTime();
steps = 0;
do
{
for (int k = 0; k < 1000; k++)
{
SharedLoop sl(5);
ParallelJob ( [&sl] (TaskInfo ti)
{
for (auto i : sl)
(void)i; // silence warning
} );
}
steps += 1000;
time = WallTime()-starttime;
}
while (time < maxtime);
timings.push_back(make_tuple("short SharedLoop", time/steps*1e9));
starttime = WallTime();
steps = 0;
do
{
for (int k = 0; k < 1000; k++)
{
SharedLoop sl1(5), sl2(5), sl3(5), sl4(5), sl5(5);
ParallelJob ( [&sl1, &sl2, &sl3, &sl4, &sl5] (TaskInfo ti)
{
for (auto i : sl1)
(void)i; // silence warning
for (auto i : sl2)
(void)i; // silence warning
for (auto i : sl3)
(void)i; // silence warning
for (auto i : sl4)
(void)i; // silence warning
for (auto i : sl5)
(void)i; // silence warning
} );
}
steps += 1000;
time = WallTime()-starttime;
}
while (time < maxtime);
timings.push_back(make_tuple("5 short SharedLoops", time/steps*1e9));
starttime = WallTime();
steps = 0;
SharedLoop2 sl2(5);
do
{
for (int k = 0; k < 1000; k++)
{
sl2.Reset(5);
ParallelJob ( [&sl2] (TaskInfo ti)
{
for (auto i : sl2)
(void)i; // silence warning
} );
}
steps += 1000;
time = WallTime()-starttime;
}
while (time < maxtime);
timings.push_back(make_tuple("short SharedLoop2", time/steps*1e9));
{
starttime = WallTime();
steps = 0;
SharedLoop2 sl1(5), sl2(5), sl3(5), sl4(5), sl5(5);
do
{
for (int k = 0; k < 1000; k++)
{
sl1.Reset(5);
sl2.Reset(5);
sl3.Reset(5);
sl4.Reset(5);
sl5.Reset(5);
ParallelJob ( [&sl1,&sl2,&sl3,&sl4,&sl5] (TaskInfo ti)
{
for (auto i : sl1)
(void)i; // silence warning
for (auto i : sl2)
(void)i; // silence warning
for (auto i : sl3)
(void)i; // silence warning
for (auto i : sl4)
(void)i; // silence warning
for (auto i : sl5)
(void)i; // silence warning
} );
}
steps += 1000;
time = WallTime()-starttime;
}
while (time < maxtime);
timings.push_back(make_tuple("5 short SharedLoop2", time/steps*1e9));
}
starttime = WallTime();
steps = 0;
{
SharedLoop2 sl(1000);
do
{
for (int k = 0; k < 1000; k++)
{
sl.Reset(1000);
ParallelJob ( [&sl] (TaskInfo ti)
{
for (auto i : sl)
(void)i; // silence warning
} );
steps += 1000;
}
time = WallTime()-starttime;
}
while (time < maxtime);
timings.push_back(make_tuple("SharedLoop2 1000, time per iteration", time/steps*1e9));
}
{
starttime = WallTime();
steps = 0;
SharedLoop2 sl(1000000);
do
{
sl.Reset(1000000);
ParallelJob ( [&sl] (TaskInfo ti)
{
for (auto i : sl)
(void)i; // silence warning
} );
steps += 1000000;
time = WallTime()-starttime;
}
while (time < maxtime);
timings.push_back(make_tuple("SharedLoop2 1000000, time per iteration", time/steps*1e9));
}
return timings;
}
