taisei/src/menu/mainmenu.c

/*
 * This software is licensed under the terms of the MIT-License
 * See COPYING for further information.
 * ---
 * Copyright (c) 2011-2019, Lukas Weber <laochailan@web.de>.
 * Copyright (c) 2012-2019, Andrei Alexeyev <akari@alienslab.net>.
 */

#include "taisei.h"

#include "mainmenu.h"
#include "menu.h"
#include "submenus.h"

#include "common.h"

#include "savereplay.h"
#include "stagepractice.h"
#include "difficultyselect.h"

#include "global.h"
#include "video.h"
#include "stage.h"
#include "version.h"
#include "plrmodes.h"

static MenuEntry *spell_practice_entry;
static MenuEntry *stage_practice_entry;

void main_menu_update_practice_menus(void) {
	spell_practice_entry->action = NULL;
	stage_practice_entry->action = NULL;

	for(StageInfo *stg = stages; stg->procs && (!spell_practice_entry->action || !stage_practice_entry->action); ++stg) {
		if(stg->type == STAGE_SPELL) {
			StageProgress *p = stage_get_progress_from_info(stg, D_Any, false);

			if(p && p->unlocked) {
				spell_practice_entry->action = menu_action_enter_spellpractice;
			}
		} else if(stg->type == STAGE_STORY) {
			for(Difficulty d = D_Easy; d <= D_Lunatic; ++d) {
				StageProgress *p = stage_get_progress_from_info(stg, d, false);

				if(p && p->unlocked) {
					stage_practice_entry->action = menu_action_enter_stagepractice;
				}
			}
		}
	}
}

static void begin_main_menu(MenuData *m) {
	start_bgm("menu");
}

static void update_main_menu(MenuData *menu) {
	menu->drawdata[1] += 0.1*(menu->cursor-menu->drawdata[1]);

	for(int i = 0; i < menu->ecount; i++) {
		menu->entries[i].drawdata += 0.2 * ((i == menu->cursor) - menu->entries[i].drawdata);
	}
}

attr_unused
static bool main_menu_input_handler(SDL_Event *event, void *arg) {
	MenuData *m = arg;
	TaiseiEvent te = TAISEI_EVENT(event->type);
	static hrtime_t last_abort_time = 0;

	if(te == TE_MENU_ABORT) {
		play_ui_sound("hit");
		m->cursor = m->ecount - 1;
		hrtime_t t = time_get();

		if(t - last_abort_time < HRTIME_RESOLUTION/5 && last_abort_time > 0) {
			m->selected = m->cursor;
			close_menu(m);
		}

		last_abort_time = t;
		return true;
	}

	return menu_input_handler(event, arg);
}

attr_unused
static void main_menu_input(MenuData *m) {
	events_poll((EventHandler[]){
		{ .proc = main_menu_input_handler, .arg = m },
		{ NULL }
	}, EFLAG_MENU);
}

MenuData* create_main_menu(void) {
	MenuData *m = alloc_menu();

	m->begin = begin_main_menu;
	m->draw = draw_main_menu;
	m->logic = update_main_menu;

	add_menu_entry(m, "Start Story", start_game, NULL);
	add_menu_entry(m, "Start Extra", NULL, NULL);
	add_menu_entry(m, "Stage Practice", menu_action_enter_stagepractice, NULL);
	add_menu_entry(m, "Spell Practice", menu_action_enter_spellpractice, NULL);
#ifdef DEBUG
	add_menu_entry(m, "Select Stage", menu_action_enter_stagemenu, NULL);
#endif
	add_menu_entry(m, "Replays", menu_action_enter_replayview, NULL);
	add_menu_entry(m, "Music Room", menu_action_enter_musicroom, NULL);
	add_menu_entry(m, "Options", menu_action_enter_options, NULL);
#ifndef __EMSCRIPTEN__
	add_menu_entry(m, "Quit", menu_action_close, NULL)->transition = TransFadeBlack;
	m->input = main_menu_input;
#endif

	stage_practice_entry = m->entries + 2;
	spell_practice_entry = m->entries + 3;
	main_menu_update_practice_menus();

	progress_unlock_bgm("menu");
	start_bgm("menu");

	return m;
}

void draw_main_menu_bg(MenuData* menu, double center_x, double center_y, double R, const char *tex1, const char *tex2) {
	r_color4(1, 1, 1, 1);
	r_shader("mainmenubg");
	r_uniform_float("R", R/(1-menu_fade(menu)));
	r_uniform_vec2("bg_translation", 0.001*menu->frames, 0);
	r_uniform_vec2("center", 0.5 + center_x / SCREEN_W, 0.5 + center_y / SCREEN_H);
	r_uniform_float("inv_aspect_ratio", 1.0 / VIDEO_ASPECT_RATIO);
	r_uniform_sampler("blend_mask", "cell_noise");
	r_uniform_sampler("tex2", tex2);
	fill_screen(tex1);
	r_shader_standard();
}

