2647 lines
63 KiB
C
Executable File
2647 lines
63 KiB
C
Executable File
//
|
|
// levelblit.c
|
|
//
|
|
// Copyright 2007, 2008 Lancer-X/ASCEAI
|
|
//
|
|
// This file is part of Meritous.
|
|
//
|
|
// Meritous is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Meritous is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Meritous. If not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
#include <time.h>
|
|
#include <SDL.h>
|
|
#include <SDL_image.h>
|
|
#include <assert.h>
|
|
|
|
#include "mapgen.h"
|
|
#include "demon.h"
|
|
#include "gamemap.h"
|
|
#include "tiles.h"
|
|
#include "save.h"
|
|
#include "help.h"
|
|
#include "audio.h"
|
|
#include "boss.h"
|
|
#include "ending.h"
|
|
|
|
#define PLAYERW 16
|
|
#define PLAYERH 24
|
|
|
|
#define MERITOUS_VERSION "v 1.1"
|
|
int RECORDING = 0;
|
|
int PLAYBACK = 0;
|
|
|
|
int expired_ms = 0;
|
|
int frame_len = 33;
|
|
int WriteBitmaps = 0;
|
|
int WB_StartRange = 0;
|
|
int WB_EndRange = 1000000;
|
|
int training = 0;
|
|
int game_paused = 0;
|
|
int show_ending = 0;
|
|
int voluntary_exit = 0;
|
|
int tele_select = 0;
|
|
int enter_room_x = 0, enter_room_y = 0;
|
|
|
|
int agate_knife_loc = -1;
|
|
|
|
FILE *record_file;
|
|
char record_filename[256];
|
|
|
|
void DrawLevel(int off_x, int off_y, int hide_not_visited, int fog_of_war);
|
|
void DrawPlayer(int x, int y, int pl_dir, int pl_frm);
|
|
void LoadLevel();
|
|
void ActivateRoom(int room);
|
|
|
|
void DrawCircuit();
|
|
void ReleaseCircuit();
|
|
void DrawCircle(int x, int y, int r, unsigned char c);
|
|
|
|
void DrawArtifacts();
|
|
|
|
void HandleEvents();
|
|
|
|
void text_init();
|
|
void draw_text(int x, int y, char *str, Uint8 tcol);
|
|
unsigned char font_data[128][8][8];
|
|
|
|
void DrawShield();
|
|
|
|
int key_held[10] = {0};
|
|
int game_running = 1;
|
|
|
|
int player_x;
|
|
int player_y;
|
|
int player_dying;
|
|
int magic_circuit;
|
|
int circuit_range;
|
|
int release_range;
|
|
int release_x;
|
|
int release_y;
|
|
int release_str;
|
|
|
|
int shield_hp;
|
|
int shield_recover;
|
|
int player_gems;
|
|
int checkpoints_found;
|
|
int circuit_size;
|
|
int first_game;
|
|
int player_hp;
|
|
int player_lives = 5;
|
|
int player_lives_part = 0;
|
|
|
|
int player_room;
|
|
int player_dir;
|
|
int player_wlk;
|
|
int player_walk_speed;
|
|
int wlk_wait;
|
|
int circuit_release;
|
|
int scroll_home;
|
|
int enter_pressed;
|
|
|
|
int opening_door_x, opening_door_y, opening_door_i = 0, opening_door_n;
|
|
|
|
int checkpoint_x;
|
|
int checkpoint_y;
|
|
|
|
int explored = 0;
|
|
//#define DEBUG_STATS 1
|
|
|
|
int artifacts[12];
|
|
SDL_Surface *artifact_spr = NULL;
|
|
|
|
int player_shield;
|
|
int circuit_fillrate;
|
|
int circuit_recoverrate;
|
|
|
|
int scroll_x, scroll_y;
|
|
|
|
int map_enabled;
|
|
|
|
int prv_player_room;
|
|
|
|
int specialmessage;
|
|
int specialmessagetimer;
|
|
|
|
int timer_ps = 0;
|
|
int timer_v[10];
|
|
|
|
float RandomDir()
|
|
{
|
|
return (float)(rand()%256)*M_PI*2.0/256.0;
|
|
}
|
|
|
|
int UpgradePrice(int t);
|
|
|
|
void PlayerDefaultStats()
|
|
{
|
|
int i;
|
|
|
|
player_dying = 0;
|
|
magic_circuit = 0;
|
|
circuit_range = 100;
|
|
release_range = 100;
|
|
shield_hp = 0;
|
|
shield_recover = 0;
|
|
player_gems = 0;
|
|
checkpoints_found = 0;
|
|
circuit_size = 1000;
|
|
first_game = 1;
|
|
player_hp = 3;
|
|
|
|
explored = 0;
|
|
|
|
voluntary_exit = 0;
|
|
player_room = 0;
|
|
player_dir = 0;
|
|
player_wlk = 0;
|
|
player_walk_speed = 5;
|
|
player_lives = 5;
|
|
player_lives_part = 0;
|
|
wlk_wait = 8;
|
|
circuit_release = 0;
|
|
scroll_home = 0;
|
|
enter_pressed = 0;
|
|
show_ending = 0;
|
|
|
|
game_paused = 0;
|
|
|
|
player_shield = 0;
|
|
circuit_fillrate = 2;
|
|
circuit_recoverrate = 3;
|
|
|
|
prv_player_room = -1;
|
|
|
|
specialmessage = 0;
|
|
specialmessagetimer = 0;
|
|
|
|
opening_door_i = 0;
|
|
|
|
map_enabled = 0;
|
|
|
|
for (i = 0; i < 12; i++) {
|
|
artifacts[i] = 0;
|
|
}
|
|
|
|
#ifdef DEBUG_STATS
|
|
|
|
player_shield = 24;
|
|
circuit_fillrate = 24;
|
|
circuit_recoverrate = 24;
|
|
|
|
for (i = 0; i < 12; i++) {
|
|
artifacts[i] = 1;
|
|
}
|
|
|
|
#endif
|
|
}
|
|
|
|
|
|
void ScrollTo(int x, int y);
|
|
#define K_UP 0
|
|
#define K_DN 1
|
|
#define K_LT 2
|
|
#define K_RT 3
|
|
#define K_SP 4
|
|
|
|
SDL_Surface *screen;
|
|
|
|
void SetGreyscalePalette();
|
|
void SetTonedPalette(float pct);
|
|
void SetTitlePalette(int curve_start, int curve_end);
|
|
void SetTitlePalette2(int t);
|
|
int TouchTile(int ix, int iy);
|
|
void SpecialTile(int x, int y);
|
|
void DrawRect(int x, int y, int w, int h, unsigned char c);
|
|
|
|
void DrawCircleEx(int x, int y, int r, int r2, unsigned char c);
|
|
|
|
void ThinLine(SDL_Surface *scr, int x1, int y1, int x2, int y2, Uint8 col);
|
|
void LockDoors(int r);
|
|
|
|
#define SCREEN_W 640
|
|
#define SCREEN_H 480
|
|
|
|
void VideoUpdate()
|
|
{
|
|
static int bmp = 0;
|
|
char bmp_name[256];
|
|
|
|
SDL_UpdateRect(screen, 0, 0, 0, 0);
|
|
if (WriteBitmaps) {
|
|
if ((bmp >= WB_StartRange)&&(bmp < WB_EndRange)) {
|
|
sprintf(bmp_name, "v/bmp%d.bmp", bmp);
|
|
SDL_SaveBMP(screen, bmp_name);
|
|
}
|
|
bmp++;
|
|
}
|
|
}
|
|
|
|
void EndCycle(int n)
|
|
{
|
|
static int last_ticks;
|
|
int tick_delta;
|
|
tick_delta = SDL_GetTicks() - last_ticks;
|
|
|
|
if (n == 0) n = frame_len;
|
|
|
|
if (tick_delta < n) {
|
|
SDL_Delay(n-tick_delta);
|
|
}
|
|
|
|
if (!game_paused) expired_ms += n;
|
|
|
|
last_ticks = SDL_GetTicks();
|
|
}
|
|
|
|
void WritePlayerData()
|
|
{
|
|
int i;
|
|
|
|
FWInt(expired_ms);
|
|
FWInt(checkpoint_x);
|
|
FWInt(checkpoint_y);
|
|
FWInt(scroll_x);
|
|
FWInt(scroll_y);
|
|
FWInt(magic_circuit);
|
|
FWInt(checkpoint_x);
|
|
FWInt(checkpoint_y);
|
|
FWInt(player_walk_speed);
|
|
FWInt(wlk_wait);
|
|
FWInt(circuit_fillrate);
|
|
FWInt(circuit_recoverrate);
|
|
FWInt(explored);
|
|
FWInt(player_shield);
|
|
FWInt(shield_recover);
|
|
FWInt(shield_hp);
|
|
FWInt(player_gems);
|
|
FWInt(checkpoints_found);
|
|
FWInt(player_hp);
|
|
FWInt(player_lives);
|
|
FWInt(player_lives_part);
|
|
FWInt(current_boss);
|
|
FWInt(training);
|
|
FWInt(agate_knife_loc);
|
|
|
|
for (i = 0; i < 12; i++) {
|
|
FWChar(artifacts[i]);
|
|
}
|
|
}
|
|
|
|
void ReadPlayerData()
|
|
{
|
|
int i;
|
|
|
|
expired_ms = FRInt();
|
|
player_x = FRInt();
|
|
player_y = FRInt();
|
|
scroll_x = FRInt();
|
|
scroll_y = FRInt();
|
|
magic_circuit = FRInt();
|
|
checkpoint_x = FRInt();
|
|
checkpoint_y = FRInt();
|
|
player_walk_speed = FRInt();
|
|
wlk_wait = FRInt();
|
|
circuit_fillrate = FRInt();
|
|
circuit_recoverrate = FRInt();
|
|
explored = FRInt();
|
|
player_shield = FRInt();
|
|
shield_recover = FRInt();
|
|
shield_hp = FRInt();
|
|
player_gems = FRInt();
|
|
checkpoints_found = FRInt();
|
|
player_hp = FRInt();
|
|
player_lives = FRInt();
|
|
player_lives_part = FRInt();
|
|
current_boss = FRInt();
|
|
training = FRInt();
|
|
|
|
agate_knife_loc = FRInt();
|
|
|
|
for (i = 0; i < 12; i++) {
|
|
artifacts[i] = FRChar();
|
|
}
|
|
}
|
|
|
|
int min(int x, int y)
|
|
{
|
|
if (x<y) return x;
|
|
return y;
|
|
}
|
|
|
|
void DummyEventPoll()
|
|
{
|
|
SDL_Event e;
|
|
SDL_PollEvent(&e);
|
|
}
|
|
|
|
int DungeonPlay(char *fname);
|
|
|
|
Uint8 Uint8_Bound(int c)
|
|
{
|
|
if (c<0) return 0;
|
|
if (c>255) return 255;
|
|
return c;
|
|
}
|
|
|
|
int dist(int x1, int y1, int x2, int y2)
|
|
{
|
|
int dx, dy;
|
|
dx = x2 - x1;
|
|
dy = y2 - y1;
|
|
|
|
return sqrt((dx*dx)+(dy*dy));
|
|
}
|
|
|
|
void ClearInput()
|
|
{
|
|
key_held[K_SP] = 0;
|
|
key_held[K_UP] = 0;
|
|
key_held[K_DN] = 0;
|
|
key_held[K_LT] = 0;
|
|
key_held[K_RT] = 0;
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
int on_title = 1;
|
|
int executable_running = 1;
|
|
SDL_Surface *title, *title_pr, *asceai;
|
|
SDL_Surface *wm_icon;
|
|
Uint8 *src_p, *col_p;
|
|
Uint8 wm_mask[128];
|
|
int i;
|
|
int light = 0;
|
|
int x, y;
|
|
int pulse[SCREEN_W * SCREEN_H];
|
|
int precalc_sine[400];
|
|
int tick = 10000000;
|
|
int option = 0;
|
|
int can_continue = 0;
|
|
int maxoptions;
|
|
|
|
int last_key = 0;
|
|
|
|
int fullscreen = 0;
|
|
int ticker_tick = 0;
|
|
unsigned int stime = 0;
|
|
|
|
FILE *wm_mask_file;
|
|
|
|
if (argc > 1) {
|
|
for (i = 1; i < argc; i++) {
|
|
if (!strcasecmp(argv[i], "fullscreen")) {
|
|
fullscreen = 1;
|
|
}
|
|
/* if (!strcasecmp(argv[i], "record")) {
|
|
RECORDING = 1;
|
|
strcpy(record_filename, argv[i+1]);
|
|
}
|
|
if (!strcasecmp(argv[i], "play")) {
|
|
PLAYBACK = 1;
|
|
strcpy(record_filename, argv[i+1]);
|
|
}
|
|
if (!strcasecmp(argv[i], "framedelay")) {
|
|
frame_len = atoi(argv[i+1]);
|
|
}
|
|
if (!strcasecmp(argv[i], "bmpwrite")) {
|
|
WriteBitmaps = 1;
|
|
}
|
|
if (!strcasecmp(argv[i], "bmpstart")) {
|
|
WB_StartRange = atoi(argv[i+1]);
|
|
}
|
|
if (!strcasecmp(argv[i], "bmpend")) {
|
|
WB_EndRange = atoi(argv[i+1]);
|
|
} */
|
|
}
|
|
}
|
|
|
|
if ((RECORDING) && (PLAYBACK)) {
|
|
exit(1);
|
|
}
|
|
srand(time(NULL));
|
|
if (RECORDING) {
|
|
record_file = fopen(record_filename, "wb");
|
|
stime = time(NULL);
|
|
|
|
fputc(stime & 0x000000FF, record_file);
|
|
fputc((stime & 0x0000FF00) >> 8, record_file);
|
|
fputc((stime & 0x00FF0000) >> 16, record_file);
|
|
fputc((stime & 0xFF000000) >> 24, record_file);
|
|
|
|
srand(stime);
|
|
}
|
|
if (PLAYBACK) {
|
|
record_file = fopen(record_filename, "rb");
|
|
stime = fgetc(record_file);
|
|
stime |= fgetc(record_file) << 8;
|
|
stime |= fgetc(record_file) << 16;
|
|
stime |= fgetc(record_file) << 24;
|
|
|
|
srand(stime);
|
|
}
|
|
|
|
asceai = IMG_Load("dat/i/asceai.png");
|
|
wm_icon = IMG_Load("dat/i/icon.png");
|
|
|
|
screen = SDL_SetVideoMode(SCREEN_W, SCREEN_H, 8, SDL_SWSURFACE | (SDL_FULLSCREEN * fullscreen));
|
|
|
|
wm_mask_file = fopen("dat/d/icon_bitmask.dat", "rb");
|
|
fread(wm_mask, 1, 128, wm_mask_file);
|
|
fclose(wm_mask_file);
|
|
SDL_WM_SetCaption("~ m e r i t o u s ~", "MT");
|
|
SDL_WM_SetIcon(wm_icon, wm_mask);
|
|
InitAudio();
|
|
|
|
text_init();
|
|
for (i = 0; i < 400; i++) {
|
|
precalc_sine[i] = sin((float)i / 400 * M_PI * 2)*24+24;
|
|
}
|
|
|
|
|
|
for (i = 0; i < screen->w * screen->h; i++) {
|
|
x = i % SCREEN_W;
|
|
y = i / SCREEN_W;
|
|
|
|
pulse[i] = dist(x, y, SCREEN_W / 2, SCREEN_H / 2);
|
|
}
|
|
SetGreyscalePalette();
|
|
|
|
// asceai logo
|
|
SDL_BlitSurface(asceai, NULL, screen, NULL);
|
|
|
|
for (i = 0; i < 75; i++) {
|
|
SetTitlePalette(i * 5 - 375, i * 5 - 120);
|
|
VideoUpdate();
|
|
DummyEventPoll();
|
|
EndCycle(20);
|
|
}
|
|
SDL_Delay(500);
|
|
for (i = 0; i < 50; i++) {
|
|
SetTitlePalette(i * 5, 255 - (i * 5));
|
|
VideoUpdate();
|
|
DummyEventPoll();
|
|
EndCycle(20);
|
|
}
|
|
SDL_Delay(500);
|
|
for (i = 0; i < 50; i++) {
|
|
SetTitlePalette(255, (i * 5)+5);
|
|
VideoUpdate();
|
|
DummyEventPoll();
|
|
EndCycle(20);
|
|
}
|
|
|
|
while (executable_running) {
|
|
ticker_tick = 0;
|
|
TitleScreenMusic();
|
|
|
|
if (IsSaveFile()) {
|
|
can_continue = 1;
|
|
} else {
|
|
can_continue = 0;
|
|
}
|
|
|
|
maxoptions = 2 + can_continue;
|
|
|
|
title = IMG_Load("dat/i/title.png");
|
|
title_pr = IMG_Load("dat/i/title.png");
|
|
|
|
while (on_title) {
|
|
SetTitlePalette2(ticker_tick);
|
|
col_p = (Uint8 *)title_pr->pixels;
|
|
src_p = (Uint8 *)title->pixels;
|
|
if ((tick % 10) == 0) {
|
|
for (i = 0; i < 640*480; i++) {
|
|
*(col_p++) = Uint8_Bound(*(src_p++)+precalc_sine[(pulse[i]+tick)%400]);
|
|
}
|
|
}
|
|
SDL_BlitSurface(title_pr, NULL, screen, NULL);
|
|
|
|
draw_text(17, 156, MERITOUS_VERSION, 225 + sin((float)ticker_tick / 15)*30);
|
|
if (can_continue) draw_text((SCREEN_W - 14*8)/2, 310, "Continue", 255);
|
|
draw_text((SCREEN_W - 14*8)/2, 310 + can_continue*10, "New Game", 255);
|
|
draw_text((SCREEN_W - 14*8)/2, 320 + can_continue*10, "New Game (Wuss mode)", 255);
|
|
|
|
if (ticker_tick >= 30) {
|
|
draw_text((SCREEN_W - 14*8)/2 - 17, 310 + option * 10, "-", 205 + sin((float)ticker_tick / 5.0)*24);
|
|
draw_text((SCREEN_W - 14*8)/2 - 20, 310 + option * 10, " >", 205 + sin((float)ticker_tick / 5.0)*24);
|
|
draw_text((SCREEN_W - 14*8)/2 - 19, 310 + option * 10, " >", 190 + sin((float)ticker_tick / 5.0)*24);
|
|
draw_text((SCREEN_W - 14*8)/2 - 21, 310 + option * 10, " >", 190 + sin((float)ticker_tick / 5.0)*24);
|
|
draw_text((SCREEN_W - 14*8)/2 - 18, 310 + option * 10, " >", 165 + sin((float)ticker_tick / 5.0)*24);
|
|
draw_text((SCREEN_W - 14*8)/2 - 22, 310 + option * 10, " >", 165 + sin((float)ticker_tick / 5.0)*24);
|
|
}
|
|
|
|
VideoUpdate();
|
|
|
|
if (ticker_tick++ > 30) {
|
|
HandleEvents();
|
|
|
|
if (key_held[K_UP]) {
|
|
if (last_key != 1)
|
|
if (option > 0) option--;
|
|
last_key = 1;
|
|
} else {
|
|
if (key_held[K_DN]) {
|
|
if (last_key != 2)
|
|
if (option < maxoptions-1) option++;
|
|
last_key = 2;
|
|
} else {
|
|
last_key = 0;
|
|
if (key_held[K_SP] || enter_pressed) {
|
|
on_title = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (voluntary_exit) {
|
|
executable_running = 0;
|
|
on_title = 0;
|
|
SDL_Quit();
|
|
exit(0);
|
|
}
|
|
}
|
|
|
|
EndCycle(10);
|
|
|
|
light = 0;
|
|
tick -= 2;
|
|
}
|
|
|
|
ClearInput();
|
|
|
|
if (executable_running == 1) {
|
|
SDL_FreeSurface(title);
|
|
SDL_FreeSurface(title_pr);
|
|
if ((option == 0) && can_continue) {
|
|
DungeonPlay("SaveFile.sav");
|
|
} else {
|
|
if (option == (0 + can_continue)) {
|
|
training = 0;
|
|
DungeonPlay("");
|
|
} else {
|
|
training = 1;
|
|
DungeonPlay("");
|
|
}
|
|
}
|
|
// clean up
|
|
ClearInput();
|
|
DestroyDungeon();
|
|
DestroyThings();
|
|
on_title = 1;
|
|
game_load = 0;
|
|
|
|
game_running = 1;
|
|
}
|
|
}
|
|
|
|
// if (argc >= 2) DungeonPlay(argv[1]);
|
|
// else DungeonPlay("");
|
|
|
|
SDL_Quit();
|
|
return 0;
|
|
}
|
|
|
|
void DrawMeter(int x, int y, int n)
|
|
{
|
|
static SDL_Surface *meter = NULL;
|
|
SDL_Rect drawfrom, drawto;
|
|
if (meter == NULL) {
|
|
meter = IMG_Load("dat/i/meter.png");
|
|
SDL_SetColorKey(meter, SDL_SRCCOLORKEY | SDL_RLEACCEL, 0);
|
|
}
|
|
|
|
drawfrom.x = 0;
|
|
drawfrom.y = 6;
|
|
drawfrom.w = 150;
|
|
drawfrom.h = 6;
|
|
|
|
drawto.x = x;
|
|
drawto.y = y;
|
|
|
|
SDL_BlitSurface(meter, &drawfrom, screen, &drawto);
|
|
|
|
drawfrom.w = n*6;
|
|
drawfrom.y = 0;
|
|
|
|
SDL_BlitSurface(meter, &drawfrom, screen, &drawto);
|
|
}
|
|
|
|
void ProgressBarScreen(int part, float progress, char *message, float t_parts)
|
|
{
|
|
memset(screen->pixels, 0, 640*480);
|
|
|
|
DrawRect(200, 217, 240, 50, 80);
|
|
DrawRect(202, 219, 236, 46, 20);
|
|
draw_text(232, 228, message, 255);
|
|
DrawRect(232, 244, 176, 12, 128);
|
|
DrawRect(234, 246, 172, 8, 0);
|
|
|
|
if ((int)(172.0 * progress / t_parts + (172.0 / t_parts * part)) > 0) {
|
|
DrawRect(234, 246, (int)(172.0 * progress / t_parts + (172.0 / t_parts * part)), 8, 200);
|
|
}
|
|
VideoUpdate();
|
|
DummyEventPoll();
|
|
}
|
|
|
|
void LoadingScreen(int part, float progress)
|
|
{
|
|
float t_parts;
|
|
|
|
if (game_load) t_parts = 5.0;
|
|
else t_parts = 3.0;
|
|
|
|
ProgressBarScreen(part, progress, "Loading... please wait", t_parts);
|
|
ClearInput();
|
|
}
|
|
|
|
void SavingScreen(int part, float progress)
|
|
{
|
|
ProgressBarScreen(part, progress, "Saving... please wait", 4.0);
|
|
ClearInput();
|
|
}
|
|
|
|
void Arc(SDL_Surface *s, int x, int y, int r, float dir)
|
|
{
|
|
int bright;
|
|
int i, c;
|
|
float pdir, cdir, ndir;
|
|
|
|
int l_x = x, l_y = y;
|
|
int cx, cy, c1x, c1y, c2x, c2y;
|
|
|
|
bright = rand()%128+63;
|
|
i = 0;
|
|
while (i < r) {
|
|
i += rand()%5+25;
|
|
pdir = dir + (float)(rand()%16)/16.0*2.0*(M_PI / 15.0);
|
|
ndir = dir - (float)(rand()%16)/16.0*2.0*(M_PI / 15.0);
|
|
cdir = dir + (float)(rand()%16)/16.0*2.0*(M_PI / 20.0) - (float)(rand()%16)/16.0*2.0*(M_PI / 20.0);
|
|
|
|
bright += rand()%30;
|
|
bright -= rand()%30;
|
|
|
|
if (bright < 0) bright = 0;
|
|
if (bright > 255) bright = 255;
|
|
|
|
c1x = x + cos(pdir) * i;
|
|
c1y = y + sin(pdir) * i;
|
|
ThinLine(s, l_x, l_y, c1x, c1y, bright);
|
|
c2x = x + cos(ndir) * i;
|
|
c2y = y + sin(ndir) * i;
|
|
ThinLine(s, l_x, l_y, c2x, c2y, bright);
|
|
|
|
for (c = 0; c < 5; c++) {
|
|
DrawRect(x + cos(dir - (M_PI / 10.0) + (float)(rand()%16)/16.0*2.0*(M_PI / 10.0)) * i, y + sin(dir - (M_PI / 10.0) +
|
|
(float)(rand()%16)/16.0*2.0*(M_PI / 10.0)) * i, 1, 1, rand()%128+63);
|
|
}
|
|
|
|
i += rand()%5+25;
|
|
cx = x + cos(cdir) * i;
|
|
cy = y + sin(cdir) * i;
|
|
ThinLine(s, c1x, c1y, cx, cy, bright);
|
|
ThinLine(s, c2x, c2y, cx, cy, bright);
|
|
l_x = cx;
|
|
l_y = cy;
|
|
}
|
|
|
|
}
|
|
|
|
int DungeonPlay(char *fname)
|
|
{
|
|
int ix, iy;
|
|
int off_x, off_y;
|
|
int t = 0;
|
|
int i, j;
|
|
int lost_gems;
|
|
int rg_x, rg_y, rg_v;
|
|
int max_dist;
|
|
int last_killed = 0;
|
|
int n_arcs = 0;
|
|
int can_move;
|
|
|
|
float arcdir;
|
|
|
|
char buf[50];
|
|
|
|
expired_ms = 0;
|
|
LoadingScreen(0, 0.0);
|
|
if (fname[0] != 0) {
|
|
LoadGame(fname);
|
|
}
|
|
|
|
RandomGenerateMap();
|
|
InitEnemies();
|
|
InitBossVars();
|
|
|
|
PlayerDefaultStats();
|
|
if (game_load) {
|
|
first_game = 0;
|
|
ReadPlayerData();
|
|
//Paint(rooms[0].x+1, rooms[0].y+1, rooms[0].w-2, rooms[0].h-2, "dat/d/fbossroom.loc");
|
|
} else {
|
|
player_x = map.w * 32 / 2 - PLAYERW/2;
|
|
player_y = map.h * 32 / 2 - PLAYERH/2;
|
|
}
|
|
|
|
InitAutomap();
|
|
|
|
if (game_load) CloseFile();
|
|
|
|
max_dist = 0;
|
|
for (i = 0; i < 3000; i++) {
|
|
if (rooms[i].s_dist > max_dist) {
|
|
max_dist = rooms[i].s_dist;
|
|
}
|
|
}
|
|
|
|
game_running = 1;
|
|
while (game_running) {
|
|
//sprintf(buf, "X: %d Y: %d", (player_x + PLAYERW/2)/32*32 + PLAYERW/2, (player_y + PLAYERH/2)/32*32 + PLAYERH/2);
|
|
//SDL_WM_SetCaption(buf, "MT");
|
|
if (!game_paused) {
|
|
if (player_dying > 30) {
|
|
player_hp--;
|
|
|
|
if (player_hp <= 0) {
|
|
if (!training) player_lives--;
|
|
lost_gems = player_gems / 3;
|
|
player_gems -= lost_gems;
|
|
|
|
lost_gems = lost_gems * 95 / 100;
|
|
while (lost_gems > 0) {
|
|
rg_x = rooms[player_room].x * 32 + 32 + rand()%(rooms[player_room].w*32-64);
|
|
rg_y = rooms[player_room].y * 32 + 32 + rand()%(rooms[player_room].h*32-64);
|
|
rg_v = rand() % (lost_gems / 4 + 2);
|
|
CreateGem(rg_x, rg_y, player_room, rg_v);
|
|
lost_gems -= rg_v;
|
|
}
|
|
|
|
player_dying = 0;
|
|
shield_hp = 0;
|
|
|
|
if ( (current_boss == 3) && (boss_fight_mode != 0) ) {
|
|
player_x = enter_room_x;
|
|
player_y = enter_room_y;
|
|
prv_player_room = 1;
|
|
} else {
|
|
player_x = checkpoint_x;
|
|
player_y = checkpoint_y;
|
|
}
|
|
scroll_home = 1;
|
|
CircuitBullets(player_x, player_y, 100);
|
|
player_hp = 3 + (player_shield == 30)*3;
|
|
} else {
|
|
player_dying = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
circuit_size = 250 + 50*(circuit_fillrate + circuit_recoverrate);
|
|
|
|
if (magic_circuit > 0) {
|
|
circuit_range = (sqrt(magic_circuit + 1) * 6 + min(magic_circuit / 2, 50))*1.66;
|
|
if (artifacts[3]) circuit_range += circuit_range / 2.4;
|
|
} else circuit_range = -1;
|
|
player_room = GetRoom(player_x/32, player_y/32);
|
|
|
|
if (player_room != prv_player_room) {
|
|
SetTonedPalette((float)rooms[player_room].s_dist / (float)max_dist);
|
|
prv_player_room = player_room;
|
|
RecordRoom(player_room);
|
|
|
|
enter_room_x = player_x;
|
|
enter_room_y = player_y;
|
|
|
|
if (rooms[player_room].room_type == 2) {
|
|
// lock the doors
|
|
LockDoors(player_room);
|
|
// it's a boss room
|
|
BossRoom(player_room);
|
|
}
|
|
if (((rooms[player_room].checkpoint)||(player_room==0))&&(!artifacts[11])) {
|
|
checkpoint_x = rooms[player_room].x * 32 + (rooms[player_room].w / 2 * 32) + 8;
|
|
checkpoint_y = rooms[player_room].y * 32 + (rooms[player_room].h / 2 * 32) + 4;
|
|
}
|
|
if (rooms[player_room].visited == 0) {
|
|
rooms[player_room].visited = 1;
|
|
explored++;
|
|
|
|
if (explored == 3000) {
|
|
agate_knife_loc = player_room;
|
|
}
|
|
|
|
ActivateRoom(player_room);
|
|
}
|
|
}
|
|
|
|
if (last_killed != killed_enemies) {
|
|
SetTonedPalette((float)rooms[player_room].s_dist / (float)max_dist);
|
|
last_killed = killed_enemies;
|
|
} else {
|
|
if ((player_room == 0)&&(artifacts[11] == 1)) {
|
|
SetTonedPalette(0);
|
|
}
|
|
}
|
|
|
|
if (!map_enabled) {
|
|
ScrollTo(player_x + PLAYERW/2 - 320, player_y + PLAYERH/2 - 240);
|
|
DrawLevel(scroll_x, scroll_y, 1, 1);
|
|
//DrawLevel(player_x + 8 - 320, player_y + 12 - 240);
|
|
|
|
if (player_dying == 0) {
|
|
DrawShield();
|
|
|
|
if (magic_circuit > 0) {
|
|
if (player_dying == 0) {
|
|
if (circuit_release == 0) {
|
|
arcdir = RandomDir();
|
|
n_arcs = 1 + (circuit_size / 200 + 2) * magic_circuit / circuit_size;
|
|
for (i = 0; i < n_arcs; i++) {
|
|
Arc(screen, player_x - scroll_x + PLAYERW/2, player_y - scroll_y + PLAYERH/2, circuit_range, arcdir);
|
|
arcdir += (float)(rand()%16) / 16.0 * (M_PI*2/(float)n_arcs);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
DrawPlayer(312, 228, player_dir, player_wlk / wlk_wait);
|
|
} else {
|
|
if (t % 2 == 0) DrawPlayer(312, 228, player_dir, player_wlk / wlk_wait);
|
|
|
|
if (!game_paused)
|
|
player_dying++;
|
|
}
|
|
t++;
|
|
if ((boss_fight_mode != 0)&&(boss_fight_mode < 23)&&(!game_paused)) {
|
|
BossControl();
|
|
}
|
|
DrawEntities();
|
|
if (!game_paused) MoveEntities();
|
|
|
|
if (boss_fight_mode == 2) {
|
|
DrawBossHP(100);
|
|
}
|
|
|
|
if (rooms[player_room].room_type == 5) {
|
|
DrawPowerObject();
|
|
}
|
|
if ( (rooms[player_room].room_type == 6) && (current_boss == 3) ) {
|
|
DrawPowerObject();
|
|
}
|
|
if ((rooms[player_room].room_type == 4) && ((player_room % 1000) == 999)) {
|
|
DrawPowerObject();
|
|
}
|
|
if (player_room == agate_knife_loc) {
|
|
{
|
|
static float agate_t = 0.0;
|
|
static SDL_Surface *agate_knife = NULL;
|
|
int xpos, ypos;
|
|
int room_w, room_h;
|
|
int room_x, room_y;
|
|
|
|
room_x = rooms[player_room].x * 32 + 32;
|
|
room_y = rooms[player_room].y * 32 + 32;
|
|
room_w = rooms[player_room].w * 32 - 64;
|
|
room_h = rooms[player_room].h * 32 - 64;
|
|
|
|
SDL_Rect draw_to;
|
|
if (agate_knife == NULL) {
|
|
agate_knife = IMG_Load("dat/i/agate.png");
|
|
SDL_SetColorKey(agate_knife, SDL_SRCCOLORKEY | SDL_RLEACCEL, 0);
|
|
}
|
|
xpos = (int)((sin(agate_t * 1.33)*0.5+0.5) * (float)room_w) + room_x;
|
|
ypos = (int)((cos(agate_t * 0.7)*0.5+0.5) * (float)room_h) + room_y;
|
|
|
|
if (dist(player_x, player_y, xpos, ypos) < 20) {
|
|
agate_knife_loc = -1;
|
|
specialmessage = 50;
|
|
specialmessagetimer = 150;
|
|
SND_Pos("dat/a/crystal2.wav", 128, 0);
|
|
|
|
player_shield = 30;
|
|
circuit_fillrate = 30;
|
|
circuit_recoverrate = 30;
|
|
player_hp = 6;
|
|
}
|
|
draw_to.x = xpos - 16 - scroll_x;
|
|
draw_to.y = ypos - 16 - scroll_y;
|
|
|
|
SDL_BlitSurface(agate_knife, NULL, screen, &draw_to);
|
|
|
|
agate_t += 0.05;
|
|
}
|
|
}
|
|
|
|
if (opening_door_i > 0) {
|
|
DrawArtifactOverhead(opening_door_n);
|
|
for (i = 0; i < 5; i++) {
|
|
j = i * 50 - 250 + (opening_door_i * 5);
|
|
if (j > 0) {
|
|
DrawCircle(player_x - scroll_x, player_y - scroll_y, j, 255);
|
|
}
|
|
}
|
|
|
|
if (!game_paused) {
|
|
opening_door_i++;
|
|
if (opening_door_i >= 100) {
|
|
opening_door_i = 0;
|
|
Put(opening_door_x, opening_door_y, Get(opening_door_x, opening_door_y) - 38 + 13, GetRoom(opening_door_x, opening_door_y));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (circuit_release > 0) {
|
|
DrawCircle(release_x - player_x + 320, release_y - player_y + 240, circuit_release * release_range / 20, sin((float)circuit_release / 20.0)*127+127);
|
|
if (!game_paused) {
|
|
CircuitBullets(release_x, release_y, circuit_release * release_range / 20);
|
|
//HurtEnemies(release_x, release_y, circuit_release * release_range / 20, release_str);
|
|
circuit_release+=2;
|
|
|
|
if (circuit_release > 24) {
|
|
circuit_release = 0;
|
|
HurtEnemies(release_x, release_y, release_range, release_str);
|
|
if (boss_fight_mode == 2) TryHurtBoss(release_x, release_y, release_range, release_str);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!game_paused) {
|
|
if (shield_hp < player_shield) {
|
|
shield_recover += player_shield * 3 / (3 - training - (player_shield == 30));
|
|
if (artifacts[1]) shield_recover += player_shield * 3 / (3 - training - (player_shield == 30));
|
|
if (shield_recover >= 50) {
|
|
shield_hp++;
|
|
shield_recover -= 50 - (player_shield == 30)*25;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
DrawRect(0, 0, 640, 29, 0);
|
|
DrawRect(1, 1, 638, 27, 32);
|
|
DrawRect(2, 2, 636, 25, 64);
|
|
|
|
if (!tele_select) {
|
|
sprintf(buf, "Psi Crystals: %d", player_gems);
|
|
draw_text(3, 3, buf, 200);
|
|
sprintf(buf, "Explored: %.1f%% (%d/%d rooms)", (float)explored/30.0, explored, 3000);
|
|
draw_text(3, 11, buf, 200);
|
|
sprintf(buf, "Cleared: %.1f%% (%d/%d monsters)", (float)killed_enemies/(float)total_enemies*100.0, killed_enemies, total_enemies);
|
|
draw_text(3, 19, buf, 200);
|
|
|
|
draw_text(316, 3, "Reflect shield", (player_gems >= UpgradePrice(0))&&(player_shield!=30) ? (231 + (t%13)*2) : 200);
|
|
DrawMeter(434, 3, player_shield);
|
|
|
|
draw_text(316, 11, "Circuit charge", (player_gems >= UpgradePrice(1))&&(circuit_fillrate!=30) ? (231 + (t%13)*2) : 200);
|
|
DrawMeter(434, 11, circuit_fillrate);
|
|
|
|
draw_text(316, 19, "Circuit refill", (player_gems >= UpgradePrice(2))&&(circuit_recoverrate!=30) ? (231 + (t%13)*2) : 200);
|
|
DrawMeter(434, 19, circuit_recoverrate);
|
|
|
|
} else {
|
|
draw_text(80, 11-6, "Use the movement keys to locate a checkpoint. Press ENTER to", 240);
|
|
draw_text(52, 11+6, "teleport to this checkpoint. Press ESCAPE or TAB once you are done.", 240);
|
|
}
|
|
|
|
if (!training) {
|
|
buf[0] = 30;
|
|
|
|
if (player_lives <= 99) {
|
|
if (player_lives < 10) {
|
|
sprintf(buf+1, " %d", player_lives);
|
|
} else {
|
|
sprintf(buf+1, "%d", player_lives);
|
|
}
|
|
} else {
|
|
sprintf(buf+1, "**");
|
|
}
|
|
|
|
draw_text(615, 4, buf, 200);
|
|
|
|
DrawRect(615, 13, 24, 4, 240);
|
|
DrawRect(616, 14, 22, 2, 0);
|
|
i = (player_lives_part * 22 / 88);
|
|
if (i > 0) {
|
|
DrawRect(616, 14, i, 2, 160 + (t % 40));
|
|
}
|
|
}
|
|
|
|
if (player_shield != 30) {
|
|
for (i = 0; i < player_hp; i++) {
|
|
buf[i] = 3;
|
|
}
|
|
buf[player_hp]=0;
|
|
} else {
|
|
for (i = 0; i < (player_hp / 2); i++) {
|
|
buf[i] = 3;
|
|
}
|
|
if ((player_hp % 2) == 1) {
|
|
buf[(player_hp + 1) / 2 - 1] = 2;
|
|
}
|
|
buf[(player_hp+1)/2]=0;
|
|
}
|
|
|
|
draw_text(615, 18 - (5*training), buf, 200);
|
|
|
|
DrawRect(0, 466, 640, 14, 0);
|
|
DrawRect(1, 467, 638, 12, 32);
|
|
DrawRect(2, 468, 636, 10, 64);
|
|
|
|
DrawCircuit();
|
|
DrawArtifacts();
|
|
|
|
SpecialTile((player_x+PLAYERW/2)/32, (player_y+PLAYERH/2)/32);
|
|
|
|
if (map_enabled) DisplayAutomap();
|
|
|
|
if ((boss_fight_mode != 0)&&(boss_fight_mode == 23)&&(!game_paused)) {
|
|
BossControl();
|
|
}
|
|
if ( (boss_dlg != 0) && (!game_paused)) {
|
|
BossDialog();
|
|
}
|
|
|
|
if (game_paused && (!map_enabled) && (!voluntary_exit)) {
|
|
for (i = 0; i < 10; i++) {
|
|
DrawRect((640 - 6 * 8) / 2 - i, (480 - 8) / 2 - i, 6*8 + 2*i, 8 + 2*i, 64 - i*5);
|
|
}
|
|
draw_text((640 - 6 * 8) / 2, (480 - 8) / 2, "Paused", 255);
|
|
|
|
{
|
|
int t_days;
|
|
int t_hours;
|
|
int t_minutes;
|
|
int t_seconds;
|
|
|
|
t_seconds = (expired_ms / 1000) % 60;
|
|
t_minutes = ((expired_ms / 1000) / 60) % 60;
|
|
t_hours = (((expired_ms / 1000) / 60) / 60) % 24;
|
|
t_days = (((expired_ms / 1000) / 60) / 60) / 24;
|
|
|
|
if (t_days > 0) {
|
|
sprintf(buf, "%dd %dh %dm %ds", t_days, t_hours, t_minutes, t_seconds);
|
|
} else {
|
|
if (t_hours > 0) {
|
|
sprintf(buf, "%dh %dm %ds", t_hours, t_minutes, t_seconds);
|
|
} else {
|
|
sprintf(buf, "%dm %ds", t_minutes, t_seconds);
|
|
}
|
|
}
|
|
draw_text(636 - strlen(buf)*8, 470, buf, 255);
|
|
}
|
|
}
|
|
|
|
if (voluntary_exit) {
|
|
DrawRect(152, 200, 336, 80, 128);
|
|
DrawRect(160, 208, 320, 64, 64);
|
|
draw_text((640 - 30 * 8) / 2, (480 - 8) / 2 - 4, "Are you sure you want to quit?", 255);
|
|
draw_text((640 - 23 * 8) / 2, (480 - 8) / 2 + 4, "Press enter to confirm.", 255);
|
|
}
|
|
|
|
VideoUpdate();
|
|
|
|
MusicUpdate();
|
|
|
|
EndCycle(0);
|
|
|
|
can_move = 1;
|
|
|
|
if ((player_dying != 0) && (player_hp <= 1)) can_move = 0;
|
|
if (rooms[player_room].room_type == 5)
|
|
if (CanGetArtifact())
|
|
if (Get((player_x+PLAYERW/2)/32, (player_y+PLAYERH/2)/32)==42)
|
|
if (rooms[player_room].enemies == 0)
|
|
can_move = 0;
|
|
|
|
if (rooms[player_room].room_type == 6)
|
|
if (CanGetArtifact())
|
|
if (PlayerDist(rooms[player_room].w * 16 + rooms[player_room].x * 32,
|
|
rooms[player_room].h * 16 + rooms[player_room].y * 32) < 32)
|
|
if (rooms[player_room].enemies == 0)
|
|
if (current_boss == 3)
|
|
can_move = 0;
|
|
|
|
if (scroll_home != 0) can_move = 0;
|
|
if (boss_fight_mode == 1) can_move = 0;
|
|
if (boss_fight_mode >= 3) can_move = 0;
|
|
if (opening_door_i != 0) can_move = 0;
|
|
if (game_paused) can_move = 0;
|
|
|
|
HandleEvents();
|
|
if (map_enabled) {
|
|
game_paused = 1;
|
|
}
|
|
|
|
if (can_move) {
|
|
|
|
ix = player_x;
|
|
iy = player_y;
|
|
off_x = 0;
|
|
off_y = 0;
|
|
if (key_held[K_UP] && !key_held[K_DN]) {
|
|
iy -= player_walk_speed * (artifacts[4]?1.4:1);
|
|
player_dir = 0;
|
|
}
|
|
if (key_held[K_DN] && !key_held[K_UP]) {
|
|
iy += player_walk_speed * (artifacts[4]?1.4:1);;
|
|
player_dir = 1;
|
|
off_y = 24;
|
|
}
|
|
if (key_held[K_LT] && !key_held[K_RT]) {
|
|
ix -= player_walk_speed * (artifacts[4]?1.4:1);;
|
|
if (!(key_held[K_UP] || key_held[K_DN])) {
|
|
player_dir = 3;
|
|
}
|
|
}
|
|
if (key_held[K_RT] && !key_held[K_LT]) {
|
|
off_x = 16;
|
|
ix += player_walk_speed * (artifacts[4]?1.4:1);;
|
|
if (!(key_held[K_UP] || key_held[K_DN])) {
|
|
player_dir = 2;
|
|
|
|
}
|
|
}
|
|
if ((key_held[K_SP])&&(magic_circuit >= 0)) {
|
|
magic_circuit += (circuit_fillrate * (3+training+(circuit_fillrate==30))/3);
|
|
} else {
|
|
if (magic_circuit < 0) {
|
|
magic_circuit += (circuit_recoverrate * (3+training+(circuit_recoverrate==30))/3);
|
|
if (magic_circuit > 0) magic_circuit = 0;
|
|
} else {
|
|
if (magic_circuit > 0) {
|
|
ReleaseCircuit();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (magic_circuit > circuit_size) magic_circuit = circuit_size;
|
|
|
|
if ((ix!=player_x)||(iy!=player_y)) {
|
|
// Are we changing to a new square?
|
|
if (((player_x / 32)!=((ix+off_x) / 32)) || ((player_y / 32)!=((iy+off_y) / 32))) {
|
|
//printf("%d\n", tile);
|
|
if (TouchTile(ix, iy)) {
|
|
player_wlk = (player_wlk + 1 + artifacts[4]*3) % (4*wlk_wait);
|
|
} else {
|
|
if (TouchTile(player_x, iy)) {
|
|
player_wlk = (player_wlk + 1 + artifacts[4]*3) % (4*wlk_wait);
|
|
} else {
|
|
if (TouchTile(ix, player_y)) {
|
|
player_wlk = (player_wlk + 1 + artifacts[4]*3) % (4*wlk_wait);
|
|
if (off_x > 0) player_dir = 2;
|
|
else player_dir = 3;
|
|
}
|
|
}
|
|
|
|
}
|
|
} else {
|
|
player_x = ix;
|
|
player_y = iy;
|
|
|
|
player_wlk = (player_wlk + 1 + artifacts[4]*3) % (4*wlk_wait);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((t % (33 * 10))==(33 * 10 - 1)) {
|
|
ActivateRand();
|
|
}
|
|
|
|
if (voluntary_exit && enter_pressed) {
|
|
voluntary_exit = 0;
|
|
game_running = 0;
|
|
game_paused = 0;
|
|
}
|
|
|
|
if ((player_lives == 0) && (!training)) {
|
|
break;
|
|
}
|
|
if (show_ending) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (show_ending) {
|
|
show_ending = 0;
|
|
ShowEnding();
|
|
}
|
|
|
|
if ((player_lives == 0) && (!training)) {
|
|
SDL_FillRect(screen, NULL, 0);
|
|
draw_text(252, 236, "G A M E O V E R", 255);
|
|
VideoUpdate();
|
|
SDL_Delay(2000);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void UpRoom()
|
|
{
|
|
int i, nd;
|
|
|
|
nd = rooms[player_room].s_dist + 1;
|
|
|
|
for (i = 0; i < 3000; i++) {
|
|
if (rooms[i].s_dist == nd) {
|
|
player_x = rooms[i].x * 32 + 64;
|
|
player_y = rooms[i].y * 32 + 64;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CancelVoluntaryExit()
|
|
{
|
|
if (voluntary_exit) {
|
|
voluntary_exit = 0;
|
|
game_paused = 0;
|
|
}
|
|
}
|
|
|
|
void HandleEvents()
|
|
{
|
|
unsigned short db;
|
|
static SDL_Event event;
|
|
int pressed_tab = 0;
|
|
|
|
if (PLAYBACK) {
|
|
db = fgetc(record_file);
|
|
db |= fgetc(record_file) << 8;
|
|
|
|
key_held[K_UP] = (db & 0x0001)>0;
|
|
key_held[K_DN] = (db & 0x0002)>0;
|
|
key_held[K_LT] = (db & 0x0004)>0;
|
|
key_held[K_RT] = (db & 0x0008)>0;
|
|
key_held[K_SP] = (db & 0x0010)>0;
|
|
enter_pressed = (db & 0x0020)>0;
|
|
map_enabled = (db & 0x0040)>0;
|
|
game_running = (db & 0x0080)>0;
|
|
game_paused = (db & 0x0100)>0;
|
|
voluntary_exit = (db & 0x0200)>0;
|
|
pressed_tab = (db & 0x0400)>0;
|
|
tele_select = (db & 0x0800)>0;
|
|
|
|
return;
|
|
}
|
|
|
|
if (pressed_tab) {
|
|
c_scroll_x = player_x;
|
|
c_scroll_y = player_y;
|
|
}
|
|
|
|
enter_pressed = 0;
|
|
while (SDL_PollEvent(&event)) {
|
|
if (event.type == SDL_KEYDOWN) {
|
|
switch (event.key.keysym.sym) {
|
|
case SDLK_w:
|
|
case SDLK_UP:
|
|
key_held[K_UP] = 1;
|
|
CancelVoluntaryExit();
|
|
break;
|
|
case SDLK_s:
|
|
case SDLK_DOWN:
|
|
key_held[K_DN] = 1;
|
|
CancelVoluntaryExit();
|
|
break;
|
|
case SDLK_a:
|
|
case SDLK_LEFT:
|
|
key_held[K_LT] = 1;
|
|
CancelVoluntaryExit();
|
|
break;
|
|
case SDLK_d:
|
|
case SDLK_RIGHT:
|
|
key_held[K_RT] = 1;
|
|
CancelVoluntaryExit();
|
|
break;
|
|
case SDLK_SPACE:
|
|
key_held[K_SP] = 1;
|
|
CancelVoluntaryExit();
|
|
break;
|
|
case SDLK_RETURN:
|
|
enter_pressed = 1;
|
|
break;
|
|
case SDLK_ESCAPE:
|
|
if (map_enabled) {
|
|
map_enabled = 0;
|
|
game_paused = 0;
|
|
tele_select = 0;
|
|
} else {
|
|
voluntary_exit ^= 1;
|
|
game_paused = voluntary_exit;
|
|
}
|
|
break;
|
|
case SDLK_TAB:
|
|
if (tele_select) {
|
|
map_enabled = 0;
|
|
game_paused = 0;
|
|
tele_select = 0;
|
|
} else {
|
|
pressed_tab = 1;
|
|
map_enabled ^= 1;
|
|
game_paused = map_enabled;
|
|
c_scroll_x = player_x;
|
|
c_scroll_y = player_y;
|
|
}
|
|
CancelVoluntaryExit();
|
|
break;
|
|
case SDLK_h:
|
|
CancelVoluntaryExit();
|
|
ShowHelp();
|
|
break;
|
|
case SDLK_p:
|
|
game_paused ^= 1;
|
|
CancelVoluntaryExit();
|
|
break;
|
|
|
|
|
|
/*
|
|
case SDLK_j:
|
|
{
|
|
player_shield = 20;
|
|
circuit_recoverrate = 20;
|
|
circuit_fillrate = 20;
|
|
}
|
|
break;
|
|
case SDLK_k:
|
|
{
|
|
int i, n, j;
|
|
for (j = 0; j < 1; j++) {
|
|
for (i = 0; i < 50000; i++) {
|
|
n = rand()%3000;
|
|
if (rooms[n].visited == 0) {
|
|
player_x = rooms[n].x * 32 + rooms[n].w * 16;
|
|
player_y = rooms[n].y * 32 + rooms[n].h * 16;
|
|
rooms[n].visited = 1;
|
|
explored++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case SDLK_m:
|
|
{
|
|
int i;
|
|
for (i = 0; i < 8; i++) {
|
|
artifacts[i] = 1;
|
|
}
|
|
for (i = 8; i < 11; i++) {
|
|
artifacts[i] = 0;
|
|
}
|
|
artifacts[11] = 0;
|
|
}
|
|
break;
|
|
|
|
case SDLK_n:
|
|
{
|
|
current_boss = 3;
|
|
expired_ms = 1000000;
|
|
}
|
|
break;
|
|
*/
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (event.type == SDL_KEYUP) {
|
|
switch (event.key.keysym.sym) {
|
|
case SDLK_w:
|
|
case SDLK_UP:
|
|
key_held[K_UP] = 0;
|
|
break;
|
|
case SDLK_s:
|
|
case SDLK_DOWN:
|
|
key_held[K_DN] = 0;
|
|
break;
|
|
case SDLK_a:
|
|
case SDLK_LEFT:
|
|
key_held[K_LT] = 0;
|
|
break;
|
|
case SDLK_d:
|
|
case SDLK_RIGHT:
|
|
key_held[K_RT] = 0;
|
|
break;
|
|
case SDLK_SPACE:
|
|
key_held[K_SP] = 0;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (event.type == SDL_QUIT) {
|
|
voluntary_exit = 1;
|
|
}
|
|
}
|
|
|
|
if (RECORDING) {
|
|
db = 0;
|
|
|
|
db |= 0x0001 * key_held[K_UP];
|
|
db |= 0x0002 * key_held[K_DN];
|
|
db |= 0x0004 * key_held[K_LT];
|
|
db |= 0x0008 * key_held[K_RT];
|
|
db |= 0x0010 * key_held[K_SP];
|
|
db |= 0x0020 * enter_pressed;
|
|
db |= 0x0040 * map_enabled;
|
|
db |= 0x0080 * game_running;
|
|
db |= 0x0100 * game_paused;
|
|
db |= 0x0200 * voluntary_exit;
|
|
db |= 0x0400 * pressed_tab;
|
|
db |= 0x0800 * tele_select;
|
|
|
|
fputc(db & 0x00FF, record_file);
|
|
fputc((db & 0xFF00)>>8, record_file);
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
void DrawLevel(int off_x, int off_y, int hide_not_visited, int fog_of_war)
|
|
{
|
|
static SDL_Surface *tiles = NULL;
|
|
static SDL_Surface *fog = NULL;
|
|
Uint8 *pp;
|
|
SDL_Rect tilerec, screenrec;
|
|
int x, y, i;
|
|
int resolve_x, resolve_y;
|
|
|
|
DrawRect(0, 0, 640, 480, 255);
|
|
|
|
if (tiles == NULL) {
|
|
tiles = IMG_Load("dat/i/tileset.png");
|
|
fog = IMG_Load("dat/i/tileset.png");
|
|
|
|
pp = fog->pixels;
|
|
|
|
for (i = 0; i < fog->w*fog->h; i++) {
|
|
*pp = *pp / 2 + 128;
|
|
pp++;
|
|
}
|
|
}
|
|
for (y = 0; y < 16; y++) {
|
|
for (x = 0; x < 21; x++) {
|
|
resolve_x = x + (off_x/32);
|
|
resolve_y = y + (off_y/32);
|
|
|
|
if ((GetVisited(resolve_x, resolve_y) == 0)&&(player_room != GetRoom(resolve_x, resolve_y))&&(hide_not_visited)) {
|
|
tilerec.x = 17 * 32;
|
|
} else {
|
|
tilerec.x = Get(resolve_x, resolve_y) * 32;
|
|
}
|
|
tilerec.y = 0;
|
|
tilerec.w = 32;
|
|
tilerec.h = 32;
|
|
|
|
screenrec.x = x*32 - ( (off_x) %32);
|
|
screenrec.y = y*32 - ( (off_y) %32);
|
|
|
|
if ((player_room != GetRoom(resolve_x, resolve_y))&&(fog_of_war)) {
|
|
SDL_BlitSurface(fog, &tilerec, screen, &screenrec);
|
|
} else {
|
|
SDL_BlitSurface(tiles, &tilerec, screen, &screenrec);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void DrawPlayer(int x, int y, int pl_dir, int pl_frm)
|
|
{
|
|
static SDL_Surface *playersprite = NULL;
|
|
SDL_Rect playerrec, screenrec;
|
|
|
|
if (playersprite == NULL) {
|
|
playersprite = IMG_Load("dat/i/player.png");
|
|
SDL_SetColorKey(playersprite, SDL_SRCCOLORKEY | SDL_RLEACCEL, 0);
|
|
}
|
|
|
|
playerrec.x = pl_frm * 16;
|
|
playerrec.y = pl_dir * 24;
|
|
playerrec.w = 16;
|
|
playerrec.h = 24;
|
|
|
|
screenrec.x = x;
|
|
screenrec.y = y;
|
|
|
|
SDL_BlitSurface(playersprite, &playerrec, screen, &screenrec);
|
|
}
|
|
|
|
void SetGreyscalePalette()
|
|
{
|
|
SDL_Color grey[256];
|
|
SDL_Color pal[256];
|
|
int i;
|
|
|
|
float ip;
|
|
|
|
for (i = 0; i < 256; i++) {
|
|
grey[i].r = grey[i].g = grey[i].b = i;
|
|
}
|
|
|
|
for (i = 0; i < 256; i++) {
|
|
ip = (float)i / 255.0;
|
|
pal[i].r = (cos(ip * M_PI / 2.0 + M_PI) + 1.0) * 255;
|
|
pal[i].g = (sin(ip * M_PI / 2.0) * 255 + i) / 2;
|
|
pal[i].b = sin(ip * M_PI / 2.0) * 255;
|
|
}
|
|
|
|
SDL_SetPalette(screen, SDL_LOGPAL, grey, 0, 256);
|
|
SDL_SetPalette(screen, SDL_PHYSPAL, pal, 0, 256);
|
|
}
|
|
|
|
void SetTonedPalette(float dct)
|
|
{
|
|
SDL_Color pal[256];
|
|
float pct = 1.0 - dct;
|
|
float rp_dct, rp_pct;
|
|
float ip;
|
|
int ec;
|
|
int i;
|
|
static int tk = 0;
|
|
|
|
ec = rooms[player_room].enemies;
|
|
|
|
if (ec < 50) {
|
|
rp_dct = (float)ec / 50.0;
|
|
} else {
|
|
rp_dct = 1.0;
|
|
}
|
|
rp_pct = 1.0 - rp_dct;
|
|
|
|
if ( (player_room == 0) && (current_boss == 3) && (boss_fight_mode >= 3) ) {
|
|
if (boss_fight_mode == 23) {
|
|
for (i = 0; i < 256; i++) {
|
|
pal[i].r = i;
|
|
pal[i].g = i;
|
|
pal[i].b = i;
|
|
}
|
|
} else {
|
|
tk++;
|
|
pct = sin((float)tk / 20.0 * M_PI) * (0.5 - (float)(boss_fight_mode-3)*0.025) + (0.5 - (float)(boss_fight_mode-3)*0.025);
|
|
|
|
if (magic_circuit < 0.1) pct = 1.0;
|
|
|
|
for (i = 0; i < 256; i++) {
|
|
ip = (float)i / 255.0;
|
|
pal[i].r = 255 - (255 - (cos(ip * M_PI / 2.0 + M_PI) + 1.0) * 255)*pct;
|
|
pal[i].g = 255 - (255 - i)*pct;
|
|
pal[i].b = 255 - (255 - sin(ip * M_PI / 2.0) * 255) * pct;
|
|
}
|
|
|
|
|
|
pal[1].r = 0;
|
|
pal[1].g = 0;
|
|
pal[1].b = 0;
|
|
}
|
|
} else {
|
|
if (artifacts[11]) {
|
|
if (player_room == 0) {
|
|
tk++;
|
|
pct = sin((float)tk / 33.0 * M_PI) * 0.5 + 0.5;
|
|
for (i = 0; i < 256; i++) {
|
|
pal[i].r = i;
|
|
pal[i].g = (i / 3)*pct;
|
|
pal[i].b = (i * 2 / 3)*pct;
|
|
}
|
|
} else {
|
|
for (i = 0; i < 256; i++) {
|
|
ip = (float)i / 255.0;
|
|
pal[i].r = i;
|
|
pal[i].g = i * dct;
|
|
pal[i].b = (cos(ip * M_PI / 2.0 + M_PI) + 1.0) * 255 * dct;
|
|
}
|
|
}
|
|
|
|
if ( (current_boss == 3) && (player_shield == 30) && (player_room == 0)) {
|
|
if (boss_lives <= 1) {
|
|
tk++;
|
|
for (i = 0; i < 256; i++) {
|
|
pct = sin((float) (tk + i) / 24.0 * M_PI) * 0.5 + 0.5;
|
|
|
|
pal[i].r = (i * 0.5 + 128)*pct;
|
|
pal[i].g = i * 0.5 + 128;
|
|
pal[i].b = (i * 0.5 + 128)*pct;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for (i = 0; i < 256; i++) {
|
|
ip = (float)i / 255.0;
|
|
pal[i].r = (((cos(ip * M_PI / 2.0 + M_PI) + 1.0) * 255)*pct + i*dct)*rp_pct + (sin(ip * M_PI / 2.0) * 207 + 48)*rp_dct;
|
|
pal[i].g = (i)*rp_pct + ((cos(ip * M_PI / 2.0 + M_PI) + 1.0) * 255)*rp_dct;
|
|
pal[i].b = ((sin(ip * M_PI / 2.0) * 255 * pct)+((cos(ip * M_PI / 2.0 + M_PI) + 1.0) * 255 * dct))*rp_pct + ((cos(ip * M_PI / 2.0 + M_PI) + 1.0) * 255)*rp_dct;
|
|
}
|
|
}
|
|
}
|
|
|
|
SDL_SetPalette(screen, SDL_PHYSPAL, pal, 0, 256);
|
|
}
|
|
|
|
void SetTitlePalette(int curve_start, int curve_end)
|
|
{
|
|
SDL_Color pal[256];
|
|
int ec;
|
|
int i;
|
|
|
|
for (i = 0; i < 256; i++) {
|
|
ec = (i - curve_start) * 255 / (curve_end-curve_start);
|
|
if (ec < 0) ec = 0;
|
|
if (ec > 255) ec = 255;
|
|
|
|
pal[i].r = ec;
|
|
pal[i].g = ec;
|
|
pal[i].b = ec;
|
|
}
|
|
|
|
SDL_SetPalette(screen, SDL_PHYSPAL, pal, 0, 256);
|
|
}
|
|
|
|
void SetTitlePalette2(int t)
|
|
{
|
|
SDL_Color pal[256];
|
|
int i;
|
|
|
|
float ip;
|
|
float bright;
|
|
float b_coeff;
|
|
|
|
bright = 1 - ((float)t / 30.0);
|
|
if (bright < 0.0) bright = 0.0;
|
|
b_coeff = 1 - bright;
|
|
|
|
for (i = 0; i < 256; i++) {
|
|
ip = (float)i / 255.0;
|
|
pal[i].r = (cos(ip * M_PI / 2.0 + M_PI) + 1.0) * 255 * b_coeff + 255*bright;
|
|
pal[i].g = (sin(ip * M_PI / 2.0) * 255 + i) / 2 * b_coeff + 255*bright;
|
|
pal[i].b = sin(ip * M_PI / 2.0) * 255 * b_coeff + 255*bright;
|
|
}
|
|
|
|
SDL_SetPalette(screen, SDL_PHYSPAL, pal, 0, 256);
|
|
}
|
|
|
|
int IsSolid(unsigned char tile)
|
|
{
|
|
return TileData[tile].Is_Solid;
|
|
}
|
|
|
|
void ActivateBossDoor(int x, int y)
|
|
{
|
|
static int bd_timer = 0;
|
|
int bx = x, by = y;
|
|
|
|
// find boss room
|
|
if (rooms[GetRoom(x+1, y)].room_type == 2) {
|
|
bx += 1;
|
|
} else
|
|
if (rooms[GetRoom(x-1, y)].room_type == 2) {
|
|
bx -= 1;
|
|
} else
|
|
if (rooms[GetRoom(x, y+1)].room_type == 2) {
|
|
by += 1;
|
|
} else
|
|
if (rooms[GetRoom(x, y-1)].room_type == 2) {
|
|
by -= 1;
|
|
} else
|
|
return;
|
|
|
|
if (artifacts[8 + rooms[GetRoom(bx, by)].room_param]) {
|
|
opening_door_x = x;
|
|
opening_door_y = y;
|
|
opening_door_i = 1;
|
|
opening_door_n = rooms[GetRoom(bx, by)].room_param;
|
|
if ((SDL_GetTicks() - bd_timer) > 100) {
|
|
SND_Pos("dat/a/crystal2.wav", 100, 0);
|
|
bd_timer = SDL_GetTicks();
|
|
}
|
|
}
|
|
}
|
|
|
|
int TouchTile(int ix, int iy)
|
|
{
|
|
int i;
|
|
int off_x, off_y;
|
|
int ret = 1;
|
|
unsigned char tile;
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
off_x = 15*(i%2);
|
|
off_y = 23*(i/2);
|
|
|
|
tile = Get((ix+off_x)/32, (iy+off_y)/32);
|
|
switch (tile) {
|
|
case 38:
|
|
case 39:
|
|
case 40:
|
|
case 41:
|
|
ActivateBossDoor((ix+off_x)/32, (iy+off_y)/32);
|
|
ret = 0;
|
|
break;
|
|
case 13:
|
|
player_x = (ix + off_x) / 32 * 32 + 8;
|
|
player_y = (iy/32 + 2)*32 + 32;
|
|
return 1;
|
|
break;
|
|
case 14:
|
|
player_x = (ix + off_x) / 32 * 32 + 8;
|
|
player_y = (iy/32 - 2)*32 + 8;
|
|
return 1;
|
|
break;
|
|
case 15:
|
|
player_x = (ix/32 + 2)*32 + 32;
|
|
player_y = (iy + off_y) / 32 * 32 + 4;
|
|
return 1;
|
|
break;
|
|
case 16:
|
|
player_x = (ix/32 - 2)*32 + 16;
|
|
player_y = (iy + off_y) / 32 * 32 + 4;
|
|
return 1;
|
|
break;
|
|
default:
|
|
if (TileData[tile].Is_Solid) ret = 0;
|
|
//ret = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (ret == 1) {
|
|
player_x = ix;
|
|
player_y = iy;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void text_init()
|
|
{
|
|
FILE *font_data_file;
|
|
int chr, x, y;
|
|
font_data_file = fopen("dat/d/font.dat", "rb");
|
|
|
|
for (chr = 0; chr < 128; chr++) {
|
|
for (y = 0; y < 8; y++) {
|
|
for (x = 0; x < 8; x++) {
|
|
font_data[chr][x][y] = fgetc(font_data_file);
|
|
}
|
|
}
|
|
}
|
|
|
|
fclose(font_data_file);
|
|
}
|
|
|
|
void draw_char(int cur_x, int cur_y, int c, Uint8 tcol)
|
|
{
|
|
int px, py;
|
|
Uint8 *pix;
|
|
|
|
for (py = 0; py < 8; py++) {
|
|
pix = (Uint8 *)screen->pixels;
|
|
pix += (py+cur_y)*screen->w;
|
|
pix += cur_x;
|
|
|
|
if ((cur_x >= 0)&&(py+cur_y >= 0)&&(cur_x < screen->w-8)&&(py+cur_y < screen->h)) {
|
|
for (px = 0; px < 8; px++) {
|
|
if (font_data[c][px][py] == 255) {
|
|
*pix = tcol;
|
|
}
|
|
if ((font_data[c][px][py] < 255)&&(font_data[c][px][py] > 0)) {
|
|
*pix = ((int)tcol * font_data[c][px][py] / 256) + ((int)*pix * (256-font_data[c][px][py]) / 256);
|
|
}
|
|
pix++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void draw_text(int x, int y, char *str, Uint8 tcol)
|
|
{
|
|
int c, cur_x, cur_y;
|
|
|
|
cur_x = x;
|
|
cur_y = y;
|
|
|
|
while (*str != 0) {
|
|
c = *(str++);
|
|
if (c == '\n') {
|
|
cur_x = x;
|
|
cur_y+=10;
|
|
} else {
|
|
draw_char(cur_x, cur_y, c, tcol);
|
|
cur_x+=8;
|
|
}
|
|
}
|
|
}
|
|
|
|
void draw_text_ex(int x, int y, char *str, Uint8 tcol, SDL_Surface *srf)
|
|
{
|
|
Uint8 *pix;
|
|
int c, cur_x, cur_y, px, py;
|
|
|
|
cur_x = x;
|
|
cur_y = y;
|
|
|
|
while (*str != 0) {
|
|
c = *(str++);
|
|
if (c == '\n') {
|
|
cur_x = x;
|
|
cur_y+=8;
|
|
} else {
|
|
for (py = 0; py < 8; py++) {
|
|
pix = (Uint8 *)srf->pixels;
|
|
pix += (py+cur_y)*srf->w;
|
|
pix += cur_x;
|
|
for (px = 0; px < 8; px++) {
|
|
if (font_data[c][px][py]) {
|
|
*pix = tcol;
|
|
}
|
|
pix++;
|
|
}
|
|
}
|
|
cur_x+=8;
|
|
}
|
|
}
|
|
}
|
|
|
|
void LockDoors(int r)
|
|
{
|
|
//printf("Locking room %d...", r);
|
|
int x, y;
|
|
int rx, ry;
|
|
int rt;
|
|
int rcount = 0;
|
|
|
|
for (y = 0; y < rooms[r].h; y++) {
|
|
for (x = 0; x < rooms[r].w; x++) {
|
|
rx = x + rooms[r].x;
|
|
ry = y + rooms[r].y;
|
|
rt = Get(rx, ry);
|
|
|
|
if ((rt >= 13) && (rt <= 16)) {
|
|
rcount++;
|
|
Put(rx, ry, rt - 13 + 21, r);
|
|
}
|
|
}
|
|
}
|
|
//printf("locked %d doors\n", rcount);
|
|
}
|
|
|
|
void ActivateRoom(int room)
|
|
{
|
|
//printf("Activating room %d (type %d)\n", room, rooms[room].room_type);
|
|
if (rooms[room].checkpoint) {
|
|
checkpoints_found++;
|
|
}
|
|
if (rooms[room].room_type == 3) {
|
|
// lock the doors!
|
|
LockDoors(room);
|
|
}
|
|
ActivateEnemies(room);
|
|
}
|
|
|
|
void DrawRect(int x, int y, int w, int h, unsigned char c)
|
|
{
|
|
SDL_Rect r;
|
|
|
|
r.x = x;
|
|
r.y = y;
|
|
r.w = w;
|
|
r.h = h;
|
|
|
|
SDL_FillRect(screen, &r, c);
|
|
}
|
|
|
|
void DrawCircuit()
|
|
{
|
|
int vd = 520;
|
|
char buf[20];
|
|
|
|
if (magic_circuit != 0) {
|
|
DrawRect(110, 469, 8+abs(magic_circuit) * vd / circuit_size, 9, (magic_circuit > 0) ? 159 : 72);
|
|
DrawRect(111, 470, 6+abs(magic_circuit) * vd / circuit_size, 7, (magic_circuit > 0) ? 183 : 80);
|
|
DrawRect(112, 471, 4+abs(magic_circuit) * vd / circuit_size, 5, (magic_circuit > 0) ? 207 : 96);
|
|
DrawRect(113, 472, 2+abs(magic_circuit) * vd / circuit_size, 3, (magic_circuit > 0) ? 231 : 112);
|
|
DrawRect(114, 473, abs(magic_circuit) * vd / circuit_size, 1, (magic_circuit > 0) ? 255 : 128);
|
|
}
|
|
sprintf(buf, "%.1f", fabs((float)magic_circuit / 100.0));
|
|
draw_text(115, 470, buf, 0);
|
|
draw_text(3, 469, "Psi Circuit", 200);
|
|
}
|
|
|
|
void ReleaseCircuit()
|
|
{
|
|
circuit_release = 1;
|
|
release_range = circuit_range;
|
|
release_x = player_x;
|
|
release_y = player_y;
|
|
release_str = magic_circuit;
|
|
if (circuit_fillrate==30) {
|
|
release_str *= 1.25;
|
|
}
|
|
|
|
SND_CircuitRelease(release_str);
|
|
magic_circuit *= -1;
|
|
}
|
|
|
|
void DrawCircle(int x, int y, int r, unsigned char c)
|
|
{
|
|
int circ_y;
|
|
|
|
int len_x, outer_len_x, inner_len_x;
|
|
|
|
int inner_r = r - 10;
|
|
if (inner_r < 1) inner_r = 1;
|
|
|
|
if (r < 1) return;
|
|
// a^2 + b^2 = c^2
|
|
for (circ_y = 0; circ_y < r; circ_y++) {
|
|
if (circ_y < (r-10)) {
|
|
outer_len_x = sqrt(r*r - circ_y*circ_y);
|
|
inner_len_x = sqrt((r-10)*(r-10) - circ_y*circ_y);
|
|
DrawRect(x - outer_len_x, y - circ_y, (outer_len_x - inner_len_x), 1, c);
|
|
DrawRect(x + inner_len_x, y - circ_y, (outer_len_x - inner_len_x), 1, c);
|
|
DrawRect(x - outer_len_x, y + circ_y, (outer_len_x - inner_len_x), 1, c);
|
|
DrawRect(x + inner_len_x, y + circ_y, (outer_len_x - inner_len_x), 1, c);
|
|
} else {
|
|
len_x = sqrt(r*r - circ_y*circ_y);
|
|
|
|
DrawRect(x - len_x, y - circ_y, len_x*2, 1, c);
|
|
DrawRect(x - len_x, y + circ_y, len_x*2, 1, c);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DrawCircleEx(int x, int y, int r, int r2, unsigned char c)
|
|
{
|
|
int circ_y;
|
|
|
|
int len_x, outer_len_x, inner_len_x;
|
|
|
|
int inner_r = r2;
|
|
int diffi = r-r2;
|
|
if (inner_r < 1) inner_r = 1;
|
|
|
|
|
|
|
|
if (r < 1) return;
|
|
// a^2 + b^2 = c^2
|
|
for (circ_y = 0; circ_y < r; circ_y++) {
|
|
if (circ_y < (r-diffi)) {
|
|
outer_len_x = sqrt(r*r - circ_y*circ_y);
|
|
inner_len_x = sqrt((r-diffi)*(r-diffi) - circ_y*circ_y);
|
|
DrawRect(x - outer_len_x, y - circ_y, (outer_len_x - inner_len_x), 1, c);
|
|
DrawRect(x + inner_len_x, y - circ_y, (outer_len_x - inner_len_x), 1, c);
|
|
DrawRect(x - outer_len_x, y + circ_y, (outer_len_x - inner_len_x), 1, c);
|
|
DrawRect(x + inner_len_x, y + circ_y, (outer_len_x - inner_len_x), 1, c);
|
|
} else {
|
|
len_x = sqrt(r*r - circ_y*circ_y);
|
|
|
|
DrawRect(x - len_x, y - circ_y, len_x*2, 1, c);
|
|
DrawRect(x - len_x, y + circ_y, len_x*2, 1, c);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DrawShield()
|
|
{
|
|
static int t=0;
|
|
int s_size;
|
|
int belts = 0;
|
|
int i, bpos;
|
|
t++;
|
|
|
|
if (player_shield == 0) return;
|
|
if (shield_hp == 0) return;
|
|
|
|
s_size = shield_hp;
|
|
if (s_size > 15) {
|
|
belts = s_size - 15;
|
|
s_size = 15;
|
|
}
|
|
DrawCircleEx(320, 240, 28+s_size, 28-s_size, 128 + (shield_hp*127/player_shield) - (50*(shield_hp<player_shield) + shield_recover) - 45 + ((t%4)*15));
|
|
|
|
for (i = 0; i < belts; i++) {
|
|
bpos = 13 + (30 * (i+1) / (belts+1));
|
|
DrawCircleEx(320, 240, bpos + 1, bpos - 1, ((i+t)%6*12));
|
|
}
|
|
}
|
|
|
|
void ST_Teleport()
|
|
{
|
|
}
|
|
|
|
int UpgradePrice(int t)
|
|
{
|
|
int price = 0;
|
|
switch (t) {
|
|
case 0:
|
|
price = (100 - training*50) * player_shield + (5<<player_shield) * (5 - training*2);
|
|
break;
|
|
case 1:
|
|
price = (80 - training*40) * circuit_fillrate + (5<<circuit_fillrate) * (4 - training*2);
|
|
break;
|
|
case 2:
|
|
price = (80 - training*40) * circuit_recoverrate + (5<<circuit_recoverrate) * (4 - training*2);
|
|
break;
|
|
default:
|
|
price = 123;
|
|
break;
|
|
}
|
|
|
|
return price;
|
|
}
|
|
|
|
void RoomTreasure(int room, int typ)
|
|
{
|
|
int treasure;
|
|
int given_treasure = 0;
|
|
|
|
if (typ == 0) {
|
|
// Treasure
|
|
treasure = rooms[room].room_param;
|
|
artifacts[treasure] = 1;
|
|
specialmessage = treasure + 1;
|
|
specialmessagetimer = 30;
|
|
SND_Pos("dat/a/crystal2.wav", 128, 0);
|
|
}
|
|
if (typ == 1) {
|
|
// Reward
|
|
while (!given_treasure) {
|
|
treasure = rand() % 4;
|
|
|
|
switch (treasure) {
|
|
case 0:
|
|
specialmessage = 20;
|
|
player_gems += rand()%((1 << (rooms[room].s_dist / 7)) * 1500);
|
|
given_treasure = 1;
|
|
SND_Pos("dat/a/tone.wav", 128, 0);
|
|
break;
|
|
case 1:
|
|
if (player_shield < 25) {
|
|
specialmessage = 10;
|
|
player_shield += 1;
|
|
given_treasure = 1;
|
|
SND_Pos("dat/a/tone.wav", 128, 0);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (circuit_fillrate < 25) {
|
|
specialmessage = 11;
|
|
circuit_fillrate += 1;
|
|
given_treasure = 1;
|
|
SND_Pos("dat/a/tone.wav", 128, 0);
|
|
}
|
|
break;
|
|
case 3:
|
|
if (circuit_recoverrate < 25) {
|
|
specialmessage = 12;
|
|
circuit_recoverrate += 1;
|
|
given_treasure = 1;
|
|
SND_Pos("dat/a/tone.wav", 128, 0);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
specialmessagetimer = 30;
|
|
}
|
|
}
|
|
|
|
int GetNearestCheckpoint(int nx, int ny)
|
|
{
|
|
int i;
|
|
int nearest_checkpoint = -1;
|
|
int nearest_dist = 10000000;
|
|
int cp_x, cp_y, cp_dist;
|
|
int room_chk[3000] = {0};
|
|
int x, y, rx, ry;
|
|
|
|
i = GetRoom(nx/32, ny/32);
|
|
if (i != -1) {
|
|
room_chk[i] = 1;
|
|
if ((rooms[i].checkpoint != 0)&&(rooms[i].visited!=0)) {
|
|
nearest_checkpoint = i;
|
|
}
|
|
}
|
|
if (nearest_checkpoint == -1) {
|
|
|
|
for (y = 0; y < 54;) {
|
|
for (x = 0; x < 54;) {
|
|
rx = nx/32 - 27 + x;
|
|
ry = ny/32 - 27 + y;
|
|
|
|
i = GetRoom(rx, ry);
|
|
if (i != -1) {
|
|
if (room_chk[i] == 0) {
|
|
room_chk[i] = 1;
|
|
if ((rooms[i].checkpoint != 0)&&(rooms[i].visited!=0)) {
|
|
cp_x = rooms[i].x * 32 + rooms[i].w * 16;
|
|
cp_y = rooms[i].y * 32 + rooms[i].h * 16;
|
|
cp_dist = dist(cp_x, cp_y, nx, ny);
|
|
if (cp_dist < nearest_dist) {
|
|
nearest_dist = cp_dist;
|
|
nearest_checkpoint = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
x += 2;
|
|
}
|
|
y += 2;
|
|
}
|
|
|
|
}
|
|
|
|
return nearest_checkpoint;
|
|
}
|
|
|
|
void TeleportPlayerToRoom(int c_room)
|
|
{
|
|
if (c_room == 0) {
|
|
player_x = 8232;
|
|
player_y = 8108;
|
|
} else {
|
|
player_x = rooms[c_room].x * 32 + (rooms[c_room].w / 2 * 32) + 8;
|
|
player_y = rooms[c_room].y * 32 + (rooms[c_room].h / 2 * 32) + 4;
|
|
}
|
|
c_scroll_x = player_x;
|
|
c_scroll_y = player_y;
|
|
scroll_home = 1;
|
|
}
|
|
|
|
|
|
void TeleportPlayerToNextRoom()
|
|
{
|
|
int c_room;
|
|
c_room = (player_room + 1) % 3000;
|
|
while (! ((rooms[c_room].checkpoint!=0)&&(rooms[c_room].visited!=0))) {
|
|
c_room = (c_room + 1) % 3000;
|
|
}
|
|
|
|
if (c_room == 0) {
|
|
player_x = 8232;
|
|
player_y = 8108;
|
|
} else {
|
|
player_x = rooms[c_room].x * 32 + (rooms[c_room].w / 2 * 32) + 8;
|
|
player_y = rooms[c_room].y * 32 + (rooms[c_room].h / 2 * 32) + 4;
|
|
}
|
|
c_scroll_x = player_x;
|
|
c_scroll_y = player_y;
|
|
scroll_home = 1;
|
|
}
|
|
|
|
void ActivateTile(unsigned char tile, int x, int y)
|
|
{
|
|
int c_room;
|
|
|
|
enter_pressed = 0;
|
|
switch (tile) {
|
|
case 25:
|
|
if (artifacts[11]) break;
|
|
|
|
c_room = GetNearestCheckpoint(c_scroll_x, c_scroll_y);
|
|
if (tele_select) {
|
|
if (c_room != -1) {
|
|
if (c_room == player_room) {
|
|
TeleportPlayerToNextRoom();
|
|
} else {
|
|
TeleportPlayerToRoom(c_room);
|
|
}
|
|
}
|
|
} else {
|
|
map_enabled = 1;
|
|
game_paused = 1;
|
|
tele_select = 1;
|
|
|
|
c_scroll_x = player_x;
|
|
c_scroll_y = player_y;
|
|
}
|
|
|
|
break;
|
|
case 26:
|
|
RoomTreasure(GetRoom(x, y), (x+y)%2);
|
|
Put(x, y, 27, GetRoom(x, y));
|
|
break;
|
|
case 28:
|
|
if (player_shield >= 24) return;
|
|
if (player_gems >= UpgradePrice(0)) {
|
|
player_gems -= UpgradePrice(0);
|
|
player_shield += 1;
|
|
SND_Pos("dat/a/crystal.wav", 128, 0);
|
|
}
|
|
break;
|
|
case 29:
|
|
if (circuit_fillrate >= 24) return;
|
|
if (player_gems >= UpgradePrice(1)) {
|
|
player_gems -= UpgradePrice(1);
|
|
circuit_fillrate += 1;
|
|
SND_Pos("dat/a/crystal.wav", 128, 0);
|
|
}
|
|
break;
|
|
case 30:
|
|
if (circuit_recoverrate >= 24) return;
|
|
if (player_gems >= UpgradePrice(2)) {
|
|
player_gems -= UpgradePrice(2);
|
|
circuit_recoverrate += 1;
|
|
SND_Pos("dat/a/crystal.wav", 128, 0);
|
|
}
|
|
break;
|
|
case 31:
|
|
DoSaveGame();
|
|
break;
|
|
case 32:
|
|
CrystalSummon();
|
|
SND_Pos("dat/a/crystal.wav", 80, 0);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CompassPoint()
|
|
{
|
|
int nearest = 1000000;
|
|
int n_room = -1;
|
|
int i;
|
|
int loc_x, loc_y;
|
|
int cdist;
|
|
int rplx, rply;
|
|
int bosses_defeated = current_boss;
|
|
float pdir_1 = 0;
|
|
float pdir_2 = 0;
|
|
int pdir_1t = 0, pdir_2t = 0;
|
|
|
|
rplx = player_x + PLAYERW/2;
|
|
rply = player_y + PLAYERH/2;
|
|
// Find the nearest SIGNIFICANT LOCATION for the player
|
|
|
|
// Look at the three artifacts
|
|
// Unless the player is going for the place of power
|
|
|
|
if (current_boss < 3) {
|
|
for (i = 0; i < 3; i++) {
|
|
// Has the player got this artifact already?
|
|
if (artifacts[8+i] == 0) { // no
|
|
// Has the player already destroyed the boss?
|
|
if (rooms[i * 1000 + 999].room_type == 2) { // no
|
|
// Can the player get the artifact?
|
|
if (CanGetArtifact()) {
|
|
// Point player to this artifact room, if it is the nearest
|
|
loc_x = rooms[i * 1000 + 499].x * 32 + rooms[i * 1000 + 499].w * 16;
|
|
loc_y = rooms[i * 1000 + 499].y * 32 + rooms[i * 1000 + 499].h * 16;
|
|
cdist = dist(rplx, rply, loc_x, loc_y);
|
|
if (cdist < nearest) {
|
|
nearest = cdist;
|
|
n_room = i * 1000 + 499;
|
|
}
|
|
}
|
|
}
|
|
} else { // has artifact
|
|
// Has the player already destroyed the boss?
|
|
if (rooms[i * 1000 + 999].room_type == 2) { // no
|
|
// Point player to the boss room, if it is the nearest
|
|
loc_x = rooms[i * 1000 + 999].x * 32 + rooms[i * 1000 + 999].w * 16;
|
|
loc_y = rooms[i * 1000 + 999].y * 32 + rooms[i * 1000 + 999].h * 16;
|
|
cdist = dist(rplx, rply, loc_x, loc_y);
|
|
if (cdist < nearest) {
|
|
nearest = cdist;
|
|
n_room = i * 1000 + 999;
|
|
}
|
|
} else { // yes
|
|
bosses_defeated++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// If, on the other hand, the player has destroyed all three bosses, point them towards the
|
|
// PLACE OF POWER
|
|
if (bosses_defeated == 3) {
|
|
// If the player already has the seal, point them to home
|
|
if (artifacts[11] == 1) {
|
|
loc_x = rooms[0].x * 32 + rooms[0].w * 16;
|
|
loc_y = rooms[0].y * 32 + rooms[0].h * 16;
|
|
cdist = dist(rplx, rply, loc_x, loc_y);
|
|
if (cdist < nearest) {
|
|
nearest = cdist;
|
|
n_room = 0;
|
|
}
|
|
} else {
|
|
// Can the player touch the seal?
|
|
if (CanGetArtifact()) {
|
|
loc_x = rooms[place_of_power].x * 32 + rooms[place_of_power].w * 16;
|
|
loc_y = rooms[place_of_power].y * 32 + rooms[place_of_power].h * 16;
|
|
cdist = dist(rplx, rply, loc_x, loc_y);
|
|
if (cdist < nearest) {
|
|
nearest = cdist;
|
|
n_room = place_of_power;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Did we find a room? If so, point to it
|
|
|
|
if (n_room != -1) {
|
|
loc_x = rooms[n_room].x * 32 + rooms[n_room].w * 16;
|
|
loc_y = rooms[n_room].y * 32 + rooms[n_room].h * 16;
|
|
|
|
pdir_1 = PlayerDir(loc_x, loc_y) + M_PI;
|
|
pdir_1t = 1;
|
|
|
|
n_room = -1;
|
|
}
|
|
|
|
nearest = 1000000;
|
|
// Find the nearest uncleared artifact room
|
|
for (i = 0; i < 3000; i++) {
|
|
if (rooms[i].room_type == 3) {
|
|
loc_x = rooms[i].x * 32 + rooms[i].w * 16;
|
|
loc_y = rooms[i].y * 32 + rooms[i].h * 16;
|
|
cdist = dist(rplx, rply, loc_x, loc_y);
|
|
if (cdist < nearest) {
|
|
nearest = cdist;
|
|
n_room = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (n_room != -1) {
|
|
loc_x = rooms[n_room].x * 32 + rooms[n_room].w * 16;
|
|
loc_y = rooms[n_room].y * 32 + rooms[n_room].h * 16;
|
|
|
|
pdir_2 = PlayerDir(loc_x, loc_y) + M_PI;
|
|
pdir_2t = 1;
|
|
|
|
n_room = -1;
|
|
}
|
|
|
|
// Did we find at least one thing to point to? If not, abort
|
|
if (!(pdir_1t || pdir_2t))
|
|
return;
|
|
|
|
DrawCircleEx(rplx - scroll_x, rply - scroll_y, 200, 190, 255);
|
|
if (pdir_1t)
|
|
DrawCircleEx(rplx - scroll_x + cos(pdir_1) * 170, rply - scroll_y + sin(pdir_1) * 170, 30, 20, 255);
|
|
if (pdir_2t)
|
|
DrawCircleEx(rplx - scroll_x + cos(pdir_2) * 170, rply - scroll_y + sin(pdir_2) * 170, 30, 20, 195);
|
|
|
|
for (i = 0; i < 50; i++) {
|
|
if (pdir_1t)
|
|
DrawCircle(rplx - scroll_x + cos(pdir_1) * (25 + i * 4), rply - scroll_y + sin(pdir_1) * (25 + i * 4), 5, 255);
|
|
if (pdir_2t)
|
|
DrawCircle(rplx - scroll_x + cos(pdir_2) * (25 + i * 4), rply - scroll_y + sin(pdir_2) * (25 + i * 4), 5, 195);
|
|
}
|
|
DrawCircleEx(rplx - scroll_x, rply - scroll_y, 30, 20, 255);
|
|
|
|
DrawCircleEx(rplx - scroll_x, rply - scroll_y, 197, 193, 128);
|
|
if (pdir_1t)
|
|
DrawCircleEx(rplx - scroll_x + cos(pdir_1) * 170, rply - scroll_y + sin(pdir_1) * 170, 27, 23, 128);
|
|
if (pdir_2t)
|
|
DrawCircleEx(rplx - scroll_x + cos(pdir_2) * 170, rply - scroll_y + sin(pdir_2) * 170, 27, 23, 78);
|
|
|
|
for (i = 0; i < 50; i++) {
|
|
if (pdir_1t)
|
|
DrawCircle(rplx - scroll_x + cos(pdir_1) * (25 + i * 4), rply - scroll_y + sin(pdir_1) * (25 + i * 4), 3, 128);
|
|
if (pdir_2t)
|
|
DrawCircle(rplx - scroll_x + cos(pdir_2) * (25 + i * 4), rply - scroll_y + sin(pdir_2) * (25 + i * 4), 3, 78);
|
|
}
|
|
DrawCircleEx(rplx - scroll_x, rply - scroll_y, 27, 23, 128);
|
|
}
|
|
|
|
void SpecialTile(int x, int y)
|
|
{
|
|
static int otext = 0;
|
|
static int t = 0;
|
|
unsigned char tile;
|
|
char message[100] = "";
|
|
|
|
tile = Get(x, y);
|
|
switch (tile) {
|
|
case 25:
|
|
if (artifacts[11]) {
|
|
sprintf(message, "This is a checkpoint, but it doesn't seem to be working");
|
|
break;
|
|
}
|
|
if (checkpoints_found <= 1) {
|
|
sprintf(message, "This is a checkpoint. You will return here when you die.");
|
|
} else {
|
|
sprintf(message, "Press ENTER to teleport between checkpoints.");
|
|
}
|
|
break;
|
|
case 26:
|
|
sprintf(message, "Press ENTER to open the storage chest");
|
|
break;
|
|
case 28:
|
|
if (player_shield >= 25) {
|
|
sprintf(message, "Your shield is already at full efficiency");
|
|
} else {
|
|
sprintf(message, "Press ENTER to upgrade shields (%d crystals)", UpgradePrice(0));
|
|
}
|
|
break;
|
|
case 29:
|
|
if (circuit_fillrate >= 25) {
|
|
sprintf(message, "Your circuit charge rate is already at its highest");
|
|
} else {
|
|
sprintf(message, "Press ENTER to upgrade circuit charge (%d crystals)", UpgradePrice(1));
|
|
}
|
|
break;
|
|
case 30:
|
|
if (circuit_recoverrate >= 25) {
|
|
sprintf(message, "Your circuit refill rate is already at its highest");
|
|
} else {
|
|
sprintf(message, "Press ENTER to upgrade circuit refill (%d crystals)", UpgradePrice(2));
|
|
}
|
|
break;
|
|
case 31:
|
|
sprintf(message, "Press ENTER to record your progress");
|
|
break;
|
|
case 32:
|
|
if (total_gems == 0) {
|
|
sprintf(message, "This is a crystal device. It isn't working at the moment.");
|
|
} else {
|
|
sprintf(message, "Press ENTER to activate the crystal device");
|
|
}
|
|
break;
|
|
case 42:
|
|
if (rooms[player_room].room_type == 5) {
|
|
if (CanGetArtifact(rooms[player_room].room_param)) {
|
|
|
|
} else {
|
|
sprintf(message, "The artifact is tainted with shadow. You must slay more of the shadow first.");
|
|
}
|
|
}
|
|
break;
|
|
case 53:
|
|
CompassPoint();
|
|
break;
|
|
default:
|
|
if (first_game) {
|
|
if (otext < 60) {
|
|
sprintf(message, "Press H to read the help file");
|
|
otext++;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (message[0] == 0) {
|
|
if (specialmessage != 0) {
|
|
switch (specialmessage) {
|
|
case 1: sprintf(message, "Ancient artifact: Complete Map"); break;
|
|
case 2: sprintf(message, "Ancient artifact: Shield boost"); break;
|
|
case 3: sprintf(message, "Ancient artifact: Extra crystal efficiency"); break;
|
|
case 4: sprintf(message, "Ancient artifact: Circuit booster"); break;
|
|
case 5: sprintf(message, "Ancient artifact: Metabolism increase"); break;
|
|
case 6: sprintf(message, "Ancient artifact: Dodge enhancer"); break;
|
|
case 7: sprintf(message, "Ancient artifact: Ethereal Monocle"); break;
|
|
case 8: sprintf(message, "Ancient artifact: Crystal gatherer"); break;
|
|
|
|
case 10: sprintf(message, "Enhancement: Shield upgrade"); break;
|
|
case 11: sprintf(message, "Enhancement: Circuit charge upgrade"); break;
|
|
case 12: sprintf(message, "Enhancement: Circuit refill upgrade"); break;
|
|
|
|
case 20: sprintf(message, "Reward: Psi crystals"); break;
|
|
|
|
case 30: sprintf(message, "Holy Sword 'Balmung' answers your call"); break;
|
|
case 31: sprintf(message, "Mystic Halberd 'Amenonuhoko' answers your call"); break;
|
|
case 32: sprintf(message, "Divine Bow 'Gandiva' answers your call"); break;
|
|
case 33: sprintf(message, "You capture the cursed seal. Return to the entrance"); break;
|
|
|
|
case 40: sprintf(message, "Balmung will remain here, where the ley lines are strong"); break;
|
|
case 41: sprintf(message, "Amenonuhoko will remain here, where the ley lines are strong"); break;
|
|
case 42: sprintf(message, "Gandiva will remain here, where the ley lines are strong"); break;
|
|
|
|
case 50: sprintf(message, ". . . . . . retrieved 'Agate Knife'"); break;
|
|
|
|
default: sprintf(message, "ERROR: NO MESSAGE VALUE GIVEN"); break;
|
|
}
|
|
specialmessagetimer--;
|
|
if (specialmessagetimer <= 0) {
|
|
specialmessage = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (message[0] == 0) return;
|
|
|
|
DrawRect(320 - strlen(message)*8 / 2 - 20, 100, strlen(message)*8+40, 48, 200);
|
|
DrawRect(320 - strlen(message)*8 / 2 - 15, 105, strlen(message)*8+30, 38, 32);
|
|
DrawRect(320 - strlen(message)*8 / 2 - 10, 110, strlen(message)*8+20, 28, 64);
|
|
|
|
draw_text(320 - strlen(message)*8 / 2, 120, message, t%16<8 ? 255 : 192);
|
|
t++;
|
|
if (enter_pressed) {
|
|
ActivateTile(tile, x, y);
|
|
}
|
|
}
|
|
|
|
void ScrollTo(int x, int y)
|
|
{
|
|
static int scrollspeed_x = 1, scrollspeed_y = 1;
|
|
if (scroll_home == 0) {
|
|
scroll_x = x;
|
|
scroll_y = y;
|
|
return;
|
|
}
|
|
|
|
if (scroll_home == 1) {
|
|
scrollspeed_x = (x - scroll_x)/20;
|
|
scrollspeed_y = (y - scroll_y)/20;
|
|
scroll_home = 2;
|
|
}
|
|
|
|
if (scroll_home == 2) {
|
|
scroll_x += (x - scroll_x)/2;
|
|
scroll_y += (y - scroll_y)/2;
|
|
|
|
if ((abs(scroll_x-x)<2)&&(abs(scroll_y-y)<2)) {
|
|
scroll_x = x;
|
|
scroll_y = y;
|
|
scroll_home = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
void DrawArtifacts()
|
|
{
|
|
int i;
|
|
SDL_Rect from, to;
|
|
|
|
if (artifact_spr == NULL) {
|
|
artifact_spr = IMG_Load("dat/i/artifacts.png");
|
|
SDL_SetColorKey(artifact_spr, SDL_SRCCOLORKEY | SDL_RLEACCEL, 0);
|
|
}
|
|
|
|
for (i = 0; i < 12; i++) {
|
|
if (artifacts[i]) {
|
|
from.x = i * 32;
|
|
from.y = 0;
|
|
from.w = 32;
|
|
from.h = 32;
|
|
|
|
to.x = 608;
|
|
to.y = 47 + i * 35;
|
|
SDL_BlitSurface(artifact_spr, &from, screen, &to);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Swap(int *a, int *b)
|
|
{
|
|
*a ^= *b ^= *a ^= *b;
|
|
}
|
|
|
|
void ThinLine(SDL_Surface *scr, int x1, int y1, int x2, int y2, Uint8 col)
|
|
{
|
|
int dx, dy, dm;
|
|
int i, j;
|
|
|
|
dx = (x2 - x1);
|
|
dy = (y2 - y1);
|
|
|
|
dm = abs(dx) > abs(dy) ? dx : dy;
|
|
|
|
if (dm == 0) return;
|
|
|
|
if (dm < 0) {
|
|
Swap(&x1, &x2);
|
|
Swap(&y1, &y2);
|
|
dx = (x2 - x1);
|
|
dy = (y2 - y1);
|
|
|
|
dm = dm * -1;
|
|
}
|
|
|
|
if (dm == dx) {
|
|
if (dy == 0) {
|
|
DrawRect(x1, y1, x2-x1+1, 1, col);
|
|
return;
|
|
}
|
|
for (i = 0; i < dm; i++) {
|
|
j = (dy * i / dm);
|
|
DrawRect(i+x1, j+y1, 1, 1, col);
|
|
}
|
|
}
|
|
if (dm == dy) {
|
|
if (dx == 0) {
|
|
DrawRect(x1, y1, 1, y2-y1+1, col);
|
|
return;
|
|
}
|
|
for (i = 0; i < dm; i++) {
|
|
j = (dx * i / dm);
|
|
DrawRect(j+x1, i+y1, 1, 1, col);
|
|
}
|
|
}
|
|
}
|