void OurHero::drawProjectile(Projectiles projectile[], int size) { for (int i = 0; i < size; i++) { if (projectile[i].isLive()) { al_draw_circle(projectile[i].getX(), projectile[i].getY(), 2, al_map_rgb(255, 255, 255), 2); } } }
void draw_config(game *g) { ALLEGRO_TRANSFORM trans; al_identity_transform(&trans); al_use_transform(&trans); int x, y; x = (g->Size->x - 150) / 2; y = 0; al_draw_text(ttf_font, al_map_rgb(200, 200, 200), x, y, ALLEGRO_ALIGN_LEFT, "CONFIGURATION"); if(get_config("display_width") == NULL) return; x = 100; y = 100; char msg[22]; sprintf(msg, "DISPLAY WIDTH: %d", atoi(get_config("display_width"))); al_draw_text(ttf_font, al_map_rgb(200, 200, 200), x, y, ALLEGRO_ALIGN_LEFT, msg); x = 100; y = 125; sprintf(msg, "DISPLAY HEIGHT: %d", atoi(get_config("display_height"))); al_draw_text(ttf_font, al_map_rgb(200, 200, 200), x, y, ALLEGRO_ALIGN_LEFT, msg); al_draw_circle(80, 110 + config_pos * 25, 3.0, SHOOT_COLOR, 1.5); }
void Draw_body(b2Body* body, b2Vec2 camera) { float scale = 10; b2Vec2 position = scale*body->GetPosition() - camera; float32 angle = body->GetAngle(); al_draw_pixel(position.x, position.y, al_map_rgb_f(1, 0, 0)); for (b2Fixture* f = body->GetFixtureList(); f; f = f->GetNext()) { b2Shape* shape_base = f->GetShape(); if(shape_base->GetType() == b2Shape::e_polygon) { b2PolygonShape& shape = dynamic_cast<b2PolygonShape&>(*shape_base); int np = shape.GetVertexCount (); b2Vec2 pn = scale*shape.GetVertex(np-1); b2Vec2 ps, pe; ps.x = cos(angle)*pn.x - sin(angle)*pn.y; ps.y = sin(angle)*pn.x + cos(angle)*pn.y; for(int i=0; i<np; ++i) { pn = scale*shape.GetVertex(i); pe.x = cos(angle)*pn.x - sin(angle)*pn.y; pe.y = sin(angle)*pn.x + cos(angle)*pn.y; al_draw_line(position.x+ps.x, position.y+ps.y, position.x+pe.x, position.y+pe.y, al_map_rgb_f(1, 0, 0), 0); ps = pe; } } if(shape_base->GetType() == b2Shape::e_circle) { b2CircleShape& shape = dynamic_cast<b2CircleShape&>(*shape_base); al_draw_circle(position.x, position.y, shape.m_radius * scale, al_map_rgb_f(1, 0, 0), 0); } } }
void show_tower_information(Torre torre[], int t, ALLEGRO_FONT *fonte) //Monstra as informaçoes da torre selecionada { al_draw_circle(torre[t].x, torre[t].y, torre[t].range, al_map_rgb(10, 110, 10), 0); al_draw_textf(fonte, al_map_rgb(0, 0, 0), 5 * l_celula, 19 * a_celula, ALLEGRO_ALIGN_LEFT, "Tower type: %i", torre[t].n); al_draw_textf(fonte, al_map_rgb(0, 0, 0), 5 * l_celula, 20 * a_celula, ALLEGRO_ALIGN_LEFT, "Tower fire power: %i", torre[t].fire_power); al_draw_textf(fonte, al_map_rgb(0, 0, 0), 5 * l_celula, 21 * a_celula, ALLEGRO_ALIGN_LEFT, "Tower range: %i", torre[t].range); al_draw_textf(fonte, al_map_rgb(0, 0, 0), 5 * l_celula, 22 * a_celula, ALLEGRO_ALIGN_LEFT, "Tower fire rate: %.2fs", torre[t].fire_rate); al_draw_textf(fonte, al_map_rgb(0, 0, 0), 5 * l_celula, 23 * a_celula, ALLEGRO_ALIGN_LEFT, "Upgrade: %i", torre[t].upgrade); }
/**< Função Desenha um circulo na Janela */ void Des_Circulo(int desenha_circulo, ALLEGRO_FONT *fonte, int x1, int y1, int x2, int y2) { if (desenha_circulo == 1) { float r = sqrt(pow(x1 - x2,2) + pow(y1 - y2,2)); al_draw_text(fonte, al_map_rgb(255, 255, 255), 320, 70, ALLEGRO_ALIGN_CENTRE, "Precione em 2 pontos:"); al_draw_circle(x1, y1, r, al_map_rgb(255, 255, 255), 2); } }
void m_draw_circle(int x, int y, int radius, MCOLOR color, int flags) { if (flags & M_FILLED) { al_draw_filled_circle(x, y, radius, color); } else { al_draw_circle(x, y, radius, color, 1); } }
static void draw_touches(int num, TOUCH touches[]) { int i; for (i = 0; i < num; i++) { int x = touches[i].x; int y = touches[i].y; al_draw_circle(x, y, 50, al_map_rgb(255, 0, 0), 4); } }
// Draw void particle::draw(){ if( type == PIXEL){ al_put_pixel( x, y, color); } else if( type == SQUARE){ al_draw_rectangle( x, y, x + size, y + size, color, 1); } else if( type == CIRCLE){ al_draw_circle( x, y, size, color, 1); } }
void ShapeRenderer::drawCircleOutline(float x, float y, float rad, float lineW, uint8_t r, uint8_t g, uint8_t b, uint8_t a) { ALLEGRO_COLOR color; if (a != UINT8_MAX) color = al_map_rgba(r, g, b, a); else color = al_map_rgb(r, g, b); float adjustedX = (x + xOff) * xScale; float adjustedY = (y + yOff) * yScale; al_draw_circle(adjustedX, adjustedY, rad * ((xScale + yScale) / 2), color, lineW); }
void RenderTarget::drawCircle(float cx, float cy, float r, bool fill, const ALLEGRO_COLOR &color) { convertCoords(cx, cy); if (r <= 0) { return; } setAsCurrent(); if (fill) { al_draw_filled_circle(cx, cy, r, color); } else { al_draw_circle(cx, cy, r, color, CBEnchanted::instance()->gfxInterface->getLineWidth()); } }
int main() { ALLEGRO_DISPLAY *display = NULL; ALLEGRO_FONT* century_gothic24; if(!al_init()) { printf("al_init Failed!\n"); return -1; } if(!al_init_primitives_addon()) { printf("al_init_primitives_addon Failed!\n"); return -1; } display = al_create_display(640, 480); if(!display) { printf("al_create_display Failed!\n"); return -1; } al_init_font_addon(); al_init_ttf_addon(); century_gothic24 = al_load_ttf_font("C:\\Windows\\Fonts\\GOTHIC.TTF" , 24, ALLEGRO_ALIGN_CENTRE); // Paint a hidden screen (a buffer), that we'll apply later. al_clear_to_color(al_map_rgb(0,0,0)); // Draw an ugly red triangle to the buffer. al_draw_filled_triangle(10, 10, 200, 200, 350, 230, al_map_rgb(255,0,0)); // Draw text to the buffer al_draw_text(century_gothic24, al_map_rgb(255,255,255), 550, 440, ALLEGRO_ALIGN_CENTRE, "Hello World!"); // Draw a line to the buffer al_draw_line(400,400,500,34,al_map_rgb(255,255,255), 5); // Draw a circle al_draw_circle(300,300, 50, al_map_rgb(255,255,0), 5); // Draw Eclipse al_draw_filled_ellipse(500, 300, 40, 56, al_map_rgb(255,0,255)); // Draw a rectangle al_draw_rectangle(100,200,200,300,al_map_rgb(0,255,0), 6);s // Draw a polygon al_draw_filled_rectangle(0,480,50,400,al_map_rgb(25,185,35)); al_draw_filled_rectangle(0,480,200,450,al_map_rgb(25,185,35)); // Apply the buffer to the front. al_flip_display(); // Wait for 3 secs. al_rest(10.0); // Destroying the display we created, to avoid memory leaking. al_destroy_display(display); return 0; }
void bn_desenhaBola(const BN_BOLA *b) { if(b->efeito == 'c') { al_draw_circle(b->x, b->y, b->raio, b->cor, 2); } else if(b->efeito == 't') { al_draw_filled_circle(b->x, b->y, b->raio, al_map_rgba(255, 255, 255, 128)); } else { al_draw_filled_circle(b->x, b->y, b->raio, b->cor); } }
void shal_draw_circle(float cx, float cy, float r, float color_r, float color_g, float color_b, float color_a, float thickness) { ALLEGRO_COLOR color; color.r = color_r; color.g = color_g; color.b = color_b; color.a = color_a; return al_draw_circle(cx, cy, r, color, thickness); }
static duk_ret_t js_OutlinedCircle(duk_context* ctx) { bool antialiased = false; color_t color; int n_args; int x, y, radius; n_args = duk_get_top(ctx); x = duk_to_int(ctx, 0); y = duk_to_int(ctx, 1); radius = duk_to_int(ctx, 2); color = duk_require_sphere_color(ctx, 3); if (n_args >= 5) antialiased = duk_require_boolean(ctx, 4); if (!is_skipped_frame()) al_draw_circle(x, y, radius, nativecolor(color), 1); return 0; }
void AIMap::draw() { for(int i = 0; i < map_obstacles.size(); i++) { drawObstacle(map_obstacles[i]); } for(int i = 0; i < graphNodes.size(); i++) { for(int j = 0; j < graphNodes[i]->neighbours.size(); j++) { al_draw_line(graphNodes[i]->position.x, graphNodes[i]->position.y, graphNodes[i]->neighbours[j]->position.x, graphNodes[i]->neighbours[j]->position.y, al_map_rgb(150,150,150), 1.0f); } al_draw_circle(graphNodes[i]->position.x, graphNodes[i]->position.y, 1, al_map_rgb(0,255,0), 2.0f); if(Keyboard::getInstance().key[Keyboard::KEY_1]) { } } }
Steering* WanderAndSeekOrFlee::getSteering() { Vector2D direction = mpTarget->getPosition() - mpMover->getPosition(); float distance = direction.getLength(); ALLEGRO_COLOR color; if (mShouldFlee) color = al_map_rgb(0, 0, 0); else color = al_map_rgb(0, 191, 255); if (debugOn) al_draw_circle(mpMover->getPosition().getX(), mpMover->getPosition().getY(), mRadius, color, 2.0f); if (distance > mRadius) return mpDynamicWanderSteering->getSteering(); else return mpDynamicSeekSteering->getSteering(); }
void ship_draw(const ship *s) { // draw the bullets bullet_draw(s->bullets); // draw the ship const uint32_t bitmap_width = al_get_bitmap_width(s->bitmap); const uint32_t bitmap_height = al_get_bitmap_height(s->bitmap); if (s->attr.is_immune) { const double time_passed = al_get_time() - s->attr.time_stamp; if (time_passed - floor(time_passed) < 0.5) { al_draw_tinted_scaled_rotated_bitmap(s->bitmap, color_gray(), bitmap_width / 2, bitmap_height / 2, s->center.x, s->center.y, SHIP_SIZE / bitmap_width, SHIP_SIZE / bitmap_height, s->direction, 0); } else { al_draw_scaled_rotated_bitmap(s->bitmap, bitmap_width / 2, bitmap_height / 2, s->center.x, s->center.y, SHIP_SIZE / bitmap_width, SHIP_SIZE / bitmap_height, s->direction, 0); } } else { al_draw_scaled_rotated_bitmap(s->bitmap, bitmap_width / 2, bitmap_height / 2, s->center.x, s->center.y, SHIP_SIZE / bitmap_width, SHIP_SIZE / bitmap_height, s->direction, 0); } #ifdef DEBUG al_draw_circle(s->center.x, s->center.y, 5, al_map_rgb(255, 0, 0), 3); #endif }
void FlareManager::Flare::__default_draw(Flare *flare) { float inverse_counter = 1.0 - flare->counter; if (flare->bitmap) { if (flare->blending_mode == BLENDER_ADDITIVE) al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ONE); al_draw_tinted_scaled_rotated_bitmap(flare->bitmap, al_map_rgba_f(flare->opacity,flare->opacity,flare->opacity,flare->opacity), al_get_bitmap_width(flare->bitmap)*flare->align_x, al_get_bitmap_height(flare->bitmap)*flare->align_y, flare->x, flare->y, flare->scale, flare->scale, flare->rotation, 0); if (flare->blending_mode == BLENDER_ADDITIVE) al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA); } else { al_draw_circle(flare->x, flare->y, 30*inverse_counter, al_map_rgba_f(flare->counter, flare->counter, flare->counter, flare->counter), 2); } }
int main() { //inicialização camera *cam = camera_inicializa(0); if(!cam) erro("erro na inicializacao da camera\n"); int largura = cam->largura; int altura = cam->altura; if(!al_init()) erro("erro na inicializacao do allegro\n"); if(!al_init_image_addon()) erro("erro na inicializacao do adicional de imagem\n"); if(!al_init_primitives_addon()) erro("erro na inicializacao do adicional de primitivas\n"); ALLEGRO_TIMER *timer = al_create_timer(1.0 / FPS); if(!timer) erro("erro na criacao do relogio\n"); ALLEGRO_DISPLAY *display = al_create_display(largura, altura); if(!display) erro("erro na criacao da janela\n"); ALLEGRO_EVENT_QUEUE *queue = al_create_event_queue(); if(!queue) erro("erro na criacao da fila\n"); al_register_event_source(queue, al_get_timer_event_source(timer)); al_register_event_source(queue, al_get_display_event_source(display)); al_start_timer(timer); /**********/ unsigned char ***matriz = camera_aloca_matriz(cam); int ***background = alocaHsvMatriz(cam->largura, cam->altura); fila *f = aloca(); //cor para desenhar o círculo ALLEGRO_COLOR cor = al_map_rgb_f(0, 0, 1); ALLEGRO_BITMAP *buffer = al_get_backbuffer(display); //tela exibindo img normal ALLEGRO_BITMAP *esquerda = al_create_sub_bitmap(buffer, 0, 0, largura, altura); //tela mostrando como o computador enxerga //ALLEGRO_BITMAP *direita = al_create_sub_bitmap(buffer, largura/2, 0, largura/2, altura/2); ALLEGRO_BITMAP *silhueta = al_create_bitmap(largura, altura); /**********/ srand(time(NULL)); int desenhar = 0; int terminar = 0; int cycle = 0; int hitx = rand() % (largura); int hity = rand() % (altura); int x, y; float cyr, cxr, cnr, lastCx, lastCy; int r, g, b, r2, g2, b2; int h, s, v, h2, s2, v2; int fh, fs, fv; int dh, ds, dv; int tempH; int token; double value; int dist; al_rest(1); for(y = 0; y < altura; y++) for(x = 0; x < largura; x++){ rgbToHsv(cam->quadro[y][x][0], cam->quadro[y][x][1], cam->quadro[y][x][2], &background[y][x][0], &background[y][x][1], &background[y][x][2]); if(background[y][x][0] > 180){ background[y][x][0] -= 360; background[y][x][0] = -background[y][x][0]; } } al_rest(1); for(y = 0; y < altura; y++) for(x = 0; x < largura; x++){ rgbToHsv(cam->quadro[y][x][0], cam->quadro[y][x][1], cam->quadro[y][x][2], &fh, &fs, &fv); if(fh > 180){ fh -= 360; fh = -fh; } background[y][x][0] += fh; background[y][x][0] /=2; background[y][x][1] += fs; background[y][x][1] /=2; background[y][x][2] += fv; background[y][x][2] /=2; } //gameloop while(1) { ALLEGRO_EVENT event; al_wait_for_event(queue, &event); switch(event.type) { case ALLEGRO_EVENT_TIMER: desenhar = 1; break; case ALLEGRO_EVENT_DISPLAY_CLOSE: terminar = 1; break; default: printf("evento desconhecido\n"); } if(terminar) break; //interpretar img e realizar transformações printf("%d\n", al_is_event_queue_empty(queue)); if(desenhar && al_is_event_queue_empty(queue)) { desenhar = 0; camera_atualiza(cam); /**********/ int bx, by, bn; cyr = 0; cxr = 0; cnr = 0; for(y = 0; y < altura; y++){ for(x = 0; x < largura; x++){ //Espada r = cam->quadro[y][x][0]; g = cam->quadro[y][x][1]; b = cam->quadro[y][x][2]; rgbToHsv(r, g, b, &h, &s, &v); if(h < 15 || h > 345) if(s > 75 && v > 75){ cyr += y; cxr += x; cnr++; } //Silhueta (REFINAR!!!) if(h > 180) tempH = -(h - 360); else tempH = h; dh = tempH - background[y][x][0]; if(dh < 0) dh = -dh; ds = s - background[y][x][1]; if(ds < 0) ds = -ds; dv = v - background[y][x][2]; if(dv < 0) dv = -dv; //dh > 15 && ds > 10 para tirar a interfencia de iluminacao, mas gera mtuiro ruido //ds > 25 é o mais preciso, mas sofre de interferencia de iluminacao if(dv > 25){ //valores para teste! matriz[y][x][0] = 37; matriz[y][x][1] = 50; matriz[y][x][2] = 248; } else{ matriz[y][x][0] = 0; matriz[y][x][1] = 0; matriz[y][x][2] = 0; } //Escudo if(h < 135 && h > 105 && s > 50 && v > 75){ by += y; bx += x; bn++; matriz[y][x][0] = 0; matriz[y][x][1] = 255; matriz[y][x][2] = 0; } } } /*for(y = 1; y < altura-1; y++) for(x = 1; x < largura-1; x++){ token = 4; if(255 != matriz[y+1][x][0]) token--; if(255 != matriz[y-1][x][0]) token--; if(255 != matriz[y][x+1][0]) token--; if(255 != matriz[y][x-1][0]) token--; if(token == 0){ matriz[y][x][0] = 0; matriz[y][x][1] = 0; matriz[y][x][2] = 0; }*/ cycle++; if(cycle > 50 && bn > 0){ value = (pow(hitx - (bx / 2 /bn), 2) + pow(hity - (by / 2 / bn), 2)); dist = sqrt(value) - 7; if(dist < 100 && dist > -100 && bn > 0) printf("block!\n"); else{ if(matriz[hity][hitx][0] == 255) printf("hit\n"); else printf("miss\n"); } cycle = 0; hitx = rand() % (largura/2); hity = rand() % (altura/2); } /**********/ camera_copia(cam, cam->quadro, esquerda); //Copia img editada na img direita camera_copia(cam, matriz, silhueta); //cor para teste! al_convert_mask_to_alpha(silhueta, al_map_rgb(37, 50, 248)); al_draw_bitmap(silhueta, 0, 0, 0); /**********/ if(bn > 0) al_draw_circle(bx / bn, by / bn, 100, al_map_rgb(0, 0, 255), 1); if(cycle >= 40){ if(cycle < 48){ al_draw_circle(hitx, hity, 15, al_map_rgb(0, 0, 255), 30); al_draw_circle(hitx + largura, hity, 6, al_map_rgb(0, 0, 255), 3); } else al_draw_circle(hitx, hity, 15, al_map_rgb(255, 0, 0), 30); } if(cnr > 10){ lastCx = cxr / cnr; lastCy = cyr / cnr; al_draw_circle(lastCx, lastCy, 100, al_map_rgb(255, 0, 0), 1); insere(f, lastCx, lastCy); } else insere(f, lastCx, lastCy); if(f->count > 10) retira(f); drawAtk(f); al_flip_display(); } } /**********/ libera(f); al_destroy_bitmap(silhueta); al_destroy_bitmap(esquerda); camera_libera_matriz(cam, matriz); liberaHsvMatriz(background, cam->largura, cam->altura); /**********/ al_stop_timer(timer); al_unregister_event_source(queue, al_get_display_event_source(display)); al_unregister_event_source(queue, al_get_timer_event_source(timer)); al_destroy_event_queue(queue); al_destroy_display(display); al_destroy_timer(timer); al_shutdown_primitives_addon(); al_shutdown_image_addon(); al_uninstall_system(); camera_finaliza(cam); return EXIT_SUCCESS; }
static void draw_the_controls(bool draw_controls, ALLEGRO_COLOR tint) { #if defined ALLEGRO_IPHONE || defined ALLEGRO_ANDROID if (use_dpad && dpad_buttons && draw_controls && global_draw_controls) { if ((dpad_type == DPAD_TOTAL_2 || dpad_type == DPAD_HYBRID_2)) { ALLEGRO_COLOR light = al_map_rgba(100*tint.r, 200*tint.g, 100*tint.b, 255*tint.a); ALLEGRO_COLOR dark = al_map_rgba(150*tint.r, 250*tint.g, 150*tint.b, 255*tint.a); int x = BUTTON_SIZE+10; int y = dpad_at_top ? 5 : BH-5-BUTTON_SIZE; if (!config.getSwapButtons()) { al_draw_circle(BW-20-BUTTON_SIZE/2, y+BUTTON_SIZE/2, BUTTON_SIZE/2, light, 2); al_draw_circle(BW-20-BUTTON_SIZE/2, y+BUTTON_SIZE/2, BUTTON_SIZE/2+1, dark, 1); al_draw_filled_circle(BW-25-BUTTON_SIZE*1.5, y+BUTTON_SIZE/2, BUTTON_SIZE/2, light); al_draw_circle(BW-25-BUTTON_SIZE*1.5, y+BUTTON_SIZE/2, BUTTON_SIZE/2, dark, 1); } else { al_draw_circle(BW-25-BUTTON_SIZE*1.5, y+BUTTON_SIZE/2, BUTTON_SIZE/2, light, 2); al_draw_circle(BW-25-BUTTON_SIZE*1.5, y+BUTTON_SIZE/2, BUTTON_SIZE/2+1, dark, 1); al_draw_filled_circle(BW-20-BUTTON_SIZE/2, y+BUTTON_SIZE/2, BUTTON_SIZE/2, light); al_draw_circle(BW-20-BUTTON_SIZE/2, y+BUTTON_SIZE/2, BUTTON_SIZE/2, dark, 1); } y = dpad_at_top ? 5 : BH-BUTTON_SIZE*3-5; int l = BUTTON_SIZE*1.5-10; al_draw_rounded_rectangle(10, y, 10+BUTTON_SIZE*3, y+BUTTON_SIZE*3, 5, 5, light, 2); al_draw_rounded_rectangle(9, y-1, 10+BUTTON_SIZE*3+1, y+BUTTON_SIZE*3+1, 5, 5, dark, 1); m_draw_line(17, y+7, 17+l, y+7+l, dark); m_draw_line(10+BUTTON_SIZE*3-8, y+7, 10+BUTTON_SIZE*3-8-l, y+7+l, dark); m_draw_line(17, y+BUTTON_SIZE*3-7, 17+l, y+BUTTON_SIZE*3-7-l, dark); m_draw_line(10+BUTTON_SIZE*3-7, y+BUTTON_SIZE*3-7, 10+BUTTON_SIZE*3-7-l, y+BUTTON_SIZE*3-7-l, dark); al_draw_filled_triangle(x+4, y+BUTTON_SIZE-4, x+BUTTON_SIZE/2, y+4, x+BUTTON_SIZE-4, y+BUTTON_SIZE-4, light/*, 1*/); al_draw_triangle(x+4, y+BUTTON_SIZE-4, x+BUTTON_SIZE/2, y+4, x+BUTTON_SIZE-4, y+BUTTON_SIZE-4, dark, 1); x = 10; y += BUTTON_SIZE; al_draw_filled_triangle(x+4, y+BUTTON_SIZE/2, x+BUTTON_SIZE-4, y+4, x+BUTTON_SIZE-4, y+BUTTON_SIZE-4, light/*, 1*/); al_draw_triangle(x+4, y+BUTTON_SIZE/2, x+BUTTON_SIZE-4, y+4, x+BUTTON_SIZE-4, y+BUTTON_SIZE-4, dark, 1); x = 10+BUTTON_SIZE*2; al_draw_filled_triangle(x+BUTTON_SIZE-4, y+BUTTON_SIZE/2, x+4, y+BUTTON_SIZE-4, x+4, y+4, light/*, 1*/); al_draw_triangle(x+BUTTON_SIZE-4, y+BUTTON_SIZE/2, x+4, y+BUTTON_SIZE-4, x+4, y+4, dark, 1); x = 10+BUTTON_SIZE; y += BUTTON_SIZE; al_draw_filled_triangle(x+4, y+4, x+BUTTON_SIZE/2, y+BUTTON_SIZE-4, x+BUTTON_SIZE-4, y+4, light/*, 1*/); al_draw_triangle(x+4, y+4, x+BUTTON_SIZE/2, y+BUTTON_SIZE-4, x+BUTTON_SIZE-4, y+4, dark, 1); } else { ALLEGRO_VERTEX verts[36]; InputDescriptor ie = getInput()->getDescriptor(); int x = BUTTON_SIZE+10; int y = dpad_at_top ? 5 : BH-5-BUTTON_SIZE; const int s = 20; // bitmap size const int o = (BUTTON_SIZE-s)/2; // offset to draw int nv = 0; int vx, vy; int vu, vv; #define SETXY \ verts[nv].x = vx; \ verts[nv].y = vy; \ verts[nv].z = 0; \ verts[nv+1].x = vx+20; \ verts[nv+1].y = vy; \ verts[nv+1].z = 0; \ verts[nv+2].x = vx; \ verts[nv+2].y = vy+20; \ verts[nv+2].z = 0; \ verts[nv+3].x = vx+20; \ verts[nv+3].y = vy; \ verts[nv+3].z = 0; \ verts[nv+4].x = vx+20; \ verts[nv+4].y = vy+20; \ verts[nv+4].z = 0; \ verts[nv+5].x = vx; \ verts[nv+5].y = vy+20; \ verts[nv+5].z = 0; #define SETUV \ verts[nv].u = vu; \ verts[nv].v = vv; \ verts[nv+1].u = vu+20; \ verts[nv+1].v = vv; \ verts[nv+2].u = vu; \ verts[nv+2].v = vv+20; \ verts[nv+3].u = vu+20; \ verts[nv+3].v = vv; \ verts[nv+4].u = vu+20; \ verts[nv+4].v = vv+20; \ verts[nv+5].u = vu; \ verts[nv+5].v = vv+20; \ nv += 6; if (config.getSwapButtons()) { vx = BW-20-BUTTON_SIZE+o; vy = y+o; } else { vx = BW-25-BUTTON_SIZE*2; vy = y+o; } SETXY if (ie.button1) { vu = 20; vv = 40; SETUV } else { vu = 0; vv = 40; SETUV } if (config.getSwapButtons()) { vx = BW-25-BUTTON_SIZE*2; vy = y+o; } else { vx = BW-20-BUTTON_SIZE+o; vy = y+o; } SETXY if (ie.button2) { vu = 60; vv = 40; SETUV }
void Circle::draw_in_another_target() { if(get_filled_status()) al_draw_filled_circle(_V_pos_x,_V_pos_y,_V_radius,_V_color); al_draw_circle(_V_pos_x,_V_pos_y,_V_radius,_V_color,_V_thickness); }
void TEnterprise::DrawPlanetInfo(const Sector & a_sector,int a_nX, int a_nY) { size_t n = a_sector.m_Planet.size(); a_nX -= 22; if (a_sector.m_blHasAsteroidField) { al_draw_circle(a_nX, a_nY,15, m_pEngine->m_clYELLOW,2); } if (n>0) { // plot starbases ALLEGRO_COLOR col; int nSize =10; int nShift =0; for ( size_t i=0; i<n; i++) { switch(a_sector.m_Planet[i].m_PlanetType) { case ID_STAR_BLUE: col = m_pEngine->m_clBLUE; nSize = 7; nShift= 11; break; case ID_STAR_WHITE: col = m_pEngine->m_clWHITE; nSize =6; nShift= 10; break; case ID_STAR_YELLOW: col = m_pEngine->m_clYELLOW; nSize =8; nShift= 12; break; case ID_STAR_RED: col = m_pEngine->m_clRED; nSize =10; nShift= 14; break; case ID_CLASS_A: col = m_pEngine->m_clRED; nSize = 2; nShift= 5; break; case ID_CLASS_B: col = m_pEngine->m_clMAGENTA; nSize = 3; nShift= 7; break; case ID_CLASS_L: col = m_pEngine->m_clBROWN; nSize = 2; nShift= 5; break; case ID_CLASS_N: col = m_pEngine->m_clYELLOW; nSize = 4; nShift= 9; break; case ID_CLASS_M1: col = m_pEngine->m_clAQUA; nSize = 2; nShift= 5; break; case ID_CLASS_M2: col = m_pEngine->m_clAQUA; nSize = 3; nShift= 7; break; case ID_CLASS_M3: col = m_pEngine->m_clAQUA; nSize = 4; nShift= 9; break; default: col = m_pEngine->m_clBLACK; nSize = 10; nShift= 14; break; } al_draw_filled_circle(a_nX, a_nY,nSize,col); a_nX += nShift; } } }
void DrawingClass::DrawCircle (float cx, float cy, float radius, int r, int g, int b, int thick) { ALLEGRO_COLOR color = al_map_rgb(r, g, b); al_draw_circle(cx, cy, radius, color, thick); }
int main() { const int SCREEN_W = 1280, SCREEN_H = 768; ALLEGRO_DISPLAY *display = NULL; ALLEGRO_EVENT_QUEUE* queue; ALLEGRO_FONT* century_gothic40; ALLEGRO_FONT* century_gothic24; ALLEGRO_BITMAP* MenuBackground; ALLEGRO_BITMAP* ArenaBackground; ALLEGRO_BITMAP* Ball; //ALLEGRO_SAMPLE* BackgroundMusic; //ALLEGRO_SAMPLE* Boop; //ALLEGRO_SAMPLE* Score; //ALLEGRO_SAMPLE* Intro; ALLEGRO_TIMER* timer; Gamemode gamemode = Menu; std::string player_text = "PLAYER : 0", ai_text = "BOT : 0"; unsigned int player_score = 0, ai_score = 0; if(!al_init()) { printf("al_init Failed!\n"); return -1; } //if(!al_install_audio()) //{ //fprintf(stderr, "Failed to initialize audio!\n"); //return -1; //} //if(!al_init_acodec_addon()) //{ //fprintf(stderr, "Failed to initialize audio codecs!\n"); //return -1; //} //if (!al_reserve_samples(1)) //{ //fprintf(stderr, "Failed to reserve samples!\n"); //return -1; //} if(!al_install_mouse()) { fprintf(stderr, "Failed to initialize the mouse!\n"); return -1; } if(!al_init_primitives_addon()) { printf("al_init_primitives_addon Failed!\n"); return -1; } display = al_create_display(SCREEN_W, SCREEN_H); if(!display) { printf("al_create_display Failed!\n"); return -1; } srand(time(NULL)); al_init_font_addon(); al_init_ttf_addon(); al_install_keyboard(); al_init_image_addon(); queue = al_create_event_queue(); timer = al_create_timer(1.0 / 60); al_register_event_source(queue, al_get_keyboard_event_source()); al_register_event_source(queue, al_get_mouse_event_source()); al_register_event_source(queue, al_get_display_event_source(display)); al_register_event_source(queue, al_get_timer_event_source(timer)); al_start_timer(timer); century_gothic40 = al_load_ttf_font("C:\\Windows\\Fonts\\GOTHIC.TTF" , 40, ALLEGRO_ALIGN_CENTRE); century_gothic24 = al_load_ttf_font("C:\\Windows\\Fonts\\GOTHIC.TTF" , 24, ALLEGRO_ALIGN_CENTRE); MenuBackground = LoadB("res\\menu.png"); ArenaBackground = LoadB("res\\arena.png"); Ball = LoadB("res\\ball.png"); //BackgroundMusic = LoadS("res\\rain.wav"); //Boop = LoadS("res\\boop.ogg"); //Score = LoadS("res\\score.wav"); //Intro = LoadS("res\\intro.ogg"); //ALLEGRO_VOICE *audioDevice = al_create_voice(44100, ALLEGRO_AUDIO_DEPTH_FLOAT32 , ALLEGRO_CHANNEL_CONF_2); //ALLEGRO_MIXER *mixerMaster = al_create_mixer(44100, ALLEGRO_AUDIO_DEPTH_FLOAT32 , ALLEGRO_CHANNEL_CONF_2); //ALLEGRO_MIXER *mixerMusic = al_create_mixer(44100, ALLEGRO_AUDIO_DEPTH_FLOAT32 , ALLEGRO_CHANNEL_CONF_2); //ALLEGRO_MIXER *mixerSounds = al_create_mixer(44100, ALLEGRO_AUDIO_DEPTH_FLOAT32 , ALLEGRO_CHANNEL_CONF_2); //if (audioDevice == NULL || mixerMaster == NULL || mixerMusic == NULL || mixerSounds == NULL) //{ //printf("Failed to start audio devices"); //} /* Attempt of Audio al_attach_sample_instance_to_mixer(Boop, mixerSounds); al_attach_sample_instance_to_mixer(BackgroundMusic, mixerMusic); al_attach_sample_instance_to_mixer(Score, mixerSounds); al_attach_sample_instance_to_mixer(Intro, mixerSounds); al_attach_mixer_to_mixer(mixerMusic, mixerMaster); al_attach_mixer_to_mixer(mixerSounds, mixerMaster); al_attach_mixer_to_voice(mixerMaster, audioDevice); //ALLEGRO_SAMPLE_INSTANCE BoopI = al_create_sample_instance(Boop); //ALLEGRO_SAMPLE_INSTANCE ScoreI = al_create_sample_instance(Score); //al_play_sample(BackgroundMusic, 1.0, 0.0,1.0,ALLEGRO_PLAYMODE_LOOP,NULL);*/ float player_y = 0, player_y_vel = 0, ai_y_vel = 0, ai_y = 0, ball_x = (SCREEN_W/2)-12, ball_x_vel = (rand() % 2) ? 5 : -5, ball_y = (SCREEN_H/2)-15, ball_y_vel = 0, multiplier = 1; bool render , scored, executing = true; //al_play_sample(Intro, 1.0, 0.0,1.0,ALLEGRO_PLAYMODE_ONCE,NULL); while (executing) { ALLEGRO_EVENT event; al_wait_for_event(queue, &event); switch(event.type) { case ALLEGRO_EVENT_MOUSE_BUTTON_DOWN: switch (gamemode) { case Menu: if ((event.mouse.x >= (SCREEN_W / 2) - 150) && (event.mouse.x <= (SCREEN_W / 2) + 150)) { if ((event.mouse.y >= 205) && (event.mouse.y <= 280)) { gamemode = Game; } else if ((event.mouse.y >= 305) && (event.mouse.y <= 380)) { gamemode = Description; } else if ((event.mouse.y >= 405) && (event.mouse.y <= 480)) { executing = false; } } break; case Description: break; case Conclusion: if ((event.mouse.x >= (SCREEN_W/2)-150) && (event.mouse.x <= (SCREEN_W/2)+150)) { if ((event.mouse.y >= 305) && (event.mouse.y <= 380)) { player_score = ai_score = player_y = player_y_vel = ai_y_vel = ai_y = ball_y_vel = 0; ball_x_vel = (rand() % 2) ? 5 : -5; ball_x = (SCREEN_W / 2) - 12; ball_y = (SCREEN_H / 2) - 15; multiplier = 1; player_text = "PLAYER : 0"; ai_text = "BOT : 0"; gamemode = Menu; } else if ((event.mouse.y >= 405) && (event.mouse.y <= 480)) { executing = false; } } break; } break; case ALLEGRO_EVENT_DISPLAY_CLOSE: executing = false; break; case ALLEGRO_EVENT_KEY_DOWN: switch(event.keyboard.keycode) { case ALLEGRO_KEY_ESCAPE: switch (gamemode) { case Game: executing = false; break; } break; case ALLEGRO_KEY_UP: case ALLEGRO_KEY_W: player_y_vel = -10; break; case ALLEGRO_KEY_DOWN: case ALLEGRO_KEY_S: player_y_vel = 10; break; case ALLEGRO_KEY_ENTER: executing = false; break; } gamemode = Game; break; case ALLEGRO_EVENT_KEY_UP: player_y_vel = 0; break; case ALLEGRO_EVENT_TIMER: render = true; switch(gamemode) { case Game: // Scoring bool scored = false; if (ball_x >= SCREEN_W) { player_score++; scored = true; std::stringstream ss; ss << "PLAYER : " << player_score; player_text = ss.str(); } if (ball_x <= 0) { ai_score++; scored = true; std::stringstream ss; ss << "BOT : " << ai_score; ai_text = ss.str(); } if (scored) { //al_play_sample(Score, 1.0, 0.0,1.0,ALLEGRO_PLAYMODE_ONCE,NULL); //al_play_sample_instance(ScoreI); ball_x = (SCREEN_W/2)-12; ball_y = (SCREEN_H/2)-15; ball_x_vel = (rand() % 2) ? 5.75 : -5.75; ball_y_vel = 0; ai_y = 0; player_y = 0; multiplier = 1; } // Collision if (((((SCREEN_H/2)-50)+player_y)<=0)&&(player_y_vel<0)) player_y_vel = 0; if (((((SCREEN_H/2)+50)+player_y)>=SCREEN_H)&&(player_y_vel>0)) player_y_vel = 0; if ((ball_y <= 0) || (ball_y >= SCREEN_H)) ball_y_vel = -ball_y_vel; if (((ball_y <= (((SCREEN_H / 2) + 50) + player_y) && (ball_y >= (((SCREEN_H / 2) - 50) + player_y))) && ((ball_x <= 90) && (ball_x >= 75))) || (((ball_y <= (((SCREEN_H / 2) + 50) + ai_y)) && (ball_y >= (((SCREEN_H / 2) - 50) + ai_y))) && (((ball_x >= SCREEN_W - 110)) && (ball_x <= SCREEN_W - 75)))) { //al_play_sample(Boop, 1.0, 0.0,1.0,ALLEGRO_PLAYMODE_ONCE,NULL); //al_play_sample_instance(BoopI); ball_x_vel = -ball_x_vel * multiplier; multiplier += 0.005f; ball_y_vel = (rand() % 10) - 5; } // AI if (ball_x_vel > 0) // Ball comming towards AI { if ((ai_y <= 340) && (ai_y >= -340)) // AI is in game bounds { if ((SCREEN_H/2)+ai_y < ball_y) ai_y_vel = abs(ball_y_vel) < 3 ? abs(ball_y_vel) : 5; else if ((SCREEN_H/2)+ai_y == ball_y) ai_y_vel = 0; else ai_y_vel = abs(ball_y_vel) < 3 ? -abs(ball_y_vel) : -5; } else if (ai_y > 340) ai_y_vel = -3; else if (ai_y < -340) ai_y_vel = 3; else ai_y_vel = 0; } else // Go towards center { if (ai_y > 10) ai_y_vel = -1; else if (ai_y < 10) ai_y_vel = 1; else ai_y_vel = 0; } // Movement player_y += player_y_vel; ai_y += ai_y_vel; ball_x += ball_x_vel; ball_y += ball_y_vel; if (player_score >= 10 || ai_score >= 10) gamemode = Conclusion; break; } break; } if (al_is_event_queue_empty(queue) && render) { al_clear_to_color(al_map_rgb(0,0,0)); al_set_target_bitmap(al_get_backbuffer(display)); //////////////////////////////////////////////////////////////////// switch(gamemode) { case Menu: al_draw_bitmap(MenuBackground, 0, 0, 0); al_draw_text(century_gothic40, al_map_rgb(250,250,250), SCREEN_W/2, 40, ALLEGRO_ALIGN_CENTRE, "Ultimate Pong"); al_draw_rectangle((SCREEN_W / 2) - 150, 205, (SCREEN_W / 2) + 150, 280, al_map_rgb(255, 255, 255), 3); al_draw_text(century_gothic40, al_map_rgb(250, 250, 250), SCREEN_W / 2, 220, ALLEGRO_ALIGN_CENTRE, "Play"); al_draw_rectangle((SCREEN_W / 2) - 150, 305, (SCREEN_W / 2) + 150, 380, al_map_rgb(255, 255, 255), 3); al_draw_text(century_gothic40, al_map_rgb(250, 250, 250), SCREEN_W / 2, 320, ALLEGRO_ALIGN_CENTRE, "About"); al_draw_rectangle((SCREEN_W / 2) - 150, 405, (SCREEN_W / 2) + 150, 480, al_map_rgb(255, 255, 255), 3); al_draw_text(century_gothic40, al_map_rgb(250, 250, 250), SCREEN_W / 2, 420, ALLEGRO_ALIGN_CENTRE, "Quit"); al_draw_text(century_gothic24, al_map_rgb(250,250,250), 200, SCREEN_H - 50, ALLEGRO_ALIGN_CENTRE, "Game by Thomas Steinholz"); break; case Description: al_draw_bitmap(MenuBackground, 0, 0, 0); al_draw_text(century_gothic40, al_map_rgb(250, 250, 250), SCREEN_W / 2, 40, ALLEGRO_ALIGN_CENTRE, "About Ultimate Pong"); al_draw_text(century_gothic24, al_map_rgb(250,250,250), 100, 240, ALLEGRO_ALIGN_LEFT, "This is the game of Ultimate Pong! The game consists of 2 paddles knocking a ball back and"); al_draw_text(century_gothic24, al_map_rgb(250,250,250), 100, 260, ALLEGRO_ALIGN_LEFT, "forth until one misses it and it goes into the goal. The point of the game is to score 10 "); al_draw_text(century_gothic24, al_map_rgb(250,250,250), 100, 280, ALLEGRO_ALIGN_LEFT, "points. You can score a point by getting the ball in the other player's goal (right behind"); al_draw_text(century_gothic24, al_map_rgb(250,250,250), 100, 300, ALLEGRO_ALIGN_LEFT, "the enemy paddle). You control the game by using either the UP and DOWN arrow or the W and"); al_draw_text(century_gothic24, al_map_rgb(250,250,250), 100, 320, ALLEGRO_ALIGN_LEFT, "S key. As you can guess, the up arrow brings your player up while the down arrow brings "); al_draw_text(century_gothic24, al_map_rgb(250,250,250), 100, 340, ALLEGRO_ALIGN_LEFT, "your player down. The W key functions the same as the UP arrow as the S key functions the"); al_draw_text(century_gothic24, al_map_rgb(250,250,250), 100, 360, ALLEGRO_ALIGN_LEFT, "same as the DOWN key. The game ends once either the player of AI has reached a point value"); al_draw_text(century_gothic24, al_map_rgb(250,250,250), 100, 380, ALLEGRO_ALIGN_LEFT, "of 10. You play as the left paddle and the AI plays as the right paddle. You can see the "); al_draw_text(century_gothic24, al_map_rgb(250,250,250), 100, 400, ALLEGRO_ALIGN_LEFT, "corresponding scores above the side you play as if you get lost or confused. To get "); al_draw_text(century_gothic24, al_map_rgb(250,250,250), 100, 420, ALLEGRO_ALIGN_LEFT, "started, hit the ESC button. DISCLAIMER : IF YOU GET HURT, ITS NOT PONGS FAULT SO DONT SUE"); al_draw_text(century_gothic24, al_map_rgb(250,250,250), 200, SCREEN_H - 50, ALLEGRO_ALIGN_CENTRE, "PRESS sESC TO PLAY"); break; case Game: al_draw_bitmap(ArenaBackground, 0, 0, 0); al_draw_line((SCREEN_W/2)-3,0,(SCREEN_W/2)-3,SCREEN_H,al_map_rgb(255,255,255), 2); al_draw_circle((SCREEN_W/2)-5,(SCREEN_H/2)-5, 150, al_map_rgb(255,255,255), 2); al_draw_filled_rectangle(75,((SCREEN_H/2)-50)+player_y,90,((SCREEN_H/2)+50)+player_y,al_map_rgb(255,255,255)); //Player al_draw_filled_rectangle(SCREEN_W-75,((SCREEN_H/2)-50)+ai_y,SCREEN_W-90,((SCREEN_H/2)+50)+ai_y,al_map_rgb(255,255,255)); //AI al_draw_scaled_bitmap( Ball, 0, 0, al_get_bitmap_width(Ball), al_get_bitmap_height(Ball), ball_x, ball_y, 15, 15, 0); al_draw_text(century_gothic40, al_map_rgb(250,250,250), 140, 40, ALLEGRO_ALIGN_CENTRE, player_text.c_str()); al_draw_text(century_gothic40, al_map_rgb(250,250,250), SCREEN_W-100, 40, ALLEGRO_ALIGN_CENTRE, ai_text.c_str()); break; case Conclusion: al_draw_bitmap(MenuBackground, 0, 0, 0); al_draw_text(century_gothic40, al_map_rgb(250, 250, 250), SCREEN_W / 2, 40, ALLEGRO_ALIGN_CENTRE, "Game Over!"); al_draw_text(century_gothic40, al_map_rgb(250, 250, 250), SCREEN_W / 2, 80, ALLEGRO_ALIGN_CENTRE, ai_score < player_score ? "You Win!" : "You Lose!"); al_draw_textf(century_gothic40, al_map_rgb(250, 250, 250), SCREEN_W / 2, 120, ALLEGRO_ALIGN_CENTRE, "%d : %d", player_score, ai_score); al_draw_rectangle((SCREEN_W/2)-150, 305, (SCREEN_W/2)+150, 380, al_map_rgb(255, 255, 255), 3); al_draw_text(century_gothic40, al_map_rgb(250, 250, 250), SCREEN_W / 2, 320, ALLEGRO_ALIGN_CENTRE, "Restart"); al_draw_rectangle((SCREEN_W / 2) - 150, 405, (SCREEN_W / 2) + 150, 480, al_map_rgb(255, 255, 255), 3); al_draw_text(century_gothic40, al_map_rgb(250, 250, 250), SCREEN_W / 2, 420, ALLEGRO_ALIGN_CENTRE, "Quit"); break; } //////////////////////////////////////////////////////////////////// al_flip_display(); } render = false; } al_destroy_bitmap(MenuBackground); al_destroy_bitmap(ArenaBackground); al_destroy_bitmap(Ball); //al_destroy_sample(BackgroundMusic); //al_destroy_sample(Boop); //al_destroy_sample(Score); al_destroy_display(display); return 0; }
int main(int argc, char **argv) { A.x = 0; A.y = 0; B.x = 400; B.y = 0; C.x = 400; C.y = 350; D.x = 0; D.y = 350; if (!al_install_system(ALLEGRO_VERSION_INT, NULL)) { printf("could not init Allegro\n"); return 1; } ALLEGRO_DISPLAY *display = al_create_display(800, 600); if (!display) { printf("could not create display\n"); return 1; } if (!al_init_primitives_addon()) { printf("could not init primitives\n"); return 1; } if (!al_install_keyboard()) { printf("could not install keybaord\n"); return 1; } if (!al_install_mouse()) { printf("could not install mouse\n"); return 1; } ALLEGRO_BITMAP *bitmap = al_create_bitmap(800, 600); if (bitmap == NULL) { printf("could not create bitmap\n"); return 1; } al_set_target_bitmap(bitmap); al_clear_to_color(al_map_rgb(255, 255, 255)); al_draw_rectangle(A.x + xOfs, A.y + yOfs, C.x + xOfs, C.y + yOfs, al_map_rgb(0, 0, 0), 2.0); al_set_target_backbuffer(display); al_draw_bitmap(bitmap, 0, 0, 0); al_flip_display(); int pair1 = 0; int pair2 = 0; ALLEGRO_EVENT_QUEUE *queue = al_create_event_queue(); ALLEGRO_EVENT event; al_register_event_source(queue, al_get_mouse_event_source()); al_register_event_source(queue, al_get_keyboard_event_source()); al_register_event_source(queue, al_get_display_event_source(display)); while (input_counter < 4) { al_wait_for_event(queue, &event); if (event.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN && event.mouse.button == 1) { input_points[input_counter].x = event.mouse.x; input_points[input_counter].y = event.mouse.y; input_counter++; if (input_counter > 1) { pair1 = input_counter - 2; pair2 = input_counter - 1; al_set_target_bitmap(bitmap); al_draw_line(input_points[pair1].x, input_points[pair1].y, input_points[pair2].x, input_points[pair2].y, al_map_rgb(0, 150, 0), 3.0); al_set_target_backbuffer(display); al_draw_bitmap(bitmap, 0, 0, 0); al_flip_display(); } if (input_counter == 4) { pair1 = 3; pair2 = 0; al_set_target_bitmap(bitmap); al_draw_line(input_points[pair1].x, input_points[pair1].y, input_points[pair2].x, input_points[pair2].y, al_map_rgb(0, 150, 0), 3.0); al_set_target_backbuffer(display); al_draw_bitmap(bitmap, 0, 0, 0); al_flip_display(); } } } VECTOR AAPrime = getCornerOffset(input_points[0], A); VECTOR BBPrime = getCornerOffset(input_points[1], B); VECTOR CCPrime = getCornerOffset(input_points[2], C); VECTOR DDPrime = getCornerOffset(input_points[3], D); VECTOR AAPrimeS, BBPrimeS, CCPrimeS, DDPrimeS; ALLEGRO_MOUSE_STATE state; POINT p; POINT PPPrime; POINT center; center.x = 0; center.y = 0; for (int i = 0; i < 4; i++) { center.x += input_points[i].x; center.y += input_points[i].y; } center.x /= 4; center.y /= 4; float total; al_flush_event_queue(queue); while (1) { al_wait_for_event(queue, &event); if (event.type != ALLEGRO_EVENT_MOUSE_AXES) { if (event.type == ALLEGRO_EVENT_KEY_DOWN || event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) { break; } continue; } al_draw_bitmap(bitmap, 0, 0, 0); // get the input point al_get_mouse_state(&state); p.x = state.x; p.y = state.y; // calculate the distances float ADistance = distance(p, input_points[0]); float BDistance = distance(p, input_points[1]); float CDistance = distance(p, input_points[2]); float DDistance = distance(p, input_points[3]); float AB = ADistance / BDistance; float BA = BDistance / ADistance; total = AB + BA; AB /= total; BA /= total; float topVec = AAPrime.y * BA + BBPrime.y * AB; float ACurs = fabs(p.y - input_points[0].y); float BCurs = fabs(p.y - input_points[1].y); float topCurs = ACurs * BA + BCurs * AB; al_draw_line(p.x, p.y, p.x, p.y + topVec, al_map_rgb(0, 255, 0), 4.0); al_draw_circle(p.x, p.y + topVec, 5, al_map_rgb(0, 0, 0), 2.0); float CD = CDistance / DDistance; float DC = DDistance / CDistance; total = DC + CD; CD /= total; DC /= total; float bottomVec = CCPrime.y * DC + DDPrime.y * CD; float DCurs = fabs(p.y - input_points[3].y); float CCurs = fabs(p.y - input_points[2].y); float bottomCurs = DCurs * CD + CCurs * DC; al_draw_line(p.x, p.y, p.x, p.y + bottomVec, al_map_rgb(0, 255, 0), 4.0); al_draw_circle(p.x, p.y + bottomVec, 5, al_map_rgb(0, 0, 0), 2.0); float topBottom = topCurs / bottomCurs; float bottomTop = bottomCurs / topCurs; total = topBottom + bottomTop; topBottom /= total; bottomTop /= total; float BC = BDistance / CDistance; float CB = CDistance / BDistance; total = BC + CB; BC /= total; CB /= total; float rightVec = BBPrime.x * CB + CCPrime.x * BC; BCurs = fabs(p.x - input_points[1].x); CCurs = fabs(p.x - input_points[2].x); float rightCurs= BCurs * CB + CCurs * BC; al_draw_line(p.x, p.y, p.x + rightVec, p.y, al_map_rgb(0, 255, 0), 4.0); al_draw_circle(p.x + rightVec, p.y, 5, al_map_rgb(0, 0, 0), 2.0); float DA = DDistance / ADistance; float AD = ADistance / DDistance; total = DA + AD; DA /= total; AD /= total; float leftVec = DDPrime.x * AD + AAPrime.x * DA; ACurs = fabs(p.x - input_points[0].x); DCurs = fabs(p.x - input_points[3].x); float leftCurs = ACurs * DA + DCurs * AD; al_draw_line(p.x, p.y, p.x + leftVec, p.y, al_map_rgb(0, 255, 0), 4.0); al_draw_circle(p.x + leftVec, p.y, 5, al_map_rgb(0, 0, 0), 2.0); float leftRight = leftCurs / rightCurs; float rightLeft = rightCurs / leftCurs; total = leftRight + rightLeft; leftRight /= total; rightLeft /= total; // draw the main corner vectors /* al_draw_line(input_points[0].x, input_points[0].y, input_points[0].x + AAPrime.x, input_points[0].y + AAPrime.y, al_map_rgb(0, 0, 0), 2.0);*/ /* al_draw_line(input_points[1].x, input_points[1].y, input_points[1].x + BBPrime.x, input_points[1].y + BBPrime.y, al_map_rgb(0, 0, 0), 2.0);*/ /* al_draw_line(input_points[2].x, input_points[2].y, input_points[2].x + CCPrime.x, input_points[2].y + CCPrime.y, al_map_rgb(0, 0, 0), 2.0);*/ /* al_draw_line(input_points[3].x, input_points[3].y, input_points[3].x + DDPrime.x, input_points[3].y + DDPrime.y, al_map_rgb(0, 0, 0), 2.0);*/ // draw the corner vector components /* al_draw_line(input_points[0].x, input_points[0].y, input_points[0].x + AAPrime.x, input_points[0].y, al_map_rgb(255, 0, 0), 1.0);*/ /* al_draw_line(input_points[0].x, input_points[0].y, input_points[0].x, input_points[0].y + AAPrime.y, al_map_rgb(255, 0, 0), 1.0);*/ /* al_draw_line(input_points[1].x, input_points[1].y, input_points[1].x + BBPrime.x, input_points[1].y, al_map_rgb(255, 0, 0), 1.0);*/ /* al_draw_line(input_points[1].x, input_points[1].y, input_points[1].x, input_points[1].y + BBPrime.y, al_map_rgb(255, 0, 0), 1.0);*/ /* al_draw_line(input_points[2].x, input_points[2].y, input_points[2].x + CCPrime.x, input_points[2].y, al_map_rgb(255, 0, 0), 1.0);*/ /* al_draw_line(input_points[2].x, input_points[2].y, input_points[2].x, input_points[2].y + CCPrime.y, al_map_rgb(255, 0, 0), 1.0);*/ /* al_draw_line(input_points[3].x, input_points[3].y, input_points[3].x + DDPrime.x, input_points[3].y, al_map_rgb(255, 0, 0), 1.0);*/ /* al_draw_line(input_points[3].x, input_points[3].y, input_points[3].x, input_points[3].y + DDPrime.y, al_map_rgb(255, 0, 0), 1.0);*/ // draw the processed point PPPrime.y = topVec * bottomTop + bottomVec * topBottom; PPPrime.x = rightVec * leftRight + leftVec * rightLeft; al_draw_line(p.x, p.y, p.x + PPPrime.x, p.y, al_map_rgb(0, 0, 255), 2.0); al_draw_line(p.x, p.y, p.x, p.y + PPPrime.y, al_map_rgb(0, 0, 255), 2.0); al_draw_circle(p.x + xOfs + PPPrime.x, p.y + yOfs + PPPrime.y, 5, al_map_rgb(0, 255, 0), 2.0); al_draw_circle(p.x + xOfs + PPPrime.x, p.y + yOfs + PPPrime.y, 1, al_map_rgb(0, 0, 0), 1.0); al_flip_display(); } return 0; }
int main(int argc, char **argv) { ALLEGRO_KEYBOARD_STATE estadoTeclado; bool figuras = al_init_primitives_addon(); bool inicio_allegro = al_init(); bool teclado = al_install_keyboard(); bool imagenes = al_init_image_addon(); if(!figuras) { fprintf(stderr, "Error: No pudo cargar figuras.\n"); return -1; } if(!imagenes) { fprintf(stderr, "Error: No pudo cargar imagenes.\n"); return -1; } if(!inicio_allegro) { fprintf(stderr, "Error: Allegro no pudo iniciar.\n"); return -1; } if(!teclado) { fprintf(stderr, "Error: El teclado no se detecto.\n"); return -1; } ALLEGRO_BITMAP *perro[4]; perro[0] = al_load_bitmap("0.png"); perro[1] = al_load_bitmap("1.png"); perro[2] = al_load_bitmap("2.png"); perro[3] = al_load_bitmap("3.png"); ALLEGRO_BITMAP *arbol[3]; arbol[0] = al_load_bitmap("arbol1.png"); arbol[1] = al_load_bitmap("arbol2.png"); arbol[2] = al_load_bitmap("arbol3.png"); ALLEGRO_BITMAP *cerca; cerca = al_load_bitmap("Cerca.png"); ALLEGRO_BITMAP *Perder; Perder = al_load_bitmap("Perder.png"); const int Mx = 600; const int My = 600; al_create_display(Mx,My); int cielo=0; int DegradCielo=0; int DegradSol=0; int Tierra=0; int perroX = 0; int perroY = 500; int perroE = 0; int tiempoE = 0; bool salta=false; bool arriba=false; bool perder=false; int arbolX1=Mx; int arbolX2=Mx+rand() % 600; int arbolX3=Mx+rand() % 600; int ArbolE1=rand() % 3; int ArbolE2=rand() % 3; int ArbolE3=rand() % 3; int cercaX=Mx; int cercaY=520; int nivel=1; while(true) { cielo=0; DegradCielo=0; DegradSol=0; Tierra=0; al_get_keyboard_state(&estadoTeclado); if (al_key_down(&estadoTeclado, ALLEGRO_KEY_ESCAPE)) { break; } while(DegradCielo<155) { al_draw_line(0,cielo,Mx,cielo,al_map_rgb(50+(cielo/3),50+(cielo/3),100+DegradCielo),3); DegradCielo++; cielo+=3; } while(DegradSol<75) { al_draw_circle(Mx/2, 400, DegradSol*2, al_map_rgb(255-DegradSol,255-DegradSol,DegradSol*-2.5),3); DegradSol++; } while(Tierra<155) { al_draw_line(0,445+Tierra,Mx,445+Tierra,al_map_rgb(70,100+Tierra,100),1); Tierra++; } if(perder==false) { if(salta==false) { tiempoE++; if(tiempoE==15) { perroE++; if(perroE>2) { perroE=1; } tiempoE=0; } if(al_key_down(&estadoTeclado,ALLEGRO_KEY_RIGHT) && perroX<Mx-100 ) { //al_clear_to_color(al_map_rgb(0,0,0)); perroX++; } if(al_key_down(&estadoTeclado,ALLEGRO_KEY_LEFT) && perroX>0) { //al_clear_to_color(al_map_rgb(0,0,0)); perroX--; } if(al_key_down(&estadoTeclado,ALLEGRO_KEY_SPACE)) { //al_clear_to_color(al_map_rgb(0,0,0)); perroE=3; arriba=true; salta=true; } } else { if(arriba==true) { perroY-=1; if(perroY<=420) { arriba=false; } } else { perroY+=1; if(perroY==500) { salta=false; perroE=0; } } } al_draw_bitmap(arbol[ArbolE1],arbolX1,400,0); arbolX1-=nivel; if(arbolX1<=-60) { arbolX1=Mx; ArbolE1=rand() % 3; } al_draw_bitmap(arbol[ArbolE2],arbolX2,400,0); arbolX2-=nivel; if(arbolX2<=-60) { arbolX2=Mx+rand() % 500; ArbolE2=rand() % 3; } al_draw_bitmap(arbol[ArbolE3],arbolX3,400,0); arbolX3-=nivel; if(arbolX3<=-60) { arbolX3=Mx+rand() % 500; ArbolE3=rand() % 3; } al_draw_bitmap(cerca,cercaX,cercaY,0); cercaX-=nivel; if(cercaX<=-60) { cercaX=Mx; nivel+=1; } al_draw_bitmap(perro[perroE],perroX,perroY,0); // if( (perroX)>cercaX && (perroX+100)<cercaX && cercaY-20==perroY) // { // printf("Pierdes"); // } if( ((perroX+30)<cercaX && (perroX+60)>cercaX) && perroY+20<=cercaY && perroY+30>=cercaY ) { perder=true; } } else { al_draw_bitmap(Perder,(Mx/2)-150,My/2,0); if(al_key_down(&estadoTeclado,ALLEGRO_KEY_ENTER) ) { perroX = 0; perroY = 500; perroE = 0; tiempoE = 0; salta=false; arriba=false; cercaX=Mx; cercaY=520; nivel=1; perder=false; } } //printf("Perro: x=%d y=%d\nCerca: x=%d y=%d\n",perroX,perroY,cercaX,cercaY); al_flip_display(); al_rest(0.001); } al_destroy_display(ventana); return 0; }
int main(int argc, char *argv[]) { ALLEGRO_DISPLAY *display = NULL; ALLEGRO_EVENT_QUEUE *evqueue = NULL; ALLEGRO_TIMER *timer = NULL; ALLEGRO_KEYBOARD_STATE keyboard_state; ALLEGRO_EVENT event; ALLEGRO_FONT *font; ALLEGRO_BITMAP *clock_hand, *clock_quadrant, *bow, *sword; float clock_ray = 0, clock_angle = 0; int clock_ray_alpha; float soul_interval = SOUL_TIME_INTERVAL; FuzzyPlayer *player, *cpu; FuzzyGame * game; bool running = true; bool redraw = true; int map_x = 13*16, map_y = 5*16; int screen_width = WINDOW_WIDTH; int screen_height = WINDOW_HEIGHT; double curtime; /* Initialization */ fuzzy_iz_error(al_init(), "Failed to initialize allegro"); fuzzy_load_addon("image", al_init_image_addon()); fuzzy_load_addon("primitives", al_init_primitives_addon()); fuzzy_load_addon("keyboard", al_install_keyboard()); fuzzy_load_addon("mouse", al_install_mouse()); al_init_font_addon(); fuzzy_iz_error(timer = al_create_timer(1.0 / FPS), "Cannot create FPS timer"); fuzzy_iz_error(evqueue = al_create_event_queue(), "Cannot create event queue"); fuzzy_iz_error(display = al_create_display(screen_width, screen_height), "Cannot initialize display"); al_set_window_title(display, WINDOW_TITLE); fuzzy_iz_error(font = al_load_font(fuzzy_res(FONT_FOLDER, "fixed_font.tga"), 0, 0), "Cannot load 'fixed_font.tga'"); clock_hand = al_load_bitmap(fuzzy_res(PICTURE_FOLDER, "clock_hand.png")); fuzzy_iz_error(clock_hand, "Cannot load clock handle"); clock_quadrant = al_load_bitmap(fuzzy_res(PICTURE_FOLDER, "clock_quadrant.png")); fuzzy_iz_error(clock_hand, "Cannot load clock quadrant"); bow = al_load_bitmap(fuzzy_res(PICTURE_FOLDER, "bow.png")); fuzzy_iz_error(clock_hand, "Cannot load bow image"); sword = al_load_bitmap(fuzzy_res(PICTURE_FOLDER, "sword.png")); fuzzy_iz_error(clock_hand, "Cannot load sword image"); /* Queue setup */ al_register_event_source(evqueue, al_get_display_event_source(display)); al_register_event_source(evqueue, al_get_timer_event_source(timer)); al_register_event_source(evqueue, al_get_keyboard_event_source()); al_register_event_source(evqueue, al_get_mouse_event_source()); /* Game setup */ game = fuzzy_game_new("level000.tmx"); player = fuzzy_player_new(game, FUZZY_PLAYER_LOCAL, "Dolly"); cpu = fuzzy_player_new(game, FUZZY_PLAYER_CPU, "CPU_0"); fuzzy_chess_add(game, player, FUZZY_FOO_LINK, 34, 30); fuzzy_chess_add(game, player, FUZZY_FOO_LINK, 33, 30); fuzzy_chess_add(game, cpu, FUZZY_FOO_LINK, 40, 30); bool showing_area = false; FuzzyChess *chess, *focus = NULL; al_clear_to_color(al_map_rgb(0, 0, 0)); al_draw_bitmap(game->map->bitmap, -map_x, -map_y, 0); al_flip_display(); #if DEBUG ALLEGRO_BITMAP *icon; int fps, fps_accum; double fps_time; icon = al_load_bitmap(fuzzy_res(PICTURE_FOLDER, "icon.tga")); if (icon) al_set_display_icon(display, icon); fps_accum = fps_time = 0; fps = FPS; #endif /* Server connection */ int svsock; //~ FuzzyMessage * sendmsg = fuzzy_message_new(); svsock = fuzzy_server_connect(FUZZY_DEFAULT_SERVER_ADDRESS, FUZZY_DEFAULT_SERVER_PORT); _aaa_menu(game, svsock); /* MAIN loop */ player->soul_time = al_get_time(); al_start_timer(timer); while (running) { /* wait until an event happens */ al_wait_for_event(evqueue, &event); switch (event.type) { case ALLEGRO_EVENT_TIMER: /* check soul ticks */ curtime = al_get_time(); while (curtime - player->soul_time >= soul_interval) { //~ fuzzy_debug("Soul tick!"); player->soul_time += soul_interval; player->soul_points += SOUL_POINTS_BOOST; clock_ray = 1; } clock_angle = (curtime - player->soul_time)/soul_interval * FUZZY_2PI; if (clock_ray) { clock_ray = (curtime - player->soul_time)/RAY_TIME_INTERVAL * 50 + 40; clock_ray_alpha = (curtime - player->soul_time)/RAY_TIME_INTERVAL*(55) + 200; if (clock_ray >= 90) clock_ray = 0; } al_get_keyboard_state(&keyboard_state); if (al_key_down(&keyboard_state, ALLEGRO_KEY_RIGHT)) { map_x += 5; if (map_x > (game->map->tot_width - screen_width)) map_x = game->map->tot_width - screen_width; } else if (al_key_down(&keyboard_state, ALLEGRO_KEY_LEFT)) { map_x -= 5; if (map_x < 0) map_x = 0; } else if (al_key_down(&keyboard_state, ALLEGRO_KEY_UP)) { map_y -= 5; if (map_y < 0) map_y = 0; } else if (al_key_down(&keyboard_state, ALLEGRO_KEY_DOWN)) { map_y += 5; if (map_y > (game->map->tot_height - screen_height)) map_y = game->map->tot_height - screen_height; } else if (al_key_down(&keyboard_state, ALLEGRO_KEY_O)) { soul_interval = fuzzy_max(0.1, soul_interval - 0.05); } else if (al_key_down(&keyboard_state, ALLEGRO_KEY_P)) { soul_interval += 0.05; } redraw = true; break; case ALLEGRO_EVENT_KEY_DOWN: if(! focus) break; _attack_area_off(); switch(event.keyboard.keycode) { case ALLEGRO_KEY_W: _chess_move(game, player, focus, focus->x, focus->y-1); break; case ALLEGRO_KEY_A: _chess_move(game, player, focus, focus->x-1, focus->y); break; case ALLEGRO_KEY_S: _chess_move(game, player, focus, focus->x, focus->y+1); break; case ALLEGRO_KEY_D: _chess_move(game, player, focus, focus->x+1, focus->y); break; case ALLEGRO_KEY_K: _attack_area_on(); break; case ALLEGRO_KEY_SPACE: /* switch attack type */ if (! focus) break; if (focus->atkarea == &FuzzyMeleeMan) focus->atkarea = &FuzzyRangedMan; else focus->atkarea = &FuzzyMeleeMan; break; } break; case ALLEGRO_EVENT_DISPLAY_CLOSE: running = false; break; case ALLEGRO_EVENT_KEY_UP: break; case ALLEGRO_EVENT_KEY_CHAR: break; case ALLEGRO_EVENT_MOUSE_BUTTON_DOWN: if(event.mouse.button == RIGHT_BUTTON) { _attack_area_on(); } else if(event.mouse.button == LEFT_BUTTON) { /* world to tile coords */ int tx = (event.mouse.x+map_x) / game->map->tile_width; int ty = (event.mouse.y+map_y) / game->map->tile_height; #ifdef DEBUG printf("SELECT %d %d\n", tx, ty); #endif if(showing_area && fuzzy_chess_inside_target_area(game, focus, tx, ty)) { /* select attack target */ if (fuzzy_map_spy(game->map, FUZZY_LAYER_SPRITES, tx, ty) == FUZZY_CELL_SPRITE) { if (fuzzy_chess_local_attack(game, player, focus, tx, ty)) _attack_area_off(); } } else { /* select chess */ chess = fuzzy_chess_at(game, player, tx, ty); if (chess && focus != chess) { _attack_area_off(); if (focus != NULL) { // already has a focus effect, just move it fuzzy_sprite_move(game->map, FUZZY_LAYER_BELOW, focus->x, focus->y, tx, ty); } else { fuzzy_sprite_create(game->map, FUZZY_LAYER_BELOW, GID_TARGET, tx, ty); } focus = chess; } else if (! chess) { if (showing_area) { // just hide the attack area _attack_area_off(); } else if(focus) { // remove the focus fuzzy_sprite_destroy(game->map, FUZZY_LAYER_BELOW, focus->x, focus->y); focus = NULL; } } } } break; default: #ifdef DEBUG //~ fprintf(stderr, "Unknown event received: %d\n", event.type); #endif break; } if (redraw && al_is_event_queue_empty(evqueue)) { curtime = al_get_time(); fuzzy_map_update(game->map, curtime); // Clear the screen al_clear_to_color(al_map_rgb(0, 0, 0)); al_draw_bitmap(game->map->bitmap, -map_x, -map_y, 0); #ifdef GRID_ON /* Draw the grid */ int tw = game->map->tile_width; int ty = game->map->tile_height; int x, y; for (x=(tw-map_x)%tw; x<screen_width; x+=tw) al_draw_line(x, 0, x, screen_height, al_map_rgba(7,7,7,100), 1); for (y=(ty-map_y)%ty; y<screen_height; y+=ty) al_draw_line(0, y, screen_width, y, al_map_rgba(7,7,7,100), 1); #endif #if DEBUG al_draw_filled_rounded_rectangle(screen_width-100, 4, screen_width, 30, 8, 8, al_map_rgba(0, 0, 0, 200)); al_draw_textf(font, al_map_rgb(255, 255, 255), screen_width-50, 8, ALLEGRO_ALIGN_CENTRE, "FPS: %d", fps); #endif /* draw SP count */ al_draw_filled_rounded_rectangle(4, screen_height-170, 175, screen_height-4, 8, 8, al_map_rgba(0, 0, 0, 200)); al_draw_textf(font, al_map_rgb(255, 255, 255), 15, screen_height-163, ALLEGRO_ALIGN_LEFT, "SP: %d", player->soul_points); /* draw Soul Clock */ al_draw_scaled_bitmap(clock_quadrant, 0, 0, 301, 301, 20, screen_height-80-139/2, 139, 139, 0); al_draw_scaled_rotated_bitmap(clock_hand, 160, 607, 90, screen_height-80, 0.11, 0.11, clock_angle, 0); al_draw_circle(90, screen_height-80, clock_ray, al_map_rgb(80, clock_ray_alpha, 80), 2.0); /* draw weapon */ if (focus) { ALLEGRO_BITMAP * weapon; if (focus->atkarea == &FuzzyMeleeMan) weapon = sword; else weapon = bow; al_draw_scaled_bitmap(weapon, 0, 0, 90, 90, 20, 20, 60, 60, 0); } al_flip_display(); #if DEBUG fps_accum++; if (curtime - fps_time >= 1) { fps = fps_accum; fps_accum = 0; fps_time = curtime; } #endif redraw = false; } } /* Cleanup */ //~ void * retval; //~ char srvkey[FUZZY_SERVERKEY_LEN]; //~ fuzzy_protocol_server_shutdown(svsock, sendmsg, srvkey); //~ fuzzy_message_del(sendmsg); fuzzy_game_free(game); al_destroy_event_queue(evqueue); al_destroy_display(display); al_destroy_timer(timer); return 0; }
void StateControl::start_radio () { Initialize(); states.push_back(new LoginState()); states.push_back(new SignUpState()); states.push_back(new AdminAccState()); states.push_back(new RegularAccState()); states.push_back(new ManageMusicsState()); states.push_back(new AddMusicState()); states.push_back(new EditMusicState()); states.push_back(new TopTenState()); states.push_back(new MyPlaylistState()); states.push_back(new SearchState()); states.push_back(new CompetitionState()); state = -1; ChangeState(Login); cout << "Starting control cycle..." << endl; done = false; draw = true; while (!done) { ALLEGRO_EVENT ev; al_wait_for_event(event_queue, & ev); /* --- controlling left mouse button double press --- */ if (possible_double_press && double_press_counter < 15) { double_press_counter++; } else if (possible_double_press) { possible_double_press = false; double_press_counter = 0; } /* --- advancing through music --- */ if (ev.timer.source == timer && playing_music && music_time_counter < 130) { music_time_counter++; } else if (ev.timer.source == timer && playing_music) { playing_music = false; music_time_counter = 0; } /* --- tracking mouse --- */ if (ev.type == ALLEGRO_EVENT_MOUSE_AXES) { mouse_x = ev.mouse.x; mouse_y = ev.mouse.y; draw = true; } if (ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) { if (ev.mouse.button & 1) { left_mouse_button_pressed = true; left_mouse_button_released = false; draw = true; } if (ev.mouse.button & 2) { right_mouse_button_pressed = true; right_mouse_button_released = false; draw = true; } } if (ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_UP) { if (ev.mouse.button & 1) { if (possible_double_press) { cout << "* Left mouse button pressed twice *" << endl; left_mouse_button_pressed_twice = true; } else { cout << "* Left mouse button pressed *" << endl; } possible_double_press = true; left_mouse_button_pressed = false; left_mouse_button_released = true; draw = true; } if (ev.mouse.button & 2) { cout << "* Right mouse button pressed *" << endl; right_mouse_button_pressed = false; right_mouse_button_released = true; draw = true; } } /* --- UPDATING --- */ if (states[state]->Update(& ev) || ev.type == ALLEGRO_EVENT_TIMER || draw) { StateControl::GetInstance()->left_mouse_button_released = false; StateControl::GetInstance()->left_mouse_button_pressed_twice = false; StateControl::GetInstance()->right_mouse_button_released = false; draw = true; } /* --- now drawing --- */ if (draw && al_event_queue_is_empty(event_queue)) { states[state]->Draw(); /* player active UI */ if (state != Login && state != SignUp && state != AddMusic && state != EditMusic && state != ManageMusics && state != Competition) { al_draw_text(musics_font, DarkGray, 10, player_interface_y_coord, NULL, "Playing:"); al_draw_line(10, 420, 140, 420, DarkGray, 2.0); switch (playing_music) { case 0: { al_draw_text(tiny_font, DarkGray, 10, player_interface_y_coord + 20, NULL, "<Double-click a music>"); al_draw_circle(10, player_interface_y_coord + 40, 5, LightGray, 1.0); al_draw_filled_circle(10, player_interface_y_coord + 40, 4, White); break; } case 1: { al_draw_text(tiny_font, DarkGray, 10, player_interface_y_coord + 20, NULL, music_playing_title.c_str()); al_draw_circle(10 + music_time_counter, player_interface_y_coord + 40, 5, LightGray, 1.0); al_draw_filled_circle(10 + music_time_counter, player_interface_y_coord + 40, 4, White); break; } } } /* // mouse temp coords stringstream ss; ss << mouse_x << " " << mouse_y; al_draw_text(forms_font, Yellow, 0, 0, NULL, ss.str().c_str()); // ----------------- */ al_flip_display(); al_clear_to_color(al_map_rgb(0, 0, 0)); draw = false; } /* if window is closed */ if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) { cout << "Close button pressed..." << endl; done = true; } } Terminate(); }
int main(){ int SCREEN_W = 400; int SCREEN_H = 400; ALLEGRO_DISPLAY *display = NULL; if(!al_init()) { fprintf(stderr, "failed to initialize allegro!\n"); return 0; } display = al_create_display(SCREEN_W, SCREEN_H); if(!display) { fprintf(stderr, "failed to create display!\n"); return 0; } if(!al_install_keyboard()) { fprintf(stderr, "failed to initialize the keyboard!\n"); return 0; } ALLEGRO_COLOR negro = al_map_rgb(0,0,0); ALLEGRO_COLOR rojo = al_map_rgb(255,0,0); ALLEGRO_COLOR azul = al_map_rgb(0,0,255); al_clear_to_color(negro); al_flip_display(); int i,j,n,nl; scanf("%d",&n);//cantidad de puntos. nl = n*(n-1)/2;//cantidad de lineas. _linea * l = (_linea *)malloc(sizeof(_linea)*nl); int puntos[n][2];//matriz para almacenar los puntos. for(i=0;i<n;i++){ scanf("%d",&puntos[i][0]); scanf("%d",&puntos[i][1]); al_draw_circle(puntos[i][0],SCREEN_H - puntos[i][1], 1, rojo,2);//dibujo de los puntos en la pantalla. al_flip_display(); } ALLEGRO_EVENT_QUEUE *queue = NULL; queue = al_create_event_queue(); if(!queue) { return 0; } ALLEGRO_EVENT event; al_register_event_source(queue, al_get_keyboard_event_source()); do{ al_wait_for_event(queue, &event); } while (event.type != ALLEGRO_EVENT_KEY_DOWN); //espera para que el usuario aprete una tecla para que el programa siga. int a=0; for(i=0;i<n;i++){ //creación de todas las lineas. for(j=i+1;j<n;j++){ l[a].x0=puntos[i][0]; l[a].y0=puntos[i][1]; l[a].x1=puntos[j][0]; l[a].y1=puntos[j][1]; a++; } } quicksort(l,0,nl-1); // ordenamiento de las lineas para que queden primero las con menor longitud. _linea *sol = (_linea *)malloc(sizeof(_linea)*nl); // conjunto de líneas que forman la solución. int sol_size = 0; for (i=0;i<nl;i++){ //comprobar si cada linea existente se intersecta con las lineas que pertenecen a la solución int flag=1; for(j=0;j<sol_size;j++){ if(inter(l[i],sol[j])==1){ flag=0; j=sol_size; } } if(flag==1){ // si no se intersecta con ninguna linea que sea parte de la solución se guarda como parte de la solución sol[sol_size]=l[i]; al_draw_line(sol[sol_size].x0,SCREEN_H-sol[sol_size].y0, sol[sol_size].x1,SCREEN_H-sol[sol_size].y1, azul, 1); al_flip_display(); sol_size++; } } al_rest(3); al_destroy_display(display); return 0; }
void Map::redrawRegions() { if(playerTurn == NULL) return; int screenW = Base::instance()->getEngine()->getWindowSize().x; int screenH = Base::instance()->getEngine()->getWindowSize().y; int worldx = Base::instance()->getCoords()->first; int worldy = Base::instance()->getCoords()->second; al_clear_to_color(al_map_rgb(0, 0, 255)); al_draw_bitmap_region(mapaPtr,-worldx,-worldy,screenW, screenH,0,0,0); std::list<Region>::iterator it0; for(it0=regions.begin(); it0!=regions.end(); it0++) { std::vector<Region*>::iterator it2; for(it2=it0->regionsConnected.begin(); it2!=it0->regionsConnected.end(); it2++) { ALLEGRO_COLOR color = al_map_rgb(0,0,0); Region *region2 = *it2; if(selectedRegion!=NULL) { if(movType==MOVE && ((it0->regionname==selectedRegion->regionname || region2->regionname==selectedRegion->regionname) && //BREAKS SOMETIMES (it0->owner->name == region2->owner->name)) && (it0->owner->name == playerTurn->realm->name)) color = al_map_rgb(0,255,0); else if(movType==ATTACK&& ((it0->regionname==selectedRegion->regionname || region2->regionname==selectedRegion->regionname) && (it0->owner->name != region2->owner->name)) && (it0->owner->name != playerTurn->realm->name)) color = al_map_rgb(255,0,0); } al_draw_line(it0->x+worldx+5, it0->y+worldy+5,(*it2)->x+worldx+5, (*it2)->y+worldy+5,color,2); } } std::list<Region>::iterator it; for(it=regions.begin(); it!=regions.end(); it++) { std::list<DiplomaticState>::iterator stateIt; for(stateIt=playerTurn->realm->diplomacy.begin(); stateIt!=playerTurn->realm->diplomacy.end(); stateIt++) { if(playerTurn->realm->name == it->owner->name) { al_draw_rectangle(it->x+worldx-1, it->y+worldy-1, it->x+it->w+worldx+1, it->y+it->h+worldy+1, al_map_rgb(255, 255, 0), 3); break; } else if(stateIt->realm->name == it->owner->name) { if(stateIt->state == WAR) al_draw_rectangle(it->x+worldx-1, it->y+worldy-1, it->x+it->w+worldx+1, it->y+it->h+worldy+1, al_map_rgb(255, 0, 0), 3); else if(stateIt->state == ALLIANCE) al_draw_rectangle(it->x+worldx-1, it->y+worldy-1, it->x+it->w+worldx+1, it->y+it->h+worldy+1, al_map_rgb(0, 255, 0), 3); else if(stateIt->state == TRADE_AGREEMENT) al_draw_rectangle(it->x+worldx-1, it->y+worldy-1, it->x+it->w+worldx+1, it->y+it->h+worldy+1, al_map_rgb(0, 0, 255), 3); else al_draw_rectangle(it->x+worldx-1, it->y+worldy-1, it->x+it->w+worldx+1, it->y+it->h+worldy+1, al_map_rgb(255, 255, 255), 3); } } al_draw_filled_rectangle(it->x+worldx, it->y+worldy, it->x+it->w+worldx, it->y+it->h+worldy, it->owner->color); al_draw_rectangle(it->x+worldx, it->y+worldy, it->x+it->w+worldx, it->y+it->h+worldy, al_map_rgb(0, 0, 0), 2); if(&*it==selectedRegion) { al_draw_circle(it->x+worldx+5, it->y+worldy+5, 10, al_map_rgb(0,0,0), 4); } } }