//main函数
int main(int argc, char *argv[]){
database_init("a","a","a","a");
setlocale(LC_ALL, "");
initscr();
start_menu();
endwin();
database_close();
exit(EXIT_SUCCESS);
}
//用户注册页面
static void register_menu(){
char phone_num[15];
memset(static_message.userinfo_data.pwd, '\0', sizeof(static_message.userinfo_data.pwd));
erase();
mvprintw(3 ,25, "%s", " 欢迎访问模拟铁路订票系统！");
mvprintw(5, 25, "%s", "请输入用户名：");
getstr(static_message.userinfo_data.u_name);
mvprintw(6, 25, "%s", "请输入密码：");
refresh();
cbreak();
noecho();
int i=0;
while(i<20){
static_message.userinfo_data.pwd[i]=getch();
if(static_message.userinfo_data.pwd[i]=='\n'){
static_message.userinfo_data.pwd[i]='\0';
break;
}
move(6, 37+i);
addch('*');
refresh();
i++;
}
echo();
nocbreak();
mvprintw(7, 25, "%s", "请输入性别(男/女)：");
getstr(static_message.userinfo_data.sex);
mvprintw(8, 25, "%s", "请输入电话号码：");
getstr(phone_num);
static_message.userinfo_data.phone_num=atoi(phone_num);
mvprintw(9, 25, "%s", "请输入电子邮箱：");
getstr(static_message.userinfo_data.email);
int result=add_userinfo(static_message.userinfo_data);
if(result){
mvprintw(10, 25, "%s", " 注册成功，跳转中...");
refresh();
sleep(1);
printw("%s", ".");
refresh();
sleep(1);
printw("%s", ".");
refresh();
sleep(1);
printw("%s", ".");
refresh();
sleep(1);
main_menu();
}else{
mvprintw(10, 25, "%s", " 注册失败！跳转中...");
refresh();
sleep(3);
start_menu();
}
}
// 用户登录界面
static void login_menu(){
memset(static_message.userinfo_data.pwd, '\0', sizeof(static_message.userinfo_data.pwd));
erase();
mvprintw(3 ,25, "%s", " 欢迎访问模拟铁路订票系统！");
mvprintw(8, 35, "%s", " 用户名：");
getstr(static_message.userinfo_data.u_name);
mvprintw(11, 35, "%s", " 密 码：");
refresh();
cbreak();
noecho();
int i=0;
while(i<20){
static_message.userinfo_data.pwd[i]=getch();
if(static_message.userinfo_data.pwd[i]=='\n'){
static_message.userinfo_data.pwd[i]='\0';
break;
}
move(11, 44+i);
addch('*');
refresh();
i++;
}
echo();
nocbreak();
static_message.userinfo_data=get_userinfo(static_message.userinfo_data.u_name, static_message.userinfo_data.pwd);
refresh();
userinfo userinfo_cmp;
memset(&userinfo_cmp, 0, sizeof(userinfo_cmp));
if(memcmp(&userinfo_cmp, &(static_message.userinfo_data), sizeof(userinfo))){
mvprintw(13, 35, "%s", "登录成功，跳转中");
refresh();
sleep(1);
printw("%s", ".");
refresh();
sleep(1);
printw("%s", ".");
refresh();
sleep(1);
printw("%s", ".");
refresh();
sleep(1);
main_menu();
}else{
mvprintw(13, 35, "%s", "登录失败，用户名或密码错误！跳转中...");
refresh();
sleep(3);
start_menu();
}
}
/*
* Program entry point
*/
void main(void) {
os_init();
/* Start the timer that will seed the RNG */
TCCR1B |= (1 << CS10);
os_add_task( run_game, 30, 1);
os_add_task( collect_delta, 60, 1);
//os_add_task( check_switches, 60, 1);
start_menu();
sei();
for(;;){}
}
const char *nds_get_bool_option()
{
int i, j;
int optcnt;
winid win;
menu_item *sel;
ANY_P *ids;
const char *res;
for (i = 0, optcnt = 0; boolopt[i].name; i++) {
if (boolopt[i].addr != NULL) {
optcnt++;
}
}
ids = (ANY_P *)malloc(sizeof(ANY_P) * optcnt);
win = create_nhwindow(NHW_MENU);
start_menu(win);
for (i = 0, j = 0; boolopt[i].name; i++) {
if ((boolopt[i].addr == NULL) || (boolopt[i].optflags != SET_IN_GAME)) {
continue;
}
ids[j].a_int = i + 1;
add_menu(win, NO_GLYPH, &(ids[j]), 0, 0, 0, boolopt[i].name, 0);
j++;
}
end_menu(win, "Which Option Should Be Toggled?");
if (select_menu(win, PICK_ONE, &sel) >= 0) {
res = boolopt[sel->item.a_int - 1].name;
} else {
res = NULL;
}
destroy_nhwindow(win);
NULLFREE(sel);
NULLFREE(ids);
return res;
}
//登录后主页
static void main_menu(){
int index=1;
char commend[1];
erase();
cbreak();
noecho();
mvprintw(3 ,25, "%s", " 欢迎访问模拟铁路订票系统！");
mvprintw(5 ,25, "%s", " 主菜单：");
mvprintw(7, 30, "%s", "1. 个人资料");
mvprintw(8, 30, "%s", "2. 车次信息");
mvprintw(9, 30, "%s", "3. 我的订单");
mvprintw(10, 30, "%s", "4. 注销登录");
mvprintw(11, 30, "%s", "5. 退出系统");
refresh();
while(index){
commend[0]=getch();
switch(commend[0]){
case '1':
echo();
nocbreak();
userinfo_menu();
index=0;
break;
case '2':
echo();
nocbreak();
select_traininfo_menu();
index=0;
break;
case '3':
echo();
nocbreak();
order_menu();
index=0;
break;
case '4':
echo();
nocbreak();
start_menu();
index=0;
break;
case '5': index=0; break;
default: mvprintw(13, 30, "%s", "无效的命令!"); break;
}
}
}
nds_cmd_t nds_get_pan_direction()
{
winid win;
menu_item *sel;
ANY_P ids[4];
nds_cmd_t cmd;
int res;
win = create_nhwindow(NHW_MENU);
start_menu(win);
ids[0].a_int = CMD_PAN_UP;
ids[1].a_int = CMD_PAN_DOWN;
ids[2].a_int = CMD_PAN_LEFT;
ids[3].a_int = CMD_PAN_RIGHT;
add_menu(win, NO_GLYPH, &(ids[0]), 0, 0, 0, "Pan Up", 0);
add_menu(win, NO_GLYPH, &(ids[1]), 0, 0, 0, "Pan Down", 0);
add_menu(win, NO_GLYPH, &(ids[2]), 0, 0, 0, "Pan Left", 0);
add_menu(win, NO_GLYPH, &(ids[3]), 0, 0, 0, "Pan Right", 0);
end_menu(win, "What Direction?");
res = select_menu(win, PICK_ONE, &sel);
destroy_nhwindow(win);
if (res <= 0) {
cmd.f_char = -1;
cmd.name = NULL;
} else {
cmd.f_char = sel->item.a_int;
if (cmd.f_char == CMD_PAN_UP) {
cmd.name = "Pan Up";
} else if (cmd.f_char == CMD_PAN_DOWN) {
cmd.name = "Pan Down";
} else if (cmd.f_char == CMD_PAN_LEFT) {
cmd.name = "Pan Left";
} else if (cmd.f_char == CMD_PAN_RIGHT) {
cmd.name = "Pan Right";
}
}
NULLFREE(sel);
return cmd;
}
int main(int argc, char const *argv[])
{
welcome_screen();
start_menu();
return 0;
}
/*
* Generic yes/no function. 'def' is the default (returned by space or
* return; 'esc' returns 'q', or 'n', or the default, depending on
* what's in the string. The 'query' string is printed before the user
* is asked about the string.
* If resp is NULL, any single character is accepted and returned.
* If not-NULL, only characters in it are allowed (exceptions: the
* quitchars are always allowed, and if it contains '#' then digits
* are allowed); if it includes an <esc>, anything beyond that won't
* be shown in the prompt to the user but will be acceptable as input.
*/
char nds_yn_function(const char *ques, const char *cstr, CHAR_P def)
{
char buffer[INPUT_BUFFER_SIZE];
char *choices;
ANY_P header_id;
ANY_P *ids;
winid win;
menu_item *sel = NULL;
int ret;
int yn = 0;
int ynaq = 0;
char *direction_keys = nds_get_direction_keys();
if ((strstr(ques, "In what direction") != NULL) ||
(strstr(ques, "in what direction") != NULL)) {
/*
* We're going to use nh_poskey to get a command from the user. However,
* we must handle clicks specially. Unlike normal movement, you can't
* just click anywhere to pick a direction. Instead, the user will be
* expected to click in one of the adjacent squares around the player,
* and the click will then be translated into a movement character.
*/
while (1) {
int x, y, mod;
int sym;
nds_draw_prompt("Tap an adjacent square or press a direction key.");
nds_flush(0);
sym = nds_get_input(&x, &y, &mod);
nds_clear_prompt();
if (mod == CLICK_1) {
if ((x == u.ux - 1) && (y == u.uy - 1)) {
return direction_keys[DIR_UP_LEFT];
} else if ((x == u.ux) && (y == u.uy - 1)) {
return direction_keys[DIR_UP];
} else if ((x == u.ux + 1) && (y == u.uy - 1)) {
return direction_keys[DIR_UP_RIGHT];
} else if ((x == u.ux - 1) && (y == u.uy)) {
return direction_keys[DIR_LEFT];
} else if ((x == u.ux) && (y == u.uy)) {
return direction_keys[DIR_WAIT];
} else if ((x == u.ux + 1) && (y == u.uy)) {
return direction_keys[DIR_RIGHT];
} else if ((x == u.ux - 1) && (y == u.uy + 1)) {
return direction_keys[DIR_DOWN_LEFT];
} else if ((x == u.ux) && (y == u.uy + 1)) {
return direction_keys[DIR_DOWN];
} else if ((x == u.ux + 1) && (y == u.uy + 1)) {
return direction_keys[DIR_DOWN_RIGHT];
}
} else if (mod == CLICK_2) {
if ((x == u.ux) && (y == u.uy)) {
return '>';
}
} else {
return sym;
}
}
} else if (! iflags.cmdwindow) {
return nds_prompt_char(ques, cstr, 0);
} else if (strstr(ques, "Adjust letter to what") != NULL) {
return nds_prompt_char(ques, cstr, 0);
} else if (strstr(ques, "What command?") != NULL) {
nds_cmd_t cmd;
nds_draw_prompt("Select a command.");
nds_flush(0);
cmd = nds_cmd_loop(CMDLOOP_WHATDOES);
nds_clear_prompt();
return cmd.f_char;
} else if (strstr(ques, "What do you look for?") != NULL) {
return nds_prompt_char(ques, cstr, 0);
} else if (strstr(ques, "adjust?") != NULL) {
cstr = ynchars;
}
if ((index(ques, '[') == NULL) && (cstr == NULL)) {
nds_draw_prompt(ques);
return '*';
}
win = create_nhwindow(NHW_MENU);
start_menu(win);
if ((cstr != NULL) &&
((strcasecmp(cstr, ynchars) == 0) ||
(strcasecmp(cstr, ynqchars) == 0) ||
((ynaq = strcasecmp(cstr, ynaqchars)) == 0))) {
ids = (ANY_P *)malloc(sizeof(ANY_P) * 2);
yn = 1;
ids[0].a_int = 'y';
ids[1].a_int = 'n';
add_menu(win, NO_GLYPH, &(ids[0]), 0, 0, 0, "Yes", 0);
add_menu(win, NO_GLYPH, &(ids[1]), 0, 0, 0, "No", 0);
if (ynaq) {
ids[2].a_int = 'a';
add_menu(win, NO_GLYPH, &(ids[2]), 0, 0, 0, "All", 0);
}
} else if ((cstr != NULL) && (strcasecmp(cstr, "rl") == 0)) {
ids = (ANY_P *)malloc(sizeof(ANY_P) * 2);
ids[0].a_int = 'r';
ids[1].a_int = 'l';
add_menu(win, NO_GLYPH, &(ids[0]), 0, 0, 0, "Right Hand", 0);
add_menu(win, NO_GLYPH, &(ids[1]), 0, 0, 0, "Left Hand", 0);
} else {
int i;
char curclass = -1;
choices = _nds_parse_choices(ques);
ids = (ANY_P *)malloc(sizeof(ANY_P) * strlen(choices));
header_id.a_int = 0;
for (i = 0; i < strlen(choices); i++) {
ids[i].a_int = choices[i];
if (choices[i] == ' ') {
add_menu(win, NO_GLYPH, &(header_id), 0, 0, 0, "Other", 0);
} else if (choices[i] == '*') {
add_menu(win, NO_GLYPH, &(ids[i]), 0, 0, 0, "Something from your inventory", 0);
} else if ((choices[i] == '-') || (choices[i] == '.')) {
add_menu(win, NO_GLYPH, &(ids[i]), 0, 0, 0, "Nothing/your finger", 0);
} else if (choices[i] == '?') {
continue;
} else {
int oclass;
char oname[BUFSZ];
if (choices[i] == '$') {
oclass = COIN_CLASS;
sprintf(oname, "%ld gold piece%s", u.ugold, plur(u.ugold));
} else {
struct obj *otmp = obj_for_let(choices[i]);
oclass = otmp->oclass;
strcpy(oname, doname(otmp));
}
if (oclass != curclass) {
add_menu(win, NO_GLYPH, &(header_id), 0, 0, 0, let_to_name(oclass, FALSE), 0);
curclass = oclass;
}
add_menu(win, NO_GLYPH, &(ids[i]), 0, 0, 0, oname, 0);
}
}
}
end_menu(win, ques);
int mode = ((cstr == NULL) || (index(cstr, '#') != NULL)) ? PICK_ONE_TYPE : PICK_ONE;
int cnt = select_menu(win, mode, &sel);
if (cnt <= 0) {
ret = yn ? 'n' : '\033';
} else if ((mode == PICK_ONE) || (sel->count < 0)) {
ret = sel->item.a_int;
} else if (mode == PICK_ONE_TYPE) {
sprintf(buffer, "%d%c", sel->count, sel->item.a_int);
nds_input_buffer_append(buffer + 1);
ret = *buffer;
}
if (sel != NULL) {
free(sel);
}
free(ids);
destroy_nhwindow(win);
return ret;
}
nds_cmd_t nds_get_direction()
{
winid win;
menu_item *sel;
ANY_P ids[25];
nds_cmd_t cmd;
int i, j, k;
int res;
char tmp[2];
char *direction_keys = nds_get_direction_keys();
win = create_nhwindow(NHW_MENU);
start_menu(win);
ids[0].a_int = 0;
for (i = 0, j = 1; i < 3; i++) {
switch (i) {
case 0:
add_menu(win, NO_GLYPH, &(ids[0]), 0, 0, 0, "Walk", 0);
break;
case 1:
add_menu(win, NO_GLYPH, &(ids[0]), 0, 0, 0, "Run", 0);
break;
case 2:
add_menu(win, NO_GLYPH, &(ids[0]), 0, 0, 0, "Fight", 0);
break;
}
for (k = 0; k < 8; j++, k++) {
tmp[0] = direction_keys[k];
tmp[1] = '\0';
ids[j].a_int = j;
add_menu(win, NO_GLYPH, &(ids[j]), 0, 0, 0, nds_command_to_string(tmp), 0);
}
}
end_menu(win, "What Type of Movement?");
res = select_menu(win, PICK_ONE, &sel);
destroy_nhwindow(win);
if (res <= 0) {
cmd.f_char = -1;
cmd.name = NULL;
} else if (sel->item.a_int < 9) {
tmp[0] = direction_keys[sel->item.a_int - 1];
tmp[1] = '\0';
cmd.f_char = direction_keys[sel->item.a_int - 1];
cmd.name = nds_command_to_string(tmp);
} else if (sel->item.a_int < 17) {
nds_input_buffer_push(direction_keys[sel->item.a_int - 9]);
cmd.f_char = 'g';
cmd.name = nds_command_to_string(nds_input_buffer_shiftall());
} else {
nds_input_buffer_push(direction_keys[sel->item.a_int - 17]);
cmd.f_char = 'F';
cmd.name = nds_command_to_string(nds_input_buffer_shiftall());
}
NULLFREE(sel);
return cmd;
}
void nds_player_selection()
{
int i, k, n;
char pick4u = 'n', thisch, lastch = 0;
char pbuf[PROMPT_LAYER_WIDTH], plbuf[PROMPT_LAYER_WIDTH];
winid win;
anything any;
menu_item *selected = 0;
/* prevent an unnecessary prompt */
rigid_role_checks();
/* Should we randomly pick for the player? */
if (!flags.randomall &&
(flags.initrole == ROLE_NONE || flags.initrace == ROLE_NONE ||
flags.initgend == ROLE_NONE || flags.initalign == ROLE_NONE)) {
char *prompt = build_plselection_prompt(pbuf, PROMPT_LAYER_WIDTH, flags.initrole,
flags.initrace, flags.initgend, flags.initalign);
int res = _nds_display_yes_no_prompt(prompt);
if (res < 0) {
give_up:
return;
}
if (res) {
pick4u = 'y';
}
}
root_plselection_prompt(plbuf, PROMPT_LAYER_WIDTH - 1,
flags.initrole, flags.initrace, flags.initgend, flags.initalign);
/* Select a role, if necessary */
/* we'll try to be compatible with pre-selected race/gender/alignment,
* but may not succeed */
if (flags.initrole < 0) {
char rolenamebuf[PROMPT_LAYER_WIDTH];
/* Process the choice */
if (pick4u == 'y' || flags.initrole == ROLE_RANDOM || flags.randomall) {
/* Pick a random role */
flags.initrole = pick_role(flags.initrace, flags.initgend,
flags.initalign, PICK_RANDOM);
if (flags.initrole < 0) {
iprintf("Incompatible role!");
flags.initrole = randrole();
}
} else {
/* Prompt for a role */
win = create_nhwindow(NHW_MENU);
start_menu(win);
any.a_void = 0; /* zero out all bits */
for (i = 0; roles[i].name.m; i++) {
if (ok_role(i, flags.initrace, flags.initgend,
flags.initalign)) {
any.a_int = i+1; /* must be non-zero */
thisch = lowc(roles[i].name.m[0]);
if (thisch == lastch) thisch = highc(thisch);
if (flags.initgend != ROLE_NONE && flags.initgend != ROLE_RANDOM) {
if (flags.initgend == 1 && roles[i].name.f)
Strcpy(rolenamebuf, roles[i].name.f);
else
Strcpy(rolenamebuf, roles[i].name.m);
} else {
if (roles[i].name.f) {
Strcpy(rolenamebuf, roles[i].name.m);
Strcat(rolenamebuf, "/");
Strcat(rolenamebuf, roles[i].name.f);
} else
Strcpy(rolenamebuf, roles[i].name.m);
}
add_menu(win, NO_GLYPH, &any, thisch,
0, ATR_NONE, an(rolenamebuf), MENU_UNSELECTED);
lastch = thisch;
}
}
any.a_int = pick_role(flags.initrace, flags.initgend,
flags.initalign, PICK_RANDOM)+1;
if (any.a_int == 0) /* must be non-zero */
any.a_int = randrole()+1;
add_menu(win, NO_GLYPH, &any , '*', 0, ATR_NONE,
"Random", MENU_UNSELECTED);
any.a_int = i+1; /* must be non-zero */
add_menu(win, NO_GLYPH, &any , 'q', 0, ATR_NONE,
"Quit", MENU_UNSELECTED);
Sprintf(pbuf, "Pick a role for your %s", plbuf);
end_menu(win, pbuf);
n = select_menu(win, PICK_ONE, &selected);
destroy_nhwindow(win);
/* Process the choice */
if (n != 1 || selected[0].item.a_int == any.a_int)
goto give_up; /* Selected quit */
flags.initrole = selected[0].item.a_int - 1;
free((genericptr_t) selected), selected = 0;
}
(void) root_plselection_prompt(plbuf, PROMPT_LAYER_WIDTH - 1,
flags.initrole, flags.initrace, flags.initgend, flags.initalign);
}
/* Select a race, if necessary */
/* force compatibility with role, try for compatibility with
* pre-selected gender/alignment */
if (flags.initrace < 0 || !validrace(flags.initrole, flags.initrace)) {
/* pre-selected race not valid */
if (pick4u == 'y' || flags.initrace == ROLE_RANDOM || flags.randomall) {
flags.initrace = pick_race(flags.initrole, flags.initgend,
flags.initalign, PICK_RANDOM);
if (flags.initrace < 0) {
iprintf("Incompatible race!");
flags.initrace = randrace(flags.initrole);
}
} else { /* pick4u == 'n' */
/* Count the number of valid races */
n = 0; /* number valid */
k = 0; /* valid race */
for (i = 0; races[i].noun; i++) {
if (ok_race(flags.initrole, i, flags.initgend,
flags.initalign)) {
n++;
k = i;
}
}
if (n == 0) {
for (i = 0; races[i].noun; i++) {
if (validrace(flags.initrole, i)) {
n++;
k = i;
}
}
}
/* Permit the user to pick, if there is more than one */
if (n > 1) {
win = create_nhwindow(NHW_MENU);
start_menu(win);
any.a_void = 0; /* zero out all bits */
for (i = 0; races[i].noun; i++)
if (ok_race(flags.initrole, i, flags.initgend,
flags.initalign)) {
any.a_int = i+1; /* must be non-zero */
add_menu(win, NO_GLYPH, &any, races[i].noun[0],
0, ATR_NONE, races[i].noun, MENU_UNSELECTED);
}
any.a_int = pick_race(flags.initrole, flags.initgend,
flags.initalign, PICK_RANDOM)+1;
if (any.a_int == 0) /* must be non-zero */
any.a_int = randrace(flags.initrole)+1;
add_menu(win, NO_GLYPH, &any , '*', 0, ATR_NONE,
"Random", MENU_UNSELECTED);
any.a_int = i+1; /* must be non-zero */
add_menu(win, NO_GLYPH, &any , 'q', 0, ATR_NONE,
"Quit", MENU_UNSELECTED);
Sprintf(pbuf, "Pick the race of your %s", plbuf);
end_menu(win, pbuf);
n = select_menu(win, PICK_ONE, &selected);
destroy_nhwindow(win);
if (n != 1 || selected[0].item.a_int == any.a_int)
goto give_up; /* Selected quit */
k = selected[0].item.a_int - 1;
free((genericptr_t) selected), selected = 0;
}
flags.initrace = k;
}
(void) root_plselection_prompt(plbuf, PROMPT_LAYER_WIDTH - 1,
flags.initrole, flags.initrace, flags.initgend, flags.initalign);
}
/* Select a gender, if necessary */
/* force compatibility with role/race, try for compatibility with
* pre-selected alignment */
if (flags.initgend < 0 || !validgend(flags.initrole, flags.initrace,
flags.initgend)) {
/* pre-selected gender not valid */
if (pick4u == 'y' || flags.initgend == ROLE_RANDOM || flags.randomall) {
flags.initgend = pick_gend(flags.initrole, flags.initrace,
flags.initalign, PICK_RANDOM);
if (flags.initgend < 0) {
iprintf("Incompatible gender!");
flags.initgend = randgend(flags.initrole, flags.initrace);
}
} else { /* pick4u == 'n' */
/* Count the number of valid genders */
n = 0; /* number valid */
k = 0; /* valid gender */
for (i = 0; i < ROLE_GENDERS; i++) {
if (ok_gend(flags.initrole, flags.initrace, i,
flags.initalign)) {
n++;
k = i;
}
}
if (n == 0) {
for (i = 0; i < ROLE_GENDERS; i++) {
if (validgend(flags.initrole, flags.initrace, i)) {
n++;
k = i;
}
}
}
/* Permit the user to pick, if there is more than one */
if (n > 1) {
win = create_nhwindow(NHW_MENU);
start_menu(win);
any.a_void = 0; /* zero out all bits */
for (i = 0; i < ROLE_GENDERS; i++)
if (ok_gend(flags.initrole, flags.initrace, i,
flags.initalign)) {
any.a_int = i+1;
add_menu(win, NO_GLYPH, &any, genders[i].adj[0],
0, ATR_NONE, genders[i].adj, MENU_UNSELECTED);
}
any.a_int = pick_gend(flags.initrole, flags.initrace,
flags.initalign, PICK_RANDOM)+1;
if (any.a_int == 0) /* must be non-zero */
any.a_int = randgend(flags.initrole, flags.initrace)+1;
add_menu(win, NO_GLYPH, &any , '*', 0, ATR_NONE,
"Random", MENU_UNSELECTED);
any.a_int = i+1; /* must be non-zero */
add_menu(win, NO_GLYPH, &any , 'q', 0, ATR_NONE,
"Quit", MENU_UNSELECTED);
Sprintf(pbuf, "Pick the gender of your %s", plbuf);
end_menu(win, pbuf);
n = select_menu(win, PICK_ONE, &selected);
destroy_nhwindow(win);
if (n != 1 || selected[0].item.a_int == any.a_int)
goto give_up; /* Selected quit */
k = selected[0].item.a_int - 1;
free((genericptr_t) selected), selected = 0;
}
flags.initgend = k;
}
(void) root_plselection_prompt(plbuf, PROMPT_LAYER_WIDTH - 1,
flags.initrole, flags.initrace, flags.initgend, flags.initalign);
}
/* Select an alignment, if necessary */
/* force compatibility with role/race/gender */
if (flags.initalign < 0 || !validalign(flags.initrole, flags.initrace,
flags.initalign)) {
/* pre-selected alignment not valid */
if (pick4u == 'y' || flags.initalign == ROLE_RANDOM || flags.randomall) {
flags.initalign = pick_align(flags.initrole, flags.initrace,
flags.initgend, PICK_RANDOM);
if (flags.initalign < 0) {
iprintf("Incompatible alignment!");
flags.initalign = randalign(flags.initrole, flags.initrace);
}
} else { /* pick4u == 'n' */
/* Count the number of valid alignments */
n = 0; /* number valid */
k = 0; /* valid alignment */
for (i = 0; i < ROLE_ALIGNS; i++) {
if (ok_align(flags.initrole, flags.initrace, flags.initgend,
i)) {
n++;
k = i;
}
}
if (n == 0) {
for (i = 0; i < ROLE_ALIGNS; i++) {
if (validalign(flags.initrole, flags.initrace, i)) {
n++;
k = i;
}
}
}
/* Permit the user to pick, if there is more than one */
if (n > 1) {
win = create_nhwindow(NHW_MENU);
start_menu(win);
any.a_void = 0; /* zero out all bits */
for (i = 0; i < ROLE_ALIGNS; i++)
if (ok_align(flags.initrole, flags.initrace,
flags.initgend, i)) {
any.a_int = i+1;
add_menu(win, NO_GLYPH, &any, aligns[i].adj[0],
0, ATR_NONE, aligns[i].adj, MENU_UNSELECTED);
}
any.a_int = pick_align(flags.initrole, flags.initrace,
flags.initgend, PICK_RANDOM)+1;
if (any.a_int == 0) /* must be non-zero */
any.a_int = randalign(flags.initrole, flags.initrace)+1;
add_menu(win, NO_GLYPH, &any , '*', 0, ATR_NONE,
"Random", MENU_UNSELECTED);
any.a_int = i+1; /* must be non-zero */
add_menu(win, NO_GLYPH, &any , 'q', 0, ATR_NONE,
"Quit", MENU_UNSELECTED);
Sprintf(pbuf, "Pick the alignment of your %s", plbuf);
end_menu(win, pbuf);
n = select_menu(win, PICK_ONE, &selected);
destroy_nhwindow(win);
if (n != 1 || selected[0].item.a_int == any.a_int)
goto give_up; /* Selected quit */
k = selected[0].item.a_int - 1;
free((genericptr_t) selected), selected = 0;
}
flags.initalign = k;
}
}
}
int main(void)
{
char command[STR_LEN] = {0, };
char path[PATH_LEN];
char *token[TOKEN_SIZE];
int byteRead;
int token_num;
int cd_result;
int i;
start_menu(path);
while(1)
{
write(1 , "Input the command : " , 20);
byteRead = read(0 , command , STR_LEN);
command[byteRead] = 0;
token_num = get_token(token, command);
token[token_num] = NULL;
if((strcmp("q", token[0]) == 0) || (strcmp("Q", token[0]) == 0) || (strcmp("exit", token[0]) == 0))
{
printf("end program..\n");
return 0;
}
else if(strcmp("cd", token[0]) == 0)
{
if(token_num > 1)
{
cd_result = chdir(token[1]);
if(cd_result == -1)
printf("cd error\n");
}
getcwd(path, PATH_LEN);
printf("current path : %s\n", path);
}
else if(strcmp("ls", token[0]) == 0)
{
if(token_num > 1)
{
if(strcmp("-l", token[1]) == 0 || (strcmp("-L", token[1]) == 0))
{
do_ls(path);
}
if((strcmp("-R", token[1]) == 0 ) || (strcmp("-r", token[1]) == 0))
{
do_ls_r(path);
}
}
else
do_simple_ls(path);
}
else
{
printf("not define.\n");
}
for(i=0; i<token_num; i++)
free(token[i]);
}
return 0;
}
//メインループ
void mymain()
{
if(syokaiflag == false)
{
highscore_syori();
syokaiflag = true;
}
if(set_graph == false)
{
load_files();
}
if(logoflag == false && file_count <41)
{
logo();
}
else if(file_count == 0)
{
option();
if(option_flag == false)
{
if(syokikaflag == true)
{
syokika();
syokikaflag = false;
}
if(game_endflag == false)
{
if(game_startflag == true)
{
wall();
}
if(game_startflag == false)
{
StopSoundMem(end_m);
start_menu();
}
DrawGraph(0,0,g_wall,TRUE);
move_myship();
botten();
drawshot();
if(game_startflag == true)
{
ball();
ball_hantei();
shot_hantei();
jiki_hantei();
sky_jouken();
skyfish();
shot_sky();
if(level == level_melo)
{
start_melo = false;
level_melo += 5;
if(melo_s == 1)
{
melo_s+=2;
}
if(melo_s == 2)
{
melo_s+=2;
}
if(melo_s == 0)
{
melo_s += shot_kaisuu%2+1;
}
if(melo_s > 5)
{
start_melo = true;
melo_s = 5;
}
}
if(start_melo == false)
{
StopSoundMem(bgm[0]);
StopSoundMem(bgm[1]);
StopSoundMem(bgm[2]);
StopSoundMem(bgm[3]);
StopSoundMem(bgm[4]);
PlaySoundMem(bgm[melo_s],DX_PLAYTYPE_LOOP);
start_melo = true;
}
}
DrawGraph(0,0,g_wall_soto,TRUE);
if(score >= 1999999999)
{
score = 1999999999;
}
if(score >= highscore)
{
highscore = score;
}
DrawFormatStringToHandle(200,463,GetColor(255,100,255),font_score,"HIGHSCORE: %d",highscore);
DrawFormatStringToHandle(200,447,GetColor(255,100,255),font_score," SCORE: %d",score);
DrawFormatStringToHandle(24,454,GetColor(255,122,0),font_lv,"Lv. %d",level);
if(combo >= 4)
{
DrawFormatStringToHandle(500,454,GetColor(122,122,255),font_lv,"%d HIT!",combo);
}
}
else if(game_endflag == true)
{
gameover();
}
}
get_option();
}
}
/*
* Main function to run one tick of the game
*/
int run_game()
{
cli();
/* Movement phase */
if(game_state == 1)
{
/* Move the reticule based on readings from the rotary encoder */
int16_t newRX = (playersX[current_player] + (RETICULE_DISTANCE * ml_cos(position))/100);
int16_t newRY = (playersY[current_player] + (RETICULE_DISTANCE * ml_sin(position))/100);
rectangle reticuleOld = {reticuleX - reticule_SPR->width / 2, reticuleX + reticule_SPR->width / 2 - 1, reticuleY - reticule_SPR->height / 2, reticuleY + reticule_SPR->height / 2 - 1};
draw_background(level_map, SILVER, reticuleOld, HEIGHT_NO_UI, WIDTH);
//fill_rectangle(reticuleOld, BLACK);
if(newRX >= 0 && newRX < WIDTH && newRY >= 0 && newRY < HEIGHT)
fill_sprite(reticule_SPR, newRX, newRY, HEIGHT_NO_UI, WIDTH);
reticuleX = newRX;
reticuleY = newRY;
/* Read firing input */
if (get_switch_long(_BV(SWC)))
{
game_state = 3;
return 0;
}
/* Read directional input.*/
if (get_switch_rpt(_BV(SWE)))
{
direction = 4;
free_sprite(player_SPR);
player_SPR = botright(current_player);
}
else if (get_switch_rpt(_BV(SWW)))
{
direction = -4;
free_sprite(player_SPR);
player_SPR = botleft(current_player);
}
else
{
direction = 0;
return 0;
}
/* Move the player */
int16_t newX = playersX[current_player] + direction;
int16_t newY = ml_min(level_map[newX - PLAYER_WIDTH], level_map[newX + PLAYER_WIDTH - 1]) - PLAYER_HEIGHT;
int8_t i;
int8_t player_collision = 0;
for(i = 0; i < players; i++)
{
if(players_HP[i] != 0 && i != current_player && newX >= playersX[i] - PLAYER_WIDTH && newX <= playersX[i] + PLAYER_WIDTH - 1)
{
player_collision = 1;
break;
}
}
/* Cancel movement if trying to climb to high or off the sides of the screen */
if(player_collision || playersY[current_player] - newY > MAX_CLIMB_HEIGHT || newX <= PLAYER_WIDTH || newX + PLAYER_WIDTH > WIDTH)
{
/* DEBUGGING prints: */
//display_string_xy("Error\n", 10, 10);
//ml_printf("Cannot move there... (%u,%u) to (%u,%u)", playersX[0], playersY[0], newX, newY);
return 0;
}
rectangle playerOld = {playersX[current_player] - PLAYER_WIDTH, playersX[current_player] + PLAYER_WIDTH - 1, playersY[current_player] - PLAYER_HEIGHT, playersY[current_player] + PLAYER_HEIGHT - 1};
fill_rectangle(playerOld, BLACK);
fill_sprite(player_SPR, newX, newY, HEIGHT_NO_UI, WIDTH);
playersX[current_player] = newX;
playersY[current_player] = newY;
}
/* Projectile phase (missile in the air) */
else if(game_state == 2)
{
/* Find the new position of the projectile */
int16_t newX = projectileX + proVelX/1000;
int16_t newY = projectileY + proVelY/1000;
rectangle projectileOld = {projectileX, projectileX, projectileY, projectileY};
fill_rectangle(projectileOld, BLACK);
/* End turn if projectile goes off the sides of the level */
if(newX < 0 || newX > WIDTH)
{
start_turn();
return 0;
}
/* If the new position is in the ground, EXPLODE!
* (Also, if off the bottom of the level) */
if(newY >= level_map[newX] || newY > HEIGHT_NO_UI)
{
int i;
for(i = -EXPLOSION_RADIUS; i <= EXPLOSION_RADIUS; i++)
{
/* Make sure that terrain is on screen */
if(newX + i >= 0 && newX + i < WIDTH)
{
uint16_t new_ground_level = newY + ml_sqrt(EXPLOSION_RADIUS * EXPLOSION_RADIUS - i * i);
if(new_ground_level >= HEIGHT_NO_UI)
level_map[newX + i] = HEIGHT_NO_UI - 1; //Clamp to bottom of level
else if(new_ground_level > level_map[newX + i]) //Don't raise the ground level!
level_map[newX + i] = new_ground_level;
}
}
draw_level(level_map, SILVER, newX - EXPLOSION_RADIUS, newX + EXPLOSION_RADIUS);
/* Check players for damage + redraw them */
for(i = 0; i < players; i++)
{
int16_t deltaX = playersX[i] - newX;
int16_t deltaY = playersY[i] - newY;
int16_t distance = ml_sqrt(deltaX * deltaX + deltaY * deltaY);
if(distance < BLAST_RADIUS)
{
int16_t damage = ml_clamp(0, players_HP[i], MAX_EXPLOSION_DAMAGE - (distance * MAX_EXPLOSION_DAMAGE / BLAST_RADIUS));
players_HP[i] -= damage;
}
rectangle playerOld = {playersX[i] - PLAYER_WIDTH, playersX[i] + PLAYER_WIDTH - 1, playersY[i] - PLAYER_HEIGHT, playersY[i] + PLAYER_HEIGHT - 1};
fill_rectangle(playerOld, BLACK);
/* If the player is still alive, redraw them */
if(players_HP[i] != 0)
{
free_sprite(player_SPR);
player_SPR = botleft(i);
playersY[i] = ml_min(level_map[playersX[i] - PLAYER_WIDTH], level_map[playersX[i] + PLAYER_WIDTH - 1]) - PLAYER_HEIGHT;
fill_sprite(player_SPR, playersX[i], playersY[i], HEIGHT_NO_UI, WIDTH);
}
}
start_turn();
return 0;
}
rectangle projectileNew = {newX, newX, newY, newY};
/* Continue turn if off top of level, but only draw if projectile onscreen */
if(newY >= 0)
{
fill_rectangle(projectileNew, RED);
}
projectileX = newX;
projectileY = newY;
/* Apply gravity and wind */
proVelY += 500;
proVelX += (wind_velocity - 10) * 50;
}
/* Charging phase */
else if(game_state == 3)
{
/* Increase the launch speed while the fire button is held */
if (get_switch_state(_BV(SWC)))
{
launch_speed++;
rectangle bar = {POWER_BAR_START, POWER_BAR_START + launch_speed, 231, 236};
fill_rectangle(bar, WHITE);
/* Fire once max power is reached */
if(launch_speed == 100)
fire_projectile();
}
else
{
fire_projectile();
}
}
/* Menu phase */
else if(game_state == 4)
{
if (get_switch_press(_BV(SWE)))
{
if(players == 4)
players = 2;
else
players++;
}
else if (get_switch_press(_BV(SWW)))
{
if(players == 2)
players = 4;
else
players--;
}
ml_printf_at("< %u Players >", 5, 115, players);
if (get_switch_long(_BV(SWC)))
{
start_game();
}
}
/* End game phase */
else if(game_state == 5)
{
if (get_switch_long(_BV(SWC)))
{
start_menu();
}
}
sei();
return 0;
}
GtkWidget* ctk_gvo_sync_new(NvCtrlAttributeHandle *handle,
GtkWidget *parent_window,
CtkConfig *ctk_config,
CtkEvent *ctk_event,
CtkGvo *gvo_parent)
{
GObject *object;
CtkGvoSync *ctk_gvo_sync;
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *alignment;
GtkWidget *button;
GtkWidget *table, *menu;
gint val, i;
NVCTRLAttributeValidValuesRec valid;
ReturnStatus ret;
gint row;
const char *help_text;
/* make sure we have a handle */
g_return_val_if_fail(handle != NULL, NULL);
/* create and initialize the object */
object = g_object_new(CTK_TYPE_GVO_SYNC, NULL);
ctk_gvo_sync = CTK_GVO_SYNC(object);
ctk_gvo_sync->handle = handle;
ctk_gvo_sync->parent_window = parent_window;
ctk_gvo_sync->ctk_config = ctk_config;
ctk_gvo_sync->ctk_event = ctk_event;
ctk_gvo_sync->gvo_parent = gvo_parent;
/* Query the current GVO state */
if ( !query_init_gvo_sync_state(ctk_gvo_sync) ) {
// Free the object
g_object_ref(object);
gtk_object_sink(GTK_OBJECT(object));
g_object_unref(object);
return NULL;
}
/* set container properties for the widget */
gtk_box_set_spacing(GTK_BOX(object), 10);
/* banner */
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, 0);
ctk_gvo_sync->banner_box = hbox;
/*
* Sync options
*/
frame = gtk_frame_new("Sync Options");
ctk_gvo_sync->frame = frame;
gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
table = gtk_table_new(6, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 0);
gtk_table_set_col_spacings(GTK_TABLE(table), 0);
gtk_container_add(GTK_CONTAINER(frame), table);
/* input video format */
label = gtk_label_new("Input Video Format: ");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 1, 0, 1, GTK_FILL, GTK_FILL,
TABLE_PADDING, TABLE_PADDING);
hbox = gtk_hbox_new(FALSE, 5);
ctk_gvo_sync->input_video_format_text_entry = gtk_entry_new();
ctk_config_set_tooltip(ctk_config,
ctk_gvo_sync->input_video_format_text_entry,
__input_video_format_help);
gtk_entry_set_width_chars
(GTK_ENTRY(ctk_gvo_sync->input_video_format_text_entry),
max_input_video_format_text_entry_length());
gtk_widget_set_sensitive(ctk_gvo_sync->input_video_format_text_entry,
FALSE);
update_input_video_format_text_entry(ctk_gvo_sync);
gtk_box_pack_start(GTK_BOX(hbox),
ctk_gvo_sync->input_video_format_text_entry,
TRUE, TRUE, 0);
/* Input video format detect button */
button = gtk_toggle_button_new_with_label("Detect");
alignment = gtk_alignment_new(1, 1, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment), button);
ctk_gvo_sync->input_video_format_detect_button = button;
ctk_config_set_tooltip(ctk_config, button,
__input_video_format_detect_help);
g_signal_connect(G_OBJECT(button), "toggled",
G_CALLBACK(detect_input_toggled), ctk_gvo_sync);
gtk_box_pack_start(GTK_BOX(hbox), alignment, FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox,
1, 2, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL,
TABLE_PADDING, TABLE_PADDING);
/* Composite Termination */
if (ctk_gvo_sync->caps & NV_CTRL_GVO_CAPABILITIES_COMPOSITE_TERMINATION) {
button =
gtk_check_button_new_with_label("Enable Composite Termination");
ctk_config_set_tooltip(ctk_config, button,
__composite_termination_help);
alignment = gtk_alignment_new(1, 1, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment), button);
gtk_table_attach(GTK_TABLE(table), alignment,
0, 2, 2, 3, GTK_FILL | GTK_EXPAND, GTK_FILL,
TABLE_PADDING, TABLE_PADDING);
ctk_gvo_sync->composite_termination_button = button;
init_composite_termination(ctk_gvo_sync);
g_signal_connect(G_OBJECT(button), "toggled",
G_CALLBACK(composite_termination_toggled),
ctk_gvo_sync);
row = 3;
} else {
ctk_gvo_sync->composite_termination_button = NULL;
row = 2;
}
/* Sync Mode */
menu = start_menu("Sync Mode: ", table, row);
ctk_drop_down_menu_append_item(CTK_DROP_DOWN_MENU(menu), "Free Running",
NV_CTRL_GVO_SYNC_MODE_FREE_RUNNING);
ctk_drop_down_menu_append_item(CTK_DROP_DOWN_MENU(menu), "GenLock",
NV_CTRL_GVO_SYNC_MODE_GENLOCK);
ctk_drop_down_menu_append_item(CTK_DROP_DOWN_MENU(menu), "FrameLock",
NV_CTRL_GVO_SYNC_MODE_FRAMELOCK);
finish_menu(menu, table, row);
row++;
ctk_gvo_sync->sync_mode_menu = menu;
ctk_drop_down_menu_set_tooltip(ctk_config, CTK_DROP_DOWN_MENU(menu),
__sync_mode_help);
ctk_drop_down_menu_set_current_value
(CTK_DROP_DOWN_MENU(ctk_gvo_sync->sync_mode_menu),
ctk_gvo_sync->sync_mode);
g_signal_connect(G_OBJECT(ctk_gvo_sync->sync_mode_menu), "changed",
G_CALLBACK(sync_mode_changed), (gpointer) ctk_gvo_sync);
/* Sync Format */
menu = start_menu("Sync Format: ", table, row);
for (i = 0; syncFormatNames[i].name; i++) {
ctk_drop_down_menu_append_item(CTK_DROP_DOWN_MENU(menu),
syncFormatNames[i].name,
syncFormatNames[i].format);
}
finish_menu(menu, table, row);
row++;
ctk_gvo_sync->sync_format_menu = menu;
ctk_drop_down_menu_set_tooltip(ctk_config, CTK_DROP_DOWN_MENU(menu),
__sync_format_help);
init_sync_format_menu(ctk_gvo_sync);
g_signal_connect(G_OBJECT(ctk_gvo_sync->sync_format_menu),
"changed", G_CALLBACK(sync_format_changed),
(gpointer) ctk_gvo_sync);
/* Sync Status */
label = gtk_label_new("Sync Status:");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1,
GTK_FILL, GTK_FILL, TABLE_PADDING, TABLE_PADDING);
ctk_gvo_sync->sync_lock_status_text = gtk_label_new("");
update_sync_lock_status_text(ctk_gvo_sync);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), ctk_gvo_sync->sync_lock_status_text,
FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox,
1, 2, row, row+1,
GTK_FILL /*| GTK_EXPAND*/, GTK_FILL,
TABLE_PADDING, TABLE_PADDING);
row++;
/*
* Synchronization Skew (Delay/Advance)
*/
/* NV_CTRL_GVO_SYNC_DELAY_PIXELS */
ret = NvCtrlGetValidAttributeValues(handle, NV_CTRL_GVO_SYNC_DELAY_PIXELS,
&valid);
if ((ret == NvCtrlSuccess) && (valid.type == ATTRIBUTE_TYPE_RANGE)) {
ret = NvCtrlGetAttribute(handle, NV_CTRL_GVO_SYNC_DELAY_PIXELS, &val);
if (ret != NvCtrlSuccess) val = 0;
if (ctk_gvo_sync->caps & NV_CTRL_GVO_CAPABILITIES_ADVANCE_SYNC_SKEW) {
label = gtk_label_new("HSync Advance:");
help_text = __hsync_advance_help;
} else {
label = gtk_label_new("HSync Delay:");
help_text = __hsync_delay_help;
}
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1,
GTK_FILL, GTK_FILL, TABLE_PADDING, TABLE_PADDING);
ctk_gvo_sync->hsync_delay_spin_button =
gtk_spin_button_new_with_range(valid.u.range.min,
valid.u.range.max, 1);
ctk_config_set_tooltip(ctk_config,
ctk_gvo_sync->hsync_delay_spin_button,
help_text);
gtk_spin_button_set_value
(GTK_SPIN_BUTTON(ctk_gvo_sync->hsync_delay_spin_button), val);
g_signal_connect(G_OBJECT(ctk_gvo_sync->hsync_delay_spin_button),
"value-changed",
G_CALLBACK(hsync_delay_changed), ctk_gvo_sync);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox),
ctk_gvo_sync->hsync_delay_spin_button,
FALSE, FALSE, 0);
label = gtk_label_new("(pixels)");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox), label,
FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox,
1, 2, row, row+1,
GTK_FILL /*| GTK_EXPAND*/, GTK_FILL,
TABLE_PADDING, TABLE_PADDING);
row++;
}
/* NV_CTRL_GVO_SYNC_DELAY_LINES */
ret = NvCtrlGetValidAttributeValues(handle, NV_CTRL_GVO_SYNC_DELAY_LINES,
&valid);
if ((ret == NvCtrlSuccess) && (valid.type == ATTRIBUTE_TYPE_RANGE)) {
ret = NvCtrlGetAttribute(handle, NV_CTRL_GVO_SYNC_DELAY_LINES, &val);
if (ret != NvCtrlSuccess) val = 0;
if (ctk_gvo_sync->caps & NV_CTRL_GVO_CAPABILITIES_ADVANCE_SYNC_SKEW) {
label = gtk_label_new("VSync Advance:");
help_text = __vsync_advance_help;
} else {
label = gtk_label_new("VSync Delay:");
help_text = __vsync_delay_help;
}
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1,
GTK_FILL, GTK_FILL, TABLE_PADDING, TABLE_PADDING);
ctk_gvo_sync->vsync_delay_spin_button =
gtk_spin_button_new_with_range(valid.u.range.min,
valid.u.range.max, 1);
ctk_config_set_tooltip(ctk_config,
ctk_gvo_sync->vsync_delay_spin_button,
help_text);
gtk_spin_button_set_value
(GTK_SPIN_BUTTON(ctk_gvo_sync->vsync_delay_spin_button), val);
g_signal_connect(G_OBJECT(ctk_gvo_sync->vsync_delay_spin_button),
"value-changed",
G_CALLBACK(vsync_delay_changed), ctk_gvo_sync);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox),
ctk_gvo_sync->vsync_delay_spin_button,
FALSE, FALSE, 0);
label = gtk_label_new("(lines)");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox), label,
FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox,
1, 2, row, row+1,
GTK_FILL /*| GTK_EXPAND*/, GTK_FILL,
TABLE_PADDING, TABLE_PADDING);
row++;
}
/* create the watch cursor (for use when the "Detect" button is toggled" */
ctk_gvo_sync->wait_cursor = gdk_cursor_new(GDK_WATCH);
/* Set UI sensitivity */
update_gvo_sync_sensitivity(ctk_gvo_sync);
/* Start listening for events */
register_for_gvo_sync_events(ctk_gvo_sync);
/* show the page */
gtk_widget_show_all(GTK_WIDGET(object));
return GTK_WIDGET(object);
} /* ctk_gvo_sync_new() */
/**
Runs before player selection, and is used to determine which game
mode to play in. If the choice is to continue or start a new game, it
sets the character name to determine which (currently unused name for
the player = new game, currently used name = continue that game);
otherwise, it implements the choice itself then either loops or
exits.
This is based on the tty code, except that it uses a menu rather
than rendering the game mode selection by hand.
*/
void
Sdlgl_game_mode_selection()
{
int c;
char** saved;
char** sp;
int plname_in_saved = 0;
int plname_was_explicit = !!*plname;
(void) plname_was_explicit; /* TODO: use this */
winid menuwin;
int n;
menu_item *selected;
anything any;
saved = get_saved_games();
if (*plname && saved && *saved) {
for (sp = saved; *sp; sp++) {
/* Note that this means that public servers need to prevent two
users with the same name but different capitalisation. (If
they aren't, it's likely to cause problems anyway...) */
if (!strcmpi(plname, *sp)) {
plname_in_saved = 1;
/* Fix capitalisation of the name to match the saved game. */
strncpy(plname, *sp, sizeof(plname)-1);
}
}
} else if (*plname) {
set_savefile_name();
/* Let's just try to open the savefile directly to see if it exists */
plname_in_saved = verify_savefile();
}
retry_mode_selection:;
reread_char:
menuwin = create_nhwindow(NHW_MENU);
any.a_void = 0;
start_menu(menuwin);
any.a_int = 'c';
add_menu(menuwin, NO_GLYPH, &any, 'c', 0, ATR_NONE,
"Continue game", MENU_UNSELECTED);
any.a_int = 'n';
add_menu(menuwin, NO_GLYPH, &any, 'n', 0, ATR_NONE,
"New game", MENU_UNSELECTED);
any.a_int = 't';
add_menu(menuwin, NO_GLYPH, &any, 't', 0, ATR_NONE,
"Tutorial", MENU_UNSELECTED);
any.a_int = 'm';
add_menu(menuwin, NO_GLYPH, &any, 'm', 0, ATR_NONE,
"Other modes", MENU_UNSELECTED);
any.a_void = 0;
add_menu(menuwin, NO_GLYPH, &any, 0, 0, ATR_NONE, "", FALSE);
any.a_int = 's';
add_menu(menuwin, NO_GLYPH, &any, 's', 0, ATR_NONE,
"Continue game", MENU_UNSELECTED);
any.a_int = 'o';
add_menu(menuwin, NO_GLYPH, &any, 'o', 0, ATR_NONE,
"New game", MENU_UNSELECTED);
any.a_int = '?';
add_menu(menuwin, NO_GLYPH, &any, '?', 0, ATR_NONE,
"Tutorial", MENU_UNSELECTED);
any.a_int = 'q';
add_menu(menuwin, NO_GLYPH, &any, 'q', 0, ATR_NONE,
"Other modes", MENU_UNSELECTED);
end_menu(menuwin, "Welcome to AceHack!");
n = select_menu(menuwin, PICK_ONE, &selected);
destroy_nhwindow(menuwin);
if (n > 0) {
c = selected[0].item.a_int;
free((genericptr_t)selected);
} else goto retry_mode_selection;
#if 0
/* TODO: This is tty code for graying out unavailable options;
we should do that in SDL/GL code too */
{
if (c == 1) { /* gray out if there's no game to continue */
if (!*plname && (!saved || !*saved)) xputs("\033[31m");
else if (*plname && !plname_in_saved) xputs("\033[31m");
/* and bold if there is */
else xputs("\033[1m");
}
else if (c == 2) { /* gray out if a game must be continued */
if (*plname && plname_in_saved) xputs("\033[31m");
}
else xputc(c); /* low-level as codes are in the file itself */
}
#endif
switch (c) {
case 'c': /* continue game */
if (*plname && plname_in_saved) break; /* just load by name */
if (!saved || !*saved) goto reread_char;
if (*plname && !plname_in_saved) goto reread_char;
if (!saved[1]) {
/* only one game to continue */
(void) strncpy(plname, *saved, sizeof(plname)-1);
} else {
/* we'll have to ask which game to continue */
winid win;
win = create_nhwindow(NHW_MENU);
start_menu(win);
any.a_void = 0;
for (sp = saved; *sp; sp++) {
any.a_void = (void*) *sp;
add_menu(win, NO_GLYPH, &any, 0, 0, ATR_NONE, *sp, MENU_UNSELECTED);
}
end_menu(win, "Continue which saved game?");
c = select_menu(win, PICK_ONE, &selected);
destroy_nhwindow(win);
if (c != 1) {
free((genericptr_t) selected);
goto retry_mode_selection;
}
(void) strncpy(plname, (char*)selected[0].item.a_void, sizeof(plname)-1);
free((genericptr_t) selected);
}
break;
case 'n': case 't': case 'm': /* the new game options */
/* if the name is forced by the -u option, don't give an option to
start a new game, as we're forced onto the existing game */
if (*plname && plname_in_saved) goto reread_char;
if (!*plname) {
Sdlgl_askname();
if (saved)
for (sp = saved; *sp; sp++) {
if (!strcmpi(plname, *sp)) {
pline("A game is running with that name already.");
Sdlgl_dismiss_nhwindow(NHW_MESSAGE); /* force a --More-- */
*plname = 0;
goto retry_mode_selection;
}
}
}
if (c == 'm') {
pline("TODO: implement game mode selection here");
goto retry_mode_selection;
do {
c = 0; /* read from keyboard */
switch(c) {
/* -D, -X on command line are overriden by selecting a normal game
explicitly */
case 'n': wizard = FALSE; discover = FALSE; break;
case 't': break;
case 'd':
#ifdef WIZARD
/* The rules here are a little complex:
- with no -u (local play, private server play), anyone
can enter debug mode;
- with -u set (generally public server play), only an
authorized user can enter debug mode.
Thus people can enter it freely in their own compiles,
but on public servers likely only the admin can enter it,
as only they can tweak the command line. (-D works too
to enter wizmode, whatever the -u option, as if it's
given the player has control over the command line anyway.) */
if (plname_was_explicit && strcmpi(plname,WIZARD)) {
extern int wiz_error_flag; /* from unixmain.c */
wiz_error_flag = TRUE;
} else {
wizard = TRUE;
c = 'n';
break;
}
/*FALLTHRU*/
#endif /* otherwise fall through, as debug mode isn't compiled in */
case 'x': discover = TRUE; c = 'n'; break;
case 's': solo = TRUE; c = 'n'; break;
case '\033': goto retry_mode_selection;
default: continue;
}
} while (c != 'n' && c != 't');
}
if (c == 't') flags.tutorial = 1;
break;
case 's': /* show high score list */
prscore_interactive();
goto retry_mode_selection;
case 'o': /* options */
doset();
goto retry_mode_selection;
case '?': /* help */
dohelp();
Sdlgl_dismiss_nhwindow(NHW_MESSAGE); /* force a --More-- */
goto retry_mode_selection;
case 'q': case '\033': /* exit */
/* This is the standard Sdlgl method of exiting. */
Sdlgl_exit_nhwindows(0);
terminate(EXIT_SUCCESS);
/*NOTREACHED*/
default:
goto reread_char;
}
if (saved) free_saved_games(saved);
}
nds_cmd_t nds_get_config_cmd(u16 key)
{
winid win;
menu_item *sel;
ANY_P ids[15];
nds_cmd_t cmd;
char tmp[BUFSZ];
int res;
win = create_nhwindow(NHW_MENU);
start_menu(win);
ids[0].a_int = 1;
ids[1].a_int = 2;
ids[2].a_int = 3;
ids[3].a_int = 4;
ids[4].a_int = 5;
add_menu(win, NO_GLYPH, &(ids[0]), 0, 0, 0, "Movement", 0);
add_menu(win, NO_GLYPH, &(ids[1]), 0, 0, 0, "Game Command", 0);
add_menu(win, NO_GLYPH, &(ids[2]), 0, 0, 0, "Toggle Option", 0);
add_menu(win, NO_GLYPH, &(ids[3]), 0, 0, 0, "Map Panning", 0);
add_menu(win, NO_GLYPH, &(ids[4]), 0, 0, 0, "No Command", 0);
sprintf(tmp, "What do you want to assign to %s?", nds_key_to_string(key));
end_menu(win, tmp);
res = select_menu(win, PICK_ONE, &sel);
destroy_nhwindow(win);
if (res <= 0) {
cmd.f_char = -1;
cmd.name = NULL;
} else {
switch (sel->item.a_int) {
case 1:
cmd = nds_get_direction();
break;
case 2:
nds_flush(0);
cmd = nds_cmd_loop(CMDLOOP_CONFIG);
break;
case 3:
{
const char *tmp = nds_get_bool_option();
if (tmp != NULL) {
cmd.f_char = CMD_OPT_TOGGLE;
cmd.name = "Toggle Option";
nds_input_buffer_append((char *)tmp);
} else {
cmd.f_char = -1;
cmd.name = NULL;
}
}
break;
case 4:
cmd = nds_get_pan_direction();
break;
case 5:
nds_flush(0);
cmd.f_char = 0;
cmd.name = NULL;
break;
}
}
NULLFREE(sel);
return cmd;
}
int main()
{
system("color 1F");
int a=0,n=0;
start_menu();
printf("\n\n\t\t WHO ARE YOU???? \n\n\n\n\t\t1) STUDENT \n\t\t2) HEAD");
printf("\n\n Enter choice: ");
scanf("%d",&a);
if(a==1)
{
char name[100];
int i=100,a,b,n,c;
system("cls");
printf("\n\t\t LIBRARY MANAGEMENT SYSTEM");
printf("\n\n\n\t PLEASE SELECT FROM THE FOLLOWING: ");
printf("\n\n\n\t\t 1) LOGIN \n\t\t 2) EXIT ");
printf("\n\n Enter choice: ");
scanf("%d",&n);
system("cls");
if(n==1)
{
char *password = (char*) malloc(i*sizeof(char));
for(c=4;c>0;c--)
{
printf("\n\t\t\tWELCOME TO LOGIN PAGE");
printf("\n\n\t\t\t\t\t\tTRIES LEFT: %d",c );
int tries=c;
printf("\n\n ENTER USER NAME:");
fflush(stdin);
gets(name);
printf("\n\n ENTER PASWORD: ");
gets(password);
fflush(stdin);
a=strcmp(name,"student");
b=strcmp(password,"ssuet");
printf("\n\n PLEASE WAIT");
sleeping();
system("cls");
if((a==0)&&(b==0))
{
printf("\n\n USERNAME AND PASSWORD ACCEPTED");
printf("\n\n\n\t\t PRESS ENTER TO CONTINUE.");
getch();
system("cls");
section_1();
break;
}
else
{
printf("\n\n INVALID USERNAME OR PASSWORD ");
printf("\n\n\n\t\t TRY AGAIN.........");
tries--;
getch();
system("cls");
if(tries==0)
{
system("cls");
printf("\n\n\n\t SORRY DUE TO SECURITY REASONS WE HAVE TO CLOSE THE PROGRAM!!!!");
getch();
exit(1);
}
}
}
}
else if(n==2)
{
exit1();
}
else
{
printf("\n\n Please Select right choice..");
sleep(1000);
system("cls");
main();
}
}
else if(a==2)
{
system("cls");
printf("\n\t\t LIBRARY MANAGEMENT SYSTEM");
printf("\n\n\n\t PLEASE SELECT FROM THE FOLLOWING: ");
printf("\n\n\n\t\t 1) LOGIN \n\t\t 2) REGISTER \n\t\t 3) MANAGE ACCOUNT \n\t\t 4) EXIT ");
printf("\n\n Enter choice: ");
scanf("%d",&n);
system("cls");
switch(n)
{
case 1:
login();
system("cls");
section();
break;
case 2:
system("cls");
reg();
break;
case 3:
system("cls");
manage_account();
break;
case 4:
system("cls");
exit1();
default:
printf("\n\n Please Select right choice..");
sleep(1000);
system("cls");
main();
}
}
else
{
printf("\n\n Please Select right choice..");
sleep(1000);
system("cls");
main();
}
getch();
return 0;
}
void mainMenu_start(void)
{
start_menu(&menu_cfg);
gui_sendEvt(EVT_REDRAW);
}
