game_status state_game_over(SDL_Surface *screen, game* p_game) { bool done=false; image* game_over; game_over = image_load("./res/images/game_over.png"); SDL_Rect srcrect = {0,0,160,144}; SDL_Rect dstrect = set_rect(0,0,SCREEN_HEIGHT,SCREEN_WIDTH); while (!done) { //events SDL_Event event; while (SDL_PollEvent(&event)) { switch ( event.type ) { case SDL_QUIT: done = true; break; case SDL_KEYUP: switch ( event.key.keysym.sym ) { default:break; } default:break; } } image_draw(game_over, get_backbuffer_surface(), 0, 0); SDL_SoftStretch(get_backbuffer_surface(), &srcrect, screen, &dstrect); SDL_Flip(screen); } return MAIN_MENU; }
ButtonPanel::ButtonPanel(Server* s, const Vector2i& pos) : RectComponent(Rect()), server(s), background("core/buttons/buttonbackground"), highlight("core/buttons/buttonbackgroundhl"), buttons(), current_button(0), show_tip(false), tip_button(0) { ActionHolder* aholder = server->get_action_holder(); std::vector<ActionName::Enum> actions = aholder->get_available_actions(); set_rect(Rect(Vector2i(pos.x, pos.y - (actions.size() * 38)/2), Size(60, actions.size() * 38))); // Sort the action so that they always have the same order in the panel std::sort(actions.begin(), actions.end()); for(std::vector<ActionName::Enum>::size_type i = 0; i < actions.size(); ++i) { ActionButton button; button.name = actions[i]; button.sprite = Sprite("pingus/player0/" + ActionName::to_string(button.name) + "/right"); button.sprite.set_hotspot(origin_center, 0, 0); button.sprite.set_play_loop(true); buttons.push_back(button); } }
ground(const sf::Vector2f& windims, const float divis, const sf::Color& color) : m_windims(windims), m_divis(divis), m_side(m_windims.y/m_divis), m_posit(0.0f, m_windims.y - m_side), m_dims(m_windims.x, m_side), m_color(color), m_rect() { set_rect(); }
bool event_exec_text(event *p_event, struct t_game* p_game) { event_text *data = (event_text*)p_event->data; bool done=false; SDL_Event event; SDL_Rect srcrect = {0,0,160,144}; //the part of the screen to be stretched, must be sup 0 and inf screen surface Height and Width SDL_Rect dstrect = set_rect(0,0,SCREEN_HEIGHT,SCREEN_WIDTH); //equals screen resolution message_box* p_message_box = NULL; p_message_box = gui_new_message_box(p_message_box, data->text, 0, 144-32, 32, 160, 0, 146, 30); p_message_box->p_font = font_load("res/fonts/saxmono.ttf", 10); p_message_box->border = 0; p_message_box->border_color = 999; p_message_box->radius = 0; while (!done){ while (SDL_PollEvent (&event)){ switch (event.type){ case SDL_KEYDOWN: if(event.key.keysym.sym==SDLK_SPACE){ done = true; } break; case SDL_QUIT: exit(0); break; case SDL_JOYBUTTONDOWN: switch(event.jbutton.button) { case 0: break; case 1: break; case 2: break; case 3: done = true; break; case 4: break; case 5: break; case 6: break; } } } gui_message_box_draw(p_message_box, get_backbuffer_surface()); SDL_SoftStretch(backbuffer,&srcrect,SDL_GetVideoSurface(),&dstrect); SDL_Flip(SDL_GetVideoSurface()); } gui_message_box_free(p_message_box); return true; }
interro_block* interro_block_new(item_type type, int number) { interro_block* p_ib = malloc(sizeof(interro_block)); p_ib->item = type; p_ib->number = number; p_ib->p_sprite = malloc(sizeof(anim_sprite)); p_ib->p_sprite->p_image = gfx_item; anim_sprite_init(p_ib->p_sprite, 80, TILE_HEIGHT * 9 + 8, 3, 1, 0, 0, 1); p_ib->p_sprite->v_anim = malloc(p_ib->p_sprite->animation_nb * sizeof(animation)); animation_init(p_ib->p_sprite->v_anim+0, 1, 3, 20, 0); p_ib->p_sprite->v_anim[0].v_frame = malloc( p_ib->p_sprite->v_anim[0].frame_nb * sizeof(SDL_Rect)); p_ib->p_sprite->v_anim[0].v_frame[0] = set_rect(0, 0, 16, 16); p_ib->p_sprite->v_anim[0].v_frame[1] = set_rect(16, 0, 16, 16); p_ib->p_sprite->v_anim[0].v_frame[2] = set_rect(32, 0, 16, 16); return p_ib; }
int eventFilter( const SDL_Event *e ) { if( e->type == SDL_VIDEORESIZE ) { SDL_SetVideoMode(e->resize.w,e->resize.h,0,SDL_ANYFORMAT); dstrect = set_rect(0,0,e->resize.h,e->resize.w); } return 1; }
void sbox_set_mid_rect(control_t *p_ctrl, s16 left, s16 top, s16 right, s16 bottom) { ctrl_sbox_data_t *p_data = NULL; MT_ASSERT(p_ctrl != NULL); p_data = (ctrl_sbox_data_t *)p_ctrl->priv_data; set_rect(&p_data->mid_rect, left, top, right, bottom); }
void ennemie_init(ennemie* p_ennemie, ennemie_type type, int x, int y) { p_ennemie->type = type; p_ennemie->p_sprite = malloc(sizeof(anim_sprite)); p_ennemie->p_sprite->vel_x = -1; p_ennemie->p_sprite->vel_y = 0; p_ennemie->speed = 1; p_ennemie->dir = LEFT; p_ennemie->p_sprite->p_image = gfx_ennemie; p_ennemie->p_sprite->x = x * TILE_WIDTH; p_ennemie->p_sprite->y = y * TILE_HEIGHT; p_ennemie->p_sprite->offset.x = 0; p_ennemie->p_sprite->offset.y = 4; p_ennemie->p_sprite->offset.h = 12; p_ennemie->p_sprite->offset.w = 16; p_ennemie->p_sprite->animation_nb = 1; p_ennemie->p_sprite->v_anim = malloc(p_ennemie->p_sprite->animation_nb * sizeof(animation)); p_ennemie->p_sprite->animation_current = 0; p_ennemie->p_sprite->v_anim[0].frame_nb = 2; p_ennemie->p_sprite->v_anim[0].frame_delay = 8; p_ennemie->p_sprite->v_anim[0].frame_trigger = 0; p_ennemie->p_sprite->v_anim[0].frame_default = 1; p_ennemie->p_sprite->v_anim[0].frame_current = 1; p_ennemie->p_sprite->v_anim[0].v_frame = malloc(p_ennemie->p_sprite->v_anim[0].frame_nb * sizeof(SDL_Rect)); p_ennemie->p_sprite->v_anim[0].v_frame[0] = set_rect(0, 0, 16, 16); p_ennemie->p_sprite->v_anim[0].v_frame[1] = set_rect(16, 0, 16, 16); p_ennemie->p_sprite->tile_height=16; p_ennemie->p_sprite->tile_width=16; p_ennemie->p_sprite->frame_nb_x = p_ennemie->p_sprite->p_image->width / p_ennemie->p_sprite->tile_width; p_ennemie->p_sprite->frame_nb_y = p_ennemie->p_sprite->p_image->height / p_ennemie->p_sprite->tile_height; }
struct bomb_t* unit_put_bomb(unit *p_unit, map *p_map) { int index_x = unit_get_bounding_index_center_x(p_unit); int index_y = unit_get_bounding_index_center_y(p_unit); //Create the bomb bomb *p_bomb = malloc(sizeof(bomb)); p_bomb->power = p_unit->power; p_bomb->time_left = BOMB_TIMER; p_bomb->type = NORMAL; p_bomb->p_owner = p_unit; p_bomb->p_sprite = malloc(sizeof(anim_sprite)); //p_bomb->p_sprite->p_image = image_load("res/bomb.png"); p_bomb->p_sprite->p_image = (image*)res_get(images, "bomb")->data; p_bomb->p_sprite->frame_nb_x = 3; p_bomb->p_sprite->frame_nb_y = 1; p_bomb->p_sprite->animation_nb = 0; p_bomb->p_sprite->animation_current = 0; p_bomb->p_sprite->v_anim = malloc(p_unit->p_sprite->animation_nb * sizeof(animation)); p_bomb->p_sprite->v_anim[0].frame_current = 0; p_bomb->p_sprite->v_anim[0].frame_nb = 4; p_bomb->p_sprite->v_anim[0].frame_delay = BOMB_TIMER / 9; //Breath 3 times p_bomb->p_sprite->v_anim[0].frame_trigger = 0; p_bomb->p_sprite->v_anim[0].v_frame = malloc(p_bomb->p_sprite->v_anim[0].frame_nb * sizeof(SDL_Rect)); p_bomb->p_sprite->v_anim[0].v_frame[0] = set_rect(0, 0, 32, 32); p_bomb->p_sprite->v_anim[0].v_frame[1] = set_rect(32, 0, 32, 32); p_bomb->p_sprite->v_anim[0].v_frame[2] = set_rect(64, 0, 32, 32); p_bomb->p_sprite->v_anim[0].v_frame[3] = set_rect(32, 0, 32, 32); //image_set_transp_color(p_bomb->p_sprite->p_image, 255, 0, 255); p_bomb->p_sprite->x = index_x * TILE_SIZE; p_bomb->p_sprite->y = index_y * TILE_SIZE; p_map->pp_tile[index_y][index_x].type = BOMB; return (struct bomb_t*)p_bomb; }
void unit_calc_bounding_box(unit *p_unit) { int x = unit_get_x(p_unit); int y = unit_get_y(p_unit); int offset_x = p_unit->p_sprite->offset.x; int offset_y = p_unit->p_sprite->offset.y; int offset_h = p_unit->p_sprite->offset.h; int offset_w = p_unit->p_sprite->offset.w; p_unit->p_sprite->bounding_box = set_rect(offset_x + x, offset_y + y, offset_h, offset_w); }
game_status state_main_menu(SDL_Surface *screen, game* p_game) { bool done=false; image* main_title; main_title = image_load("./res/images/main_title.png"); SDL_Rect srcrect = {0,0,160,144}; SDL_Rect dstrect = set_rect(0,0,SCREEN_HEIGHT,SCREEN_WIDTH); int next_state=STAY; while (!done) { //events SDL_Event event; while (SDL_PollEvent(&event)) { switch ( event.type ) { case SDL_QUIT: done = true; break; default: break; } } image_draw(main_title, get_backbuffer_surface(), 0, 0); SDL_SoftStretch(get_backbuffer_surface(), &srcrect, screen, &dstrect); SDL_Flip(screen); if(next_state == STAY)next_state = menu_main(screen, p_game); else if(next_state!=QUIT){ switch(next_state){ case LOAD: menu_load(screen, &p_game); next_state = state_in_game(screen, p_game); break; case 1: p_game = game_load("./res/scripts/state.xml"); next_state = state_in_game(screen, p_game); break; default: break; } } else if(next_state==QUIT)done=true; } image_free(main_title); return QUIT; }
void text_set_mid_rect(control_t *p_ctrl, s16 left, s16 top, u16 width, u16 height) { ctrl_text_data_t *p_data = NULL; rect_t frame; MT_ASSERT(p_ctrl != NULL); ctrl_get_frame(p_ctrl, &frame); MT_ASSERT((left + width) <= RECTW(frame)); MT_ASSERT((top + height) <= RECTH(frame)); p_data = (ctrl_text_data_t *)p_ctrl->priv_data; set_rect(&p_data->mid_rect, left, top, (s16)(left + width), (s16)(top + height)); }
void unlccomp_rect(VRaster *r,void *ucbuf, LONG pixsize, Coor xorg, Coor yorg, Ucoor width, Ucoor height) { /* Uncompress data into a rectangular area inside raster using byte-run-length/delta compression scheme used in Autodesk Animator 1.0 for most frames except the first. (Unclipped.) */ static short x,y; static short lines; static char opcount; static short psize; static char *cpt; static short *wpt; wpt = (short *) ucbuf; cpt = (char *)(wpt+2); /* Data starts with 2 16 bit quantities then bytes */ y = yorg + *wpt++; lines = *wpt++; while (--lines >= 0) { x = xorg; opcount = *cpt++; while (opcount > 0) { x += *cpt++; psize = *cpt++; if (psize & 0x80) { psize = 256 - psize; set_rect(r, *cpt++, x, y, psize, 1); x += psize; opcount -= 1; } else { put_rectpix(r, cpt, x, y, psize, 1); cpt += psize; x += psize; opcount -= 1; } } y++; } }
static BOOL _sbox_get_item_rect(control_t *p_ctrl, u16 index, rect_t *p_rect) { ctrl_sbox_data_t *p_data = NULL; u16 left = 0, top = 0, height = 0, width = 0; MT_ASSERT(p_ctrl != NULL); p_data = (ctrl_sbox_data_t *)p_ctrl->priv_data; if(index >= p_data->total) { return FALSE; } left = *(p_data->p_left + index); top = p_data->mid_rect.top; height = (p_data->mid_rect.bottom - p_data->mid_rect.top); width = *(p_data->p_width + index); set_rect(p_rect, left, top, (s16)(left + width), (s16)(top + height)); return TRUE; }
static void test_color_brush(void) { D2D1_MATRIX_3X2_F matrix, tmp_matrix; D2D1_BRUSH_PROPERTIES brush_desc; D2D1_COLOR_F color, tmp_color; ID2D1SolidColorBrush *brush; IDXGISwapChain *swapchain; ID2D1RenderTarget *rt; ID3D10Device1 *device; IDXGISurface *surface; D2D1_RECT_F rect; float opacity; HWND window; HRESULT hr; if (!(device = create_device())) { skip("Failed to create device, skipping tests.\n"); return; } window = CreateWindowA("static", "d2d1_test", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 0, 0, 640, 480, NULL, NULL, NULL, NULL); swapchain = create_swapchain(device, window, TRUE); hr = IDXGISwapChain_GetBuffer(swapchain, 0, &IID_IDXGISurface, (void **)&surface); ok(SUCCEEDED(hr), "Failed to get buffer, hr %#x.\n", hr); rt = create_render_target(surface); ok(!!rt, "Failed to create render target.\n"); ID2D1RenderTarget_SetDpi(rt, 192.0f, 48.0f); ID2D1RenderTarget_SetAntialiasMode(rt, D2D1_ANTIALIAS_MODE_ALIASED); set_color(&color, 0.0f, 0.0f, 0.0f, 0.0f); hr = ID2D1RenderTarget_CreateSolidColorBrush(rt, &color, NULL, &brush); ok(SUCCEEDED(hr), "Failed to create brush, hr %#x.\n", hr); opacity = ID2D1SolidColorBrush_GetOpacity(brush); ok(opacity == 1.0f, "Got unexpected opacity %.8e.\n", opacity); set_matrix_identity(&matrix); ID2D1SolidColorBrush_GetTransform(brush, &tmp_matrix); ok(!memcmp(&tmp_matrix, &matrix, sizeof(matrix)), "Got unexpected matrix {%.8e, %.8e, %.8e, %.8e, %.8e, %.8e}.\n", tmp_matrix._11, tmp_matrix._12, tmp_matrix._21, tmp_matrix._22, tmp_matrix._31, tmp_matrix._32); tmp_color = ID2D1SolidColorBrush_GetColor(brush); ok(!memcmp(&tmp_color, &color, sizeof(color)), "Got unexpected color {%.8e, %.8e, %.8e, %.8e}.\n", tmp_color.r, tmp_color.g, tmp_color.b, tmp_color.a); ID2D1SolidColorBrush_Release(brush); set_color(&color, 0.0f, 1.0f, 0.0f, 0.8f); brush_desc.opacity = 0.3f; set_matrix_identity(&matrix); scale_matrix(&matrix, 2.0f, 2.0f); brush_desc.transform = matrix; hr = ID2D1RenderTarget_CreateSolidColorBrush(rt, &color, &brush_desc, &brush); ok(SUCCEEDED(hr), "Failed to create brush, hr %#x.\n", hr); opacity = ID2D1SolidColorBrush_GetOpacity(brush); ok(opacity == 0.3f, "Got unexpected opacity %.8e.\n", opacity); ID2D1SolidColorBrush_GetTransform(brush, &tmp_matrix); ok(!memcmp(&tmp_matrix, &matrix, sizeof(matrix)), "Got unexpected matrix {%.8e, %.8e, %.8e, %.8e, %.8e, %.8e}.\n", tmp_matrix._11, tmp_matrix._12, tmp_matrix._21, tmp_matrix._22, tmp_matrix._31, tmp_matrix._32); tmp_color = ID2D1SolidColorBrush_GetColor(brush); ok(!memcmp(&tmp_color, &color, sizeof(color)), "Got unexpected color {%.8e, %.8e, %.8e, %.8e}.\n", tmp_color.r, tmp_color.g, tmp_color.b, tmp_color.a); ID2D1RenderTarget_BeginDraw(rt); set_color(&color, 0.0f, 0.0f, 1.0f, 1.0f); ID2D1RenderTarget_Clear(rt, &color); ID2D1SolidColorBrush_SetOpacity(brush, 1.0f); set_rect(&rect, 40.0f, 120.0f, 120.0f, 360.0f); ID2D1RenderTarget_FillRectangle(rt, &rect, (ID2D1Brush *)brush); set_matrix_identity(&matrix); scale_matrix(&matrix, 0.5f, 2.0f); translate_matrix(&matrix, 320.0f, 240.0f); rotate_matrix(&matrix, M_PI / 4.0f); ID2D1RenderTarget_SetTransform(rt, &matrix); set_color(&color, 1.0f, 0.0f, 0.0f, 0.625f); ID2D1SolidColorBrush_SetColor(brush, &color); ID2D1SolidColorBrush_SetOpacity(brush, 0.75f); set_rect(&rect, -80.0f, -60.0f, 80.0f, 60.0f); ID2D1RenderTarget_FillRectangle(rt, &rect, (ID2D1Brush *)brush); hr = ID2D1RenderTarget_EndDraw(rt, NULL, NULL); ok(SUCCEEDED(hr), "Failed to end draw, hr %#x.\n", hr); ok(compare_surface(surface, "6d1218fca5e21fb7e287b3a439d60dbc251f5ceb"), "Surface does not match.\n"); ID2D1SolidColorBrush_Release(brush); ID2D1RenderTarget_Release(rt); IDXGISurface_Release(surface); IDXGISwapChain_Release(swapchain); ID3D10Device1_Release(device); DestroyWindow(window); }
int menu_main(SDL_Surface* destination, game *p_game){ bool menu_done=false; SDL_Event event; int choice_current=0; int choice_nb = 2; message_box* p_menu = NULL; p_menu = gui_new_message_box(p_menu, " Load\n New Game\n", 30, 70, 40, 100, 0, 0, 30); p_menu->p_font = font_load("res/fonts/saxmono.ttf", 12); p_menu->border = 5; p_menu->border_color = 342; p_menu->radius = 10; image* p_cursor=image_load("./res/chipsets/cursor.png"); image_set_transp_color(p_cursor, 255, 0, 255); SDL_Joystick* joystick; joystick = SDL_JoystickOpen(0); //cursor coords int src_x = 0; int src_y = 0; int dest_x = p_menu->x + 2; int dest_y = p_menu->y + 5; while(!menu_done){ SDL_Rect srcrect = {0,0,160,144}; //the part of the screen to be stretched, must be sup 0 and inf screen surface Height and Width SDL_Rect dstrect = set_rect(0,0,SCREEN_HEIGHT,SCREEN_WIDTH); //equals screen resolution gui_message_box_draw(p_menu, get_backbuffer_surface()); image_draw_part(p_cursor, get_backbuffer_surface(), dest_x, dest_y, src_x, src_y, 16, 16); SDL_SoftStretch(backbuffer,&srcrect,SDL_GetVideoSurface(),&dstrect); SDL_Flip(destination); while (SDL_PollEvent(&event)){ switch ( event.type ){ case SDL_JOYBUTTONDOWN: switch(event.jbutton.button) { case 0: break; case 1: break; case 2: src_x = 16; menu_done = true; image_draw_part(p_cursor, get_backbuffer_surface(), dest_x, dest_y, src_x, src_y, 16, 16); SDL_SoftStretch(backbuffer,&srcrect,SDL_GetVideoSurface(),&dstrect); SDL_Flip(SDL_GetVideoSurface()); SDL_Delay(200); break; case 3: break; case 4: break; case 5: break; case 6: break; } case SDL_KEYUP: switch ( event.key.keysym.sym ){ case SDLK_RETURN: src_x = 16; menu_done = true; image_draw_part(p_cursor, get_backbuffer_surface(), dest_x, dest_y, src_x, src_y, 16, 16); SDL_SoftStretch(backbuffer,&srcrect,SDL_GetVideoSurface(),&dstrect); SDL_Flip(SDL_GetVideoSurface()); SDL_Delay(200); break; case SDLK_UP: if (choice_current > 0){ choice_current--; dest_y -= TTF_FontLineSkip(p_menu->p_font); } else{ //play sound error } break; case SDLK_DOWN: if (choice_current < choice_nb-1){ choice_current++; dest_y += TTF_FontLineSkip(p_menu->p_font); } else{ //play sound error } break; default: break; } break; default: break; } } int joystate = SDL_JoystickGetHat(joystick, 0); switch (joystate){ case SDL_HAT_DOWN: if (choice_current < choice_nb-1){ choice_current++; dest_y += TTF_FontLineSkip(p_menu->p_font); } else{ //play sound error } break; case SDL_HAT_UP: if (choice_current > 0){ choice_current--; dest_y -= TTF_FontLineSkip(p_menu->p_font); } else{ //play sound error } break; } } if(choice_current==0)choice_current=LOAD; //index to next state SDL_JoystickClose(joystick); image_free(p_cursor); gui_message_box_free(p_menu); return choice_current; }
int menu_start(SDL_Surface* destination, game *p_game) { bool menu_done=false; bool timerset = false; SDL_Event event; int choice_current=0; int choice_nb = 3; message_box* p_menu = NULL; p_menu = gui_new_message_box(p_menu, " Status\n Save\n Load", 12, 16, 70, 100, 0, 0, 30); //p_menu = gui_new_message_box(p_menu, " Item\n Status\n Options\n Save\n Load", 12, 16, 70, 100, 0, 0, 30); p_menu->p_font = font_load("res/fonts/saxmono.ttf", 12); p_menu->border = 5; p_menu->border_color = 342; p_menu->radius = 10; image* p_cursor=image_load("./res/chipsets/cursor.png"); image_set_transp_color(p_cursor, 255, 0, 255); //cursor coords int src_x = 0; int src_y = 0; int dest_x = p_menu->x + 2; int dest_y = p_menu->y + 5; while(!menu_done){ SDL_Rect srcrect = {0,0,160,144}; //the part of the screen to be stretched, must be sup 0 and inf screen surface Height and Width SDL_Rect dstrect = set_rect(0,0,SCREEN_HEIGHT,SCREEN_WIDTH); //equals screen resolution gui_message_box_draw(p_menu, get_backbuffer_surface()); image_draw_part(p_cursor, get_backbuffer_surface(), dest_x, dest_y, src_x, src_y, 16, 16); SDL_SoftStretch(backbuffer,&srcrect,SDL_GetVideoSurface(),&dstrect); SDL_Flip(SDL_GetVideoSurface()); SDL_EnableKeyRepeat(10, 10); while (SDL_PollEvent(&event)) { switch ( event.type ) { case SDL_KEYUP: switch ( event.key.keysym.sym ){ case SDLK_RETURN: src_x = 16; menu_done = true; image_draw_part(p_cursor, get_backbuffer_surface(), dest_x, dest_y, src_x, src_y, 16, 16); SDL_SoftStretch(backbuffer,&srcrect,SDL_GetVideoSurface(),&dstrect); SDL_Flip(SDL_GetVideoSurface()); SDL_Delay(200); break; case SDLK_UP: if (choice_current > 0){ choice_current--; dest_y -= TTF_FontLineSkip(p_menu->p_font); } else{ //play sound error } break; case SDLK_DOWN: if (choice_current < choice_nb-1){ choice_current++; dest_y += TTF_FontLineSkip(p_menu->p_font); } else{ //play sound error } break; default: break; } case SDL_JOYBUTTONDOWN: switch(event.jbutton.button) { case 0: break; case 1: break; case 2: src_x = 16; menu_done = true; image_draw_part(p_cursor, get_backbuffer_surface(), dest_x, dest_y, src_x, src_y, 16, 16); SDL_SoftStretch(backbuffer,&srcrect,SDL_GetVideoSurface(),&dstrect); SDL_Flip(SDL_GetVideoSurface()); SDL_Delay(200); break; case 3: break; case 4: break; case 5: break; case 6: break; } break; default: break; } } unsigned int start; if (!timerset) { timerset=true; start=SDL_GetTicks(); } unsigned int now=SDL_GetTicks(); if ((now-start)>100) { timerset=false; SDL_JoystickUpdate(); int joystate = SDL_JoystickGetHat(p_game->p_unit->joystick, 0); switch (joystate){ case SDL_HAT_DOWN: if (choice_current < choice_nb-1){ choice_current++; dest_y += TTF_FontLineSkip(p_menu->p_font); } else{ //play sound error } break; case SDL_HAT_UP: if (choice_current > 0){ choice_current--; dest_y -= TTF_FontLineSkip(p_menu->p_font); } else{ //play sound error } break; } } } image_free(p_cursor); return choice_current; }
int menu_status(SDL_Surface* destination, game *p_game){ bool menu_done=false; SDL_Event event; char text[255]; sprintf(text, "Name %s\nXP %d\n", p_game->p_unit->name, p_game->p_unit->XP); message_box* p_menu = NULL; p_menu = gui_new_message_box(p_menu, text, 12, 16, 70, 100, 0, 0, 30); p_menu->p_font = font_load("res/fonts/saxmono.ttf", 12); p_menu->border = 5; p_menu->border_color = 342; p_menu->radius = 10; while(!menu_done){ SDL_Rect srcrect = {0,0,160,144}; //the part of the screen to be stretched, must be sup 0 and inf screen surface Height and Width SDL_Rect dstrect = set_rect(0,0,SCREEN_HEIGHT,SCREEN_WIDTH); //equals screen resolution gui_message_box_draw(p_menu, get_backbuffer_surface()); SDL_SoftStretch(backbuffer,&srcrect,SDL_GetVideoSurface(),&dstrect); SDL_Flip(SDL_GetVideoSurface()); while (SDL_PollEvent(&event)) { switch ( event.type ) { case SDL_KEYUP: switch ( event.key.keysym.sym ){ case SDLK_RETURN: menu_done = true; break; default: break; } break; case SDL_JOYBUTTONDOWN: switch(event.jbutton.button) { case 0: break; case 1: menu_done = true; break; case 2: break; case 3: break; case 4: break; case 5: break; case 6: break; } default: break; } } } return 1; }
game_status state_in_game(SDL_Surface *screen, game* p_game) { int i=0; bool done=false; game_status ret_code = GAME_OVER; SDL_Rect srcrect = {0,0,160,144}; dstrect = set_rect(0,0,SCREEN_HEIGHT,SCREEN_WIDTH); #ifdef USE_LUA lua_State *L; L = lua_open(); luaopen_base(L); luaL_openlibs(L); luaopen_globals(L); luaopen_game(L); luaopen_unit(L); luaopen_sprite(L); luaopen_var(L); luaopen_map(L); //register lua functions lua_register(L ,"say", script_lua_unit_say); lua_register(L ,"unit_get_x", script_lua_unit_get_x); lua_register(L ,"unit_get_y", script_lua_unit_get_y); lua_register(L ,"unit_set_index_x", script_lua_unit_set_index_x); lua_register(L ,"unit_set_index_y", script_lua_unit_set_index_y); lua_register(L ,"event_text", script_lua_event_exec_text); lua_register(L ,"event_teleport", script_lua_event_exec_teleport); lua_register(L ,"unit_set_life", script_lua_unit_set_life); lua_register(L ,"unit_set_speed", script_lua_unit_set_speed); p_game->L = L; g_game = p_game; #endif long timelastcall=SDL_GetTicks(); if(map_get_current(p_game->p_map, p_game->cur_map)->music != NULL){ char* music = strdup(map_get_current(p_game->p_map, p_game->cur_map)->music); Mix_Music* ingame_music = music_load(music); music_play(ingame_music); } message_box* p_menu = NULL; p_menu = menu_ingame_create(p_game); bool action; while (!done) { action = false; SDL_Event event; SDL_JoystickUpdate(); while (SDL_PollEvent(&event)){ switch ( event.type ){ case SDL_QUIT: ret_code = QUIT; done = true; break; case SDL_KEYUP: switch ( event.key.keysym.sym ){ case SDLK_RETURN: switch(menu_start(get_backbuffer_surface(), p_game)){ case 0: menu_status(get_backbuffer_surface(), p_game); break; case 1: menu_save(get_backbuffer_surface(), p_game); break; case 2: ret_code = LOAD; done=true; break; } break; default:break; } break; case SDL_JOYBUTTONDOWN: switch(event.jbutton.button){ case 0: switch(menu_start(get_backbuffer_surface(), p_game)){ case 0: menu_status(get_backbuffer_surface(), p_game); break; case 1: menu_save(get_backbuffer_surface(), p_game); break; case 2: ret_code = LOAD; done=true; break; } break; case 2: action = true; break; } break; default:break; } unit_handle_key(p_game->p_unit, &event, p_game); } int joystate = SDL_JoystickGetHat(p_game->p_unit->joystick, 0); switch (joystate){ case SDL_HAT_DOWN: unit_set_vel_y(p_game->p_unit, p_game->p_unit->speed); unit_set_vel_x(p_game->p_unit, 0); p_game->p_unit->p_sprite->animation_current = DOWN; p_game->p_unit->dir = DOWN; p_game->p_unit->current_action = NOTHING; break; case SDL_HAT_UP: unit_set_vel_y(p_game->p_unit, -p_game->p_unit->speed); unit_set_vel_x(p_game->p_unit, 0); p_game->p_unit->p_sprite->animation_current = UP; p_game->p_unit->dir = UP; p_game->p_unit->current_action = NOTHING; break; case SDL_HAT_RIGHT: unit_set_vel_x(p_game->p_unit, p_game->p_unit->speed); unit_set_vel_y(p_game->p_unit, 0); p_game->p_unit->p_sprite->animation_current = RIGHT; p_game->p_unit->dir = RIGHT; p_game->p_unit->current_action = NOTHING; break; case SDL_HAT_LEFT: unit_set_vel_x(p_game->p_unit, -p_game->p_unit->speed); unit_set_vel_y(p_game->p_unit, 0); p_game->p_unit->p_sprite->animation_current = LEFT; p_game->p_unit->dir = LEFT; p_game->p_unit->current_action = NOTHING; break; default: break; } //drawing SDL_FillRect(screen, 0, SDL_MapRGB(screen->format, 0, 0, 0)); map_draw(map_get_current(p_game->p_map, p_game->cur_map), backbuffer); if(p_game->p_unit->current_action == FIGHT){ anim_sprite_draw(p_game->p_unit->weapon, get_backbuffer_surface()); } anim_sprite_draw(p_game->p_unit->p_sprite, backbuffer); for(i=0;i<p_game->NPC_nb;i++){ NPC_update(p_game->p_NPC+i, map_get_current(p_game->p_map, p_game->cur_map), p_game->p_unit); anim_sprite_draw(p_game->p_NPC[i].p_sprite, backbuffer); } for(i=0;i<p_game->ennemie_nb;i++){ ennemie_update(p_game->p_ennemie+i, map_get_current(p_game->p_map, p_game->cur_map), p_game->p_unit); anim_sprite_draw(p_game->p_ennemie[i].p_sprite, backbuffer); } Uint8* key = SDL_GetKeyState(NULL); if(key[p_game->p_unit->key_b] || action){ for(i=0;i<p_game->NPC_nb;i++){ if(sprite_intersect((sprite*)p_game->p_unit->p_sprite, (sprite*)p_game->p_NPC[i].p_sprite)){ struct t_event* p_event = malloc(sizeof(struct t_event)); p_event->is_auto = true; p_event->p_next = NULL; p_event->type = EVENT_SCRIPT; event_script* p_event_script = malloc(sizeof(event_script)); p_event_script->language = strdup("lua"); p_event_script->script = strdup(p_game->p_NPC[i].script); p_event_script->version = strdup("1.0"); p_event->data = p_event_script; event_exec_script(p_event, p_game); event_free(p_event); } } } //logic sprite_calc_bounding_box((sprite*)p_game->p_unit->p_sprite, true); //events when entering a tile point* p_point_enter = unit_check_on_tile_enter(p_game->p_unit, map_get_current(p_game->p_map, p_game->cur_map)); if( p_point_enter != NULL && map_get_current(p_game->p_map, p_game->cur_map)->pp_tile[p_point_enter->y][p_point_enter->x].p_event != NULL && map_get_current(p_game->p_map, p_game->cur_map)->pp_tile[p_point_enter->y][p_point_enter->x].p_event->is_auto){ p_game->p_unit->p_sprite->v_anim[p_game->p_unit->p_sprite->animation_current].frame_current = 1; event_dispatch(map_get_current(p_game->p_map, p_game->cur_map)->pp_tile[p_point_enter->y][p_point_enter->x].p_event, p_game); free(p_point_enter); } map* p_cur_map = map_get_current(p_game->p_map, p_game->cur_map); if(SDL_GetTicks() - timelastcall>1000/40) { unit_update(p_game->p_unit, p_cur_map); for(i=0;i<p_game->ennemie_nb;i++){ //Check weapon / ennemie collides if(p_game->p_unit->current_action == FIGHT){ if(sprite_intersect((sprite*)p_game->p_unit->weapon, (sprite*)p_game->p_ennemie[i].p_sprite)){ p_game->p_ennemie[i].HP--; if(p_game->p_ennemie[i].HP <= 0){ //ennemie dead //sound dead //animation dead p_game->p_unit->XP += p_game->p_ennemie[i].XP; //increase unit status p_game->p_unit->gold += p_game->p_ennemie[i].gold; ennemie_remove(p_game->p_ennemie, i, &p_game->ennemie_nb); //remove ennemie break; } } } //Check unit / ennemie collides if(p_game->p_unit->invincible_time <= 0 && sprite_intersect((sprite*)p_game->p_unit->p_sprite, (sprite*)p_game->p_ennemie[i].p_sprite)){ //sample_play(unit_hitted); p_game->p_unit->invincible_time = 40; unit_hitted(p_game->p_unit, p_game->p_ennemie+i, p_cur_map); if(p_game->p_unit->HP <= 0){ //sound dead //animation dead //message game over ret_code = GAME_OVER; done = true; break; } } } //Game events menu_ingame_update(get_backbuffer_surface(), p_menu, p_game); //update timer timelastcall=SDL_GetTicks(); } #if RENDER == 3 && !GEKKO SDL_GL_SwapBuffers(); #else SDL_SoftStretch(backbuffer, &srcrect, screen, &dstrect); SDL_Flip(screen); #endif } game_free(p_game); return ret_code; }
unit2::unit2(mkwin_controller& controller, mkwin_display& disp, unit_map& units, int type, unit* parent, const SDL_Rect& rect) : unit(controller, disp, units, type, parent, -1) { set_rect(rect); }
static void test_bitmap_brush(void) { D2D1_BITMAP_INTERPOLATION_MODE interpolation_mode; D2D1_MATRIX_3X2_F matrix, tmp_matrix; D2D1_BITMAP_PROPERTIES bitmap_desc; ID2D1Bitmap *bitmap, *tmp_bitmap; D2D1_RECT_F src_rect, dst_rect; D2D1_EXTEND_MODE extend_mode; IDXGISwapChain *swapchain; ID2D1BitmapBrush *brush; ID2D1RenderTarget *rt; ID3D10Device1 *device; IDXGISurface *surface; D2D1_COLOR_F color; D2D1_SIZE_U size; ULONG refcount; float opacity; HWND window; HRESULT hr; static const DWORD bitmap_data[] = { 0xffff0000, 0xffffff00, 0xff00ff00, 0xff00ffff, 0xff0000ff, 0xffff00ff, 0xff000000, 0xff7f7f7f, 0xffffffff, 0xffffffff, 0xffffffff, 0xff000000, 0xffffffff, 0xff000000, 0xff000000, 0xff000000, }; if (!(device = create_device())) { skip("Failed to create device, skipping tests.\n"); return; } window = CreateWindowA("static", "d2d1_test", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 0, 0, 640, 480, NULL, NULL, NULL, NULL); swapchain = create_swapchain(device, window, TRUE); hr = IDXGISwapChain_GetBuffer(swapchain, 0, &IID_IDXGISurface, (void **)&surface); ok(SUCCEEDED(hr), "Failed to get buffer, hr %#x.\n", hr); rt = create_render_target(surface); ok(!!rt, "Failed to create render target.\n"); ID2D1RenderTarget_SetDpi(rt, 192.0f, 48.0f); ID2D1RenderTarget_SetAntialiasMode(rt, D2D1_ANTIALIAS_MODE_ALIASED); set_size_u(&size, 4, 4); bitmap_desc.pixelFormat.format = DXGI_FORMAT_B8G8R8A8_UNORM; bitmap_desc.pixelFormat.alphaMode = D2D1_ALPHA_MODE_IGNORE; bitmap_desc.dpiX = 96.0f; bitmap_desc.dpiY = 96.0f; hr = ID2D1RenderTarget_CreateBitmap(rt, size, bitmap_data, 4 * sizeof(*bitmap_data), &bitmap_desc, &bitmap); ok(SUCCEEDED(hr), "Failed to create bitmap, hr %#x.\n", hr); /* Creating a brush with a NULL bitmap crashes on Vista, but works fine on * Windows 7+. */ hr = ID2D1RenderTarget_CreateBitmapBrush(rt, bitmap, NULL, NULL, &brush); ok(SUCCEEDED(hr), "Failed to create brush, hr %#x.\n", hr); ID2D1BitmapBrush_GetBitmap(brush, &tmp_bitmap); ok(tmp_bitmap == bitmap, "Got unexpected bitmap %p, expected %p.\n", tmp_bitmap, bitmap); ID2D1Bitmap_Release(tmp_bitmap); opacity = ID2D1BitmapBrush_GetOpacity(brush); ok(opacity == 1.0f, "Got unexpected opacity %.8e.\n", opacity); set_matrix_identity(&matrix); ID2D1BitmapBrush_GetTransform(brush, &tmp_matrix); ok(!memcmp(&tmp_matrix, &matrix, sizeof(matrix)), "Got unexpected matrix {%.8e, %.8e, %.8e, %.8e, %.8e, %.8e}.\n", tmp_matrix._11, tmp_matrix._12, tmp_matrix._21, tmp_matrix._22, tmp_matrix._31, tmp_matrix._32); extend_mode = ID2D1BitmapBrush_GetExtendModeX(brush); ok(extend_mode == D2D1_EXTEND_MODE_CLAMP, "Got unexpected extend mode %#x.\n", extend_mode); extend_mode = ID2D1BitmapBrush_GetExtendModeY(brush); ok(extend_mode == D2D1_EXTEND_MODE_CLAMP, "Got unexpected extend mode %#x.\n", extend_mode); interpolation_mode = ID2D1BitmapBrush_GetInterpolationMode(brush); ok(interpolation_mode == D2D1_BITMAP_INTERPOLATION_MODE_LINEAR, "Got unexpected interpolation mode %#x.\n", interpolation_mode); ID2D1BitmapBrush_Release(brush); hr = ID2D1RenderTarget_CreateBitmapBrush(rt, bitmap, NULL, NULL, &brush); ok(SUCCEEDED(hr), "Failed to create brush, hr %#x.\n", hr); set_matrix_identity(&matrix); translate_matrix(&matrix, 40.0f, 120.0f); scale_matrix(&matrix, 20.0f, 60.0f); ID2D1BitmapBrush_SetTransform(brush, &matrix); ID2D1BitmapBrush_SetInterpolationMode(brush, D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR); ID2D1RenderTarget_BeginDraw(rt); set_color(&color, 0.0f, 0.0f, 1.0f, 1.0f); ID2D1RenderTarget_Clear(rt, &color); set_rect(&dst_rect, 40.0f, 120.0f, 120.0f, 360.0f); ID2D1RenderTarget_FillRectangle(rt, &dst_rect, (ID2D1Brush *)brush); set_matrix_identity(&matrix); scale_matrix(&matrix, 0.5f, 2.0f); translate_matrix(&matrix, 320.0f, 240.0f); rotate_matrix(&matrix, M_PI / 4.0f); ID2D1RenderTarget_SetTransform(rt, &matrix); set_matrix_identity(&matrix); translate_matrix(&matrix, -80.0f, -60.0f); scale_matrix(&matrix, 40.0f, 30.0f); ID2D1BitmapBrush_SetTransform(brush, &matrix); ID2D1BitmapBrush_SetOpacity(brush, 0.75f); set_rect(&dst_rect, -80.0f, -60.0f, 80.0f, 60.0f); ID2D1RenderTarget_FillRectangle(rt, &dst_rect, (ID2D1Brush *)brush); set_matrix_identity(&matrix); translate_matrix(&matrix, 200.0f, 120.0f); scale_matrix(&matrix, 20.0f, 60.0f); ID2D1RenderTarget_SetTransform(rt, &matrix); ID2D1RenderTarget_DrawBitmap(rt, bitmap, NULL, 0.25f, D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR, NULL); set_rect(&dst_rect, -4.0f, 12.0f, -8.0f, 8.0f); ID2D1RenderTarget_DrawBitmap(rt, bitmap, &dst_rect, 0.75f, D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR, NULL); set_rect(&dst_rect, 0.0f, 8.0f, 4.0f, 12.0f); set_rect(&src_rect, 2.0f, 1.0f, 4.0f, 3.0f); ID2D1RenderTarget_DrawBitmap(rt, bitmap, &dst_rect, 1.0f, D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR, &src_rect); hr = ID2D1RenderTarget_EndDraw(rt, NULL, NULL); ok(SUCCEEDED(hr), "Failed to end draw, hr %#x.\n", hr); ok(compare_surface(surface, "393636185359a550d459e1e5f0e25411814f724c"), "Surface does not match.\n"); ID2D1BitmapBrush_Release(brush); refcount = ID2D1Bitmap_Release(bitmap); ok(!refcount, "Bitmap has %u references left.\n", refcount); ID2D1RenderTarget_Release(rt); IDXGISurface_Release(surface); IDXGISwapChain_Release(swapchain); ID3D10Device1_Release(device); DestroyWindow(window); }
void unit_init(unit *v_unit, int unit_nb) { int k; char sz_charset_name[32]; for (k=0;k<unit_nb;k++) { sprintf(sz_charset_name, "res/Charset_%d.png", k); v_unit[k].p_sprite = malloc(sizeof(anim_sprite)); v_unit[k].p_sprite->p_image = image_load(sz_charset_name); image_set_transp_color(v_unit[k].p_sprite->p_image, 255, 0, 255); v_unit[k].victory = 0; v_unit[k].p_sprite->offset.x = 6; v_unit[k].p_sprite->offset.y = 16; v_unit[k].p_sprite->offset.h = 24; v_unit[k].p_sprite->offset.w = 22; v_unit[k].p_sprite->animation_nb = 4; v_unit[k].p_sprite->frame_nb_x = 3; v_unit[k].p_sprite->frame_nb_y = 4; v_unit[k].p_sprite->v_anim = malloc(v_unit[k].p_sprite->animation_nb * sizeof(animation)); v_unit[k].p_sprite->v_anim[UP].frame_nb = 4; v_unit[k].p_sprite->v_anim[UP].frame_delay = 5; v_unit[k].p_sprite->v_anim[UP].frame_trigger = 0; v_unit[k].p_sprite->v_anim[UP].frame_current = 1; v_unit[k].p_sprite->v_anim[UP].v_frame = malloc(v_unit[k].p_sprite->v_anim[UP].frame_nb * sizeof(SDL_Rect)); v_unit[k].p_sprite->v_anim[UP].v_frame[0] = set_rect(6, 18, 34, 44); v_unit[k].p_sprite->v_anim[UP].v_frame[1] = set_rect(56, 18, 34, 44); v_unit[k].p_sprite->v_anim[UP].v_frame[2] = set_rect(104, 18, 34, 44); v_unit[k].p_sprite->v_anim[UP].v_frame[3] = set_rect(56, 18, 34, 44); v_unit[k].p_sprite->v_anim[DOWN].frame_nb = 4; v_unit[k].p_sprite->v_anim[DOWN].frame_delay = 5; v_unit[k].p_sprite->v_anim[DOWN].frame_trigger = 0; v_unit[k].p_sprite->v_anim[DOWN].frame_current = 1; v_unit[k].p_sprite->v_anim[DOWN].v_frame = malloc(v_unit[k].p_sprite->v_anim[DOWN].frame_nb * sizeof(SDL_Rect)); v_unit[k].p_sprite->v_anim[DOWN].v_frame[0] = set_rect(8, 146, 34, 44); v_unit[k].p_sprite->v_anim[DOWN].v_frame[1] = set_rect(56, 146, 34, 44); v_unit[k].p_sprite->v_anim[DOWN].v_frame[2] = set_rect(102, 146, 34, 44); v_unit[k].p_sprite->v_anim[DOWN].v_frame[3] = set_rect(56, 146, 34, 44); v_unit[k].p_sprite->v_anim[LEFT].frame_nb = 4; v_unit[k].p_sprite->v_anim[LEFT].frame_delay = 5; v_unit[k].p_sprite->v_anim[LEFT].frame_trigger = 0; v_unit[k].p_sprite->v_anim[LEFT].frame_current = 1; v_unit[k].p_sprite->v_anim[LEFT].v_frame = malloc(v_unit[k].p_sprite->v_anim[LEFT].frame_nb * sizeof(SDL_Rect)); v_unit[k].p_sprite->v_anim[LEFT].v_frame[0] = set_rect(6, 210, 36, 44); v_unit[k].p_sprite->v_anim[LEFT].v_frame[1] = set_rect(56, 210, 36, 44); v_unit[k].p_sprite->v_anim[LEFT].v_frame[2] = set_rect(104, 210, 34, 44); v_unit[k].p_sprite->v_anim[LEFT].v_frame[3] = set_rect(56, 210, 36, 44); v_unit[k].p_sprite->v_anim[RIGHT].frame_nb = 4; v_unit[k].p_sprite->v_anim[RIGHT].frame_delay = 5; v_unit[k].p_sprite->v_anim[RIGHT].frame_trigger = 0; v_unit[k].p_sprite->v_anim[RIGHT].frame_current = 1; v_unit[k].p_sprite->v_anim[RIGHT].v_frame = malloc(v_unit[k].p_sprite->v_anim[RIGHT].frame_nb * sizeof(SDL_Rect)); v_unit[k].p_sprite->v_anim[RIGHT].v_frame[0] = set_rect(6, 82, 34, 44); v_unit[k].p_sprite->v_anim[RIGHT].v_frame[1] = set_rect(52, 82, 36, 44); v_unit[k].p_sprite->v_anim[RIGHT].v_frame[2] = set_rect(102, 82, 36, 44); v_unit[k].p_sprite->v_anim[RIGHT].v_frame[3] = set_rect(52, 82, 36, 44); v_unit[k].p_sprite->h_flip = false; snprintf(v_unit[k].name, 10, "Guy %d", k+1); //sNprintf to avoid blastguy's stack overflow exploit ;) #ifdef GEKKO v_unit[k].use_keyboard = false; v_unit[k].joystick = SDL_JoystickOpen(k); #else v_unit[k].use_keyboard = true; #endif //Key bind if (k == 0) { v_unit[k].key_left = SDLK_LEFT; v_unit[k].key_right = SDLK_RIGHT; v_unit[k].key_up = SDLK_UP; v_unit[k].key_down = SDLK_DOWN; v_unit[k].key_bomb = SDLK_SPACE; v_unit[k].key_boxe = SDLK_b; } else if (k == 1) { v_unit[k].key_left = SDLK_s; v_unit[k].key_right = SDLK_f; v_unit[k].key_up = SDLK_e; v_unit[k].key_down = SDLK_d; v_unit[k].key_bomb = SDLK_r; v_unit[k].key_boxe = SDLK_a; } else if (k == 2) { v_unit[k].key_left = SDLK_g; v_unit[k].key_right = SDLK_j; v_unit[k].key_up = SDLK_y; v_unit[k].key_down = SDLK_h; v_unit[k].key_bomb = SDLK_u; v_unit[k].key_boxe = SDLK_t; } else if (k == 3) { v_unit[k].key_left = SDLK_k; v_unit[k].key_right = SDLK_SEMICOLON; v_unit[k].key_up = SDLK_o; v_unit[k].key_down = SDLK_l; v_unit[k].key_bomb = SDLK_p; v_unit[k].key_boxe = SDLK_i; } } }
int state_in_game(SDL_Surface *screen) { SDL_Rect srcrect = {0, 0, 480, 480}; //the part of the screen to be stretched, must be sup 0 and inf screen surface Height and Width SDL_Rect dstrect = set_rect(0, 0, SCREEN_HEIGHT, SCREEN_WIDTH); //equals screen resolution int bomb_nb=0; int flame_nb=0; bool done = false; int i=0; //generic accumulator 1 int j=0; //generic accumulator 2 int k=0; //unit accumulator int tick_count=0; int tick_trigger=0; int time_elapsed=0; //time elapsed in this round (in secondes) int last_time=0; int current_game_status=-1; timer *timer_battle = timer_init(); timer_start(timer_battle); // load sample.wav in to sample Mix_Chunk *sample = sample_load("res/boom.wav"); Mix_Music* music = music_load("res/music.xm"); music_play(music); //initialize map map *p_map = malloc(sizeof(map)); p_map->tile_height = 32; p_map->tile_width = 32; map_load_level(p_map, "res/level_01.map"); p_map->p_chipset = image_load("res/classic.png"); SDL_Surface* surface_menu = IMG_Load("./res/menu.png"); SDL_SetColorKey(surface_menu, SDL_SRCCOLORKEY, SDL_MapRGB(surface_menu->format, 255, 0, 255)); for (k=0;k<g_game.unit_nb;k++) { unit_tile_protect(g_game.v_unit+k, p_map); } int block_nb = map_block_add(p_map, g_game.block_fill, .5); ///@todo the disp % is not implemented yet int panel_nb = panel_add(g_game.v_panel, p_map, block_nb); int random_comment = rand() % 9; char sz_comment[32]; SDL_Rect pos_comment = set_rect(10, 465, 0, 0); int comment_time_elapsed; timer *timer_comment = timer_init(); //Menu TTF_Font *font_menu = font_load("res/asia.ttf", 20); TTF_Font *font_result = font_load("res/asia.ttf", 75); SDL_Rect cur_pos; cur_pos.x = 42; cur_pos.y = 425; char sz_time[10]; while (!done) { SDL_Event event; SDL_JoystickUpdate(); while(SDL_PollEvent(&event)){ for (k=0;k<g_game.unit_nb;k++) { if (!g_game.v_unit[k].is_dead) { unit_handle_key(g_game.v_unit+k, &event, k, g_game.v_bomb, p_map, &bomb_nb); } } if(event.type == SDL_QUIT || ((event.type == SDL_KEYDOWN) && (event.key.keysym.sym == SDLK_ESCAPE)) || (event.type == SDL_JOYBUTTONDOWN && event.jbutton.button == 6)){ done = true; current_game_status = MAIN_MENU; } else if((event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_RETURN)|| (event.type == SDL_JOYBUTTONDOWN && event.jbutton.button == 5)){ Mix_PauseMusic(); state_paused(screen); Mix_ResumeMusic(); } } for (k=0;k<g_game.unit_nb;k++){ if(!g_game.v_unit[k].use_keyboard){ int joystate = SDL_JoystickGetHat(g_game.v_unit[k].joystick, 0); switch (joystate){ case SDL_HAT_DOWN: unit_set_vel_y(g_game.v_unit+k, g_game.v_unit[k].speed); unit_set_vel_x(g_game.v_unit+k, 0); g_game.v_unit[k].p_sprite->animation_current = DOWN; break; case SDL_HAT_UP: unit_set_vel_y(g_game.v_unit+k, -g_game.v_unit[k].speed); unit_set_vel_x(g_game.v_unit+k, 0); g_game.v_unit[k].p_sprite->animation_current = UP; break; case SDL_HAT_RIGHT: unit_set_vel_x(g_game.v_unit+k, g_game.v_unit[k].speed); unit_set_vel_y(g_game.v_unit+k, 0); g_game.v_unit[k].p_sprite->animation_current = RIGHT; break; case SDL_HAT_LEFT: unit_set_vel_x(g_game.v_unit+k, -g_game.v_unit[k].speed); unit_set_vel_y(g_game.v_unit+k, 0); g_game.v_unit[k].p_sprite->animation_current = LEFT; break; default: if ( g_game.v_unit[k].vel_x != 0 ){ unit_set_vel_x(g_game.v_unit+k, 0); g_game.v_unit[k].p_sprite->v_anim[g_game.v_unit[k].p_sprite->animation_current].frame_current = 1; } if ( g_game.v_unit[k].vel_y != 0 ){ unit_set_vel_y(g_game.v_unit+k, 0); g_game.v_unit[k].p_sprite->v_anim[g_game.v_unit[k].p_sprite->animation_current].frame_current = 1; } break; } } } tick_count = SDL_GetTicks(); if (tick_count > tick_trigger / 60){ tick_trigger = tick_count; SDL_FillRect(backbuffer, 0, SDL_MapRGB(backbuffer->format, 10, 20, 80)); //draw the map map_draw(p_map, backbuffer); for (i=0;i<panel_nb;i++) { if(p_map->pp_tile[g_game.v_panel[i]->p_sprite->y / TILE_SIZE][g_game.v_panel[i]->p_sprite->x / TILE_SIZE].type != BLOCK)panel_draw(g_game.v_panel[i], backbuffer); } //check panels for (i=0;i<panel_nb;i++) { // for all units for (k=0;k<g_game.unit_nb;k++) { //Check for bonus if (g_game.v_panel[i]->p_sprite->y / TILE_SIZE == unit_get_bounding_index_center_y(g_game.v_unit+k) && (g_game.v_panel[i]->p_sprite->x / TILE_SIZE == unit_get_bounding_index_center_x(g_game.v_unit+k))) { panel_apply(g_game.v_panel[i], g_game.v_unit+k); panel_free(g_game.v_panel[i]); panel_nb--; //Left shift the vector for (j=i;j<panel_nb;j++) { g_game.v_panel[j] = g_game.v_panel[j+1]; } } } } //Draw and update bombs for (i=0;i<bomb_nb;i++) { bomb_draw(g_game.v_bomb[i], backbuffer); anim_sprite_update_frame(g_game.v_bomb[i]->p_sprite); bomb_update_timer(g_game.v_bomb[i]); if ((g_game.v_bomb[i]->time_left <= 0) || (p_map->pp_tile[g_game.v_bomb[i]->p_sprite->y / TILE_SIZE][g_game.v_bomb[i]->p_sprite->x / TILE_SIZE].type == FLAME)) { sample_play(sample); bomb_explode(g_game.v_bomb[i], p_map, g_game.v_flame, &flame_nb); bomb_nb--; bomb_free(g_game.v_bomb[i]); //Left shift the vector for (j=i;j<bomb_nb;j++) { g_game.v_bomb[j] = g_game.v_bomb[j+1]; } } } //Check flame for (i=0;i<p_map->height;i++) { for (j=0;j<p_map->width[i];j++) { // for all units, check if hitten (if unit center is on a tile with a flame flag) for (k=0;k<g_game.unit_nb;k++) { if ((p_map->pp_tile[i][j].type == FLAME) && ((unit_get_index_x(g_game.v_unit+k) == j) && (unit_get_index_y(g_game.v_unit+k) == i)) && g_game.v_unit[k].is_dead == false) { g_game.v_unit[k].is_dead = true; timer_start(timer_comment); switch(random_comment) { case(0):sprintf(sz_comment, "Say goodbye, %s ", g_game.v_unit[k].name); break; case(1):sprintf(sz_comment, "burn %s, burn ! ", g_game.v_unit[k].name); break; case(2):sprintf(sz_comment, "%s vanished !!!!!! ", g_game.v_unit[k].name); break; case(3):sprintf(sz_comment, "unit_free(%s); //^^ ", g_game.v_unit[k].name); break; case(4):sprintf(sz_comment, "%s ? Where are you ? ", g_game.v_unit[k].name); break; case(5):sprintf(sz_comment, "%s was a good guy ", g_game.v_unit[k].name); break; case(6):sprintf(sz_comment, "HE says : \"HELLO, %s\" ", g_game.v_unit[k].name); break; case(7):sprintf(sz_comment, "%s has meet his programmer ", g_game.v_unit[k].name); break; case(8):sprintf(sz_comment, "$ %s>/dev/null ", g_game.v_unit[k].name); break; case(9):sprintf(sz_comment, "%s was not ignifugated ", g_game.v_unit[k].name); break; } } } } } //Draw and update flames for (i=0;i<flame_nb;i++) { flame_draw(g_game.v_flame[i], p_map, backbuffer); g_game.v_flame[i]->time_left--; if (g_game.v_flame[i]->time_left <= 0) { flame_free(g_game.v_flame[i], p_map); flame_nb--; //Left shift the vector for (j=i;j<flame_nb;j++) { g_game.v_flame[j] = g_game.v_flame[j+1]; } } } for (k=0;k<g_game.unit_nb;k++) { if (!g_game.v_unit[k].is_dead) { unit_calc_bounding_box(g_game.v_unit+k); unit_update(g_game.v_unit+k, p_map); } } // draw and update units unit_draw_from_z_index(g_game.v_unit, g_game.unit_nb, backbuffer); //Change every 1 second time_elapsed = timer_get_ticks (timer_battle) / 1000; if (time_elapsed != last_time){ last_time = time_elapsed; //Update current time /* Check if any unit won This function is performed every second in order to dont call it to often, and have a little delay if two or more units died almost in the same time (even ms, in the case a unit is at the left of a bomb and an other at the right, the right unit win because the flame is first put to the left...) */ int unit_win; unit_win = unit_check_victory(g_game.v_unit, g_game.unit_nb); if (unit_win >= 0) { //print win, sound, etc g_game.v_unit[unit_win].victory++; time_elapsed = 0; ///@todo set a victories limit (from 1 to 5) and display a special image if win... for the moment, another battle font_printf(font_result, TILE_SIZE * 2, TILE_SIZE * 5, 50, 150, 100, backbuffer, "%s wins", g_game.v_unit[unit_win].name); done = true; current_game_status = IN_GAME; SDL_SoftStretch(backbuffer, &srcrect, screen, &dstrect); SDL_Flip(screen); SDL_Delay(2000); break; } else if (unit_win == -1) { font_printf(font_result, (3)*TILE_SIZE, (6)*TILE_SIZE, 50, 150, 100, backbuffer, "DRAW !"); done = true; current_game_status = IN_GAME; SDL_SoftStretch(backbuffer, &srcrect, screen, &dstrect); SDL_Flip(screen); SDL_Delay(2000); } if (g_game.time - time_elapsed <= 0) { cur_pos.x = 240; cur_pos.y = 140; font_printf(font_result, (3)*TILE_SIZE, (6)*TILE_SIZE, 50, 150, 100, backbuffer, "TIMES UP !"); done = true; ///@todo select action in times up (blocks falling, etc) for the moment, just a draw... current_game_status = IN_GAME; SDL_SoftStretch(backbuffer, &srcrect, screen, &dstrect); SDL_Flip(screen); SDL_Delay(2000); } } //////////////////// MENU //////////////////// //TIME sprintf(sz_time, "%.3d", g_game.time - time_elapsed); SDL_Surface *surface_time = font_create_surface(font_menu, 200, 200, 200, 10, 100, 100, 100, 0, sz_time, SOLID); SDL_BlitSurface(surface_time, NULL, backbuffer, &cur_pos); SDL_FreeSurface(surface_time); SDL_Rect menu_src, menu_dest; menu_src.h = 32; menu_src.w = 32; menu_src.x = 0; menu_src.y = 0; menu_dest.x = 5; menu_dest.y = 420; SDL_BlitSurface(surface_menu, &menu_src, backbuffer, &menu_dest); //VICTORIES for (k=0;k<g_game.unit_nb;k++) { char sz_victory_nb[20]; SDL_Rect vic_pos = set_rect(10, 450, 0, 0); sprintf(sz_victory_nb, "%s: %d", g_game.v_unit[k].name, g_game.v_unit[k].victory); vic_pos.x += k * 100; SDL_Surface *surface_victory = font_create_surface(font_menu, 200, 200, 200, 10, 100, 100, 100, 0, sz_victory_nb, SOLID); SDL_BlitSurface(surface_victory, NULL, backbuffer, &vic_pos); SDL_FreeSurface(surface_victory); } //Comment if(timer_comment->started){ comment_time_elapsed = timer_get_ticks(timer_comment) / 1000; if (comment_time_elapsed < 3) //Display the comment 3 seconds { font_printf(font_menu, pos_comment.x, pos_comment.y, 200, 200, 200, backbuffer, sz_comment); } else{ //done timer_stop(timer_comment); random_comment = rand() % 9; } } //DEBUG #ifdef DEBUG font_printf(font_menu, 10, 10, 255, 255, 200, backbuffer, "flame nb : %d", flame_nb); font_printf(font_menu, 10, 30, 255, 255, 200, backbuffer, "bomb nb : %d", bomb_nb); font_printf(font_menu, 10, 50, 255, 255, 200, backbuffer, "unit nb : %d", g_game.unit_nb); font_printf(font_menu, 10, 70, 255, 255, 200, backbuffer, "fill nb : %.2f", g_game.block_fill); font_printf(font_menu, 10, 90, 255, 255, 200, backbuffer, "Blocks at startup : %d", block_nb); font_printf(font_menu, 10, 110, 255, 255, 200, backbuffer, "Time elapsed : %d", timer_get_ticks(timer_battle)/1000); font_printf(font_menu, 10, 130, 255, 255, 200, backbuffer, "unit 1 index: %d %d", unit_get_bounding_index_center_x(g_game.v_unit+0), unit_get_bounding_index_center_y(g_game.v_unit+0)); SDL_Rect rect = unit_get_bounding_box(g_game.v_unit+0); SDL_FillRect(backbuffer, &rect, SDL_MapRGB(backbuffer->format, 255, 255, 0)); #endif SDL_SoftStretch(backbuffer, &srcrect, screen, &dstrect); SDL_Flip(screen); }//end thick } //end while //Free the memory for (i=0;i<bomb_nb;i++) { bomb_free(g_game.v_bomb[i]); } for (i=0;i<panel_nb;i++) { panel_free(g_game.v_panel[i]); } for (i=0;i<flame_nb;i++) { flame_free(g_game.v_flame[i], p_map); } map_free(p_map); free(timer_battle); free(timer_comment); Mix_FreeChunk(sample); Mix_FreeMusic(music); TTF_CloseFont(font_menu); font_menu=NULL; // to be safe... TTF_CloseFont(font_result); font_result=NULL; // to be safe... return current_game_status; }
void gui_create_rsurf(rsurf_ceate_t *p_rsurf, roll_param_t *p_param) { rsc_fstyle_t *p_fstyle = NULL; u16 width = 0, height = 0, data_width = 0; s16 str_offset = 0; handle_t handle = 0; rect_t str_rect = {0}; hdc_t hdc = 0; u32 color_key = 0, addr = 0; u16 str_drawed = 0; roll_sept_t sept = {0}; u32 draw_style = 0; roll_param_t saved_param = {0}; roll_param_t *p_roll_param = NULL; gui_roll_t *p_info = NULL; roll_node_t *p_node = NULL; p_roll_param = p_param; p_info = (gui_roll_t *)class_get_handle_by_id(ROLL_CLASS_ID); MT_ASSERT(p_info != NULL); if(p_roll_param == NULL) { if(p_info->p_saved == NULL) { //nothing saved, so just return. return; } //use the saved parameters to create roll surface. memcpy(&saved_param, &(p_info->p_saved->param), sizeof(roll_param_t)); str_drawed = p_info->p_saved->str_drawed; str_offset = p_info->p_saved->str_off; p_roll_param = &saved_param; } //if((p_rsurf == NULL) || (p_param == NULL)) if(p_rsurf == NULL) { return; } if(p_rsurf->is_pic) { color_key = 0; //if(!p_rsurf->is_pic_rawdata) { gui_get_bmp_attr(p_rsurf->pic_data, p_rsurf->is_pic_rawdata, &width, &height); } } else { if(p_rsurf->p_str == NULL) { p_node = gui_roll_add(p_rsurf->p_ctrl, p_roll_param, handle, addr, 0, RECTH(p_rsurf->rect), &p_rsurf->rect, p_rsurf->context, NULL); MT_ASSERT(p_node != NULL); //reset the node by saved parameters. if(p_info->p_saved != NULL) { p_node->blt_x = p_info->p_saved->blt_x; p_node->blt_y = p_info->p_saved->blt_y; p_node->curn = p_info->p_saved->curn; p_node->curn_times = p_info->p_saved->curn_times; p_node->is_pause = p_info->p_saved->is_pause; p_node->p_list = p_info->p_saved->p_list; } return; } p_fstyle = rsc_get_fstyle(gui_get_rsc_handle(), p_rsurf->fstyle_idx); color_key = (p_fstyle->color ? 0 : 1); rsc_get_string_attr(gui_get_rsc_handle(), p_rsurf->p_str, p_fstyle, &width, &height); } if((width <= RECTW(p_rsurf->rect)) && (p_roll_param->is_force == FALSE)) { p_node = gui_roll_add(p_rsurf->p_ctrl, p_roll_param, handle, addr, width, RECTH(p_rsurf->rect), &p_rsurf->rect, p_rsurf->context, NULL); MT_ASSERT(p_node != NULL); p_node->sept.is_pic = p_rsurf->is_pic; p_node->sept.is_pic_rawdata = p_rsurf->is_pic_rawdata; //reset the node by saved parameters. if(p_info->p_saved != NULL) { p_node->blt_x = p_info->p_saved->blt_x; p_node->blt_y = p_info->p_saved->blt_y; p_node->curn = p_info->p_saved->curn; p_node->curn_times = p_info->p_saved->curn_times; p_node->is_pause = p_info->p_saved->is_pause; p_node->p_list = p_info->p_saved->p_list; } return; } data_width = width; if(p_rsurf->is_pic) { if(data_width > RECTW(p_rsurf->rect)) { p_rsurf->rect.right = p_rsurf->rect.left + data_width; } } width = RECTW(p_rsurf->rect); //create roll surface. handle = gdi_create_rsurf(p_rsurf->is_topmost, RECTW(p_rsurf->rect), RECTH(p_rsurf->rect), &addr); MT_ASSERT(handle != 0); MT_ASSERT(addr != 0); flinger_set_colorkey((void *)handle, color_key); //fill roll surface. set_rect(&str_rect, 0, 0, RECTW(p_rsurf->rect), RECTH(p_rsurf->rect)); if(p_roll_param->use_bg) { flinger_fill_rect((void *)handle, &str_rect, p_roll_param->bg_color); } else { flinger_fill_rect((void *)handle, &str_rect, color_key); } hdc = gdi_get_roll_dc(&str_rect, handle); MT_ASSERT(hdc != HDC_INVALID); if(p_rsurf->is_pic) { str_drawed = gui_draw_picture_offset(hdc, &str_rect, p_rsurf->pic_data, p_rsurf->is_pic_rawdata, str_drawed, data_width, height, (s16 *)&str_offset); } else { draw_style = (p_rsurf->draw_style | MAKE_DRAW_STYLE(STRDRAW_IGNORE_NLINE, 0)); str_drawed = gui_draw_unistr_offset(hdc, &str_rect, p_rsurf->p_str, p_rsurf->fstyle_idx, draw_style, str_drawed, data_width, height, (s16 *)&str_offset); } gdi_release_roll_dc(hdc); sept.p_str = p_rsurf->p_str; sept.str_drawed = str_drawed; sept.str_off = str_offset; sept.str_width = data_width; sept.str_height = height; sept.fstyle_id = p_rsurf->fstyle_idx; sept.draw_style = draw_style; sept.is_pic = p_rsurf->is_pic; sept.is_pic_rawdata = p_rsurf->is_pic_rawdata; sept.pic_data = p_rsurf->pic_data; sept.is_pic = p_rsurf->is_pic; sept.is_pic_rawdata = p_rsurf->is_pic_rawdata; p_node = gui_roll_add(p_rsurf->p_ctrl, p_roll_param, handle, addr, width, RECTH(p_rsurf->rect), &p_rsurf->rect, p_rsurf->context, &sept); MT_ASSERT(p_node != NULL); if(p_param->style == ROLL_LB) { p_node->blt_x = RECTW(p_rsurf->rect); } //reset the node by saved parameters. if(p_info->p_saved != NULL) { p_node->blt_x = p_info->p_saved->blt_x; p_node->blt_y = p_info->p_saved->blt_y; p_node->curn = p_info->p_saved->curn; p_node->curn_times = p_info->p_saved->curn_times; p_node->is_pause = p_info->p_saved->is_pause; p_node->p_list = p_info->p_saved->p_list; } return; }
void PaintWindow::createMenu() { // Adding the drop down menu to the menubar m_menu_app = menuBar()->addMenu(tr("&Application")); m_menu_tools = menuBar()->addMenu(tr("&Tools")); m_menu_colour = menuBar()->addMenu(tr("&Colour")); m_menu_help = menuBar()->addMenu(tr("&Help")); // Adding the menu items for each drop down menu QAction* quitAct = new QAction(tr("&Quit"), this); quitAct->setShortcuts(QKeySequence::Quit); quitAct->setStatusTip(tr("Exits the program")); connect(quitAct, SIGNAL(triggered()), this, SLOT(close())); m_menu_app->addAction(quitAct); QAction* clearAct = new QAction(tr("&Clear"), this); clearAct->setShortcut(QKeySequence(Qt::Key_C)); connect(clearAct, SIGNAL(triggered()), m_canvas, SLOT(clearCanvas())); m_menu_app->addAction(clearAct); QAction* drawLineAct = new QAction(tr("&Line"), this); drawLineAct->setStatusTip(tr("Draws a line")); drawLineAct->setShortcut(QKeySequence(Qt::Key_L)); drawLineAct->setCheckable(true); connect(drawLineAct, SIGNAL(triggered()), this, SLOT(set_line())); QAction* drawOvalAct = new QAction(tr("&Oval"), this); drawOvalAct->setStatusTip(tr("Draws an Oval")); drawOvalAct->setShortcut(QKeySequence(Qt::Key_O)); drawOvalAct->setCheckable(true); connect(drawOvalAct, SIGNAL(triggered()), this, SLOT(set_oval())); QAction* drawRectangleAct = new QAction(tr("&Rectangle"), this); drawRectangleAct->setStatusTip(tr("Draws a rectangle")); drawRectangleAct->setShortcut(QKeySequence(Qt::Key_R)); drawRectangleAct->setCheckable(true); connect(drawRectangleAct, SIGNAL(triggered()), this, SLOT(set_rect())); QActionGroup *toolsActionGroup = new QActionGroup(this); toolsActionGroup->addAction(drawLineAct); toolsActionGroup->addAction(drawOvalAct); toolsActionGroup->addAction(drawRectangleAct); toolsActionGroup->setExclusive(true); drawLineAct->setChecked(true); m_menu_tools->addAction(drawLineAct); m_menu_tools->addAction(drawOvalAct); m_menu_tools->addAction(drawRectangleAct); QAction* setColourBlackAct = new QAction(tr("&Black"), this); connect(setColourBlackAct, SIGNAL(triggered()), this, SLOT(setColourBlack())); QAction* setColourRedAct = new QAction(tr("&Red"), this); connect(setColourRedAct, SIGNAL(triggered()), this, SLOT(setColourRed())); QAction* setColourGreenAct = new QAction(tr("&Green"), this); connect(setColourGreenAct, SIGNAL(triggered()), this, SLOT(setColourGreen())); QAction* setColourBlueAct = new QAction(tr("&Blue"), this); connect(setColourBlueAct, SIGNAL(triggered()), this, SLOT(setColourBlue())); m_menu_colour->addAction(setColourBlackAct); m_menu_colour->addAction(setColourRedAct); m_menu_colour->addAction(setColourGreenAct); m_menu_colour->addAction(setColourBlueAct); QAction* helpLineAct = new QAction(tr("&Line Help"), this); helpLineAct->setStatusTip(tr("Help Instructions")); connect(helpLineAct, SIGNAL(triggered()), this, SLOT(help_line())); m_menu_help->addAction(helpLineAct); QAction* helpRectangleAct = new QAction(tr("&Rectangle Help"), this); helpRectangleAct->setStatusTip(tr("Help Instructions for rectangles")); connect(helpRectangleAct, SIGNAL(triggered()), this, SLOT(help_rectangle())); m_menu_help->addAction(helpRectangleAct); QAction* helpOvalAct = new QAction(tr("&Oval Help"), this); helpOvalAct->setStatusTip(tr("Help Instructions for ovals")); connect(helpOvalAct, SIGNAL(triggered()), this, SLOT(help_oval())); m_menu_help->addAction(helpOvalAct); }
int main(int argc, char** argv){ SDL_Surface *screen=NULL; srand(time(NULL)); sdl_init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK); SDL_EnableKeyRepeat(200, 200); SDL_WM_SetCaption("Game Engine demo", NULL); atexit(SDL_Quit); SDL_ShowCursor(SDL_DISABLE); dstrect = set_rect(0,0,WINDOW_HEIGHT,WINDOW_WIDTH); srcrect = set_rect(0, 0, SCREEN_HEIGHT, SCREEN_WIDTH); // create a new window int flags = SDL_HWSURFACE; screen = sdl_set_video(WINDOW_WIDTH, WINDOW_HEIGHT, 16, flags); backbuffer = SDL_DisplayFormat(screen); //create a new game game o_game; //create sprites int i; for(i=0;i<SPRITE_NUMBER;i++){ anim_sprite* p_sprite = malloc(sizeof(anim_sprite)); p_sprite->p_image = image_load("./res/coin.png"); image_set_transp_color(p_sprite->p_image, 0xFF, 0x00, 0xFF); //init sprite animation anim_sprite_init(p_sprite, 80, 16, 3, 1, 0, 0, 1); p_sprite->v_anim = malloc(p_sprite->animation_nb * sizeof(animation)); animation_init(p_sprite->v_anim+0, 1, 3, 25, 0); //one animation of three frames p_sprite->v_anim[0].v_frame = malloc(p_sprite->v_anim[0].frame_nb * sizeof(SDL_Rect)); p_sprite->v_anim[0].v_frame[0] = set_rect(0, 0, 5, 8); p_sprite->v_anim[0].v_frame[1] = set_rect(5, 0, 5, 8); p_sprite->v_anim[0].v_frame[2] = set_rect(10, 0, 5, 8); //init sprite position and velocity int x = rand() % WINDOW_WIDTH; int y = rand() % WINDOW_HEIGHT; int vel_x = rand() % 2; int vel_y = rand() % 2; p_sprite->x = x; p_sprite->y = y; p_sprite->vel_x = vel_x; p_sprite->vel_y = vel_y; o_game.p_sprite[i] = p_sprite; } //game stats game_status ret_code = IN_GAME; while(ret_code != QUIT){ switch(ret_code){ case IN_GAME: ret_code = state_in_game(screen, &o_game); break; default: break; } } SDL_Quit(); return EXIT_SUCCESS; }
static void test_clip(void) { IDXGISwapChain *swapchain; D2D1_MATRIX_3X2_F matrix; D2D1_SIZE_U pixel_size; ID2D1RenderTarget *rt; ID3D10Device1 *device; IDXGISurface *surface; D2D1_POINT_2F point; D2D1_COLOR_F color; float dpi_x, dpi_y; D2D1_RECT_F rect; D2D1_SIZE_F size; HWND window; HRESULT hr; static const D2D1_MATRIX_3X2_F identity = { 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, }; if (!(device = create_device())) { skip("Failed to create device, skipping tests.\n"); return; } window = CreateWindowA("static", "d2d1_test", WS_OVERLAPPEDWINDOW | WS_VISIBLE, 0, 0, 640, 480, NULL, NULL, NULL, NULL); swapchain = create_swapchain(device, window, TRUE); hr = IDXGISwapChain_GetBuffer(swapchain, 0, &IID_IDXGISurface, (void **)&surface); ok(SUCCEEDED(hr), "Failed to get buffer, hr %#x.\n", hr); rt = create_render_target(surface); ok(!!rt, "Failed to create render target.\n"); ID2D1RenderTarget_GetDpi(rt, &dpi_x, &dpi_y); ok(dpi_x == 96.0f, "Got unexpected dpi_x %.8e.\n", dpi_x); ok(dpi_y == 96.0f, "Got unexpected dpi_x %.8e.\n", dpi_y); size = ID2D1RenderTarget_GetSize(rt); ok(size.width == 640.0f, "Got unexpected width %.8e.\n", size.width); ok(size.height == 480.0f, "Got unexpected height %.8e.\n", size.height); pixel_size = ID2D1RenderTarget_GetPixelSize(rt); ok(pixel_size.width == 640, "Got unexpected width %u.\n", pixel_size.width); ok(pixel_size.height == 480, "Got unexpected height %u.\n", pixel_size.height); ID2D1RenderTarget_GetTransform(rt, &matrix); ok(!memcmp(&matrix, &identity, sizeof(matrix)), "Got unexpected matrix {%.8e, %.8e, %.8e, %.8e, %.8e, %.8e}.\n", matrix._11, matrix._12, matrix._21, matrix._22, matrix._31, matrix._32); ID2D1RenderTarget_BeginDraw(rt); set_color(&color, 1.0f, 1.0f, 0.0f, 1.0f); ID2D1RenderTarget_Clear(rt, &color); ID2D1RenderTarget_SetDpi(rt, 48.0f, 192.0f); ID2D1RenderTarget_GetDpi(rt, &dpi_x, &dpi_y); ok(dpi_x == 48.0f, "Got unexpected dpi_x %.8e.\n", dpi_x); ok(dpi_y == 192.0f, "Got unexpected dpi_x %.8e.\n", dpi_y); size = ID2D1RenderTarget_GetSize(rt); ok(size.width == 1280.0f, "Got unexpected width %.8e.\n", size.width); ok(size.height == 240.0f, "Got unexpected height %.8e.\n", size.height); pixel_size = ID2D1RenderTarget_GetPixelSize(rt); ok(pixel_size.width == 640, "Got unexpected width %u.\n", pixel_size.width); ok(pixel_size.height == 480, "Got unexpected height %u.\n", pixel_size.height); /* The effective clip rect is the intersection of all currently pushed * clip rects. Clip rects are in DIPs. */ set_rect(&rect, 0.0f, 0.0f, 1280.0f, 80.0f); ID2D1RenderTarget_PushAxisAlignedClip(rt, &rect, D2D1_ANTIALIAS_MODE_ALIASED); set_rect(&rect, 0.0f, 0.0f, 426.0f, 240.0f); ID2D1RenderTarget_PushAxisAlignedClip(rt, &rect, D2D1_ANTIALIAS_MODE_ALIASED); set_color(&color, 0.0f, 1.0f, 0.0f, 1.0f); ID2D1RenderTarget_Clear(rt, &color); ID2D1RenderTarget_PopAxisAlignedClip(rt); ID2D1RenderTarget_PopAxisAlignedClip(rt); ID2D1RenderTarget_SetDpi(rt, 0.0f, 0.0f); ID2D1RenderTarget_GetDpi(rt, &dpi_x, &dpi_y); ok(dpi_x == 96.0f, "Got unexpected dpi_x %.8e.\n", dpi_x); ok(dpi_y == 96.0f, "Got unexpected dpi_y %.8e.\n", dpi_y); /* Transformations apply to clip rects, the effective clip rect is the * (axis-aligned) bounding box of the transformed clip rect. */ set_point(&point, 320.0f, 240.0f); D2D1MakeRotateMatrix(30.0f, point, &matrix); ID2D1RenderTarget_SetTransform(rt, &matrix); set_rect(&rect, 215.0f, 208.0f, 425.0f, 272.0f); ID2D1RenderTarget_PushAxisAlignedClip(rt, &rect, D2D1_ANTIALIAS_MODE_ALIASED); set_color(&color, 1.0f, 1.0f, 1.0f, 1.0f); ID2D1RenderTarget_Clear(rt, &color); ID2D1RenderTarget_PopAxisAlignedClip(rt); /* Transformations are applied when pushing the clip rect, transformations * set afterwards have no effect on the current clip rect. This includes * SetDpi(). */ ID2D1RenderTarget_SetTransform(rt, &identity); set_rect(&rect, 427.0f, 320.0f, 640.0f, 480.0f); ID2D1RenderTarget_PushAxisAlignedClip(rt, &rect, D2D1_ANTIALIAS_MODE_ALIASED); ID2D1RenderTarget_SetTransform(rt, &matrix); ID2D1RenderTarget_SetDpi(rt, 48.0f, 192.0f); set_color(&color, 1.0f, 0.0f, 0.0f, 1.0f); ID2D1RenderTarget_Clear(rt, &color); ID2D1RenderTarget_PopAxisAlignedClip(rt); hr = ID2D1RenderTarget_EndDraw(rt, NULL, NULL); ok(SUCCEEDED(hr), "Failed to end draw, hr %#x.\n", hr); ok(compare_surface(surface, "035a44d4198d6e422e9de6185b5b2c2bac5e33c9"), "Surface does not match.\n"); ID2D1RenderTarget_Release(rt); IDXGISurface_Release(surface); IDXGISwapChain_Release(swapchain); ID3D10Device1_Release(device); DestroyWindow(window); }
/** * @brief 将字体的点阵模显示出来 * @param index_word_lib 该字体的模所在的首地址 * 这个参数可以取得到以下的值:\n * @arg * @param x0 该字体的模显示的横坐标 * @param y0 该字体的模显示的纵坐标 * @retval none * \date 2012-3-31 下午4:55:52 * @note 不足的是不能显示不够整数方框个数的字模,如果能显示也会有安全隐患 */ void display_word_mode(INT8U* index_word_lib , INT16U x0 , INT16U y0) { #if LIB_FONT == POINT_LIB INT32U word_mode_size = WORD_FONT_SIZE ; //为了确认到字模什么时候能够写完 INT8U temp ; INT16U count = 0 ; INT16U x0_no_change = x0 ; INT16U x = x0 ; INT16U y = y0 ; //这两个变量是为了方便控制x0,y0。 #ifdef __DEBUG__ printfs("index_word_lib:") ; printf_num((INT32U) index_word_lib, 'h') ; printfs("\r\n") ; #endif /* * 假设下面是一个点阵汉字,取模由4个8*8的方框按顺序组成 * * * 一开始的时候 * |x=x0,count指的是字库里面的原始数据,x0_no_change,这个变量不会变,如果y>8的适合将x0被这个变量置位 * | * V y=y0--> ****************************** * * * * * * * 1 * 2 * * * * * * * ****************************** * * * * * * * 3 * 4 * * * * * * * ****************************** * 当一个字节写好后 * |x * |x0_no_change |count * | |x0 * | | * V v y--> ****************************** y0--> * * * y0指向下一行的时候,x0将会被x置位,即x0,又回到一开始的位置 * * * * 1 * 2 * * * * * * * ****************************** * * * * * * * 3 * 4 * * * * * * * ****************************** * 当八个字节写好后,x,y的坐标将会指向下一个方框的首地址,都是被x,y值重置了,因为到了同一行的另外一个字框,所以x的指向会被修改为x+8,而count是只管增加就行了 * | * |x0_no_change |count * | |x * | |x0 * V v y0=y--> ****************************** * * * * * * * 1 * 2 * * * * * * * ****************************** * * * * * * * 3 * 4 * * * * * * * ****************************** *第一行的方框全部写完后,x0,x将会被原本的x0_no_change改变,重新修改为指向第一列 * |x0 * |x0_no_change | * |x | * | | * V v ****************************** * * * * * * * 1 * 2 * * * * * * * y0=y--> ****************************** * <--count * * * * * * 3 * 4 * * * * * * * ****************************** */ while(word_mode_size --) { temp = *(index_word_lib + count) ; count ++ ; if (temp == 0) { y0 ++ ; } else { while(temp) { if (temp & 0x80) { draw_word_point(x0 , y0) ; x0 ++ ; } else { x0 ++ ; } temp <<= 1 ; } y0 ++ ; x0 = x ; } if (count % 8 == 0) { y0 = y ; x += 8 ; x0 = x ; } if (count % WORD_FONT_WIDTH == 0) { y += 8 ; y0 = y ; x = x0_no_change ; x0 = x0_no_change ; } } #elif LIB_FONT == IMAGE_LIB #ifdef __DEBUG__ printf_num((INT32U) index_word_lib, 'h') ; #endif set_rect(x0, y0,WORD_FONT_WIDTH,WORD_FONT_HIGH) ; write_to_FramRam((INT16U*)index_word_lib,WORD_FONT_WIDTH,WORD_FONT_HIGH) ; #endif }
void region_tt::set_rect( const RECT& rect ) { return set_rect( rect.left, rect.top, rect.right, rect.bottom ); }
void ButtonPanel::set_pos(const Vector2i& pos) { set_rect(Rect(Vector2i(pos.x, pos.y - (buttons.size() * 38)/2), Size(60, buttons.size() * 38))); }