Navigation

← Previous Changeset
Next Changeset →

Changeset 540

Timestamp:

08/20/07 07:55:25 (1 year ago)

Author:

ajps

Message:

Try and improve the names of the ui-event things so that they look like the game events they actually are.

Files:

trunk/src/cave.c (modified) (1 diff)
trunk/src/init2.c (modified) (4 diffs)
trunk/src/monster2.c (modified) (1 diff)
trunk/src/ui-event.c (modified) (7 diffs)
trunk/src/ui-event.h (modified) (2 diffs)
trunk/src/xtra1.c (modified) (6 diffs)
trunk/src/xtra3.c (modified) (29 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

trunk/src/cave.c

r523	r540
1251	1251	void lite_spot(int y, int x)
1252	1252	{
1253		~~ui_event_signal_point(ui_MAP_CHANGED~~, x, y);
	1253	event_signal_point(EVENT_MAP, x, y);
1254	1254	}
1255	1255

trunk/src/init2.c

r538	r540
1403	1403	bool init_angband(void)
1404	1404	{
1405		~~ui_event_signal(ui~~_ENTER_INIT);
	1405	event_signal(EVENT_ENTER_INIT);
1406	1406
1407	1407	/* Initialize the menus */
…	…
1412	1412
1413	1413	/* Initialize size info */
1414		~~ui_event_signal_string(ui_INIT_~~STATUS, "Initializing array sizes...");
	1414	event_signal_string(EVENT_INITSTATUS, "Initializing array sizes...");
1415	1415	if (init_z_info()) quit("Cannot initialize sizes");
1416	1416
1417	1417	/* Initialize feature info */
1418		~~ui_event_signal_string(ui_INIT_~~STATUS, "Initializing arrays... (features)");
	1418	event_signal_string(EVENT_INITSTATUS, "Initializing arrays... (features)");
1419	1419	if (init_f_info()) quit("Cannot initialize features");
1420	1420
1421	1421	/* Initialize object info */
1422		~~ui_event_signal_string(ui_INIT_~~STATUS, "Initializing arrays... (objects)");
	1422	event_signal_string(EVENT_INITSTATUS, "Initializing arrays... (objects)");
1423	1423	if (init_k_info()) quit("Cannot initialize objects");
1424	1424
1425	1425	/* Initialize artifact info */
1426		~~ui_event_signal_string(ui_INIT_~~STATUS, "Initializing arrays... (artifacts)");
	1426	event_signal_string(EVENT_INITSTATUS, "Initializing arrays... (artifacts)");
1427	1427	if (init_a_info()) quit("Cannot initialize artifacts");
1428	1428
1429	1429	/* Initialize ego-item info */
1430		~~ui_event_signal_string(ui_INIT_~~STATUS, "Initializing arrays... (ego-items");
	1430	event_signal_string(EVENT_INITSTATUS, "Initializing arrays... (ego-items");
1431	1431	if (init_e_info()) quit("Cannot initialize ego-items");
1432	1432
1433	1433	/* Initialize monster info */
1434		~~ui_event_signal_string(ui_INIT_~~STATUS, "Initializing arrays... (monsters)");
	1434	event_signal_string(EVENT_INITSTATUS, "Initializing arrays... (monsters)");
1435	1435	if (init_r_info()) quit("Cannot initialize monsters");
1436	1436
1437	1437	/* Initialize feature info */
1438		~~ui_event_signal_string(ui_INIT_~~STATUS, "Initializing arrays... (vaults)");
	1438	event_signal_string(EVENT_INITSTATUS, "Initializing arrays... (vaults)");
1439	1439	if (init_v_info()) quit("Cannot initialize vaults");
1440	1440
1441	1441	/* Initialize history info */
1442		~~ui_event_signal_string(ui_INIT_~~STATUS, "Initializing arrays... (histories)");
	1442	event_signal_string(EVENT_INITSTATUS, "Initializing arrays... (histories)");
1443	1443	if (init_h_info()) quit("Cannot initialize histories");
1444	1444
1445	1445	/* Initialize race info */
1446		~~ui_event_signal_string(ui_INIT_~~STATUS, "Initializing arrays... (races)");
	1446	event_signal_string(EVENT_INITSTATUS, "Initializing arrays... (races)");
1447	1447	if (init_p_info()) quit("Cannot initialize races");
1448	1448
1449	1449	/* Initialize class info */
1450		~~ui_event_signal_string(ui_INIT_~~STATUS, "Initializing arrays... (classes)");
	1450	event_signal_string(EVENT_INITSTATUS, "Initializing arrays... (classes)");
1451	1451	if (init_c_info()) quit("Cannot initialize classes");
1452	1452
1453	1453	/* Initialize owner info */
1454		~~ui_event_signal_string(ui_INIT_~~STATUS, "Initializing arrays... (owners)");
	1454	event_signal_string(EVENT_INITSTATUS, "Initializing arrays... (owners)");
1455	1455	if (init_b_info()) quit("Cannot initialize owners");
1456	1456
1457	1457	/* Initialize price info */
1458		~~ui_event_signal_string(ui_INIT_~~STATUS, "Initializing arrays... (prices)");
	1458	event_signal_string(EVENT_INITSTATUS, "Initializing arrays... (prices)");
1459	1459	if (init_g_info()) quit("Cannot initialize prices");
1460	1460
1461	1461	/* Initialize flavor info */
1462		~~ui_event_signal_string(ui_INIT_~~STATUS, "Initializing arrays... (flavors)");
	1462	event_signal_string(EVENT_INITSTATUS, "Initializing arrays... (flavors)");
1463	1463	if (init_flavor_info()) quit("Cannot initialize flavors");
1464	1464
1465	1465	/* Initialize spell info */
1466		~~ui_event_signal_string(ui_INIT_~~STATUS, "Initializing arrays... (spells)");
	1466	event_signal_string(EVENT_INITSTATUS, "Initializing arrays... (spells)");
1467	1467	if (init_s_info()) quit("Cannot initialize spells");
1468	1468
1469	1469	/* Initialize spellbook info */
1470		~~ui_event_signal_string(ui_INIT_~~STATUS, "Initializing arrays... (spellbooks)");
	1470	event_signal_string(EVENT_INITSTATUS, "Initializing arrays... (spellbooks)");
1471	1471	init_books();
1472	1472
1473	1473	/* Initialize some other arrays */
1474		~~ui_event_signal_string(ui_INIT_~~STATUS, "Initializing arrays... (other)");
	1474	event_signal_string(EVENT_INITSTATUS, "Initializing arrays... (other)");
1475	1475	if (init_other()) quit("Cannot initialize other stuff");
1476	1476
1477	1477	/* Initialize some other arrays */
1478		~~ui_event_signal_string(ui_INIT_~~STATUS, "Initializing arrays... (alloc)");
	1478	event_signal_string(EVENT_INITSTATUS, "Initializing arrays... (alloc)");
1479	1479	if (init_alloc()) quit("Cannot initialize alloc stuff");
1480	1480
…	…
1482	1482
1483	1483	/* Initialize feature info */
1484		~~ui_event_signal_string(ui_INIT_~~STATUS, "Loading basic user pref file...");
	1484	event_signal_string(EVENT_INITSTATUS, "Loading basic user pref file...");
1485	1485
1486	1486	/* Process that file */
…	…
1488	1488
1489	1489	/* Done */
1490		~~ui_event_signal_string(ui_INIT_~~STATUS, "Initialization complete");
	1490	event_signal_string(EVENT_INITSTATUS, "Initialization complete");
1491	1491
1492	1492	/* Sneakily init command list */

trunk/src/monster2.c

r523 r540

83 83 /* Count monsters */
84 84 mon_cnt--;
85
86 85
87 86 /* Visual update */

trunk/src/ui-event.c

r538	r540
27	27	{
28	28	struct event_handler_entry *next;
29		ui_event_handler *fn;
	29	game_event_handler *fn;
30	30	void *user;
31	31	};
32	32
33		struct event_handler_entry *event_handlers[N_UI_EVENTS];
	33	struct event_handler_entry *event_handlers[N_GAME_EVENTS];
34	34
35		static void ~~ui_event_dispatch(ui_event_type type, ui~~_event_data *data)
	35	static void game_event_dispatch(game_event_type type, game_event_data *data)
36	36	{
37	37	struct event_handler_entry *this = event_handlers[type];
…	…
48	48	}
49	49
50		void ~~ui_event_register(ui_event_type type, ui~~_event_handler fn, void user)
	50	void event_add_handler(game_event_type type, game_event_handler fn, void user)
51	51	{
52	52	struct event_handler_entry *new;
…	…
64	64	}
65	65
66		void ~~ui_event_deregister(ui_event_type type, ui~~_event_handler fn, void user)
	66	void event_remove_handler(game_event_type type, game_event_handler fn, void user)
67	67	{
68	68	struct event_handler_entry *prev = NULL;
…	…
93	93	}
94	94
95		void ~~ui_event_register_set(ui_event_type type, size_t n_types, ui~~_event_handler fn, void *user)
	95	void event_add_handler_set(game_event_type type, size_t n_types, game_event_handler fn, void *user)
96	96	{
97	97	int i;
…	…
99	99	for (i = 0; i < n_types; i++)
100	100	{
101		~~ui_event_regist~~er(type[i], fn, user);
	101	event_add_handler(type[i], fn, user);
102	102	}
103	103	}
104	104
105		void ~~ui_event_deregister_set(ui_event_type type, size_t n_types, ui~~_event_handler fn, void *user)
	105	void event_remove_handler_set(game_event_type type, size_t n_types, game_event_handler fn, void *user)
106	106	{
107	107	int i;
…	…
109	109	for (i = 0; i < n_types; i++)
110	110	{
111		~~ui_event_deregist~~er(type[i], fn, user);
	111	event_remove_handler(type[i], fn, user);
112	112	}
113	113	}
…	…
116	116
117	117
118		void ~~ui_event_signal(ui~~_event_type type)
	118	void event_signal(game_event_type type)
119	119	{
120		ui_event_dispatch(type, NULL);
	120	game_event_dispatch(type, NULL);
121	121	}
122	122
123		void ui_event_signal_point(ui_event_type type, int x, int y)
	123
	124	void event_signal_point(game_event_type type, int x, int y)
124	125	{
125		ui_event_data data;
	126	game_event_data data;
126	127	data.point.x = x;
127	128	data.point.y = y;
128	129
129		ui_event_dispatch(type, &data);
	130	game_event_dispatch(type, &data);
130	131	}
131	132
132	133
133		void ~~ui_event_signal_string(ui~~_event_type type, const char *s)
	134	void event_signal_string(game_event_type type, const char *s)
134	135	{
135		ui_event_data data;
	136	game_event_data data;
136	137	data.string = s;
137	138
138		ui_event_dispatch(type, &data);
	139	game_event_dispatch(type, &data);
139	140	}

trunk/src/ui-event.h

r538	r540
1	1
2		#ifndef INCLUDED_UI_EVENT_H
3		#define INCLUDED_UI_EVENT_H
	2	#ifndef INCLUDED_GAME_EVENT_H
	3	#define INCLUDED_GAME_EVENT_H
4	4
5	5	/* The various events we can send signals about. */
6		typedef enum ui_event_type
	6	typedef enum game_event_type
7	7	{
8		~~ui_MAP_CHANGED~~, /* Some part of the map has changed. */
	8	EVENT_MAP, /* Some part of the map has changed. */
9	9
10		~~ui_STATS_CHANGED,~~ /* One or more of the stats. */
11		~~ui_HP_CHANGED~~, /* HP or MaxHP. */
12		~~ui_MANA_CHANGED,~~ /* Mana or MaxMana. */
13		~~ui_AC_CHANGED~~, /* Armour Class. */
14		~~ui_EXPERIENCE_CHANGED~~, /* Experience or MaxExperience. */
15		~~ui_LEVEL_CHANGED~~, /* Player's level has changed */
16		~~ui_TITLE_CHANGED~~, /* Player's title has changed */
17		~~ui_GOLD_CHANGED,~~ /* Player's gold amount. */
18		~~ui_HEALTH_CHANGED~~, /* Observed monster's health level. */
19		~~ui_DEPTH_CHANGED~~, /* Dungeon depth */
20		~~ui_SPEED_CHANG~~ED, /* Player's speed */
21		~~ui_RACE_CLASS_CHANGED~~, /* Race or Class */
22		~~ui_STUDY_CHANGED~~, /* "Study" availability */
23		~~ui_STATUS_CHANGED,~~ /* Status */
24		~~ui_DETECT_TRAPS_CHANGED,~~/* Trap detection status */
25		~~ui_STATE_CHANGED,~~ /* The three 'R's: Resting, Repeating and
	10	EVENT_STATS, /* One or more of the stats. */
	11	EVENT_HP, /* HP or MaxHP. */
	12	EVENT_MANA, /* Mana or MaxMana. */
	13	EVENT_AC, /* Armour Class. */
	14	EVENT_EXPERIENCE, /* Experience or MaxExperience. */
	15	EVENT_PLAYERLEVEL, /* Player's level has changed */
	16	EVENT_PLAYERTITLE, /* Player's title has changed */
	17	EVENT_GOLD, /* Player's gold amount. */
	18	EVENT_MONSTERHEALTH, /* Observed monster's health level. */
	19	EVENT_DUNGEONLEVEL, /* Dungeon depth */
	20	EVENT_PLAYERSPEED, /* Player's speed */
	21	EVENT_RACE_CLASS, /* Race or Class */
	22	EVENT_STUDYSTATUS, /* "Study" availability */
	23	EVENT_STATUS, /* Status */
	24	EVENT_DETECTIONSTATUS, /* Trap detection status */
	25	EVENT_STATE, /* The three 'R's: Resting, Repeating and
26	26	Searching */
27	27
28		~~ui_PLAYER_~~MOVED,
	28	EVENT_PLAYERMOVED,
29	29
30		~~ui_INVENTORY_CHANGED~~,
31		~~ui_EQUIPMENT_CHANGED~~,
32		~~ui_MONSTERLIST_CHANGED~~,
33		~~ui_MONSTER_TARGET_CHANGED~~,
34		~~ui_MESSAGES_CHANGED~~,
	30	EVENT_INVENTORY,
	31	EVENT_EQUIPMENT,
	32	EVENT_MONSTERLIST,
	33	EVENT_MONSTERTARGET,
	34	EVENT_MESSAGE,
35	35
36		~~ui_event_REDRAW, /* It's the end of a "set" of events, so safe to update */~~
37	36
38		~~ui_INIT_STATUS,~~ /* New status message for initialisation */
	37	EVENT_INITSTATUS, /* New status message for initialisation */
39	38
40	39	/* Changing of the game state/context. */
41		ui_ENTER_INIT,
42		ui_ENTER_BIRTH,
43		ui_ENTER_GAME,
44		ui_ENTER_STORE,
45		ui_ENTER_DEATH
46		} ui_event_type;
	40	EVENT_ENTER_INIT,
	41	EVENT_ENTER_BIRTH,
	42	EVENT_ENTER_GAME,
	43	EVENT_ENTER_STORE,
	44	EVENT_ENTER_DEATH,
47	45
48		#define N_UI_EVENTS ui_ENTER_DEATH
	46	EVENT_END /* Can be sent at the end of a series of events */
	47	} game_event_type;
	48
	49	#define N_GAME_EVENTS EVENT_END
49	50
50	51	typedef union
…	…
58	59	const char *string;
59	60
60		} ui_event_data;
	61	} game_event_data;
