VALUE rbal_translate_transform(VALUE r_, VALUE rtrans, VALUE rx, VALUE ry) {
ALLEGRO_TRANSFORM * trans = rbal_transform_unwrap(rtrans);
float x = RBH_FLOAT(rx);
float y = RBH_FLOAT(ry);
al_translate_transform(trans, rx, ry);
return rtrans;
}
void SetupViewport(struct Game *game) {
game->viewport.width = 320;
game->viewport.height = 180;
int resolution = al_get_display_width(game->display) / 320;
if (al_get_display_height(game->display) / 180 < resolution) resolution = al_get_display_height(game->display) / 180;
if (resolution < 1) resolution = 1;
if (atoi(GetConfigOptionDefault(game, "SuperDerpy", "letterbox", "1"))) {
int clipWidth = 320 * resolution, clipHeight = 180 * resolution;
int clipX = (al_get_display_width(game->display) - clipWidth) / 2, clipY = (al_get_display_height(game->display) - clipHeight) / 2;
al_set_clipping_rectangle(clipX, clipY, clipWidth, clipHeight);
al_build_transform(&game->projection, clipX, clipY, resolution, resolution, 0.0f);
al_use_transform(&game->projection);
} else if ((atoi(GetConfigOptionDefault(game, "SuperDerpy", "rotate", "1"))) && (game->viewport.height > game->viewport.width)) {
al_identity_transform(&game->projection);
al_rotate_transform(&game->projection, 0.5*ALLEGRO_PI);
al_translate_transform(&game->projection, game->viewport.width, 0);
al_scale_transform(&game->projection, resolution, resolution);
al_use_transform(&game->projection);
int temp = game->viewport.height;
game->viewport.height = game->viewport.width;
game->viewport.width = temp;
}
if (game->_priv.console) Console_Unload(game);
Console_Load(game);
}
void apply_identity() {
ALLEGRO_TRANSFORM t;
al_identity_transform(&t);
al_scale_transform(&t, 1.0, -1.0);
al_translate_transform(&t, 0, cfg::screen_height);
al_use_transform(&t);
}
/** Applies a translate transformation to the current transformation. */
void cbeTransformTranslate(CBEnchanted *cb) {
float transY = cb->popValue().toFloat();
float transX = cb->popValue().toFloat();
ALLEGRO_TRANSFORM t;
al_identity_transform(&t);
al_translate_transform(&t, transX, transY);
al_use_transform(&t);
cb->pushValue(0);
}
/* set up a transformation such that anything drawn will be as if its 'z'
* coordinate was at the specified 'z' */
void t3f_3d_transform_z(float z)
{
float scale = t3f_3d_project_x(1.0, z) - t3f_3d_project_x(0.0, z);
float offset_x = t3f_3d_project_x(0.0, z);
float offset_y = t3f_3d_project_y(0.0, z);
al_identity_transform(&t3f_3d_transform);
al_scale_transform(&t3f_3d_transform, scale, scale);
al_translate_transform(&t3f_3d_transform, offset_x, offset_y);
// al_transform_transform(&t3f_3d_transform, &t3f_current_transform);
al_use_transform(&t3f_3d_transform);
}
void spaceship_draw(Spaceship *s) {
ALLEGRO_TRANSFORM transform;
if(s->gone == DEAD) return;
al_identity_transform(&transform);
al_rotate_transform(&transform, DEGREES(s->heading));
al_translate_transform(&transform, s->sx, s->sy);
al_use_transform(&transform);
al_draw_line(-8, 9, 0, -11, s->color, 3.0f);
al_draw_line(0, -11, 8, 9, s->color, 3.0f);
al_draw_line(-6, 4, -1, 4, s->color, 3.0f);
al_draw_line(6, 4, 1, 4, s->color, 3.0f);
}
int main(void)
{
al_init();
ALLEGRO_DISPLAY *d = al_create_display(W, H);
ALLEGRO_VERTEX v[POINTS];
ALLEGRO_COLOR c;
v[0].x = 0;
v[0].y = 0;
c = al_map_rgb(rand()%256, rand()%256, rand()%256);
v[0].color = al_get_prim_color(c);
v[1].x = 0+R;
v[1].y = 0;
c = al_map_rgb(rand()%256, rand()%256, rand()%256);
v[1].color = al_get_prim_color(c);
float a = 0;
float r = R;
int i;
for (i = 2; i < POINTS; i++) {
v[i].x = 0+cos(a)*r;
v[i].y = 0+sin(a)*r;
a += 0.3f;
r -= 1.5f;
c = al_map_rgb(rand()%256, rand()%256, rand()%256);
v[i].color = al_get_prim_color(c);
}
int frames = 0;
ALLEGRO_TRANSFORM t;
while (true) {
al_clear_to_color(al_map_rgb(0, 0, 0));
al_identity_transform(&t);
al_rotate_transform(&t, frames*0.1f);
al_translate_transform(&t, W/2, H/2);
al_use_transform(&t);
al_draw_prim(v, NULL, 0, POINTS, ALLEGRO_PRIM_TRIANGLE_FAN);
al_flip_display();
/* GP2X Wiz is locked to 60FPS using OpenGL */
frames++;
if (frames > 400)
break;
}
al_uninstall_system();
return 0;
}
/* Draw ship */
void draw_ship(Spaceship *s)
{
ALLEGRO_TRANSFORM transform;
al_identity_transform(&transform);
al_rotate_transform(&transform, 0);
al_rotate_transform(&transform, (s->heading * (M_PI/180)));
al_translate_transform(&transform, s->sx, s->sy);
al_use_transform(&transform);
al_draw_line(-8, 9, 0, -11, s->color, 3.0f);
al_draw_line(0, -11, 8, 9, s->color, 3.0f);
al_draw_line(-6, 4, -1, 4, s->color, 3.0f);
al_draw_line(6, 4, 1, 4, s->color, 3.0f);
}
static void _al_draw_transformed_scaled_bitmap_memory(
ALLEGRO_BITMAP *src, ALLEGRO_COLOR tint,
int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh, int flags)
{
ALLEGRO_TRANSFORM local_trans;
al_identity_transform(&local_trans);
al_translate_transform(&local_trans, dx, dy);
al_compose_transform(&local_trans, al_get_current_transform());
_al_draw_transformed_bitmap_memory(src, tint, sx, sy, sw, sh, dw, dh,
&local_trans, flags);
}
static void _draw_tinted_rotated_scaled_bitmap_region(ALLEGRO_BITMAP *bitmap,
ALLEGRO_COLOR tint, float cx, float cy, float angle,
float xscale, float yscale,
float sx, float sy, float sw, float sh, float dx, float dy,
int flags)
{
ALLEGRO_TRANSFORM backup;
ALLEGRO_TRANSFORM t;
ALLEGRO_BITMAP *parent = bitmap;
float const orig_sw = sw;
float const orig_sh = sh;
ASSERT(bitmap);
al_copy_transform(&backup, al_get_current_transform());
al_identity_transform(&t);
if (bitmap->parent) {
parent = bitmap->parent;
sx += bitmap->xofs;
sy += bitmap->yofs;
}
if (sx < 0) {
sw += sx;
al_translate_transform(&t, -sx, 0);
sx = 0;
}
if (sy < 0) {
sh += sy;
al_translate_transform(&t, 0, -sy);
sy = 0;
}
if (sx + sw > parent->w)
sw = parent->w - sx;
if (sy + sh > parent->h)
sh = parent->h - sy;
if (flags & ALLEGRO_FLIP_HORIZONTAL) {
al_scale_transform(&t, -1, 1);
al_translate_transform(&t, orig_sw, 0);
flags &= ~ALLEGRO_FLIP_HORIZONTAL;
}
if (flags & ALLEGRO_FLIP_VERTICAL) {
al_scale_transform(&t, 1, -1);
al_translate_transform(&t, 0, orig_sh);
flags &= ~ALLEGRO_FLIP_VERTICAL;
}
al_translate_transform(&t, -cx, -cy);
al_scale_transform(&t, xscale, yscale);
al_rotate_transform(&t, angle);
al_translate_transform(&t, dx, dy);
al_compose_transform(&t, &backup);
al_use_transform(&t);
_bitmap_drawer(parent, tint, sx, sy, sw, sh, flags);
al_use_transform(&backup);
}
void prepareForScreenGrab1()
{
prepareForScreenGrabBackupBitmap = al_get_target_bitmap();
int dx, dy, dw, dh;
get_screen_offset_size(&dx, &dy, &dw, &dh);
m_set_target_bitmap(tmpbuffer);
ALLEGRO_TRANSFORM t;
al_copy_transform(&prepareForScreenGrabBackup, al_get_current_transform());
al_identity_transform(&t);
al_scale_transform(&t, screenScaleX, screenScaleY);
al_translate_transform(&t, dx, dy);
al_use_transform(&t);
preparingForScreenGrab = true;
}
void start_text()
{
if (!text_draw_on) {
text_draw_on = true;
int dx, dy, dw, dh;
get_screen_offset_size(&dx, &dy, &dw, &dh);
al_copy_transform(&old_view, al_get_current_transform());
ALLEGRO_TRANSFORM v;
al_identity_transform(&v);
al_scale_transform(&v, textScaleX, textScaleY);
if (al_get_bitmap_width(al_get_target_bitmap()) == al_get_display_width(display) && al_get_bitmap_height(al_get_target_bitmap()) == al_get_display_height(display)) {
al_translate_transform(&v, dx, dy);
}
al_use_transform(&v);
}
}
void draw_ship(game *game) {
ALLEGRO_TRANSFORM trans;
al_identity_transform(&trans);
al_rotate_transform(&trans, game->Ship->angle);
al_translate_transform(&trans,
(int)game->Ship->position->x,
(int)game->Ship->position->y);
al_use_transform(&trans);
float w = game->Ship->time >= 0 ? 1 : 4;
al_draw_line(-8, 20, 0, 0, SHIP_COLOR, w);
al_draw_line(8, 20, 0, 0, SHIP_COLOR, w);
al_draw_line(-6, 15, -1, 15, SHIP_COLOR, w);
al_draw_line(6, 15, 1, 15, SHIP_COLOR, w);
}
void t3f_3d_select_projection(T3F_3D_STATE * sp)
{
t3f_3d_current_state = sp;
float sx = t3f_3d_current_state->width / (float)t3f_virtual_display_width;
float sy = t3f_3d_current_state->height / (float)t3f_virtual_display_height;
float dsx = (float)al_get_display_width(t3f_display) / t3f_virtual_display_width;
float dsy = (float)al_get_display_height(t3f_display) / t3f_virtual_display_height;
float ox = t3f_3d_current_state->offset_x * dsx;
float oy = t3f_3d_current_state->offset_y * dsy;
/* apply additional transformations */
al_copy_transform(&t3f_current_transform, &t3f_base_transform);
al_scale_transform(&t3f_current_transform, sx, sy);
al_translate_transform(&t3f_current_transform, t3f_3d_current_state->offset_x * dsx, t3f_3d_current_state->offset_y * dsy);
al_use_transform(&t3f_current_transform);
/* convert virtual screen coordinates to real display coordinates */
al_set_clipping_rectangle(ox, oy, t3f_3d_current_state->width * dsx, t3f_3d_current_state->height * dsy);
}
void mw2_Rect::Draw(mw2_Camera* camera)
{
float x = WorldPosition()->x - camera->WorldPosition()->x;
float y = WorldPosition()->y - camera->WorldPosition()->y;
float teta = - camera->WorldRotation() * (float) PI / 180;
float finalAngle = WorldRotation() - camera->WorldRotation();
float finalX = (x * (float) cos(teta) - y * (float) sin(teta))
+ mw2_Application::Settings::width / 2;
float finalY = (x * (float) sin(teta) + y * (float) cos(teta))
+ mw2_Application::Settings::height / 2;
ALLEGRO_TRANSFORM T;
al_identity_transform(&T);
al_rotate_transform(&T, finalAngle * (float) PI / 180);
al_translate_transform(&T, finalX, finalY);
al_use_transform(&T);
ALLEGRO_COLOR color = al_map_rgba(mColor->x, mColor->y, mColor->z, mColor->t);
switch (mStyle)
{
case FILL:
al_draw_filled_rectangle(
- mSize->x /2, - mSize->y /2,
mSize->x /2, mSize->y /2,
color
);
break;
case LINE:
al_draw_rectangle(
- mSize->x /2, - mSize->y /2,
mSize->x /2, mSize->y /2,
color,
1
);
break;
}
al_identity_transform(&T);
al_use_transform(&T);
}
void draw_blast(Blast *blast) {
ALLEGRO_TRANSFORM transform;
if(al_get_current_transform() == NULL) {
fprintf(stderr, "no target bitmap.");
}
al_identity_transform(&transform);
al_rotate_transform(&transform, 1.58525 + head2theta(blast->heading));
al_translate_transform(&transform, blast->sx, blast->sy);
al_use_transform(&transform);
/* many small lines will eventually create a dashed line */
al_draw_line(0, 0, 0, -10, blast->color, 3.0f);
al_draw_line(0, -15, 0, -25, blast->color, 3.0f);
al_draw_line(0, -30, 0, -40, blast->color, 3.0f);
al_draw_line(0, -45, 0, -60, blast->color, 3.0f);
al_draw_line(0, -65, 0, -80, blast->color, 3.0f);
al_draw_line(0, -85, 0, -100, blast->color, 3.0f);
al_draw_line(0, -105, 0, -120, blast->color, 3.0f);
}
/* Transform asteroid */
static void draw_roid(Asteroid *roid)
{
ALLEGRO_TRANSFORM transform;
al_identity_transform(&transform);
al_rotate_transform(&transform, (roid->twist * (M_PI/180)));
al_scale_transform(&transform, roid->scale, roid->scale);
al_translate_transform(&transform, roid->sx, roid->sy);
al_use_transform(&transform);
al_draw_line(-22, 20, -18, 4, roid->color, 2.0f);
al_draw_line(-18, 4, -18, -10, roid->color, 2.0f);
al_draw_line(-18, -10, -5, -10, roid->color, 2.0f);
al_draw_line(-5, -10, -10, -22, roid->color, 2.0f);
al_draw_line(-10, -22, 4, -22, roid->color, 2.0f);
al_draw_line(4, -22, 20, -10, roid->color, 2.0f);
al_draw_line(20, -10, 20, -5, roid->color, 2.0f);
al_draw_line(20, -5, 0, 0, roid->color, 2.0f);
al_draw_line(0, 0, 20, 10, roid->color, 2.0f);
al_draw_line(20, 10, 10, 20, roid->color, 2.0f);
al_draw_line(10, 20, 0, 15, roid->color, 2.0f);
al_draw_line(0, 15, -22, 20, roid->color, 2.0f);
}
static void ogl_update_transformation(ALLEGRO_DISPLAY* disp,
ALLEGRO_BITMAP *target)
{
ALLEGRO_TRANSFORM tmp;
al_copy_transform(&tmp, &target->transform);
if (target->parent) {
/* Sub-bitmaps have an additional offset. */
al_translate_transform(&tmp, target->xofs, target->yofs);
}
if (disp->flags & ALLEGRO_USE_PROGRAMMABLE_PIPELINE) {
#ifndef ALLEGRO_CFG_NO_GLES2
GLuint program_object = disp->ogl_extras->program_object;
GLint handle;
// FIXME: In al_create_display we have no shader yet
if (program_object == 0)
return;
al_copy_transform(&disp->view_transform, &tmp);
al_compose_transform(&tmp, &disp->proj_transform);
handle = glGetUniformLocation(program_object, "projview_matrix");
if (handle >= 0) {
glUniformMatrix4fv(handle, 1, GL_FALSE, (float *)tmp.m);
}
#endif
}
else {
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf((float *)tmp.m);
}
}
void DrawMenuState(struct Game *game, struct MenuResources *data) {
const ALLEGRO_TRANSFORM *tmp_trans = al_get_current_transform();
ALLEGRO_TRANSFORM trans, cur_trans;
al_copy_transform(&trans, tmp_trans);
al_copy_transform(&cur_trans, tmp_trans);
al_translate_transform(&trans, (al_get_display_width(game->display) / 320.0) * 100, (al_get_display_height(game->display) / 260.0) * ((180-data->screen_pos) - 48));
al_use_transform(&trans);
ALLEGRO_FONT *font = data->font;
char* text = malloc(255*sizeof(char));
struct ALLEGRO_COLOR color;
switch (data->menustate) {
case MENUSTATE_MAIN:
case MENUSTATE_HIDDEN:
if (!data->invisible) {
DrawTextWithShadow(font, data->selected==0 ? al_map_rgb(128,255,128) : al_map_rgb(255,255,255), game->viewport.width*0.5, game->viewport.height*0.5, ALLEGRO_ALIGN_CENTRE, "Start game");
DrawTextWithShadow(font, data->selected==1 ? al_map_rgb(128,255,128) : al_map_rgb(255,255,255), game->viewport.width*0.5, game->viewport.height*0.6, ALLEGRO_ALIGN_CENTRE, "Options");
DrawTextWithShadow(font, data->selected==2 ? al_map_rgb(128,255,128) : al_map_rgb(255,255,255), game->viewport.width*0.5, game->viewport.height*0.7, ALLEGRO_ALIGN_CENTRE, "About");
DrawTextWithShadow(font, data->selected==3 ? al_map_rgb(128,255,128) : al_map_rgb(255,255,255), game->viewport.width*0.5, game->viewport.height*0.8, ALLEGRO_ALIGN_CENTRE, "Exit");
}
break;
case MENUSTATE_OPTIONS:
DrawTextWithShadow(font, data->selected==0 ? al_map_rgb(128,255,128) : al_map_rgb(255,255,255), game->viewport.width*0.5, game->viewport.height*0.5, ALLEGRO_ALIGN_CENTRE, "Video settings");
DrawTextWithShadow(font, data->selected==1 ? al_map_rgb(128,255,128) : al_map_rgb(255,255,255), game->viewport.width*0.5, game->viewport.height*0.6, ALLEGRO_ALIGN_CENTRE, "Audio settings");
DrawTextWithShadow(font, data->selected==3 ? al_map_rgb(128,255,128) : al_map_rgb(255,255,255), game->viewport.width*0.5, game->viewport.height*0.8, ALLEGRO_ALIGN_CENTRE, "Back");
break;
case MENUSTATE_AUDIO:
if (game->config.music) snprintf(text, 255, "Music volume: %d0%%", game->config.music);
else sprintf(text, "Music disabled");
DrawTextWithShadow(font, data->selected==0 ? al_map_rgb(128,255,128) : al_map_rgb(255,255,255), game->viewport.width*0.5, game->viewport.height*0.5, ALLEGRO_ALIGN_CENTRE, text);
if (game->config.fx) snprintf(text, 255, "Effects volume: %d0%%", game->config.fx);
else sprintf(text, "Effects disabled");
DrawTextWithShadow(font, data->selected==1 ? al_map_rgb(128,255,128) : al_map_rgb(255,255,255), game->viewport.width*0.5, game->viewport.height*0.6, ALLEGRO_ALIGN_CENTRE, text);
DrawTextWithShadow(font, data->selected==3 ? al_map_rgb(128,255,128) : al_map_rgb(255,255,255), game->viewport.width*0.5, game->viewport.height*0.8, ALLEGRO_ALIGN_CENTRE, "Back");
break;
case MENUSTATE_ABOUT:
al_use_transform(&cur_trans);
About(game, data);
break;
case MENUSTATE_VIDEO:
if (data->options.fullscreen) {
sprintf(text, "Fullscreen: yes");
color = al_map_rgba(0,0,0,128);
}
else {
sprintf(text, "Fullscreen: no");
color = data->selected==1 ? al_map_rgb(128,255,128) : al_map_rgb(255,255,255);
}
DrawTextWithShadow(font, data->selected==0 ? al_map_rgb(128,255,128) : al_map_rgb(255,255,255), game->viewport.width*0.5, game->viewport.height*0.5, ALLEGRO_ALIGN_CENTRE, text);
sprintf(text, "Resolution: %dx", data->options.resolution);
DrawTextWithShadow(font, color, game->viewport.width*0.5, game->viewport.height*0.6, ALLEGRO_ALIGN_CENTRE, text);
DrawTextWithShadow(font, data->selected==3 ? al_map_rgb(128,255,128) : al_map_rgb(255,255,255), game->viewport.width*0.5, game->viewport.height*0.8, ALLEGRO_ALIGN_CENTRE, "Back");
break;
default:
data->selected=0;
DrawTextWithShadow(font, data->selected==0 ? al_map_rgb(128,255,128) : al_map_rgb(255,255,255), game->viewport.width*0.5, game->viewport.height*0.5, ALLEGRO_ALIGN_CENTRE, "Not implemented yet");
break;
}
free(text);
al_use_transform(&cur_trans);
}
void AppBody()
{
bool done = false;
bool redraw = false;
TileMap map("data/maps/test1.tmx");
Sprite sprt("data/sprites/demo.adf");
sprt.SendNewState(AnimState::IDLE, AnimDir::DOWN);
ALLEGRO_TRANSFORM camera;
int x_offset = 0, y_offset = 0;
int x_delta, y_delta;
int key_state[2] = {0, 0};
x_delta = applicationConfig.iDispW - al_get_bitmap_width(map.GetFullMap());
y_delta = applicationConfig.iDispH - al_get_bitmap_height(map.GetFullMap());
Vec2D playerPos {0, 0};
Vec2D playerVel {0, 0};
al_start_timer(timer);
while (!done)
{
ALLEGRO_EVENT ev;
al_wait_for_event(queue, &ev);
switch (ev.type)
{
case ALLEGRO_EVENT_TIMER:
al_identity_transform(&camera);
x_offset += key_state[0];
y_offset += key_state[1];
if (x_delta > 0)
{
x_offset = x_delta / 2;
} else
{
if (x_offset < x_delta) x_offset = x_delta;
if (x_offset > 0) x_offset = 0;
}
if (y_delta > 0)
{
y_offset = y_delta / 2;
} else
{
if (y_offset < y_delta) y_offset = y_delta;
if (y_offset > 0) y_offset = 0;
}
if (map.CanWalktoTileAt(playerPos, sprt.GetSize(), {0.0f, 32.0f}) == true)
{
playerPos = playerPos + playerVel;
} else
{
Vec2D backtracing = playerVel;
playerVel = {0, 0}; // we delete player velocitity to stop oscillating in place during collision.
if (backtracing == playerVel) // If for whatever reason we are stuck and cannot determine orig vector... MAGIC!
{
backtracing.x = 2.0f;
backtracing.y = 2.0f;
float angle = rand() % 359 + 1;
backtracing.rotate(angle * (ALLEGRO_PI / 180));
std::cerr << "Warning: Unknown velocity vector. Will use [" << backtracing.x << "," << backtracing.y
<< "] as direction to solve collision." << std::endl;
}
while (map.CanWalktoTileAt(playerPos, sprt.GetSize(), {0.0f, 32.0f}) == false)
{
playerPos = playerPos - backtracing;
}
}
sprt.Update();
redraw = true;
break;
case ALLEGRO_EVENT_DISPLAY_CLOSE:
done = true;
break;
case ALLEGRO_EVENT_KEY_DOWN:
if (ev.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
{
done = true;
}
switch (ev.keyboard.keycode)
{
case ALLEGRO_KEY_LEFT: key_state[0] = 4; break;
case ALLEGRO_KEY_RIGHT: key_state[0] = -4; break;
case ALLEGRO_KEY_UP: key_state[1] = 4; break;
case ALLEGRO_KEY_DOWN: key_state[1] = -4; break;
case ALLEGRO_KEY_A:
playerVel.x = -2;
sprt.SendNewState(AnimState::MOVE, AnimDir::LEFT);
break;
case ALLEGRO_KEY_D:
playerVel.x = 2;
sprt.SendNewState(AnimState::MOVE, AnimDir::RIGHT);
break;
case ALLEGRO_KEY_W:
playerVel.y = -2;
sprt.SendNewState(AnimState::MOVE, AnimDir::UP);
break;
case ALLEGRO_KEY_S:
playerVel.y = 2;
sprt.SendNewState(AnimState::MOVE, AnimDir::DOWN);
break;
}
break;
case ALLEGRO_EVENT_KEY_UP:
switch (ev.keyboard.keycode)
{
case ALLEGRO_KEY_LEFT:
case ALLEGRO_KEY_RIGHT: key_state[0] = 0; break;
case ALLEGRO_KEY_UP:
case ALLEGRO_KEY_DOWN: key_state[1] = 0; break;
case ALLEGRO_KEY_A:
playerVel.x = 0;
sprt.SendNewState(AnimState::IDLE, AnimDir::LEFT);
break;
case ALLEGRO_KEY_D:
playerVel.x = 0;
sprt.SendNewState(AnimState::IDLE, AnimDir::RIGHT);
break;
case ALLEGRO_KEY_W:
playerVel.y = 0;
sprt.SendNewState(AnimState::IDLE, AnimDir::UP);
break;
case ALLEGRO_KEY_S:
playerVel.y = 0;
sprt.SendNewState(AnimState::IDLE, AnimDir::DOWN);
break;
}
break;
default:
break;
}
if (redraw && al_is_event_queue_empty(queue))
{
al_translate_transform(&camera, x_offset, y_offset);
al_use_transform(&camera);
redraw = false;
al_clear_to_color(styleConfig.colBackgroundColor);
map.DrawLayerMap("Background");
map.DrawLayerMap("Foreground");
/*
Playable characters should draw on this position
*/
sprt.Render(playerPos.x, playerPos.y);
map.DrawLayerMap("Top");
al_flip_display();
}
}
}
void ScrollableArea::Print()
{
wd_PrintBegin();
wd_Print_Background();
al_identity_transform(&rest);
if((wd_bf & bf_ZOOMABLE))
{
al_scale_transform(&rest, zoom, zoom);
}
al_translate_transform(&rest, wd_theme.added_thickness/2, wd_theme.added_thickness/2);
al_use_transform(&rest);
al_set_clipping_rectangle(wd_theme.added_thickness/2 + wd_theme.thickness,
wd_theme.added_thickness/2 + wd_theme.thickness,
/*wd_theme.added_thickness/2 + */wd_width - (scb_vertical_active == true ? scb_thickness:0) /*- wd_theme.thickness*/,
/*wd_theme.added_thickness/2 + */wd_height - (scb_horizontal_active == true ? scb_thickness:0) /*- wd_theme.thickness*/);
for(int a = 0; a < (int)widgets.size();a++)
{
if(( (widgets[a]->orig_x1 *zoom >= scb_horizontal->change && widgets[a]->orig_x1 *zoom<= scb_horizontal->change + wd_width)
|| (widgets[a]->orig_x2 *zoom>= scb_horizontal->change && widgets[a]->orig_x2 *zoom<= scb_horizontal->change + wd_width)
|| (widgets[a]->orig_x1 *zoom<= scb_horizontal->change && widgets[a]->orig_x2 *zoom>= scb_horizontal->change + wd_width)
) && (
(widgets[a]->orig_y1 *zoom>= scb_vertical->change && widgets[a]->orig_y1 *zoom<= scb_vertical->change + wd_height)
|| (widgets[a]->orig_y2 *zoom>= scb_vertical->change && widgets[a]->orig_y2 *zoom<= scb_vertical->change + wd_height)
|| (widgets[a]->orig_y1 *zoom<= scb_vertical->change && widgets[a]->orig_y2 *zoom>= scb_vertical->change + wd_height)))
{
if(changec_p == true)
{
widgets[a]->Change_print_coords(widgets[a]->orig_x1 - scb_horizontal->change/zoom,
widgets[a]->orig_y1 - scb_vertical->change/zoom, widgets[a]->wd_width, widgets[a]->wd_height);
widgets[a]->wd_md->Change_coords(wd_x1 + widgets[a]->orig_x1*zoom - scb_horizontal->change,
wd_y1 + widgets[a]->orig_y1*zoom - scb_vertical->change,
(widgets[a]->orig_x2 - widgets[a]->orig_x1)*zoom,
(widgets[a]->orig_y2 - widgets[a]->orig_y1)*zoom);
}
widgets[a]->Print();
}
}
changec_p = false;
al_identity_transform(&rest);
al_translate_transform(&rest, wd_theme.added_thickness/2, wd_theme.added_thickness/2);
al_use_transform(&rest);
al_set_clipping_rectangle(0,0,
wd_width + wd_theme.added_thickness, wd_height + wd_theme.added_thickness);
zoomresetb->Print();
scb_horizontal->Print();
scb_vertical->Print();
al_identity_transform(&rest);
al_use_transform(&rest);
wd_Print_Frame();
wd_PrintEnd();
}
static void redraw(void)
{
ALLEGRO_TRANSFORM t;
int i;
/* We first draw the Obp background and clear the depth buffer to 1. */
al_set_render_state(ALLEGRO_ALPHA_TEST, true);
al_set_render_state(ALLEGRO_ALPHA_FUNCTION, ALLEGRO_RENDER_GREATER);
al_set_render_state(ALLEGRO_ALPHA_TEST_VALUE, 0);
al_set_render_state(ALLEGRO_DEPTH_TEST, false);
al_set_render_state(ALLEGRO_WRITE_MASK, ALLEGRO_MASK_DEPTH | ALLEGRO_MASK_RGBA);
al_clear_depth_buffer(1);
al_clear_to_color(al_map_rgb_f(0, 0, 0));
al_draw_scaled_bitmap(example.obp, 0, 0, 532, 416, 0, 0, 640, 416 * 640 / 532, 0);
/* Next we draw all sprites but only to the depth buffer (with a depth value
* of 0).
*/
al_set_render_state(ALLEGRO_DEPTH_TEST, true);
al_set_render_state(ALLEGRO_DEPTH_FUNCTION, ALLEGRO_RENDER_ALWAYS);
al_set_render_state(ALLEGRO_WRITE_MASK, ALLEGRO_MASK_DEPTH);
for (i = 0; i < COUNT; i++) {
struct Sprite *s = example.sprites + i;
int x, y;
al_hold_bitmap_drawing(true);
for (y = -480; y <= 0; y += 480) {
for (x = -640; x <= 0; x += 640) {
al_identity_transform(&t);
al_rotate_transform(&t, s->angle);
al_translate_transform(&t, s->x + x, s->y + y);
al_use_transform(&t);
al_draw_text(example.font, al_map_rgb(0, 0, 0), 0, 0,
ALLEGRO_ALIGN_CENTER, "Allegro 5");
}
}
al_hold_bitmap_drawing(false);
}
al_identity_transform(&t);
al_use_transform(&t);
/* Finally we draw Mysha, with depth testing so she only appears where
* sprites have been drawn before.
*/
al_set_render_state(ALLEGRO_DEPTH_FUNCTION, ALLEGRO_RENDER_EQUAL);
al_set_render_state(ALLEGRO_WRITE_MASK, ALLEGRO_MASK_RGBA);
al_draw_scaled_bitmap(example.mysha, 0, 0, 320, 200, 0, 0, 320 * 480 / 200, 480, 0);
/* Finally we draw an FPS counter. */
al_set_render_state(ALLEGRO_DEPTH_TEST, false);
al_draw_textf(example.font2, al_map_rgb_f(1, 1, 1), 640, 0,
ALLEGRO_ALIGN_RIGHT, "%.1f FPS", 1.0 / example.direct_speed_measure);
}
int main(int argc, char **argv)
{
char cCurrentPath[FILENAME_MAX];
if (!GetCurrentDir(cCurrentPath, sizeof(cCurrentPath)))
{
return errno;
}
cCurrentPath[sizeof(cCurrentPath) - 1] = '\0'; /* not really required */
std::cout << cCurrentPath << std::endl;
int newsw = 771 , newsh = 600;
float _sx = (float)newsw / (float)SCREEN_W, _sy = (float)newsh / (float)SCREEN_H;
float _offx = (SCREEN_W - newsw)/2, _offy = (SCREEN_H - newsh)/2;
rGUI::Init_Allegro();
rGUI::Init_rGUI();
//rGUI::Init_rGUI(_sx, _sy, _offx, _offy);
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
ALLEGRO_BITMAP *bouncer = NULL;
float bouncer_x = SCREEN_W / 2.0 - BOUNCER_SIZE / 2.0;
float bouncer_y = SCREEN_H / 2.0 - BOUNCER_SIZE / 2.0;
bool redraw = true;
ALLEGRO_FONT *font = al_load_font("Calibri.ttf", 35, 0);
timer = al_create_timer(1.0 / FPS);
if(!timer)
{
fprintf(stderr, "failed to create timer!\n");
return -1;
}
display = al_create_display(SCREEN_W, SCREEN_H);
//display = al_create_display(newsw, newsh);
al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR);
if(!display)
{
fprintf(stderr, "failed to create display!\n");
al_destroy_timer(timer);
return -1;
}
bouncer = al_create_bitmap(BOUNCER_SIZE, BOUNCER_SIZE);
if(!bouncer)
{
fprintf(stderr, "failed to create bouncer bitmap!\n");
al_destroy_display(display);
al_destroy_timer(timer);
return -1;
}
al_set_target_bitmap(bouncer);
al_clear_to_color(al_map_rgb(255, 0, 255));
al_set_target_bitmap(al_get_backbuffer(display));
event_queue = al_create_event_queue();
if(!event_queue)
{
fprintf(stderr, "failed to create event_queue!\n");
al_destroy_bitmap(bouncer);
al_destroy_display(display);
al_destroy_timer(timer);
return -1;
}
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_register_event_source(event_queue, al_get_mouse_event_source());
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_clear_to_color(al_map_rgb(0,0,0));
al_flip_display();
al_start_timer(timer);
tmh.c_text = al_map_rgba(255,255,255,0);
tmh.c_outline = al_map_rgba(0,200,0,255);
tmh.c_background = al_map_rgba(255,0,0,255);
tmh.c_movablepart = al_map_rgb(200,0,0);
tmh.c_clicking = al_map_rgba(0,0,0,125);
tmh.thickness = 2;
tmh.added_thickness = 2;
tmh.roundx = 0;
tmh.roundy = 0;
ALLEGRO_FONT *fnt = al_load_ttf_font("Calibri.ttf",30,0);
widgets.push_back(new rGUI::Button(10,40,100,50,"wwwLong text", "Calibri.ttf",&tmh));
tmh.roundx = 3;
tmh.roundy = 3;
widgets.push_back(new rGUI::CheckBox(160, 40, 50,50,&tmh, false));
widgets.push_back(new rGUI::SlideBar(10,100,100,30,0,1,&tmh, (rGUI::bf_HORIZONTAL | rGUI::bf_HAS_FRAME) ));
widgets.push_back(new rGUI::SlideBar(115,40,30,50,0,5, &tmh, (rGUI::bf_VERTICAL | rGUI::bf_HAS_FRAME) ));
widgets.push_back(new rGUI::BitmapButton(10,140,100,45, "button.png",&tmh, 0));
widgets.push_back(new rGUI::ScrollBar(220, 5, 30, 185, 800, &tmh, (rGUI::bf_VERTICAL)));
widgets.push_back(new rGUI::ScrollBar(10, 195, 240, 30, 800, &tmh, (rGUI::bf_HORIZONTAL)));
widgets.push_back(new rGUI::InputField(115,100,95,40, "Calibri.ttf",&tmh, FPS));
widgets.push_back(new rGUI::SingleKeyInputField(115,145,95,40, ALLEGRO_KEY_BACKQUOTE, "Calibri.ttf",&tmh));
//Callback example
int progressbar = widgets.size();
widgets.push_back(new rGUI::ProgressBar(10,5,200,30,0,&tmh));
widgets[progressbar]->wd_md->md_callback_data = widgets[progressbar];
widgets[progressbar]->wd_md->Just_clicked_callback = pbar_callback;
widgets.push_back(new rGUI::ScrollableArea(10,240,440,440,2000,2000,&tmh,20, (rGUI::bf_VERTICAL | rGUI::bf_HORIZONTAL | rGUI::bf_ZOOMABLE)));
int scbapoz = widgets.size()-1;
widgets[scbapoz]->widgets.push_back(new rGUI::Button(10,10,100,30, "Text", "Calibri.ttf", &tmh));
widgets[scbapoz]->widgets.push_back(new rGUI::BitmapButton(10,50,100,45, "button.png",&tmh, 0));
widgets[scbapoz]->widgets.push_back(new rGUI::CheckBox(120, 30, 50,50,&tmh, false));
widgets[scbapoz]->widgets.push_back(new rGUI::SlideBar(10,100,120,30,0,300,&tmh, (rGUI::bf_HORIZONTAL | rGUI::bf_HAS_FRAME) ));
widgets[scbapoz]->widgets.push_back(new rGUI::ScrollBar(10, 160, 120, 30, 800, &tmh, (rGUI::bf_HORIZONTAL)));
widgets[scbapoz]->widgets.push_back(new rGUI::InputField(10,2000,100,40, "Calibri.ttf",&tmh, FPS));
widgets[scbapoz]->widgets.push_back(new rGUI::TextBox(2000,1200,300,120, "Big box", "Calibri.ttf", 200,&tmh,
(rGUI::bf_HAS_FRAME | rGUI::bf_RESIZE_CONTENT)));
widgets[scbapoz]->widgets.push_back(new rGUI::SlideBar(1000,100,200,40,0,20,&tmh, (rGUI::bf_HORIZONTAL | rGUI::bf_HAS_FRAME) ));
widgets[scbapoz]->widgets.push_back(new rGUI::BitmapButton(300,300,0,0, "image.jpg",&tmh, (rGUI::bf_RESIZE_WIDGET | rGUI::bf_DISABLE_CLICKING_SHADOW)));
((rGUI::ScrollableArea*)widgets[scbapoz])->I_added_new_widgets();
//roundXY
widgets.push_back(new rGUI::TextBox(680,5,300,40, "RoundXY", "Calibri.ttf",15, &tmh, (rGUI::bf_HAS_FRAME)));
int poz_roundXY = widgets.size();
widgets.push_back(new rGUI::SlideBar(800,10,100,30,0,10,&tmh, (rGUI::bf_HORIZONTAL)));
//Thickness
widgets.push_back(new rGUI::TextBox(680,50,300,40, "Thickness", "Calibri.ttf",15, &tmh, (rGUI::bf_HAS_FRAME)));
int poz_thickness = widgets.size();
widgets.push_back(new rGUI::SlideBar(800,55,100,30,0,10,&tmh, (rGUI::bf_HORIZONTAL)));
//Added thickness
widgets.push_back(new rGUI::TextBox(680,95,300,40, "Added Thickness", "Calibri.ttf",10, &tmh, (rGUI::bf_HAS_FRAME)));
int poz_addedthickness = widgets.size();
widgets.push_back(new rGUI::SlideBar(800,100,100,30,0,10,&tmh, (rGUI::bf_HORIZONTAL)));
//Update Button
int poz_updatebutton = widgets.size();
widgets.push_back(new rGUI::Button(680,140,180,40,"Update Theme","Calibri.ttf", &tmh));
//Reset Button
int poz_rb = widgets.size();
widgets.push_back(new rGUI::TextBox(862,140,36,40,"Reset theme","Calibri.ttf", 12, &tmh,
(rGUI::bf_AS_BUTTON | rGUI::bf_HAS_FRAME | rGUI::bf_MULTILINE)));
//widgets.push_back(new rGUI::Button(865,140,30,40,"Reset colors","Calibri.ttf", &tmh));
//Color selector
int poz_colscba = widgets.size();
widgets.push_back(new rGUI::ScrollableArea(400,5,275,180,2000,2000,&tmh,0,0));
//red
int poz_colsba_R = widgets[poz_colscba]->widgets.size();
widgets[poz_colscba]->widgets.push_back(new rGUI::SlideBar(5,5,30,140,0,255,&tmh, rGUI::bf_VERTICAL));
//Green
int poz_colsba_G = widgets[poz_colscba]->widgets.size();
widgets[poz_colscba]->widgets.push_back(new rGUI::SlideBar(40,5,30,140,0,255,&tmh, rGUI::bf_VERTICAL));
//Blue
int poz_colsba_B = widgets[poz_colscba]->widgets.size();
widgets[poz_colscba]->widgets.push_back(new rGUI::SlideBar(75,5,30,140,0,255,&tmh, rGUI::bf_VERTICAL));
//Alpha
int poz_colsba_A = widgets[poz_colscba]->widgets.size();
widgets[poz_colscba]->widgets.push_back(new rGUI::SlideBar(110,5,30,140,0,255,&tmh, rGUI::bf_VERTICAL));
//cols
int poz_colsba_cols = widgets[poz_colscba]->widgets.size();
widgets[poz_colscba]->widgets.push_back(new rGUI::TextBox(15,150,120,20, "R G B A", "Calibri.ttf", 20, &tmh, rGUI::bf_HAS_FRAME));
//TextC
int poz_colsba_c_T = widgets[poz_colscba]->widgets.size();
widgets[poz_colscba]->widgets.push_back(new rGUI::Button(150,5,120,30, "Text color", "Calibri.ttf", &tmh));
//BackgroundC
int poz_colsba_c_B = widgets[poz_colscba]->widgets.size();
widgets[poz_colscba]->widgets.push_back(new rGUI::Button(150,40,120,30, "Background color", "Calibri.ttf", &tmh));
//OutlineC
int poz_colsba_c_O = widgets[poz_colscba]->widgets.size();
widgets[poz_colscba]->widgets.push_back(new rGUI::Button(150,75,120,30, "Outline color", "Calibri.ttf", &tmh));
//ClickingC
int poz_colsba_c_C = widgets[poz_colscba]->widgets.size();
widgets[poz_colscba]->widgets.push_back(new rGUI::Button(150,110,120,30, "Clicking color", "Calibri.ttf", &tmh));
((rGUI::ScrollableArea*)widgets[poz_colscba])->I_added_new_widgets();
//Drag&drop
int poz_dbm = widgets.size();
widgets.push_back(new rGUI::DropBoxManager());
rGUI::DropBox_Item dpi;
dpi.load_bmp_fom_file = true;
dpi.bmp_str = "button.png";
dpi.print_x = 10;
dpi.print_y = 10;
dpi.print_w = 30;
dpi.print_h = 30;
widgets.push_back(new rGUI::DropBox(600,400,50,50,&tmh, (rGUI::DropBoxManager*)widgets[poz_dbm],&dpi));
dpi.load_bmp_fom_file = false;
dpi.bmp = al_load_bitmap("button.png");
al_set_target_bitmap(dpi.bmp);
al_draw_tinted_bitmap(dpi.bmp, al_map_rgba(255,0,0,100),0,0,0);
std::vector<ALLEGRO_COLOR*> colvect;
widgets[scbapoz]->widgets.push_back(new rGUI::DropBox(600,400,50,50,&tmh, (rGUI::DropBoxManager*)widgets[poz_dbm],&dpi));
for(int a = 0;a < 5;a++)
{
for(int b = 0;b < 5;b++)
{
if(a == 0 && b == 0)
{
continue;
}
ALLEGRO_COLOR tmpc = al_map_rgba(rand()%256,rand()%256,rand()%256,255);
colvect.push_back(new ALLEGRO_COLOR);
colvect[colvect.size()-1]->r = tmpc.r;
colvect[colvect.size()-1]->g = tmpc.g;
colvect[colvect.size()-1]->b = tmpc.b;
colvect[colvect.size()-1]->a = tmpc.a;
al_clear_to_color(tmpc);
dpi.data = colvect[colvect.size()-1];
widgets.push_back(new rGUI::DropBox(600 + a*55,400 + b*55,50,50,&tmh, (rGUI::DropBoxManager*)widgets[poz_dbm], nullptr));
widgets[scbapoz]->widgets.push_back(new rGUI::DropBox(600 + a*55,400 + b*55,50,50,&tmh, (rGUI::DropBoxManager*)widgets[poz_dbm], &dpi));
}
}
al_set_target_backbuffer(display);
int poz_backgroundDB = widgets.size();
widgets.push_back(new rGUI::DropBox(710,345,50,50,&tmh, (rGUI::DropBoxManager*)widgets[poz_dbm], nullptr));
int poz_scba_DP = widgets[scbapoz]->widgets.size();
widgets[scbapoz]->widgets.push_back(new rGUI::DropBox(710,345,50,50,&tmh, (rGUI::DropBoxManager*)widgets[poz_dbm], nullptr));
((rGUI::ScrollableArea*)widgets[scbapoz])->I_added_new_widgets();
//Group
int poz_ext = widgets.size();
widgets.push_back(new rGUI::Button(SCREEN_W - 50, SCREEN_H - 17,40,12,"Exit", "Calibri.ttf", &tmh));
int poz_group = widgets.size();
widgets.push_back(new rGUI::Group());
((rGUI::Group*)widgets[poz_group])->Add_Widgets(widgets, 0, widgets.size()-1);
int poz_ext_scba = widgets.size();
widgets.push_back(new rGUI::ScrollableArea( (SCREEN_W/2)-200, (SCREEN_H/2)-100, 400, 200,400,200,&tmh,14, 0));
widgets[poz_ext_scba]->widgets.push_back(new rGUI::Button(10,150,100,45,"Yes", "Calibri.ttf", &tmh));
widgets[poz_ext_scba]->widgets.push_back(new rGUI::Button(290,150,100,45,"No", "Calibri.ttf", &tmh));
widgets[poz_ext_scba]->widgets.push_back(new rGUI::TextBox(0,0,400,120, "Do you rly wanna go ?", "Calibri.ttf",100, &tmh,
(rGUI::bf_HORIZONTAL_CENTER | rGUI::bf_VERTICAL_CENTER | rGUI::bf_RESIZE_CONTENT) ));
((rGUI::ScrollableArea*)widgets[poz_ext_scba])->I_added_new_widgets();
int poz_ext_group = widgets.size();
widgets.push_back(new rGUI::Group());
((rGUI::Group*)widgets[poz_ext_group])->Add_Widgets(widgets, poz_ext_scba, widgets.size()-1);
((rGUI::Group*)widgets[poz_ext_group])->Set_all_Inputing(false);
((rGUI::Group*)widgets[poz_ext_group])->Set_all_Printing(false);
ALLEGRO_TRANSFORM trans;
al_identity_transform(&trans);
al_scale_transform(&trans, _sx, _sy);
al_translate_transform(&trans, _offx, _offy);
//al_use_transform(&trans);
int progresval = 0, progressadd = 1;
ALLEGRO_COLOR backgroundcollor = al_map_rgb(255,255,255);
float scale = 1.0f;
while(1)
{
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
rGUI::GetStatesAdnEvents(ev);
if(ev.type == ALLEGRO_EVENT_TIMER)
{
progresval++;
redraw = true;
if(progresval >= 3)
{
progresval = 0;
((rGUI::ProgressBar*)widgets[progressbar])->Set_value(
((rGUI::ProgressBar*)widgets[progressbar])->Get_value() + progressadd);
}
}
else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
{
break;
}
else if(ev.type == ALLEGRO_EVENT_MOUSE_AXES ||
ev.type == ALLEGRO_EVENT_MOUSE_ENTER_DISPLAY)
{
bouncer_x = ev.mouse.x;
bouncer_y = ev.mouse.y;
}
for(int a = 0;a < (int)widgets.size();a++)
{
widgets[a]->Input();
}
if(widgets[poz_ext]->wd_md->md_clicked == true)
{
widgets[poz_ext]->wd_md->md_clicked = false;
((rGUI::Group*)widgets[poz_group])->Set_all_Inputing(false);
((rGUI::Group*)widgets[poz_group])->Set_all_Printing(false);
((rGUI::Group*)widgets[poz_ext_group])->Set_all_Inputing(true);
((rGUI::Group*)widgets[poz_ext_group])->Set_all_Printing(true);
}
if(widgets[poz_ext_scba]->widgets[0]->wd_md->md_clicked == true)
{
break;
}
else if(widgets[poz_ext_scba]->widgets[1]->wd_md->md_clicked == true)
{
widgets[poz_ext_scba]->widgets[1]->wd_md->md_clicked = false;
((rGUI::Group*)widgets[poz_group])->Set_all_Inputing(true);
((rGUI::Group*)widgets[poz_group])->Set_all_Printing(true);
((rGUI::Group*)widgets[poz_ext_group])->Set_all_Inputing(false);
((rGUI::Group*)widgets[poz_ext_group])->Set_all_Printing(false);
}
if(widgets[poz_updatebutton]->wd_md->md_clicked == true || widgets[poz_rb]->wd_md->md_clicked == true)
{
widgets[poz_updatebutton]->wd_md->md_clicked = false;
tmh.thickness = ((rGUI::SlideBar*)widgets[poz_thickness])->value;
tmh.added_thickness = ((rGUI::SlideBar*)widgets[poz_addedthickness])->value;
tmh.roundx = tmh.roundy = ((rGUI::SlideBar*)widgets[poz_roundXY])->value;
if(widgets[poz_rb]->wd_md->md_clicked == true)
{
widgets[poz_rb]->wd_md->md_clicked = false;
thmreset();
}
for(int a = 0;a < (int)widgets.size();a++)
{
widgets[a]->Update_theme(&tmh);
}
widgets[poz_colscba]->widgets[poz_colsba_cols]->wd_theme.c_background =
al_premul_rgba(((rGUI::SlideBar*)widgets[poz_colscba]->widgets[poz_colsba_R])->Get_value(),
((rGUI::SlideBar*)widgets[poz_colscba]->widgets[poz_colsba_G])->Get_value(),
((rGUI::SlideBar*)widgets[poz_colscba]->widgets[poz_colsba_B])->Get_value(),
((rGUI::SlideBar*)widgets[poz_colscba]->widgets[poz_colsba_A])->Get_value());
}
else if(widgets[poz_colscba]->widgets[poz_colsba_R]->wd_md->md_mouse_on_it == true ||
widgets[poz_colscba]->widgets[poz_colsba_G]->wd_md->md_mouse_on_it == true ||
widgets[poz_colscba]->widgets[poz_colsba_B]->wd_md->md_mouse_on_it == true ||
widgets[poz_colscba]->widgets[poz_colsba_A]->wd_md->md_mouse_on_it == true)
{
widgets[poz_colscba]->widgets[poz_colsba_cols]->wd_theme.c_background =
al_premul_rgba(((rGUI::SlideBar*)widgets[poz_colscba]->widgets[poz_colsba_R])->Get_value(),
((rGUI::SlideBar*)widgets[poz_colscba]->widgets[poz_colsba_G])->Get_value(),
((rGUI::SlideBar*)widgets[poz_colscba]->widgets[poz_colsba_B])->Get_value(),
((rGUI::SlideBar*)widgets[poz_colscba]->widgets[poz_colsba_A])->Get_value());
}
else if(widgets[poz_colscba]->widgets[poz_colsba_c_T]->wd_md->md_clicked == true)
{
tmh.c_text = widgets[poz_colscba]->widgets[poz_colsba_cols]->wd_theme.c_background;
widgets[poz_colscba]->widgets[poz_colsba_c_T]->wd_md->md_clicked = false;
}
else if(widgets[poz_colscba]->widgets[poz_colsba_c_O]->wd_md->md_clicked == true)
{
tmh.c_outline = widgets[poz_colscba]->widgets[poz_colsba_cols]->wd_theme.c_background;
widgets[poz_colscba]->widgets[poz_colsba_c_O]->wd_md->md_clicked = false;
}
else if(widgets[poz_colscba]->widgets[poz_colsba_c_B]->wd_md->md_clicked == true)
{
tmh.c_background = widgets[poz_colscba]->widgets[poz_colsba_cols]->wd_theme.c_background;
widgets[poz_colscba]->widgets[poz_colsba_c_B]->wd_md->md_clicked = false;
}
else if(widgets[poz_colscba]->widgets[poz_colsba_c_C]->wd_md->md_clicked == true)
{
tmh.c_clicking = widgets[poz_colscba]->widgets[poz_colsba_cols]->wd_theme.c_background;
widgets[poz_colscba]->widgets[poz_colsba_c_C]->wd_md->md_clicked = false;
}
if(((rGUI::DropBox*)widgets[poz_backgroundDB])->changed)
{
if(((rGUI::DropBox*)widgets[poz_backgroundDB])->db_item != nullptr && ((rGUI::DropBox*)widgets[poz_backgroundDB])->db_item->data != nullptr)
{
((rGUI::DropBox*)widgets[poz_backgroundDB])->changed = false;
rGUI::DropBox *tmpdb = ((rGUI::DropBox*)widgets[poz_backgroundDB]);
backgroundcollor.r = ((ALLEGRO_COLOR*)(tmpdb->db_item->data))->r;
backgroundcollor.g = ((ALLEGRO_COLOR*)(tmpdb->db_item->data))->g;
backgroundcollor.b = ((ALLEGRO_COLOR*)(tmpdb->db_item->data))->b;
backgroundcollor.a = ((ALLEGRO_COLOR*)(tmpdb->db_item->data))->a;
}
else
{
backgroundcollor = al_map_rgb(255,255,255);
}
}
if(((rGUI::DropBox*)(widgets[scbapoz]->widgets[poz_scba_DP]))->db_item != nullptr &&
((rGUI::DropBox*)(widgets[scbapoz]->widgets[poz_scba_DP]))->db_item->data != nullptr &&
((rGUI::DropBox*)(widgets[scbapoz]->widgets[poz_scba_DP]))->changed)
{
((rGUI::DropBox*)(widgets[scbapoz]->widgets[poz_scba_DP]))->changed = false;
rGUI::DropBox *tmpdb = ((rGUI::DropBox*)(widgets[scbapoz]->widgets[poz_scba_DP]));
widgets[scbapoz]->wd_theme.c_background.r = ((ALLEGRO_COLOR*)(tmpdb->db_item->data))->r;
widgets[scbapoz]->wd_theme.c_background.g = ((ALLEGRO_COLOR*)(tmpdb->db_item->data))->g;
widgets[scbapoz]->wd_theme.c_background.b = ((ALLEGRO_COLOR*)(tmpdb->db_item->data))->b;
widgets[scbapoz]->wd_theme.c_background.a = ((ALLEGRO_COLOR*)(tmpdb->db_item->data))->a;
}
if(redraw && al_is_event_queue_empty(event_queue))
{
redraw = false;
al_clear_to_color(backgroundcollor);
al_draw_bitmap(bouncer, bouncer_x, bouncer_y, 0);
for(int a = 0;a < (int)widgets.size();a++)
{
widgets[a]->Print();
}
widgets[poz_dbm]->Print();
al_flip_display();
}
}
for(int a = 0;a < (int)widgets.size();a++)
{
delete widgets[a];
}
widgets.clear();
for(int a = 0;a < (int)colvect.size();a++)
{
delete colvect[a];
}
colvect.clear();
rGUI::End();
al_destroy_bitmap(bouncer);
al_destroy_timer(timer);
al_destroy_display(display);
al_destroy_event_queue(event_queue);
al_destroy_font(fnt);
al_destroy_font(font);
return 0;
}
int MonopolyGame::run() {
// Start the timer's so that revisions are properly drawn.
al_start_timer( m_alTimer );
al_start_timer( m_alFrameTimer );
// Perform the first display update.
al_flip_display();
// Zero the FPS counters.
m_oldFps = 0.0;
m_currFps = 0.0;
m_framesDone = 0.0;
al_flush_event_queue( m_alEventQueue );
// Run until the exit flag is thrown.
while( !m_exitGame )
{
ALLEGRO_EVENT alEvent;
al_wait_for_event( m_alEventQueue, &alEvent );
al_get_keyboard_state( &m_alKeyState );
// If the user clicks the window's 'close (X)' button.
if( alEvent.type == ALLEGRO_EVENT_DISPLAY_CLOSE )
{
// Exit the game.
m_exitGame = true;
}
// Or if the user hits the 'ESC' key.
else if( al_key_down( &m_alKeyState, ALLEGRO_KEY_ESCAPE ) )
{
// Exit the game.
m_exitGame = true;
}
// Process any timed events that have been triggered.
else if( alEvent.type == ALLEGRO_EVENT_TIMER )
{
if( alEvent.timer.source == m_alTimer )
{
// This is the hook into the turn logic.
handleTurn();
// We will update the camera position only if the timer has been triggered.
cameraUpdate( m_alCamera.cameraPosition, // X and Y location of the camera.
m_playerList[m_playersTurn].get_x(), // Player's x position.
m_playerList[m_playersTurn].get_y(), // Player's y position.
32, 32 ); // Width and height of player's image.
}
else if( alEvent.timer.source == m_alFrameTimer )
{
for( int pCounter = 0; pCounter < NUM_PLAYERS; pCounter++ ) {
// If this player has more than '0' money.
if( m_playerList[pCounter].get_money() > 0 ) {
// For each player, update the image we will display this frame.
m_playerList[pCounter].animationLogic();
}
}
}
// Do some camera transform magic.
al_identity_transform( &m_alCamera.alCameraTransform );
// Adjust the camera so that it is centered over our player's position.
al_translate_transform( &m_alCamera.alCameraTransform,
-m_alCamera.cameraPosition[Positions::X_POS],
-m_alCamera.cameraPosition[Positions::Y_POS] );
// Push the camera's changes.
al_use_transform( &m_alCamera.alCameraTransform );
// Since the screen has been updated, we want to flag the screen to be redrawn.
m_redrawScreen = true;
}
//if( m_redrawScreen ) {
if( m_redrawScreen && al_is_event_queue_empty( m_alEventQueue ) ) {
m_redrawScreen = false;
m_framesDone++;
draw();
}
calcFramerate();
}
return 0;
}
void CCamera::update() {
al_identity_transform(&coord);
al_translate_transform(&coord, -x + startX, -y + startY);
al_use_transform(&coord);
}
void CCamera::reset() {
ALLEGRO_TRANSFORM current = coord;
al_translate_transform(¤t, x - startX, y - startY);
al_use_transform(¤t);
}
