void init(){
allegro_init();
set_color_depth(32);
set_alpha_blender();
set_gfx_mode(GFX_AUTODETECT_WINDOWED,SCREEN_LENG_X,SCREEN_LENG_Y,0,0);
install_keyboard();
install_mouse();
BUFFER=create_bitmap(SCREEN_LENG_X,SCREEN_LENG_Y);
PLAYER_SPRITE_ALIVE=load_tga("img/Player.tga",NULL);
PLAYER_SPRITE_DEAD=load_tga("img/Explosion.tga",NULL);
BLOCK_SPRITE=load_tga("img/Block.tga",NULL);
GREEN_SPIKE_SPRITE=load_tga("img/Green_Spike.tga",NULL);
RED_SPIKE_SPRITE=load_tga("img/Red_Spike.tga",NULL);
GATE_SPRITE=load_tga("img/Gate.tga",NULL);
KEY_SPRITE=load_tga("img/Key.tga",NULL);
CHECK_POINT_SPRITE_VACANT=load_tga("img/Check_Point_Vacant.tga",NULL);
CHECK_POINT_SPRITE_OCCUPIED=load_tga("img/Check_Point_Occupied.tga",NULL);
EXIT_SPRITE=load_tga("img/Exit.tga",NULL);
CURSOR_SPRITE=load_tga("img/Cursor.tga",NULL);
blue=new Color(0,0,255);
red=new Color(255,0,0);
green=new Color(0,255,0);
yellow=new Color(255,255,0);
orange=new Color(255,100,0);
purple=new Color(155,0,155);
black=new Color(0,0,0);
white=new Color(255,255,255);
m_pressed=false;
m_released=false;
}
void renderDMXArrow(int player, int column, int color, int judgement, int x, int y)
{
if ( (judgement >= MARVELLOUS && judgement <= GREAT) || judgement == IGNORED )
{
return; // these arrows disappear once they reach the top or are hit
}
if ( judgement == GOOD && (gs.player[player].danceManiaxMode || gs.player[player].drummaniaMode) )
{
return; // in these modes, goods also count as hit
}
// calculate the length of a quarter beat, then set frame to a number 0-7
int frame = getValueFromRange(0, 7, (gs.player[player].stepZoneBeatTimer*100 / gs.player[player].stepZoneTimePerBeat));
if ( gs.player[player].stepZoneBlinkTimer > 0 )
{
frame += 8;
}
int colColor = getColorOfColumn(column);
if ( color == 2 )
{
colColor = 2; // make it gold, otherwise ignore this parameter
}
masked_blit(m_notesDMX[colColor], rm.m_backbuf, 0, frame*40, x, y, 40, 40);
set_alpha_blender(); // the game assumes the graphics are left in this mode
}
// desenha o fundo
// TODO: fazer esta funcao de verdade
void desenha_fundo( TipoCenario *cenario, BITMAP *fundo, BITMAP *fundo2 ) {
set_alpha_blender();
//--cenario obsoleto-----------------------------------------------
clear_to_color(fundo2, makecol(70,255,255));
draw_trans_sprite(fundo2, cenario->nuvem, HRES-350-cenario->posicao, VRES-430);
clear_to_color(fundo, makecol(255,0,255));
draw_trans_sprite(fundo, cenario->coco, HRES-200-cenario->posicao, VRES-370);
draw_trans_sprite(fundo, cenario->sol, 40-cenario->posicao, 20);
//-----------------------------------------------------------------
}
void Tabs::drawTab(BITMAP* bmp, JRect box, Tab* tab, int y_delta, bool selected)
{
// Is the tab outside the bounds of the widget?
if (box->x1 >= this->rc->x2 || box->x2 <= this->rc->x1)
return;
SkinTheme* theme = static_cast<SkinTheme*>(this->getTheme());
int text_color;
int face_color;
// Selected
if (selected) {
text_color = theme->get_tab_selected_text_color();
face_color = theme->get_tab_selected_face_color();
}
// Non-selected
else {
text_color = theme->get_tab_normal_text_color();
face_color = theme->get_tab_normal_face_color();
}
if (jrect_w(box) > 2) {
theme->draw_bounds_nw(bmp,
box->x1, box->y1+y_delta, box->x2-1, box->y2-1,
(selected) ? PART_TAB_SELECTED_NW:
PART_TAB_NORMAL_NW, face_color);
jdraw_text(bmp, this->getFont(), tab->text.c_str(),
box->x1+4*jguiscale(),
(box->y1+box->y2)/2-text_height(this->getFont())/2+1 + y_delta,
text_color, face_color, false, jguiscale());
}
if (selected) {
theme->draw_bounds_nw(bmp,
box->x1, box->y2, box->x2-1, this->rc->y2-1,
PART_TAB_BOTTOM_SELECTED_NW,
theme->get_tab_selected_face_color());
}
else {
theme->draw_part_as_hline(bmp,
box->x1, box->y2, box->x2-1, this->rc->y2-1,
PART_TAB_BOTTOM_NORMAL);
}
#ifdef CLOSE_BUTTON_IN_EACH_TAB
BITMAP* close_icon = theme->get_part(PART_WINDOW_CLOSE_BUTTON_NORMAL);
set_alpha_blender();
draw_trans_sprite(doublebuffer, close_icon,
box->x2-4*jguiscale()-close_icon->w,
(box->y1+box->y2)/2-close_icon->h/2+1*jguiscale());
#endif
}
void Alleg4Surface::drawRgbaSurface(const Surface* src, int srcx, int srcy, int dstx, int dsty, int w, int h)
{
if (w < 1 || h < 1)
return;
set_alpha_blender();
BITMAP* tmp = create_sub_bitmap(
static_cast<const Alleg4Surface*>(src)->m_bmp,
srcx, srcy, w, h);
draw_trans_sprite(m_bmp, tmp, dstx, dsty);
destroy_bitmap(tmp);
}
void Game::init(){
// Clears enemies
badGuy.clear();
// Create map
tile_map -> reload( true);
// Variables
character.setDead(false);
// Load enemies
for(int i = 0; i < tile_map -> mapTiles.size(); i++){
if(tile_map -> mapTiles.at(i).getType() == tile_spawn_mutant){
enemy *newBadGuy = new enemy( tile_map -> mapTiles.at(i).getX(), tile_map -> mapTiles.at(i).getY(), enemy_mutant);
newBadGuy -> load_images();
newBadGuy -> load_sounds();
badGuy.push_back(newBadGuy);
tile_map -> mapTiles.at(i).setType(0);
}
}
//Create duplicate map with only solids for updating enemies
newTileMap = new tileMap("blank");
for(int i = 0; i < tile_map -> mapTiles.size(); i++){
if(tile_map -> mapTiles.at(i).getAttribute() != gas){
newTileMap -> mapTiles.push_back(tile_map -> mapTiles.at(i));
}
}
// Spawn character
character.spawncommand(tile_map);
/*draw( false);
highcolor_fade_in( buffer,16);*/
set_alpha_blender();
}
void c_node::draw_allegro (c_drawtarget &drawtarget, c_layer &layer_any) {
auto layer = dynamic_cast<c_layer_allegro&>(layer_any);
BITMAP *frame = layer.m_frame;
const auto & gui = * drawtarget.m_gui;
const int vx = gui.view_x(m_x), vy = gui.view_y(m_y); // position in viewport - because camera position
c_osi2_switch::draw_allegro (drawtarget, layer_any);
auto color = makecol(0,0,64); // TODO is this ok?
_UNUSED(color);
////////////////////////////////////////////////////////////////////
if (layer.m_layer_nr == e_layer_nr_object) {
//BITMAP *fg1;
//const char *file1;
//file1 = "dat/server_48x48.png";
//set_color_conversion(COLORCONV_NONE);
//fg1 = load_png(file1, NULL); // TODO: optmize/cache and share across objects
set_alpha_blender();
draw_trans_sprite(frame, c_bitmaps::get_instance().m_node,
vx - c_bitmaps::get_instance().m_node->w / 2, vy - c_bitmaps::get_instance().m_node->h / 2);
}
////////////////////////////////////////////////////////////////////
}
void renderStepLaneDMX(int x, int bgColor, int outlineColor)
{
line(rm.m_backbuf, x, 40, x, 434, outlineColor);
line(rm.m_backbuf, x+1, 40, x+1, 434, outlineColor);
line(rm.m_backbuf, x+32, 40, x+32, 434, outlineColor);
line(rm.m_backbuf, x+33, 40, x+33, 434, outlineColor);
if ( rm.useAlphaLanes )
{
// if this worked without killing the fps, that would be nice
//*
drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
rectfill(rm.m_backbuf, x+2, 26, x+31, 444, bgColor);
drawing_mode(DRAW_MODE_SOLID, NULL, 0, 0);
set_alpha_blender(); // the game assumes the graphics are left in this mode
//*/
// this was actually pretty good (the asset was a solid black rectangle)
/*
set_trans_blender(0,0,0,128);
draw_trans_sprite(rm.m_backbuf, m_dmxTransLane, x+2, 26);
set_alpha_blender(); // the game assumes the graphics are left in this mode
//*/
// try this instead?
/*
int quad[8] = { x+2,26, x+2,444, x+31,444, x+31,26 };
drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
polygon(rm.m_backbuf, 4, quad, bgColor);
set_alpha_blender(); // the game assumes the graphics are left in this mode
//*/
}
else
{
rectfill(rm.m_backbuf, x+2, 26, x+31, 444, bgColor);
}
}
void renderDMXFlaresAndFlashes(int player)
{
int numColumns = gs.isDoubles || gs.isVersus ? 8 : 8;
for ( int i = 0; i < numColumns; i++ )
{
int frame = 15 - ((gs.player[player].laneFlareTimers[i] / (HIT_FLASH_DISPLAY_TIME / 16)) % 16);
int x = getColumnOffsetX_DMX(i);
if ( gs.player[player].laneFlareTimers[i] > 0 )
{
int bigSmall = gs.player[player].displayCombo >= 100 ? 1 : 0;
int color = (gs.player[player].displayCombo/100) % 5;
// for a 'marvelous' render a flashing firework
if ( gs.player[player].laneFlareColors[i] == 0 || gs.player[player].laneFlareColors[i] == 3 )
{
//color = ((gs.player[player].laneFlareTimers[i] / 20) % 3) + 2;
}
// render an offcolor firework explosion for an O.K.!
if ( gs.player[player].laneFlareColors[i] == 4 )
{
bigSmall = 1;
color = (color+1) % 5; // frame % 5;
}
// while holding a hold note, do something entirely different than a firework
if ( gs.player[player].laneFlareColors[i] != 2 )
{
set_add_blender(0,0,0,256);
draw_trans_sprite(rm.m_backbuf, m_dmxFireworks[bigSmall][color][frame], x-46, (gs.player[player].isColumnReversed(i) ? DMX_STEP_ZONE_REV_Y-34 : DMX_STEP_ZONE_Y)-46);
set_alpha_blender(); // the game assumes the graphics are left in this mode
}
}
}
}
int abreAllegro(void)
{
int retorno = 1;
allegro_init();
install_keyboard();
install_mouse();
install_timer();
srand((unsigned)time(NULL));
set_color_depth(COLOR_BITS);
if (set_gfx_mode(VIDEO_CARD, MAX_X, MAX_Y, V_MAX_X, V_MAX_Y) < 0)
{
if (set_gfx_mode(GFX_AUTODETECT, MAX_X, MAX_Y, V_MAX_X, V_MAX_Y) < 0)
{
allegro_message("Erro ao inicializar o modo grafico");
retorno = 0;
}
}
if (COLOR_BITS == 32) set_alpha_blender(); // instala o canal alpha (funciona apenas em 32 bits)
if (install_sound(DIGI_CARD, MIDI_CARD, NULL) < 0)
{
if (install_sound(DIGI_AUTODETECT, MIDI_AUTODETECT, NULL) < 0)
{
allegro_message("Erro ao inicializar o som");
retorno = 0;
}
}
return retorno;
}
void Graphics::drawAlphaBitmap(BITMAP* sprite, int x, int y)
{
set_alpha_blender();
draw_trans_sprite(m_bmp, sprite, m_dx+x, m_dy+y);
}
int main() {
const int spd = 16;
for (int x=0;x<41;++x) {
angles_y[x] = (spd*cos(PI/180*(x-20+90)));
angles_x[x] = (spd*sin(PI/180*(x-20+90)));
}
allegro_init();
install_keyboard();
install_timer();
LOCK_VARIABLE(speed_counter);
LOCK_FUNCTION(increment_speed_counter);
install_int_ex(increment_speed_counter, BPS_TO_TIMER(60));
const int width = 1024;
const int height = 768;
set_color_depth(32);
set_gfx_mode(GFX_AUTODETECT_WINDOWED, width, height, 0, 0);
set_alpha_blender();
BITMAP* buffer = create_bitmap(width, height);
//BITMAP* image3 = load_bitmap("./sprites/chopper3.tga", 0);
BITMAP* image2 = load_bitmap("./sprites/chopper.tga", 0);
BITMAP* image = load_bitmap("./sprites/chopper2.tga", 0);
BITMAP* background = load_bitmap("./sprites/background.bmp", 0);
BITMAP* image_sphere = load_bitmap("./sprites/sphere1.tga", 0);
BITMAP* image_sphere2 = load_bitmap("./sprites/sphere2.tga", 0);
BITMAP* image_shot = load_bitmap("./sprites/shot.tga", 0);
BITMAP* image_explosion[17];
image_explosion[0] = load_bitmap("./sprites/exp_frame_0.tga", 0);
image_explosion[1] = load_bitmap("./sprites/exp_frame_1.tga", 0);
image_explosion[2] = load_bitmap("./sprites/exp_frame_2.tga", 0);
image_explosion[3] = load_bitmap("./sprites/exp_frame_3.tga", 0);
image_explosion[4] = load_bitmap("./sprites/exp_frame_4.tga", 0);
image_explosion[5] = load_bitmap("./sprites/exp_frame_5.tga", 0);
image_explosion[6] = load_bitmap("./sprites/exp_frame_6.tga", 0);
image_explosion[7] = load_bitmap("./sprites/exp_frame_7.tga", 0);
image_explosion[8] = load_bitmap("./sprites/exp_frame_8.tga", 0);
image_explosion[9] = load_bitmap("./sprites/exp_frame_9.tga", 0);
image_explosion[10] = load_bitmap("./sprites/exp_frame_10.tga", 0);
image_explosion[11] = load_bitmap("./sprites/exp_frame_11.tga", 0);
image_explosion[12] = load_bitmap("./sprites/exp_frame_12.tga", 0);
image_explosion[13] = load_bitmap("./sprites/exp_frame_13.tga", 0);
image_explosion[14] = load_bitmap("./sprites/exp_frame_14.tga", 0);
image_explosion[15] = load_bitmap("./sprites/exp_frame_15.tga", 0);
image_explosion[16] = load_bitmap("./sprites/exp_frame_16.tga", 0);
std::vector<helicopter> heli;
heli.push_back(helicopter(image_explosion, 17,image->w, image->h, 40, 40, 0, 0, 0, gravity / 2, 0.8, 0.5));
heli.push_back(helicopter(image_explosion, 17,image2->w, image2->h, 720, 40, 0, 0, 0, gravity / 2, 0.8, 0.5));
//heli.push_back(helicopter(image_explosion, 17,image3->w, image3->h, 350, 200, 0, 100, 0, gravity / 2, 0.8, 0.5));
heli[0].flip = !heli[0].flip;
srand(time(NULL));
std::vector<ball> spheres;
for (int x=0;x<10;++x)
spheres.push_back(
ball(
image_sphere->w,
image_sphere->h,
(double)((int)rand()%(SCREEN_W-image_sphere->w)),
(double)((int)rand()%(SCREEN_H-image_sphere->h)),
(double)((int)rand()%60),
(double)((int)rand()%60),
0.0,
gravity * 2,
0.95,
0.95));
std::vector<explosion> explosions;
while (!key[KEY_ESC]) {
while (speed_counter > 0) {
heli[1].get_input(key[KEY_UP], key[KEY_DOWN], key[KEY_LEFT], key[KEY_RIGHT], true);
heli[0].get_input(key[KEY_W], key[KEY_S], key[KEY_A], key[KEY_D], true);
//heli[2].get_input(key[KEY_Y], key[KEY_H], key[KEY_G], key[KEY_J], true);
for (unsigned int x=0;x<heli.size();++x) {
if (!(heli[x].health>0))explosions.push_back(explosion(image_explosion, 17, (int)heli[x].pos_x, (int)heli[x].pos_y, rand()%(heli[x].size_x*2), rand()%(heli[x].size_y*2)));
heli[x].update_phys();
}
for (unsigned int x=0;x<spheres.size();++x) {
spheres[x].update_phys();
}
for (unsigned int x=0;x<explosions.size();++x)
if (explosions[x].alive)
explosions[x].update_frame();
else
explosions.erase(explosions.begin()+x);
for (unsigned int x=0;x<heli.size();++x)
for (unsigned int y=0;y<spheres.size();++y)
if (check_collision(spheres[y], heli[x])) {
heli[x].explode((heli[x].pos_x - spheres[y].pos_x)+heli[x].speed_x, (heli[x].pos_y - spheres[y].pos_y)+heli[x].speed_y, 1);
spheres[y].explode((spheres[y].pos_x - heli[x].pos_x)+spheres[y].speed_x, (spheres[y].pos_y - heli[x].pos_y)+spheres[y].speed_y);
if (heli[x].health>0) explosions.push_back(explosion(image_explosion, 17, (int)heli[x].pos_x, (int)heli[x].pos_y, heli[x].size_x, heli[x].size_y));
explosions.push_back(explosion(image_explosion, 17, (int)spheres[y].pos_x, (int)spheres[y].pos_y));
}
for (unsigned int x=0;x<spheres.size();++x)
for (unsigned int y=x+1;y<spheres.size();++y)
if (check_collision(spheres[x], spheres[y])) {
spheres[x].explode((spheres[x].pos_x - spheres[y].pos_x)+spheres[x].speed_x, (spheres[x].pos_y - spheres[y].pos_y)+spheres[x].speed_y);
spheres[y].explode((spheres[y].pos_x - spheres[x].pos_x)+spheres[y].speed_x, (spheres[y].pos_y - spheres[x].pos_y)+spheres[y].speed_y);
explosions.push_back(explosion(image_explosion, 17, (int)spheres[x].pos_x, (int)spheres[x].pos_y));
explosions.push_back(explosion(image_explosion, 17, (int)spheres[y].pos_x, (int)spheres[y].pos_y));
}
if (check_collision(heli[0], heli[1])) {
heli[0].explode((heli[0].pos_x - heli[1].pos_x)+heli[0].speed_x, (heli[0].pos_y - heli[1].pos_y)+heli[0].speed_y, 5);
heli[1].explode((heli[1].pos_x - heli[0].pos_x)+heli[1].speed_x, (heli[1].pos_y - heli[0].pos_y)+heli[1].speed_y, 5);
if (heli[0].health>0) explosions.push_back(explosion(image_explosion, 17, (int)heli[0].pos_x, (int)heli[0].pos_y, heli[0].size_x, heli[0].size_y));
if (heli[1].health>0) explosions.push_back(explosion(image_explosion, 17, (int)heli[1].pos_x, (int)heli[1].pos_y, heli[1].size_x, heli[1].size_y));
}
for (unsigned int x=0;x<heli.size();++x) {
for (unsigned int y=0;y<heli[x].shots.size();++y) {
for (unsigned int z=0;z<heli.size();++z)
if (z!=x)
if (check_collision(heli[x].shots[y], heli[z])) {
heli[z].explode((heli[z].pos_x - heli[x].shots[y].pos_x)+heli[z].speed_x, (heli[z].pos_y - heli[x].shots[y].pos_y)+heli[z].speed_y,10);
if (heli[z].health>0) explosions.push_back(explosion(image_explosion, 17, (int)heli[z].pos_x, (int)heli[z].pos_y));
}
for (unsigned int z=0;z<spheres.size();++z)
if (check_collision(heli[x].shots[y], spheres[z])) {
spheres[z].explode((spheres[z].pos_x - heli[x].shots[y].pos_x)+spheres[z].speed_x, (spheres[z].pos_y - heli[x].shots[y].pos_y)+spheres[z].speed_y);
explosions.push_back(explosion(image_explosion, 17, (int)spheres[z].pos_x, (int)spheres[z].pos_y));
if (z==0) {
spheres.erase(spheres.begin());
spheres.push_back(ball(image_sphere->w,image_sphere->h,(double)((int)rand()%(SCREEN_W-image_sphere->w)),(double)((int)rand()%(SCREEN_H-image_sphere->h)),(double)((int)rand()%60),(double)((int)rand()%60),0.0,gravity * 2,0.95,0.95));
heli[x].health += 50;
}
}
}
for (unsigned int y=x+1;y<heli.size();++y)
if (check_collision(heli[x], heli[y])) {
heli[x].explode((heli[x].pos_x - heli[y].pos_x)+heli[x].speed_x, (heli[x].pos_y - heli[y].pos_y)+heli[x].speed_y,10);
if (heli[x].health>0) explosions.push_back(explosion(image_explosion, 17, (int)heli[x].pos_x, (int)heli[x].pos_y));
heli[y].explode((heli[y].pos_x - heli[x].pos_x)+heli[y].speed_x, (heli[y].pos_y - heli[x].pos_y)+heli[y].speed_y,10);
if (heli[y].health>0) explosions.push_back(explosion(image_explosion, 17, (int)heli[y].pos_x, (int)heli[y].pos_y));
}
}
speed_counter--;
}
blit(background, buffer, 0, 0, 0, 0, width, height);
for (unsigned int x=0;x<spheres.size();++x) {
if (x==0)
spheres[x].draw(buffer, image_sphere2);
else
spheres[x].draw(buffer, image_sphere);
}
heli[0].draw(buffer, image, image_shot);
heli[1].draw(buffer, image2, image_shot);
//heli[2].draw(buffer, image3, image_shot);
draw_health(buffer, 10, 10, heli[0].health);
draw_health(buffer, SCREEN_W-110, 10, heli[1].health);
//draw_health(buffer, SCREEN_W/2, 10, heli[2].health);
for (unsigned int x=0;x<explosions.size();++x)
explosions[x].draw(buffer);
blit(buffer, screen, 0, 0, 0, 0, width, height);
clear_bitmap(buffer);
}
destroy_bitmap(buffer);
return 0;
}
void ALSoftwareGraphicsDriver::RenderToBackBuffer()
{
for (int i = 0; i < numToDraw; i++)
{
if (drawlist[i] == NULL)
{
if (_nullSpriteCallback)
_nullSpriteCallback(drawx[i], drawy[i]);
else
throw Ali3DException("Unhandled attempt to draw null sprite");
continue;
}
ALSoftwareBitmap* bitmap = drawlist[i];
int drawAtX = drawx[i];// + x;
int drawAtY = drawy[i];// + y;
if ((bitmap->_opaque) && (bitmap->_bmp == virtualScreen))
{ }
else if (bitmap->_opaque)
{
blit(bitmap->_bmp, virtualScreen, 0, 0, drawAtX, drawAtY, bitmap->_bmp->w, bitmap->_bmp->h);
}
else if (bitmap->_transparency >= 255)
{
// fully transparent... invisible, do nothing
}
else if (bitmap->_hasAlpha)
{
if (bitmap->_transparency == 0)
set_alpha_blender();
else
set_blender_mode(NULL, NULL, _trans_alpha_blender32, 0, 0, 0, bitmap->_transparency);
draw_trans_sprite(virtualScreen, bitmap->_bmp, drawAtX, drawAtY);
}
else
{
draw_sprite_with_transparency(bitmap->_bmp, drawAtX, drawAtY, bitmap->_transparency);
}
}
if (((_tint_red > 0) || (_tint_green > 0) || (_tint_blue > 0))
&& (_colorDepth > 8)) {
// screen tint
// This slows down the game no end, only experimental ATM
set_trans_blender(_tint_red, _tint_green, _tint_blue, 0);
draw_lit_sprite(virtualScreen, virtualScreen, 0, 0, 128);
/* This alternate method gives the correct (D3D-style) result, but is just too slow!
if ((_spareTintingScreen != NULL) &&
((_spareTintingScreen->w != virtualScreen->w) || (_spareTintingScreen->h != virtualScreen->h)))
{
destroy_bitmap(_spareTintingScreen);
_spareTintingScreen = NULL;
}
if (_spareTintingScreen == NULL)
{
_spareTintingScreen = create_bitmap_ex(bitmap_color_depth(virtualScreen), virtualScreen->w, virtualScreen->h);
}
tint_image(virtualScreen, _spareTintingScreen, _tint_red, _tint_green, _tint_blue, 100, 255);
blit(_spareTintingScreen, virtualScreen, 0, 0, 0, 0, _spareTintingScreen->w, _spareTintingScreen->h);*/
}
ClearDrawList();
}
int main(int argc, char *argv[])
{
BITMAP *fg;
int depth = 16;
const char *file;
allegro_init();
install_keyboard();
switch (argc) {
case 1:
file = "alpha.png";
break;
case 2:
file = argv[1];
break;
default:
file = argv[1];
depth = atoi(argv[2]);
break;
}
if (depth == 8) {
allegro_message("Truecolour modes only.\n");
return 1;
}
set_color_depth(depth);
if ((set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0) < 0) &&
(set_gfx_mode(GFX_AUTODETECT, 640, 480, 0, 0) < 0)) {
allegro_message("Unable to set video mode (640x480x%d).\n", depth);
return 1;
}
/* We can't lose the alpha channel when we load the image. */
set_color_conversion(COLORCONV_NONE);
fg = load_png(file, NULL);
if (!fg) {
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Unable to load alpha.png\n");
return 1;
}
acquire_screen();
toilet(screen);
/* Enable alpha transparency, then draw onto the screen. */
set_alpha_blender();
draw_trans_sprite(screen, fg, (SCREEN_W - fg->w) / 2, (SCREEN_H - fg->h) / 2);
release_screen();
/* Ooh, ahh. */
readkey();
destroy_bitmap(fg);
return 0;
}
// Draw loop
void draw(bool to_screen) {
// Allow transparency
set_alpha_blender();
// Menu
if(gameScreen == 1) {
//Draws grid
draw_sprite(buffer, grid, 0, 0);
//Draws tiles on board
for(int i = 0; i < 4; i++) {
for(int t = 0; t < 4; t++) {
if(gridarray[i][t] == 0)
draw_sprite(buffer, blank, (i)*100, (t)*100);
else if(gridarray[i][t] == 1)
draw_sprite(buffer, img_x, (i)*100, (t)*100);
else if(gridarray[i][t] == 2)
draw_sprite(buffer, img_o, (i)*100, (t)*100);
}
}
//Draws menu
draw_trans_sprite(buffer, main_menu, 0, 0);
//Draws Buttons
one_player.draw(buffer);
two_player.draw(buffer);
quit.draw(buffer);
sound.draw(buffer);
difficulty_b.draw(buffer);
}
// One player and 2 player
else if(gameScreen == 2 || gameScreen == 3) {
//Draws grid
draw_sprite (buffer, grid, 0, 0);
//Draws tiles on board
for (int i = 0; i < 4; i++) {
for (int t = 0; t < 4; t++) {
if (gridarray[i][t] == 0)
draw_sprite(buffer, blank, i * 100, t * 100);
else if (gridarray[i][t] == 1)
draw_sprite(buffer, img_x, i * 100, t * 100);
else if (gridarray[i][t] == 2)
draw_sprite(buffer, img_o, i * 100, t * 100);
}
}
//Draws selection tile
draw_sprite(buffer, selected[selector], x * 100, y * 100);
//Draws Menu Button
menu.draw(buffer);
}
//Draws mouse cursor
draw_sprite(buffer, cursor[(turn + 1) * (gameScreen != 1)], mouse_x, mouse_y);
//Draws buffer
if (to_screen)
draw_sprite(screen, buffer, 0, 0);
}
Menu::Menu(){
// Init fmod
FSOUND_Init (44100, 32, 0);
// Create buffer image
buffer = create_bitmap( SCREEN_W, SCREEN_H);
// Load images
if(!(menu = load_bitmap( ("images/gui/menu.png"), NULL)))
abort_on_error( "Cannot find image images/gui/menu.png \n Please check your files and try again");
if(!(menuselect = load_bitmap( ("images/gui/menuSelector.png"), NULL)))
abort_on_error( "Cannot find image images/gui/menuSelector.png \n Please check your files and try again");
if(!(help = load_bitmap( ("images/gui/help.png"), NULL)))
abort_on_error( "Cannot find image images/gui/help.png \n Please check your files and try again");
if(!(cursor[0] = load_bitmap( ("images/gui/cursor1.png"), NULL)))
abort_on_error( "Cannot find image images/gui/cursor1.png \n Please check your files and try again");
if(!(cursor[1] = load_bitmap( ("images/gui/cursor2.png"), NULL)))
abort_on_error( "Cannot find image images/gui/cursor2.png \n Please check your files and try again");
if(!(levelSelectLeft = load_bitmap( ("images/gui/levelSelectLeft.png"), NULL)))
abort_on_error( "Cannot find image images/gui/levelSelectLeft.png \n Please check your files and try again");
if(!(levelSelectRight = load_bitmap( ("images/gui/levelSelectRight.png"), NULL)))
abort_on_error( "Cannot find image images/gui/levelSelectRight.png \n Please check your files and try again");
if(!(levelSelectNumber = load_bitmap( ("images/gui/levelSelectNumber.png"), NULL)))
abort_on_error( "Cannot find image images/gui/levelSelectNumber.png \n Please check your files and try again");
if(!(copyright = load_bitmap( ("images/gui/copyright.png"), NULL)))
abort_on_error( "Cannot find image images/gui/copyright.png \n Please check your files and try again");
if(!(credits = load_bitmap( ("images/gui/credits.png"), NULL)))
abort_on_error( "Cannot find image images/gui/credits.png \n Please check your files and try again");
//Load sound effects
if(!(click = load_sample(("sounds/click.wav")))){
abort_on_error( "Cannot find sound sounds/click.png \n Please check your files and try again");
}
// Temporary fonts
FONT *f1, *f2, *f3, *f4, *f5;
//Sets Font
if(!(f1 = load_font(("fonts/arial_black.pcx"), NULL, NULL))){
abort_on_error( "Cannot find font fonts/arial_black.png \n Please check your files and try again");
}
f2 = extract_font_range(f1, ' ', 'A'-1);
f3 = extract_font_range(f1, 'A', 'Z');
f4 = extract_font_range(f1, 'Z'+1, 'z');
//Merge fonts
font = merge_fonts(f4, f5 = merge_fonts(f2, f3));
//Destroy temporary fonts
destroy_font(f1);
destroy_font(f2);
destroy_font(f3);
destroy_font(f4);
destroy_font(f5);
// Allow transparency
set_alpha_blender();
//Variables
newSelectorY = SCREEN_H - 323;
selectorY = SCREEN_H - 323;
selectorX = 60;
mouse_control = false;
selectorHovering = 0;
// Create map for live background
tile_map = new tileMap("data/levels/level_01");
// Set background scroll direction
scrollDirection = "right";
tile_map -> y = random( 0, (tile_map -> height * 64) - SCREEN_H);
tile_map -> x = 0;
levelOn = 0;
}
void RenderingManager::dimScreen(int percent)
{
drawing_mode(DRAW_MODE_TRANS, NULL, 0, 0);
rectfill(m_backbuf, 0, 0, 640, 480, makeacol(0, 0, 0, getValueFromRange(0, 255, percent)));
set_alpha_blender(); // the game assumes the graphics are left in this mode
}
void test_fire_alpha_allegro_rle(BITMAP *dst, int x, int y, int frame, int brightness)
{
set_alpha_blender();
draw_trans_rle_sprite(dst, fire_ex_rle_sprites[frame % SPRITE_COUNT], x, y);
}
void test_explosion_allegro_rle(BITMAP *dst, int x, int y, int frame, int brightness)
{
set_alpha_blender();
draw_trans_rle_sprite(dst, explosion_rle_sprites[frame % 10], x, y);
}
void Alleg4Surface::drawRgbaSurface(const Surface* src, int dstx, int dsty)
{
set_alpha_blender();
draw_trans_sprite(m_bmp, static_cast<const Alleg4Surface*>(src)->m_bmp, dstx, dsty);
}
int main(void)
{
BITMAP *dbuf;
BITMAP *b;
BITMAP *b2;
int mode = NORMAL;
float fangle = 0;
float fscale = 1;
float inc = 0.002;
int dir = -1;
if (allegro_init() != 0) {
return 1;
}
set_color_depth(32);
install_keyboard();
if (set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0) != 0) {
allegro_message("Could not set graphics mode\n");
return 1;
}
dbuf = create_bitmap(SCREEN_W, SCREEN_H);
if (!dbuf) {
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Could not create double buffer\n");
return 1;
}
/* Load the alpha bitmap. This is used for alpha and normal modes */
set_color_conversion(COLORCONV_KEEP_ALPHA);
b = load_bitmap("inkblot.tga", NULL);
if (!b) {
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Could not load inkblot.tga\n");
return 1;
}
/* Make a non-alpha copy for drawing lit */
b2 = create_bitmap(b->w, b->h);
if (!b2) {
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Error creating bitmap\n");
return 1;
}
clear_to_color(b2, makeacol(255, 255, 255, 255));
set_alpha_blender();
draw_trans_sprite(b2, b, 0, 0);
while (!key[KEY_ESC]) {
fixed angle = ftofix(fangle);
fixed scale = ftofix(fscale);
float x = (SCREEN_W-(b->w*fscale))/2;
float y = (SCREEN_H-(b->h*fscale))/2;
/* XXX flickers badly due to no buffering */
clear_to_color(dbuf, makecol(255, 255, 255));
textout_centre_ex(dbuf, font, "Press 'n' for next mode", SCREEN_W/2, SCREEN_H-30, makecol(0, 0, 0), -1);
switch (mode) {
case NORMAL:
rotate_scaled_sprite(dbuf, b, x, y, angle, scale);
textout_centre_ex(dbuf, font, "Normal", SCREEN_W/2, SCREEN_H-20, makecol(0, 0, 0), -1);
break;
case ALPHA:
set_alpha_blender();
rotate_scaled_sprite_trans(dbuf, b, x, y, angle, scale);
textout_centre_ex(dbuf, font, "Alpha", SCREEN_W/2, SCREEN_H-20, makecol(0, 0, 0), -1);
break;
case LIT:
set_trans_blender(255, 0, 0, 0);
rotate_scaled_sprite_lit(dbuf, b2, x, y, angle, scale, 128);
textout_centre_ex(dbuf, font, "Lit", SCREEN_W/2, SCREEN_H-20, makecol(0, 0, 0), -1);
break;
}
blit(dbuf, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);
fangle += 1;
fscale += dir*inc;
if (fscale < 0.5) {
dir = -dir;
fscale = 0.5;
}
else if (fscale > 1) {
dir = -dir;
fscale = 1;
}
rest(5);
if (keypressed()) {
int k = readkey();
switch (k >> 8) {
case KEY_N:
mode++;
mode %= 3;
break;
}
}
}
destroy_bitmap(b);
destroy_bitmap(b2);
destroy_bitmap(dbuf);
return 0;
}