61	62
62		~~typedef void ui_event_handler(ui_event_type type, ui_event_data data, void user);~~
63	63
64		void ui_event_register(ui_event_type type, ui_event_handler fn, void user);
65		void ui_event_deregister(ui_event_type type, ui_event_handler fn, void user);
66		void ui_event_register_set(ui_event_type type, size_t n_types, ui_event_handler fn, void *user);
67		void ui_event_deregister_set(ui_event_type type, size_t n_types, ui_event_handler fn, void *user);
	64	/*
	65	* A function called when a game event occurs - these are registered to be
	66	* called by event_add_handler or event_add_handler_set, and deregistered
	67	* when they should no longer be called through event_remove_handler or
	68	* event_remove_handler_set.
	69	*/
	70	typedef void game_event_handler(game_event_type type, game_event_data data, void user);
68	71
69		void ui_event_signal_point(ui_event_type, int x, int y);
70		void ui_event_signal_string(ui_event_type, const char *s);
71		void ui_event_signal(ui_event_type);
	72	void event_add_handler(game_event_type type, game_event_handler fn, void user);
	73	void event_remove_handler(game_event_type type, game_event_handler fn, void user);
	74	void event_add_handler_set(game_event_type type, size_t n_types, game_event_handler fn, void *user);
	75	void event_remove_handler_set(game_event_type type, size_t n_types, game_event_handler fn, void *user);
