void AddTail(int direction, int xPrev,int yPrev)
{
sf::RectangleShape square1(sf::Vector2f(sizex, sizey));
float xNew, yNew;
if(direction == 1){
xNew = xPrev + sizex + 10;
square1.setPosition(xNew,yPrev);
}
else if(direction == 2){
xNew = xPrev - (sizex + 10);
square1.setPosition(xNew,yPrev);
}
else if(direction == 3){
yNew = yPrev + sizey + 10;
square1.setPosition(xPrev,yNew);
}
else if(direction == 4){
yNew = yPrev - (sizey + 10);
square1.setPosition(xPrev,yNew);
}
square1.setFillColor(sf::Color(61, 245, 0));
square1.setOutlineThickness(2);
square1.setOutlineColor(sf::Color(42, 160, 0));
Robjects.push_back(square1);
}
void multipleSWC1()
{
// simple return
int result = 5;
int squared = square1(result);
// return the result (using an AS3 return rather than a C/C++ return)
AS3_Return(result);
}
/* Main program: Using the various functions */
int main (void) {
square1(); /* Calling the square1 function */
square2(7); /* Calling the square2 function using 7 as actual
parameter corresponding to the formal parameter i */
printf("The value of square3() is %d\n", square3()); /* Ysing the square3
function */
printf("The value of square4(5) is %d\n", square4(5)); /* Using the square4
function with 5 as actual parameter corresponding to i */
printf("The value of area(3,7) is %d\n", area(3,7)); /* Using the area
function with 3, 7 as actual parameters corresponding
to b, h respectively */
}
int main(int argc, char const *argv[])
{
square1();
square2(7);
printf("The value of square3() is %d\n", square3());
printf("The value of square4(5) is %d\n", square4(5));
printf("The value of area(3, 7) is %d\n", area(3, 7));
return 0;
}
TEST_F(PolygonMergerTest, TwoSquaresTest){
std::vector<int> square1Points = {0,1,2,3};
std::vector<int> square2Points = {1,5,6,2};
std::vector<int> expected = {2,3,0,1,5,6};
Polygon square1 (square1Points, points);
Polygon square2 (square2Points, points);
SimplePolygonMerger merger;
Polygon p = merger.mergePolygons(square1, square2, points);
EXPECT_EQ(p, Polygon(expected, points));
}
int main()
{
Rectangle square1( 1, 100, 100, 3, 4 );
printRectange( square1 );
Rectangle square2( 2, 50, 50, 0, 4 );
printRectange( square2 );
Rectangle square3( square1 );
printRectange( square3 );
square1 = square2;
printRectange( square1 );
Rectangle* pFoo = Foo();
printRectange( *pFoo );
return 0;
}
static void fill_audio(void *udata, Uint8 *stream, int len)
{
sample_t *samples = (sample_t*)stream;
audio_t *audio = (audio_t*)udata;
int num_samples = len / (sizeof(sample_t));
for(int i = 0; i < num_samples; i++)
{
float t = audio->buffer_pos / (float)FREQUENCY;
int16_t val_l = 0;
int16_t val_r = 0;
uint8_t channels[4];
#if 1
if(audio->sq1.en)
{
channels[0] = square1(t, audio);
}
if(audio->sq2.en)
{
channels[1] = square2(t, audio);
}
if(audio->wave.en && audio->wave.power)
{
channels[2] = wave(t, audio);
}
#endif
#if 1
if (audio->noise.en)
{
channels[3] = noise(t, audio);
}
#endif
for(int i = 0; i < 4; i++)
{
int16_t v = DAC(channels[i]) / 4;
if(BIT_N(audio->control.r_en, i))
{
val_r += v;
}
if(BIT_N(audio->control.l_en, i))
{
val_l += v;
}
}
samples[i] = (sample_t) { .left = val_l / 4, .right = val_r / 4 };
audio->buffer_pos = (audio->buffer_pos + 1) % FREQUENCY;
}
}
static void init_wave_table(audio_t *audio)
{
const uint8_t wave_default_table[32] =
{
0x4, 0x8, 0x0, 0x4, 0x3, 0x4,0xA, 0xA,
0xD, 0x2, 0x8, 0x7, 0x2, 0x9,0xC, 0x3,
0x0, 0x6, 0x9, 0x5, 0x9, 0x5,0x0, 0xB,
0x4, 0x3, 0x8, 0xB, 0xE, 0x2,0xA, 0xD,
};
memcpy(audio->wave_table, wave_default_table, sizeof(audio->wave_table));
}
audio_t *audio_init(cpu_state_t *state)
{
audio_t *out = CALLOC(1, sizeof(audio_t));
out->state = state;
init_wave_table(out);
#if AUDIO
SDL_AudioSpec wanted;
/* Set the audio format */
wanted.freq = FREQUENCY;
wanted.format = AUDIO_S16;
wanted.channels = NUM_CHANNELS;
wanted.samples = NUM_SAMPLES;
wanted.callback = fill_audio;
wanted.userdata = out;
/* Open the audio device, forcing the desired format */
if ( SDL_OpenAudio(&wanted, NULL) < 0 )
{
log_error("Couldn't open audio: %s\n", SDL_GetError());
}
SDL_PauseAudio(0);
#endif
return out;
}
bool updateGame(int& x, int& y, int& xBlock, int& yBlock, int& direction, int& directionOfBack,
bool checkGameOver, float timer, int& red, int& green, int& blue)
{
bool bump = false;
int timing, xNew, yNew, size;
keepMoving(direction, x, y);
square.setPosition(x,y);
elapsedInvincible = clockInvincible.getElapsedTime();
if(invincible1 == true){
if((invincible1 == true)&&(timeInv - elapsedInvincible.asSeconds() <= 0)){
invincible1 = false;
for(int i = 0; i < Robjects.size(); i++){
Robjects[i].setFillColor(sf::Color(61, 245, 0));
Robjects[i].setOutlineThickness(2);
Robjects[i].setOutlineColor(sf::Color(42, 160, 0));
}
}
else if((invincible1 == true)&&(timeInv - elapsedInvincible.asSeconds() < 5)){
timing = (timeInv - elapsedInvincible.asSeconds());
if(timing > 1){
setColor(counter, 1);
}
else if (timing > 2){
setColor(counter, 2);
}
else if(timing > 3){
setColor(counter, 3);
}
else if(timing > 4){
setColor(counter, 4);
}
counter++;
}
else if(invincible1 == true){
for(int i = 0; i < Robjects.size(); i++){
Robjects[i].setFillColor(sf::Color(200, 50, 50));
Robjects[i].setOutlineThickness(2);
Robjects[i].setOutlineColor(sf::Color(40, 40, 40));
}
}
}
else{
for(int i = 0; i < Robjects.size(); i++){
Robjects[i].setFillColor(sf::Color(61, 245, 0));
Robjects[i].setOutlineThickness(2);
Robjects[i].setOutlineColor(sf::Color(42, 160, 0));
}
}
if(eggs == true){
if(timeInv - elapsedInvincible.asSeconds() <= 0){
size = egger.size();
eggs = false;
egger.erase(egger.begin()+0, egger.begin()+size);
window.clear();
}
else{
for(int i = 0; i < 120; i++){
sf::Vector2f position = egger[i].getPosition();
xNew = position.x;
yNew = position.y;
bump = checkBlock(x, y, xNew, yNew);
if(bump == true){
score1 = score1 + 10;
text = convertInt(score1);
score.setString(text);
egger[i].setPosition(-50, -50);
bump = false;
break;
}
}
}
}
else{
bump = checkBlock(x, y, xBlock, yBlock);
if ((bump == true)&&(timer > 200)){
if(invincible == true){
invincible1 = true;
invincible = false;
elapsedInvincible = clockInvincible.getElapsedTime();
timeInv = 15 + elapsedInvincible.asSeconds();
}
if((eggs1 == true)){
sf::RectangleShape square1(sf::Vector2f(sizex, sizey));
square1.setFillColor(sf::Color(175, 175, 175));
square1.setOutlineThickness(2);
square1.setOutlineColor(sf::Color(30, 80, 30));
for(int j = 0; j < 10; j++){
for(int i = 0; i < 12; i++){
square1.setPosition((i*50) + 10, (j*50) + 10);
egger.push_back(square1);
}
}
eggs = true;
eggs1 = false;
elapsedInvincible = clockInvincible.getElapsedTime();
timeInv = 3 + elapsedInvincible.asSeconds();
}
BlockSpawn(xBlock, yBlock);
if(eggs == true){
}
else
egg.setPosition(xBlock,yBlock);
directionOfBack = CreateTail(x, y, direction, checkGameOver, true);
if(killTail == true){
size = Robjects.size();
if(size > 5)
Robjects.erase(Robjects.begin()+size -5, Robjects.begin()+size);
else if(size == 4)
Robjects.erase(Robjects.begin()+size -4, Robjects.begin()+size);
else if(size == 3)
Robjects.erase(Robjects.begin()+size -3, Robjects.begin()+size);
else if(size == 2)
Robjects.erase(Robjects.begin()+size -2, Robjects.begin()+size);
else if(size == 1)
Robjects.erase(Robjects.begin()+size -1, Robjects.begin()+size);
else
{}
killTail = false;
}
if(red == 150)
score1 = score1 + 10;
else if(red == 200)
score1 = score1 + 20;
else if(red == 40)
score1 = score1 + 30;
else if(red == 204)
score1 = score1 + 40;
else if(red == 41)
score1 = score1 + 50;
else if(red == 205)
score1 = score1 + 80;
setEgg(red, green, blue);
text = convertInt(score1);
score.setString(text);
return true;
}
return false;
}
}
void TestStelSphericalGeometry::testContains()
{
Vec3d p0(1,0,0);
Vec3d p1(1,1,1);
p1.normalize();
Vec3d v0;
Vec3d v1;
Vec3d v2;
Vec3d v3;
// Triangle polygons
QVERIFY2(triangle.contains(p1), "Triangle contains point failure");
Vec3d vt(-1, -1, -1);
vt.normalize();
QVERIFY2(!triangle.contains(vt), "Triangle not contains point failure");
foreach(const SphericalCap& h, triangle.getBoundingSphericalCaps())
{
QVERIFY(h.contains(p1));
}
// polygons-point intersect
double deg5 = 5.*M_PI/180.;
double deg2 = 2.*M_PI/180.;
StelUtils::spheToRect(-deg5, -deg5, v3);
StelUtils::spheToRect(+deg5, -deg5, v2);
StelUtils::spheToRect(+deg5, +deg5, v1);
StelUtils::spheToRect(-deg5, +deg5, v0);
//qDebug() << v0.toString() << v1.toString() << v2.toString() << v3.toString();
SphericalConvexPolygon square1(v0, v1, v2, v3);
QVERIFY(square1.checkValid());
QVERIFY2(square1.contains(p0), "Square contains point failure");
QVERIFY2(!square1.contains(p1), "Square not contains point failure");
// polygons-polygons intersect
StelUtils::spheToRect(-deg2, -deg2, v3);
StelUtils::spheToRect(+deg2, -deg2, v2);
StelUtils::spheToRect(+deg2, +deg2, v1);
StelUtils::spheToRect(-deg2, +deg2, v0);
SphericalConvexPolygon square2(v0, v1, v2, v3);
QVERIFY(square2.checkValid());
QVERIFY2(square1.contains(square2), "Square contains square failure");
QVERIFY2(!square2.contains(square1), "Square not contains square failure");
QVERIFY2(square1.intersects(square2), "Square intersect square failure");
QVERIFY2(square2.intersects(square1), "Square intersect square failure");
// Check when the polygons are far appart
QVERIFY(!square1.intersects(opositeSquare));
QVERIFY(!square2.intersects(opositeSquare));
QVERIFY(!holySquare.intersects(opositeSquare));
QVERIFY(!bigSquare.intersects(opositeSquare));
QVERIFY(opositeSquare.intersects(opositeSquare));
// Test the tricky case where 2 polygons intersect without having point within each other
StelUtils::spheToRect(-deg5, -deg2, v3);
StelUtils::spheToRect(+deg5, -deg2, v2);
StelUtils::spheToRect(+deg5, +deg2, v1);
StelUtils::spheToRect(-deg5, +deg2, v0);
SphericalConvexPolygon squareHoriz(v0, v1, v2, v3);
QVERIFY(squareHoriz.checkValid());
StelUtils::spheToRect(-deg2, -deg5, v3);
StelUtils::spheToRect(+deg2, -deg5, v2);
StelUtils::spheToRect(+deg2, +deg5, v1);
StelUtils::spheToRect(-deg2, +deg5, v0);
SphericalConvexPolygon squareVerti(v0, v1, v2, v3);
QVERIFY(squareVerti.checkValid());
QVERIFY2(!squareHoriz.contains(squareVerti), "Special intersect contains failure");
QVERIFY2(!squareVerti.contains(squareHoriz), "Special intersect contains failure");
QVERIFY2(squareHoriz.intersects(squareVerti), "Special intersect failure");
QVERIFY2(squareVerti.intersects(squareHoriz), "Special intersect failure");
}