void draw_main_menu(MenuData *menu) {
	draw_main_menu_bg(menu, 0, 0, 0.05, "menu/mainmenubg", "stage1/cirnobg");

	float rot = sqrt(menu->frames/120.0);
	float rotfac = (1 - pow(menu_fade(menu), 2.0));

	r_draw_sprite(&(SpriteParams) {
		.sprite = "menu/logo",
		.pos = { SCREEN_W/2, SCREEN_H/2 },
		.shader = "sprite_default",
		.rotation.vector = { 0, -1, 0 },
		.rotation.angle = max(0, M_PI/1.5 - min(M_PI/1.5, rot) * rotfac),
		.color = color_mul_scalar(RGBA(1, 1, 1, 1), min(1, rot) * rotfac),
	});

	r_mat_push();
	r_mat_translate(0, SCREEN_H/2, 0);
	r_shader("text_default");

	float o = 0.7;

	for(int i = 0; i < menu->ecount; i++) {

		if(menu->entries[i].action == NULL) {
			r_color4(0.2 * o, 0.3 * o, 0.5 * o, o);
		} else {
			float a = 1 - menu->entries[i].drawdata;
			r_color4(o, min(1, 0.7 + a) * o, min(1, 0.4 + a) * o, o);
		}

		text_draw(menu->entries[i].name, &(TextParams) {
			.pos = { 50-15*menu->entries[i].drawdata, 20*(i-menu->drawdata[1]) },
			.font = "standard",
		});
	}

	r_mat_pop();

	bool cullcap_saved = r_capability_current(RCAP_CULL_FACE);
	r_disable(RCAP_CULL_FACE);
	r_color4(1, 1, 1, 0);
	r_shader("sprite_default");

	for(int i = 0; i < 50; i++) { // who needs persistent state for a particle system?
		int period = 900;
		int t = menu->frames+100*i + 30*sin(35*i);
		int cycle = t/period;
		float posx = SCREEN_W+300+100*sin(100345*i)+200*sin(1003*i+13537*cycle)-(0.6+0.01*sin(35*i))*(t%period);
		float posy = 50+ 50*sin(503*i+14677*cycle)+0.8*(t%period);
		float rx = sin(56*i+2147*cycle);
		float ry = sin(913*i+137*cycle);
		float rz = sin(1303*i+89631*cycle);
		float r = sqrt(rx*rx+ry*ry+rz*rz);

		if(!r) {
			continue;
		}

		rx /= r;
		ry /= r;
		rz /= r;

		if(posx > SCREEN_W+20 || posy < -20 || posy > SCREEN_H+20)
			continue;

		r_mat_push();
		r_mat_translate(posx,posy,0);
		r_mat_scale(0.2,0.2,0.2);
		r_mat_rotate_deg(2*(t%period),rx,ry,rz);
		draw_sprite_batched(0,0,"part/petal");
		r_mat_pop();
	}

	r_shader("text_default");
	r_capability(RCAP_CULL_FACE, cullcap_saved);

	char version[32];
	snprintf(version, sizeof(version), "v%s", TAISEI_VERSION);
	text_draw(TAISEI_VERSION, &(TextParams) {
		.align = ALIGN_RIGHT,
		.pos = { SCREEN_W-5, SCREEN_H-10 },
		.font = "small",
	});

	r_shader_standard();
}

void draw_loading_screen(void) {
	preload_resource(RES_TEXTURE, "loading", RESF_DEFAULT);
	preload_resource(RES_SHADER_PROGRAM, "text_default", RESF_PERMANENT);

	set_ortho(SCREEN_W, SCREEN_H);
	fill_screen("loading");
	text_draw("Please wait warmly…", &(TextParams) {
		.align = ALIGN_CENTER,
		.pos = { SCREEN_W/2, SCREEN_H-10 },
		.font = "standard",
		.shader = "text_default",
		.color = RGBA(0.25, 0.25, 0.25, 0.25),
	});

	video_swap_buffers();
}

void menu_preload(void) {
	difficulty_preload();

	preload_resources(RES_FONT, RESF_PERMANENT,
		"big",
		"small",
	NULL);

	preload_resources(RES_TEXTURE, RESF_PERMANENT,
		"abstract_blue",
		"abstract_brown",
		"cell_noise",
		"stage1/cirnobg",
		"menu/mainmenubg",
	NULL);

	preload_resources(RES_SPRITE, RESF_PERMANENT,
		"part/smoke",
		"part/petal",
		"menu/logo",
		"menu/arrow",
		"star",
	NULL);

	preload_resources(RES_SHADER_PROGRAM, RESF_PERMANENT,
		"mainmenubg",
		"sprite_circleclipped_indicator",
	NULL);

	preload_resources(RES_SFX, RESF_PERMANENT | RESF_OPTIONAL,
		"generic_shot",
		"shot_special1",
		"hit",
	NULL);

	preload_resources(RES_BGM, RESF_PERMANENT | RESF_OPTIONAL,
		"menu",
	NULL);

	for(int i = 0; i < NUM_CHARACTERS; ++i) {
		PlayerCharacter *pchar = plrchar_get(i);
		preload_resource(RES_SPRITE, pchar->dialog_sprite_name, RESF_PERMANENT);
		preload_resource(RES_TEXTURE, pchar->menu_texture_name, RESF_PERMANENT);
	}
}