72	76
73		#endif /* INCLUDED_UI_EVENT_H */
	77	void event_signal_point(game_event_type, int x, int y);
	78	void event_signal_string(game_event_type, const char *s);
	79	void event_signal(game_event_type);
	80
	81	#endif /* INCLUDED_GAME_EVENT_H */

trunk/src/xtra1.c

r534	r540
23	23	{
24	24	u32b flag;
25		ui_event_type event;
	25	game_event_type event;
26	26	};
27	27
…	…
1559	1559	{
1560	1560	p_ptr->update &= ~(PU_PANEL);
1561		~~ui_event_signal(ui_PLAYER_~~MOVED);
	1561	event_signal(EVENT_PLAYERMOVED);
1562	1562	}
1563	1563	}
…	…
1570	1570	static const struct flag_event_trigger redraw_events[] =
1571	1571	{
1572		{ PR_MISC, ~~ui_RACE_CLASS_CHANGED~~ },
1573		{ PR_TITLE, ~~ui_TITLE_CHANGED~~ },
1574		{ PR_LEV, ~~ui_LEVEL_CHANGED~~ },
1575		{ PR_EXP, ~~ui_EXPERIENCE_CHANGED~~ },
1576		{ PR_STATS, ~~ui_STATS_CHANGED~~ },
1577		{ PR_ARMOR, ~~ui_AC_CHANGED~~ },
1578		{ PR_HP, ~~ui_HP_CHANGED~~ },
1579		{ PR_MANA, ~~ui_MANA_CHANGED~~ },
1580		{ PR_GOLD, ~~ui_GOLD_CHANGE~~D },
1581		{ PR_HEALTH, ~~ui_HEALTH_CHANGED~~ },
1582		{ PR_DEPTH, ~~ui_DEPTH_CHANGED~~ },
1583		{ PR_SPEED, ~~ui_SPEED_CHANG~~ED },
1584		{ PR_STATE, ~~ui_STATE_CHANGED~~ },
1585		{ PR_STATUS, ~~ui_STATUS_CHANGED~~ },
1586		{ PR_STUDY, ~~ui_STUDY_CHANGED~~ },
1587		{ PR_DTRAP, ~~ui_DETECT_TRAPS_CHANGED~~ },
1588
1589		{ PR_INVEN, ~~ui_INVENTORY_CHANGED~~ },
1590		{ PR_EQUIP, ~~ui_EQUIPMENT_CHANGED~~ },
1591		{ PR_MONLIST, ~~ui_MONSTERLIST_CHANGED~~ },
1592		{ PR_MONSTER, ~~ui_MONSTER_TARGET_CHANGED~~ },
1593		{ PR_MESSAGE, ~~ui_MESSAGES_CHANGED~~ },
	1572	{ PR_MISC, EVENT_RACE_CLASS },
	1573	{ PR_TITLE, EVENT_PLAYERTITLE },
	1574	{ PR_LEV, EVENT_PLAYERLEVEL },
	1575	{ PR_EXP, EVENT_EXPERIENCE },
	1576	{ PR_STATS, EVENT_STATS },
	1577	{ PR_ARMOR, EVENT_AC },
	1578	{ PR_HP, EVENT_HP },
	1579	{ PR_MANA, EVENT_MANA },
	1580	{ PR_GOLD, EVENT_GOLD },
	1581	{ PR_HEALTH, EVENT_MONSTERHEALTH },
	1582	{ PR_DEPTH, EVENT_DUNGEONLEVEL },
	1583	{ PR_SPEED, EVENT_PLAYERSPEED },
	1584	{ PR_STATE, EVENT_STATE },
	1585	{ PR_STATUS, EVENT_STATUS },
	1586	{ PR_STUDY, EVENT_STUDYSTATUS },
	1587	{ PR_DTRAP, EVENT_DETECTIONSTATUS },
	1588
	1589	{ PR_INVEN, EVENT_INVENTORY },
	1590	{ PR_EQUIP, EVENT_EQUIPMENT },
	1591	{ PR_MONLIST, EVENT_MONSTERLIST },
	1592	{ PR_MONSTER, EVENT_MONSTERTARGET },
	1593	{ PR_MESSAGE, EVENT_MESSAGE },
1594	1594	};
1595	1595
…	…
1616	1616
1617	1617	if (p_ptr->redraw & hnd->flag)
1618		~~ui_~~event_signal(hnd->event);
	1618	event_signal(hnd->event);
1619	1619	}
1620	1620
…	…
1623	1623	{
1624	1624	/* Mark the whole map to be redrawn */
1625		~~ui_event_signal_point(ui_MAP_CHANGED~~, -1, -1);
	1625	event_signal_point(EVENT_MAP, -1, -1);
1626	1626	}
1627	1627
…	…
1632	1632	* is over.
1633	1633	*/
1634		~~ui_event_signal(ui_event_REDRAW~~);
	1634	event_signal(EVENT_END);
1635	1635	}
1636	1636

trunk/src/xtra3.c

r538	r540
28	28	* in this list.
29	29	*/
30		ui_event_type player_events[] =
31		{
32		ui_RACE_CLASS_CHANGED,
33		ui_TITLE_CHANGED,
34		ui_EXPERIENCE_CHANGED,
35		ui_LEVEL_CHANGED,
36		ui_GOLD_CHANGED,
37		ui_EXPERIENCE_CHANGED,
38		ui_EQUIPMENT_CHANGED,
39		ui_STATS_CHANGED,
40		ui_AC_CHANGED,
41		ui_MANA_CHANGED,
42		ui_HP_CHANGED,
43		ui_HEALTH_CHANGED,
44		ui_SPEED_CHANGED,
45		ui_DEPTH_CHANGED,
	30	game_event_type player_events[] =
	31	{
	32	EVENT_RACE_CLASS,
	33	EVENT_PLAYERTITLE,
	34	EVENT_EXPERIENCE,
	35	EVENT_PLAYERLEVEL,
	36	EVENT_GOLD,
	37	EVENT_EQUIPMENT, /* For equippy chars */
	38	EVENT_STATS,
	39	EVENT_HP,
	40	EVENT_MANA,
	41	EVENT_AC,
	42
	43	EVENT_MONSTERHEALTH,
	44
	45	EVENT_PLAYERSPEED,
	46	EVENT_DUNGEONLEVEL,
46	47	};
47	48
48		ui_event_type statusline_events[] =
49		{
50		~~ui_STATE_CHANGED~~,
51		~~ui_STATUS_CHANGED~~,
52		~~ui_DETECT_TRAPS_CHANGED~~,
53		~~ui_STUDY_CHANGED~~
	49	game_event_type statusline_events[] =
	50	{
	51	EVENT_STUDYSTATUS,
	52	EVENT_STATUS,
	53	EVENT_DETECTIONSTATUS,
	54	EVENT_STATE,
54	55	};
55	56
…	…
498	499	void (hook)(int, int); / int row, int col */
499	500	int priority; /* 1 is most important (always displayed) */
500		ui_event_type type; /* PR_* flag this corresponds to */
	501	game_event_type type; /* PR_* flag this corresponds to */
501	502	} side_handlers[] =
502	503	{
503		{ prt_race, 19, ~~ui_RACE_CLASS_CHANGED~~ },
504		{ prt_title, 18, ~~ui_TITLE_CHANGED~~ },
505		{ prt_class, 22, ~~ui_RACE_CLASS_CHANGED~~ },
506		{ prt_level, 10, ~~ui_LEVEL_CHANGED~~ },
507		{ prt_exp, 16, ~~ui_EXPERIENCE_CHANGED~~ },
508		{ prt_gold, 11, ~~ui_GOLD_CHANGE~~D },
509		{ prt_equippy, 17, ~~ui_EQUIPMENT_CHANGED~~ },
510		{ prt_str, 6, ~~ui_STATS_CHANGED~~ },
511		{ prt_int, 5, ~~ui_STATS_CHANGED~~ },
512		{ prt_wis, 4, ~~ui_STATS_CHANGED~~ },
513		{ prt_dex, 3, ~~ui_STATS_CHANGED~~ },
514		{ prt_con, 2, ~~ui_STATS_CHANGED~~ },
515		{ prt_chr, 1, ~~ui_STATS_CHANGED~~ },
	504	{ prt_race, 19, EVENT_RACE_CLASS },
	505	{ prt_title, 18, EVENT_PLAYERTITLE },
	506	{ prt_class, 22, EVENT_RACE_CLASS },
	507	{ prt_level, 10, EVENT_PLAYERLEVEL },
	508	{ prt_exp, 16, EVENT_EXPERIENCE },
	509	{ prt_gold, 11, EVENT_GOLD },
	510	{ prt_equippy, 17, EVENT_EQUIPMENT },
	511	{ prt_str, 6, EVENT_STATS },
	512	{ prt_int, 5, EVENT_STATS },
	513	{ prt_wis, 4, EVENT_STATS },
	514	{ prt_dex, 3, EVENT_STATS },
	515	{ prt_con, 2, EVENT_STATS },
	516	{ prt_chr, 1, EVENT_STATS },
516	517	{ NULL, 15, 0 },
517		{ prt_ac, 7, ~~ui_AC_CHANGED~~ },
518		{ prt_hp, 8, ~~ui_HP_CHANGED~~ },
519		{ prt_sp, 9, ~~ui_MANA_CHANGED~~ },
	518	{ prt_ac, 7, EVENT_AC },
	519	{ prt_hp, 8, EVENT_HP },
	520	{ prt_sp, 9, EVENT_MANA },
520	521	{ NULL, 21, 0 },
521		{ prt_health, 12, ~~ui_HEALTH_CHANGED~~ },
	522	{ prt_health, 12, EVENT_MONSTERHEALTH },
522	523	{ NULL, 20, 0 },
523	524	{ NULL, 22, 0 },
524		{ prt_speed, 13, ~~ui_SPEED_CHANG~~ED }, /* Slow (-NN) / Fast (+NN) */
525		{ prt_depth, 14, ~~ui_DEPTH_CHANGED~~ }, /* Lev NNN / NNNN ft */
	525	{ prt_speed, 13, EVENT_PLAYERSPEED }, /* Slow (-NN) / Fast (+NN) */
	526	{ prt_depth, 14, EVENT_DUNGEONLEVEL }, /* Lev NNN / NNNN ft */
526	527	};
527	528
…	…
535	536	* disappear in the order of lowest to highest importance.
536	537	*/
537		static void update_sidebar(~~ui_event_type type, ui~~_event_data data, void user)
	538	static void update_sidebar(game_event_type type, game_event_data data, void user)
538	539	{
539	540	int x, y, row;
…	…
578	579	}
579	580
580		static void hp_colour_change(~~ui_event_type type, ui~~_event_data data, void user)
	581	static void hp_colour_change(game_event_type type, game_event_data data, void user)
581	582	{
582	583	/*
…	…
889	890	* Print the status line.
890	891	*/
891		static void update_statusline(~~ui_event_type type, ui~~_event_data data, void user)
	892	static void update_statusline(game_event_type type, game_event_data data, void user)
892	893	{
893	894	int row = Term->hgt - 1;
…	…
907	908	* Map redraw.
908	909	* ------------------------------------------------------------------------ */
909		static void trace_map_updates(~~ui_event_type type, ui~~_event_data data, void user)
	910	static void trace_map_updates(game_event_type type, game_event_data data, void user)
910	911	{
911	912	if (data->point.x == -1 && data->point.y == -1)
…	…
919	920	}
920	921
921		static void update_maps(~~ui_event_type type, ui~~_event_data data, void user)
	922	static void update_maps(game_event_type type, game_event_data data, void user)
922	923	{
923	924	term *t = user;
…	…
1006	1007	static bool flip_inven;
1007	1008
1008		static void update_inven_subwindow(~~ui_event_type type, ui~~_event_data *data,
	1009	static void update_inven_subwindow(game_event_type type, game_event_data *data,
1009	1010	void *user)
1010	1011	{
…	…
1027	1028	}
1028	1029
1029		static void update_equip_subwindow(~~ui_event_type type, ui~~_event_data *data,
	1030	static void update_equip_subwindow(game_event_type type, game_event_data *data,
1030	1031	void *user)
1031	1032	{
…	…
1055	1056	}
1056	1057
1057		static void update_monlist_subwindow(~~ui_event_type type, ui~~_event_data data, void user)
	1058	static void update_monlist_subwindow(game_event_type type, game_event_data data, void user)
1058	1059	{
1059	1060	term *old = Term;
…	…
1071	1072
1072	1073
1073		static void update_monster_subwindow(~~ui_event_type type, ui~~_event_data data, void user)
	1074	static void update_monster_subwindow(game_event_type type, game_event_data data, void user)
1074	1075	{
1075	1076	term *old = Term;
…	…
1090	1091
1091	1092
1092		static void update_messages_subwindow(~~ui_event_type type, ui~~_event_data data, void user)
	1093	static void update_messages_subwindow(game_event_type type, game_event_data data, void user)
1093	1094	{
1094	1095	term *old = Term;
…	…
1141	1142	} minimap_data[ANGBAND_TERM_MAX];
1142	1143
1143		static void update_minimap_subwindow(~~ui_event_type type, ui~~_event_data data, void user)
	1144	static void update_minimap_subwindow(game_event_type type, game_event_data data, void user)
1144	1145	{
1145	1146	struct minimap_flags *flags = user;
1146	1147
1147		if (type == ~~ui_MAP_CHANGED~~)
	1148	if (type == EVENT_MAP)
1148	1149	{
1149	1150	flags->needs_redraw = TRUE;
1150	1151	}
1151		else if (type == ~~ui_event_REDRAW~~)
	1152	else if (type == EVENT_END)
1152	1153	{
1153	1154	term *old = Term;
…	…
1172	1173	* Hack -- display player in sub-windows (mode 0)
1173	1174	*/
1174		static void update_player0_subwindow(~~ui_event_type type, ui~~_event_data data, void user)
	1175	static void update_player0_subwindow(game_event_type type, game_event_data data, void user)
1175	1176	{
1176	1177	term *old = Term;
…	…
1192	1193	* Hack -- display player in sub-windows (mode 1)
1193	1194	*/
1194		static void update_player1_subwindow(~~ui_event_type type, ui~~_event_data data, void user)
	1195	static void update_player1_subwindow(game_event_type type, game_event_data data, void user)
1195	1196	{
1196	1197	term *old = Term;
…	…
1213	1214	* Display the left-hand-side of the main term, in more compact fashion.
1214	1215	*/
1215		static void update_player_compact_subwindow(~~ui_event_type type, ui~~_event_data data, void user)
	1216	static void update_player_compact_subwindow(game_event_type type, game_event_data data, void user)
1216	1217	{
1217	1218	int row = 0;
…	…
1267	1268
1268	1269
1269		static void flush_subwindow(~~ui_event_type type, ui~~_event_data data, void user)
	1270	static void flush_subwindow(game_event_type type, game_event_data data, void user)
1270	1271	{
1271	1272	term *old = Term;
…	…
1284	1285	static void subwindow_flag_changed(int win_idx, u32b flag, bool new_state)
1285	1286	{
1286		void (register_or_deregister)(~~ui_event_type type, ui~~_event_handler fn, void *user);
1287		void (set_register_or_deregister)(~~ui_event_type type, size_t n_events, ui~~_event_handler fn, void user);
	1287	void (register_or_deregister)(game_event_type type, game_event_handler fn, void *user);
	1288	void (set_register_or_deregister)(game_event_type type, size_t n_events, game_event_handler fn, void user);
1288	1289
1289	1290	/* Decide whether to register or deregister an evenrt handler */
1290	1291	if (new_state == FALSE)
1291	1292	{
1292		register_or_deregister = ~~ui_event_deregist~~er;
1293		set_register_or_deregister = ~~ui_event_deregist~~er_set;
	1293	register_or_deregister = event_remove_handler;
	1294	set_register_or_deregister = event_remove_handler_set;
1294	1295	}
1295	1296	else
1296	1297	{
1297		register_or_deregister = ~~ui_event_regist~~er;
1298		set_register_or_deregister = ~~ui_event_regist~~er_set;
	1298	register_or_deregister = event_add_handler;
	1299	set_register_or_deregister = event_add_handler_set;
1299	1300	}
1300	1301
…	…
1303	1304	case PW_INVEN:
1304	1305	{
1305		register_or_deregister(~~ui_INVENTORY_CHANGED~~,
	1306	register_or_deregister(EVENT_INVENTORY,
1306	1307	update_inven_subwindow,
1307	1308	angband_term[win_idx]);
…	…
1311	1312	case PW_EQUIP:
1312	1313	{
1313		register_or_deregister(~~ui_EQUIPMENT_CHANGED~~,
	1314	register_or_deregister(EVENT_EQUIPMENT,
1314	1315	update_equip_subwindow,
1315	1316	angband_term[win_idx]);
…	…
1346	1347	case PW_MAP:
1347	1348	{
1348		register_or_deregister(~~ui_MAP_CHANGED~~,
	1349	register_or_deregister(EVENT_MAP,
1349	1350	update_maps,
1350	1351	angband_term[win_idx]);
1351	1352
1352		register_or_deregister(~~ui_event_REDRAW~~,
	1353	register_or_deregister(EVENT_END,
1353	1354	flush_subwindow,
1354	1355	angband_term[win_idx]);
…	…
1359	1360	case PW_MESSAGE:
1360	1361	{
1361		register_or_deregister(~~ui_MONSTER_TARGET_CHANGED~~,
	1362	register_or_deregister(EVENT_MESSAGE,
1362	1363	update_messages_subwindow,
1363	1364	angband_term[win_idx]);
…	…
1369	1370	minimap_data[win_idx].win_idx = win_idx;
1370	1371
1371		register_or_deregister(~~ui_MAP_CHANGED~~,
	1372	register_or_deregister(EVENT_MAP,
1372	1373	update_minimap_subwindow,
1373	1374	&minimap_data[win_idx]);
1374	1375
1375		register_or_deregister(~~ui_event_REDRAW~~,
	1376	register_or_deregister(EVENT_END,
1376	1377	update_minimap_subwindow,
1377	1378	&minimap_data[win_idx]);
…	…
1381	1382	case PW_MONSTER:
1382	1383	{
1383		register_or_deregister(~~ui_MONSTER_TARGET_CHANGED~~,
	1384	register_or_deregister(EVENT_MONSTERTARGET,
1384	1385	update_monster_subwindow,
1385	1386	angband_term[win_idx]);
…	…
1389	1390	case PW_MONLIST:
1390	1391	{
1391		register_or_deregister(~~ui_MONSTERLIST_CHANGED~~,
	1392	register_or_deregister(EVENT_MONSTERLIST,
1392	1393	update_monlist_subwindow,
1393	1394	angband_term[win_idx]);
…	…
1476	1477	* Hack -- take notes on line 23
1477	1478	*/
1478		static void splashscreen_note(~~ui_event_type type, ui~~_event_data data, void user)
	1479	static void splashscreen_note(game_event_type type, game_event_data data, void user)
1479	1480	{
1480	1481	Term_erase(0, 23, 255);
…	…
1483	1484	}
1484	1485
1485		static void show_splashscreen(~~ui_event_type type, ui~~_event_data data, void user)
	1486	static void show_splashscreen(game_event_type type, game_event_data data, void user)
1486	1487	{
1487	1488	ang_file *fp;
…	…
1530	1531	* Temporary (hopefully) hackish solutions.
1531	1532	* ------------------------------------------------------------------------ */
1532		static void check_panel(~~ui_event_type type, ui~~_event_data data, void user)
	1533	static void check_panel(game_event_type type, game_event_data data, void user)
1533	1534	{
1534	1535	verify_panel();
…	…
1542	1543	/* Because of the "flexible" sidebar, all these things trigger
1543	1544	the same function. */
1544		~~ui_event_regist~~er_set(player_events, N_ELEMENTS(player_events),
	1545	event_add_handler_set(player_events, N_ELEMENTS(player_events),
1545	1546	update_sidebar, NULL);
1546	1547
1547	1548	/* The flexible statusbar has similar requirements, so is
1548	1549	also trigger by a large set of events. */
1549		~~ui_event_regist~~er_set(statusline_events, N_ELEMENTS(statusline_events),
	1550	event_add_handler_set(statusline_events, N_ELEMENTS(statusline_events),
1550	1551	update_statusline, NULL);
1551	1552
1552	1553	/* Player HP can optionally change the colour of the '@' now. */
1553		~~ui_event_register(ui_HP_CHANGED~~, hp_colour_change, NULL);
	1554	event_add_handler(EVENT_HP, hp_colour_change, NULL);
1554	1555
1555	1556	/* Simplest way to keep the map up to date - will do for now */
1556		~~ui_event_register(ui_MAP_CHANGED~~, update_maps, angband_term[0]);
	1557	event_add_handler(EVENT_MAP, update_maps, angband_term[0]);
1557	1558	#if 0
1558		~~ui_event_register(ui_MAP_CHANGED~~, trace_map_updates, angband_term[0]);
	1559	event_add_handler(EVENT_MAP, trace_map_updates, angband_term[0]);
1559	1560	#endif
1560	1561	/* Check if the panel should shift when the player's moved */
1561		~~ui_event_register(ui_PLAYER_~~MOVED, check_panel, NULL);
	1562	event_add_handler(EVENT_PLAYERMOVED, check_panel, NULL);
1562	1563
1563	1564
1564	1565	/* Set up our splashscreen handlers */
1565		~~ui_event_register(ui~~_ENTER_INIT, show_splashscreen, NULL);
1566		~~ui_event_register(ui_INIT_~~STATUS, splashscreen_note, NULL);
1567		}
	1566	event_add_handler(EVENT_ENTER_INIT, show_splashscreen, NULL);
	1567	event_add_handler(EVENT_INITSTATUS, splashscreen_note, NULL);
	1568	}

Download in other formats: