eukara
/
fallout2-ce
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
fallout2-ce/src/game_mouse.cc

2370 lines
70 KiB
C++
Raw Normal View History

Initial commit
2022-05-19 01:51:26 -07:00
#include "game_mouse.h"
#include "actions.h"
#include "color.h"
#include "combat.h"
#include "core.h"
#include "critter.h"
#include "draw.h"
#include "game.h"
#include "game_config.h"
#include "game_sound.h"
#include "interface.h"
#include "item.h"
#include "map.h"
#include "object.h"
#include "proto.h"
#include "proto_instance.h"
#include "skilldex.h"
#include "text_font.h"
#include "tile.h"
#include "window_manager.h"
#include <assert.h>
#include <stdio.h>
#include <string.h>
// 0x518BF8
bool gGameMouseInitialized = false;
// 0x518BFC
int _gmouse_enabled = 0;
// 0x518C00
int _gmouse_mapper_mode = 0;
// 0x518C04
int _gmouse_click_to_scroll = 0;
// 0x518C08
int _gmouse_scrolling_enabled = 1;
// 0x518C0C
int gGameMouseCursor = MOUSE_CURSOR_NONE;
// 0x518C10
CacheEntry* gGameMouseCursorFrmHandle = INVALID_CACHE_ENTRY;
// 0x518C14
const int gGameMouseCursorFrmIds[MOUSE_CURSOR_TYPE_COUNT] = {
266,
267,
268,
269,
270,
271,
272,
273,
274,
275,
276,
277,
330,
331,
329,
328,
332,
334,
333,
335,
279,
280,
281,
293,
310,
278,
295,
};
// 0x518C80
bool gGameMouseObjectsInitialized = false;
// 0x518C84
bool _gmouse_3d_hover_test = false;
// 0x518C88
unsigned int _gmouse_3d_last_move_time = 0;
// actmenu.frm
// 0x518C8C
Art* gGameMouseActionMenuFrm = NULL;
// 0x518C90
CacheEntry* gGameMouseActionMenuFrmHandle = INVALID_CACHE_ENTRY;
// 0x518C94
int gGameMouseActionMenuFrmWidth = 0;
// 0x518C98
int gGameMouseActionMenuFrmHeight = 0;
// 0x518C9C
int gGameMouseActionMenuFrmDataSize = 0;
// 0x518CA0
int _gmouse_3d_menu_frame_hot_x = 0;
// 0x518CA4
int _gmouse_3d_menu_frame_hot_y = 0;
// 0x518CA8
unsigned char* gGameMouseActionMenuFrmData = NULL;
// actpick.frm
// 0x518CAC
Art* gGameMouseActionPickFrm = NULL;
// 0x518CB0
CacheEntry* gGameMouseActionPickFrmHandle = INVALID_CACHE_ENTRY;
// 0x518CB4
int gGameMouseActionPickFrmWidth = 0;
// 0x518CB8
int gGameMouseActionPickFrmHeight = 0;
// 0x518CBC
int gGameMouseActionPickFrmDataSize = 0;
// 0x518CC0
int _gmouse_3d_pick_frame_hot_x = 0;
// 0x518CC4
int _gmouse_3d_pick_frame_hot_y = 0;
// 0x518CC8
unsigned char* gGameMouseActionPickFrmData = NULL;
// acttohit.frm
// 0x518CCC
Art* gGameMouseActionHitFrm = NULL;
// 0x518CD0
CacheEntry* gGameMouseActionHitFrmHandle = INVALID_CACHE_ENTRY;
// 0x518CD4
int gGameMouseActionHitFrmWidth = 0;
// 0x518CD8
int gGameMouseActionHitFrmHeight = 0;
// 0x518CDC
int gGameMouseActionHitFrmDataSize = 0;
// 0x518CE0
unsigned char* gGameMouseActionHitFrmData = NULL;
// blank.frm
// 0x518CE4
Art* gGameMouseBouncingCursorFrm = NULL;
// 0x518CE8
CacheEntry* gGameMouseBouncingCursorFrmHandle = INVALID_CACHE_ENTRY;
// 0x518CEC
int gGameMouseBouncingCursorFrmWidth = 0;
// 0x518CF0
int gGameMouseBouncingCursorFrmHeight = 0;
// 0x518CF4
int gGameMouseBouncingCursorFrmDataSize = 0;
// 0x518CF8
unsigned char* gGameMouseBouncingCursorFrmData = NULL;
// msef000.frm
// 0x518CFC
Art* gGameMouseHexCursorFrm = NULL;
// 0x518D00
CacheEntry* gGameMouseHexCursorFrmHandle = INVALID_CACHE_ENTRY;
// 0x518D04
int gGameMouseHexCursorFrmWidth = 0;
// 0x518D08
int gGameMouseHexCursorHeight = 0;
// 0x518D0C
int gGameMouseHexCursorDataSize = 0;
// 0x518D10
unsigned char* gGameMouseHexCursorFrmData = NULL;
// 0x518D14
unsigned char gGameMouseActionMenuItemsLength = 0;
// 0x518D18
unsigned char* _gmouse_3d_menu_actions_start = NULL;
// 0x518D1C
unsigned char gGameMouseActionMenuHighlightedItemIndex = 0;
// 0x518D1E
const short gGameMouseActionMenuItemFrmIds[GAME_MOUSE_ACTION_MENU_ITEM_COUNT] = {
253, // Cancel
255, // Drop
257, // Inventory
259, // Look
261, // Rotate
263, // Talk
265, // Use/Get
302, // Unload
304, // Skill
435, // Push
};
// 0x518D34
int _gmouse_3d_modes_enabled = 1;
// 0x518D38
int gGameMouseMode = GAME_MOUSE_MODE_MOVE;
// 0x518D3C
int gGameMouseModeFrmIds[GAME_MOUSE_MODE_COUNT] = {
249,
250,
251,
293,
293,
293,
293,
293,
293,
293,
293,
};
// 0x518D68
const int gGameMouseModeSkills[GAME_MOUSE_MODE_SKILL_COUNT] = {
SKILL_FIRST_AID,
SKILL_DOCTOR,
SKILL_LOCKPICK,
SKILL_STEAL,
SKILL_TRAPS,
SKILL_SCIENCE,
SKILL_REPAIR,
};
// 0x518D84
int gGameMouseAnimatedCursorNextFrame = 0;
// 0x518D88
unsigned int gGameMouseAnimatedCursorLastUpdateTimestamp = 0;
// 0x518D8C
int _gmouse_bk_last_cursor = -1;
// 0x518D90
bool gGameMouseItemHighlightEnabled = true;
// 0x518D94
Object* gGameMouseHighlightedItem = NULL;
// 0x518D98
bool _gmouse_clicked_on_edge = false;
// 0x518D9C
int dword_518D9C = -1;
// 0x596C3C
int gGameMouseActionMenuItems[GAME_MOUSE_ACTION_MENU_ITEM_COUNT];
// 0x596C64
int gGameMouseLastX;
// 0x596C68
int gGameMouseLastY;
// blank.frm
// 0x596C6C
Object* gGameMouseBouncingCursor;
// msef000.frm
// 0x596C70
Object* gGameMouseHexCursor;
// 0x596C74
Object* gGameMousePointedObject;
// 0x44B2B0
int gameMouseInit()
{
if (gGameMouseInitialized) {
return -1;
}
if (gameMouseObjectsInit() != 0) {
return -1;
}
gGameMouseInitialized = true;
_gmouse_enabled = 1;
gameMouseSetCursor(MOUSE_CURSOR_ARROW);
return 0;
}
// 0x44B2E8
int gameMouseReset()
{
if (!gGameMouseInitialized) {
return -1;
}
// NOTE: Uninline.
if (gameMouseObjectsReset() != 0) {
return -1;
}
// NOTE: Uninline.
_gmouse_enable();
_gmouse_scrolling_enabled = 1;
gameMouseSetCursor(MOUSE_CURSOR_ARROW);
gGameMouseAnimatedCursorNextFrame = 0;
gGameMouseAnimatedCursorLastUpdateTimestamp = 0;
_gmouse_clicked_on_edge = 0;
return 0;
}
// 0x44B3B8
void gameMouseExit()
{
if (!gGameMouseInitialized) {
return;
}
mouseHideCursor();
mouseSetFrame(NULL, 0, 0, 0, 0, 0, 0);
// NOTE: Uninline.
gameMouseObjectsFree();
if (gGameMouseCursorFrmHandle != INVALID_CACHE_ENTRY) {
artUnlock(gGameMouseCursorFrmHandle);
}
gGameMouseCursorFrmHandle = INVALID_CACHE_ENTRY;
_gmouse_enabled = 0;
gGameMouseInitialized = false;
gGameMouseCursor = -1;
}
// 0x44B454
void _gmouse_enable()
{
if (!_gmouse_enabled) {
gGameMouseCursor = -1;
gameMouseSetCursor(MOUSE_CURSOR_NONE);
_gmouse_scrolling_enabled = 1;
_gmouse_enabled = 1;
_gmouse_bk_last_cursor = -1;
}
}
// 0x44B48C
void _gmouse_disable(int a1)
{
if (_gmouse_enabled) {
gameMouseSetCursor(MOUSE_CURSOR_NONE);
_gmouse_enabled = 0;
if (a1 & 1) {
_gmouse_scrolling_enabled = 1;
} else {
_gmouse_scrolling_enabled = 0;
}
}
}
// 0x44B4CC
void _gmouse_enable_scrolling()
{
_gmouse_scrolling_enabled = 1;
}
// 0x44B4D8
void _gmouse_disable_scrolling()
{
_gmouse_scrolling_enabled = 0;
}
// 0x44B504
int _gmouse_get_click_to_scroll()
{
return _gmouse_click_to_scroll;
}
// 0x44B54C
int _gmouse_is_scrolling()
{
int v1 = 0;
if (_gmouse_scrolling_enabled) {
int x;
int y;
mouseGetPosition(&x, &y);
if (x == _scr_size.left || x == _scr_size.right || y == _scr_size.top || y == _scr_size.bottom) {
switch (gGameMouseCursor) {
case MOUSE_CURSOR_SCROLL_NW:
case MOUSE_CURSOR_SCROLL_N:
case MOUSE_CURSOR_SCROLL_NE:
case MOUSE_CURSOR_SCROLL_E:
case MOUSE_CURSOR_SCROLL_SE:
case MOUSE_CURSOR_SCROLL_S:
case MOUSE_CURSOR_SCROLL_SW:
case MOUSE_CURSOR_SCROLL_W:
case MOUSE_CURSOR_SCROLL_NW_INVALID:
case MOUSE_CURSOR_SCROLL_N_INVALID:
case MOUSE_CURSOR_SCROLL_NE_INVALID:
case MOUSE_CURSOR_SCROLL_E_INVALID:
case MOUSE_CURSOR_SCROLL_SE_INVALID:
case MOUSE_CURSOR_SCROLL_S_INVALID:
case MOUSE_CURSOR_SCROLL_SW_INVALID:
case MOUSE_CURSOR_SCROLL_W_INVALID:
v1 = 1;
break;
default:
return v1;
}
}
}
return v1;
}
// 0x44B684
void gameMouseRefresh()
{
if (!gGameMouseInitialized) {
return;
}
int mouseX;
int mouseY;
if (gGameMouseCursor >= FIRST_GAME_MOUSE_ANIMATED_CURSOR) {
_mouse_info();
if (_gmouse_scrolling_enabled) {
mouseGetPosition(&mouseX, &mouseY);
int oldMouseCursor = gGameMouseCursor;
if (gameMouseHandleScrolling(mouseX, mouseY, gGameMouseCursor) == 0) {
switch (oldMouseCursor) {
case MOUSE_CURSOR_SCROLL_NW:
case MOUSE_CURSOR_SCROLL_N:
case MOUSE_CURSOR_SCROLL_NE:
case MOUSE_CURSOR_SCROLL_E:
case MOUSE_CURSOR_SCROLL_SE:
case MOUSE_CURSOR_SCROLL_S:
case MOUSE_CURSOR_SCROLL_SW:
case MOUSE_CURSOR_SCROLL_W:
case MOUSE_CURSOR_SCROLL_NW_INVALID:
case MOUSE_CURSOR_SCROLL_N_INVALID:
case MOUSE_CURSOR_SCROLL_NE_INVALID:
case MOUSE_CURSOR_SCROLL_E_INVALID:
case MOUSE_CURSOR_SCROLL_SE_INVALID:
case MOUSE_CURSOR_SCROLL_S_INVALID:
case MOUSE_CURSOR_SCROLL_SW_INVALID:
case MOUSE_CURSOR_SCROLL_W_INVALID:
break;
default:
_gmouse_bk_last_cursor = oldMouseCursor;
break;
}
return;
}
if (_gmouse_bk_last_cursor != -1) {
gameMouseSetCursor(_gmouse_bk_last_cursor);
_gmouse_bk_last_cursor = -1;
return;
}
}
gameMouseSetCursor(gGameMouseCursor);
return;
}
if (!_gmouse_enabled) {
if (_gmouse_scrolling_enabled) {
mouseGetPosition(&mouseX, &mouseY);
int oldMouseCursor = gGameMouseCursor;
if (gameMouseHandleScrolling(mouseX, mouseY, gGameMouseCursor) == 0) {
switch (oldMouseCursor) {
case MOUSE_CURSOR_SCROLL_NW:
case MOUSE_CURSOR_SCROLL_N:
case MOUSE_CURSOR_SCROLL_NE:
case MOUSE_CURSOR_SCROLL_E:
case MOUSE_CURSOR_SCROLL_SE:
case MOUSE_CURSOR_SCROLL_S:
case MOUSE_CURSOR_SCROLL_SW:
case MOUSE_CURSOR_SCROLL_W:
case MOUSE_CURSOR_SCROLL_NW_INVALID:
case MOUSE_CURSOR_SCROLL_N_INVALID:
case MOUSE_CURSOR_SCROLL_NE_INVALID:
case MOUSE_CURSOR_SCROLL_E_INVALID:
case MOUSE_CURSOR_SCROLL_SE_INVALID:
case MOUSE_CURSOR_SCROLL_S_INVALID:
case MOUSE_CURSOR_SCROLL_SW_INVALID:
case MOUSE_CURSOR_SCROLL_W_INVALID:
break;
default:
_gmouse_bk_last_cursor = oldMouseCursor;
break;
}
return;
}
if (_gmouse_bk_last_cursor != -1) {
gameMouseSetCursor(_gmouse_bk_last_cursor);
_gmouse_bk_last_cursor = -1;
}
}
return;
}
mouseGetPosition(&mouseX, &mouseY);
int oldMouseCursor = gGameMouseCursor;
if (gameMouseHandleScrolling(mouseX, mouseY, MOUSE_CURSOR_NONE) == 0) {
switch (oldMouseCursor) {
case MOUSE_CURSOR_SCROLL_NW:
case MOUSE_CURSOR_SCROLL_N:
case MOUSE_CURSOR_SCROLL_NE:
case MOUSE_CURSOR_SCROLL_E:
case MOUSE_CURSOR_SCROLL_SE:
case MOUSE_CURSOR_SCROLL_S:
case MOUSE_CURSOR_SCROLL_SW:
case MOUSE_CURSOR_SCROLL_W:
case MOUSE_CURSOR_SCROLL_NW_INVALID:
case MOUSE_CURSOR_SCROLL_N_INVALID:
case MOUSE_CURSOR_SCROLL_NE_INVALID:
case MOUSE_CURSOR_SCROLL_E_INVALID:
case MOUSE_CURSOR_SCROLL_SE_INVALID:
case MOUSE_CURSOR_SCROLL_S_INVALID:
case MOUSE_CURSOR_SCROLL_SW_INVALID:
case MOUSE_CURSOR_SCROLL_W_INVALID:
break;
default:
_gmouse_bk_last_cursor = oldMouseCursor;
break;
}
return;
}
if (_gmouse_bk_last_cursor != -1) {
gameMouseSetCursor(_gmouse_bk_last_cursor);
_gmouse_bk_last_cursor = -1;
}
if (windowGetAtPoint(mouseX, mouseY) != gIsoWindow) {
if (gGameMouseCursor == MOUSE_CURSOR_NONE) {
gameMouseObjectsHide();
gameMouseSetCursor(MOUSE_CURSOR_ARROW);
if (gGameMouseMode >= 2 && !isInCombat()) {
gameMouseSetMode(GAME_MOUSE_MODE_MOVE);
}
}
return;
}
// NOTE: Strange set of conditions and jumps. Not sure about this one.
switch (gGameMouseCursor) {
case MOUSE_CURSOR_NONE:
case MOUSE_CURSOR_ARROW:
case MOUSE_CURSOR_SMALL_ARROW_UP:
case MOUSE_CURSOR_SMALL_ARROW_DOWN:
case MOUSE_CURSOR_CROSSHAIR:
case MOUSE_CURSOR_USE_CROSSHAIR:
if (gGameMouseCursor != MOUSE_CURSOR_NONE) {
gameMouseSetCursor(MOUSE_CURSOR_NONE);
}
if ((gGameMouseHexCursor->flags & OBJECT_HIDDEN) != 0) {
gameMouseObjectsShow();
}
break;
}
Rect r1;
if (_gmouse_3d_move_to(mouseX, mouseY, gElevation, &r1) == 0) {
tileWindowRefreshRect(&r1, gElevation);
}
if ((gGameMouseHexCursor->flags & OBJECT_HIDDEN) != 0 || _gmouse_mapper_mode != 0) {
return;
}
unsigned int v3 = _get_bk_time();
if (mouseX == gGameMouseLastX && mouseY == gGameMouseLastY) {
if (_gmouse_3d_hover_test || getTicksBetween(v3, _gmouse_3d_last_move_time) < 250) {
return;
}
if (gGameMouseMode != GAME_MOUSE_MODE_MOVE) {
if (gGameMouseMode == GAME_MOUSE_MODE_ARROW) {
_gmouse_3d_last_move_time = v3;
_gmouse_3d_hover_test = true;
Object* pointedObject = gameMouseGetObjectUnderCursor(-1, true, gElevation);
if (pointedObject != NULL) {
int primaryAction = -1;
switch ((pointedObject->fid & 0xF000000) >> 24) {
case OBJ_TYPE_ITEM:
primaryAction = GAME_MOUSE_ACTION_MENU_ITEM_USE;
if (gGameMouseItemHighlightEnabled) {
Rect tmp;
if (objectSetOutline(pointedObject, OUTLINE_TYPE_ITEM, &tmp) == 0) {
tileWindowRefreshRect(&tmp, gElevation);
gGameMouseHighlightedItem = pointedObject;
}
}
break;
case OBJ_TYPE_CRITTER:
if (pointedObject == gDude) {
primaryAction = GAME_MOUSE_ACTION_MENU_ITEM_ROTATE;
} else {
if (_obj_action_can_talk_to(pointedObject)) {
if (isInCombat()) {
primaryAction = GAME_MOUSE_ACTION_MENU_ITEM_LOOK;
} else {
primaryAction = GAME_MOUSE_ACTION_MENU_ITEM_TALK;
}
} else {
if (_critter_flag_check(pointedObject->pid, 32)) {
primaryAction = GAME_MOUSE_ACTION_MENU_ITEM_LOOK;
} else {
primaryAction = GAME_MOUSE_ACTION_MENU_ITEM_USE;
}
}
}
break;
case OBJ_TYPE_SCENERY:
if (!_obj_action_can_use(pointedObject)) {
primaryAction = GAME_MOUSE_ACTION_MENU_ITEM_LOOK;
} else {
primaryAction = GAME_MOUSE_ACTION_MENU_ITEM_USE;
}
break;
case OBJ_TYPE_WALL:
primaryAction = GAME_MOUSE_ACTION_MENU_ITEM_LOOK;
break;
}
if (primaryAction != -1) {
if (gameMouseRenderPrimaryAction(mouseX, mouseY, primaryAction, _scr_size.right - _scr_size.left + 1, _scr_size.bottom - _scr_size.top - 99) == 0) {
Rect tmp;
int fid = buildFid(6, 282, 0, 0, 0);
if (objectSetFid(gGameMouseHexCursor, fid, &tmp) == 0) {
tileWindowRefreshRect(&tmp, gElevation);
}
}
}
if (pointedObject != gGameMousePointedObject) {
gGameMousePointedObject = pointedObject;
_obj_look_at(gDude, gGameMousePointedObject);
}
}
} else if (gGameMouseMode == GAME_MOUSE_MODE_CROSSHAIR) {
Object* pointedObject = gameMouseGetObjectUnderCursor(OBJ_TYPE_CRITTER, false, gElevation);
if (pointedObject == NULL) {
pointedObject = gameMouseGetObjectUnderCursor(-1, false, gElevation);
if (!objectIsDoor(pointedObject)) {
pointedObject = NULL;
}
}
if (pointedObject != NULL) {
bool pointedObjectIsCritter = (pointedObject->fid & 0xF000000) >> 24 == OBJ_TYPE_CRITTER;
int combatLooks = 0;
configGetInt(&gGameConfig, GAME_CONFIG_PREFERENCES_KEY, GAME_CONFIG_COMBAT_LOOKS_KEY, &combatLooks);
if (combatLooks != 0) {
if (_obj_examine(gDude, pointedObject) == -1) {
_obj_look_at(gDude, pointedObject);
}
}
int color;
int accuracy;
char formattedAccuracy[8];
if (_combat_to_hit(pointedObject, &accuracy)) {
sprintf(formattedAccuracy, "%d%%", accuracy);
if (pointedObjectIsCritter) {
if (pointedObject->data.critter.combat.team != 0) {
color = _colorTable[32767];
} else {
color = _colorTable[32495];
}
} else {
color = _colorTable[17969];
}
} else {
sprintf(formattedAccuracy, " %c ", 'X');
if (pointedObjectIsCritter) {
if (pointedObject->data.critter.combat.team != 0) {
color = _colorTable[31744];
} else {
color = _colorTable[18161];
}
} else {
color = _colorTable[32239];
}
}
if (gameMouseRenderAccuracy(formattedAccuracy, color) == 0) {
Rect tmp;
int fid = buildFid(6, 284, 0, 0, 0);
if (objectSetFid(gGameMouseHexCursor, fid, &tmp) == 0) {
tileWindowRefreshRect(&tmp, gElevation);
}
}
if (gGameMousePointedObject != pointedObject) {
gGameMousePointedObject = pointedObject;
}
} else {
Rect tmp;
if (gameMouseUpdateHexCursorFid(&tmp) == 0) {
tileWindowRefreshRect(&tmp, gElevation);
}
}
_gmouse_3d_last_move_time = v3;
_gmouse_3d_hover_test = true;
}
return;
}
char formattedActionPoints[8];
int color;
int v6 = _make_path(gDude, gDude->tile, gGameMouseHexCursor->tile, NULL, 1);
if (v6) {
if (!isInCombat()) {
formattedActionPoints[0] = '\0';
color = _colorTable[31744];
} else {
int v7 = critterGetMovementPointCostAdjustedForCrippledLegs(gDude, v6);
int v8;
if (v7 - _combat_free_move >= 0) {
v8 = v7 - _combat_free_move;
} else {
v8 = 0;
}
if (v8 <= gDude->data.critter.combat.ap) {
sprintf(formattedActionPoints, "%d", v8);
color = _colorTable[32767];
} else {
sprintf(formattedActionPoints, "%c", 'X');
color = _colorTable[31744];
}
}
} else {
sprintf(formattedActionPoints, "%c", 'X');
color = _colorTable[31744];
}
if (gameMouseRenderActionPoints(formattedActionPoints, color) == 0) {
Rect tmp;
objectGetRect(gGameMouseHexCursor, &tmp);
tileWindowRefreshRect(&tmp, 0);
}
_gmouse_3d_last_move_time = v3;
_gmouse_3d_hover_test = true;
dword_518D9C = gGameMouseHexCursor->tile;
return;
}
_gmouse_3d_last_move_time = v3;
_gmouse_3d_hover_test = false;
gGameMouseLastX = mouseX;
gGameMouseLastY = mouseY;
if (!_gmouse_mapper_mode) {
int fid = buildFid(6, 0, 0, 0, 0);
gameMouseSetBouncingCursorFid(fid);
}
int v34 = 0;
Rect r2;
Rect r26;
if (gameMouseUpdateHexCursorFid(&r2) == 0) {
v34 |= 1;
}
if (gGameMouseHighlightedItem != NULL) {
if (objectClearOutline(gGameMouseHighlightedItem, &r26) == 0) {
v34 |= 2;
}
gGameMouseHighlightedItem = NULL;
}
switch (v34) {
case 3:
rectUnion(&r2, &r26, &r2);
// FALLTHROUGH
case 1:
tileWindowRefreshRect(&r2, gElevation);
break;
case 2:
tileWindowRefreshRect(&r26, gElevation);
break;
}
}
// 0x44BFA8
void _gmouse_handle_event(int mouseX, int mouseY, int mouseState)
{
if (!gGameMouseInitialized) {
return;
}
if (gGameMouseCursor >= MOUSE_CURSOR_WAIT_PLANET) {
return;
}
if (!_gmouse_enabled) {
return;
}
if (_gmouse_clicked_on_edge) {
if (_gmouse_get_click_to_scroll()) {
return;
}
}
if (!_mouse_click_in(0, 0, _scr_size.right - _scr_size.left, _scr_size.bottom - _scr_size.top - 100)) {
return;
}
if ((mouseState & MOUSE_EVENT_RIGHT_BUTTON_DOWN) != 0) {
if ((mouseState & MOUSE_EVENT_RIGHT_BUTTON_REPEAT) == 0 && (gGameMouseHexCursor->flags & OBJECT_HIDDEN) == 0) {
gameMouseCycleMode();
}
return;
}
if ((mouseState & MOUSE_EVENT_LEFT_BUTTON_UP) != 0) {
if (gGameMouseMode == GAME_MOUSE_MODE_MOVE) {
int actionPoints;
if (isInCombat()) {
actionPoints = _combat_free_move + gDude->data.critter.combat.ap;
} else {
actionPoints = -1;
}
bool running;
configGetBool(&gGameConfig, GAME_CONFIG_PREFERENCES_KEY, GAME_CONFIG_RUNNING_KEY, &running);
if (gPressedPhysicalKeys[DIK_LSHIFT] || gPressedPhysicalKeys[DIK_RSHIFT]) {
if (running) {
_dude_move(actionPoints);
return;
}
} else {
if (!running) {
_dude_move(actionPoints);
return;
}
}
_dude_run(actionPoints);
return;
}
if (gGameMouseMode == GAME_MOUSE_MODE_ARROW) {
Object* v5 = gameMouseGetObjectUnderCursor(-1, true, gElevation);
if (v5 != NULL) {
switch ((v5->fid & 0xF000000) >> 24) {
case OBJ_TYPE_ITEM:
actionPickUp(gDude, v5);
break;
case OBJ_TYPE_CRITTER:
if (v5 == gDude) {
if (((gDude->fid & 0xFF0000) >> 16) == ANIM_STAND) {
Rect a1;
if (objectRotateClockwise(v5, &a1) == 0) {
tileWindowRefreshRect(&a1, v5->elevation);
}
}
} else {
if (_obj_action_can_talk_to(v5)) {
if (isInCombat()) {
if (_obj_examine(gDude, v5) == -1) {
_obj_look_at(gDude, v5);
}
} else {
actionTalk(gDude, v5);
}
} else {
_action_loot_container(gDude, v5);
}
}
break;
case OBJ_TYPE_SCENERY:
if (_obj_action_can_use(v5)) {
_action_use_an_object(gDude, v5);
} else {
if (_obj_examine(gDude, v5) == -1) {
_obj_look_at(gDude, v5);
}
}
break;
case OBJ_TYPE_WALL:
if (_obj_examine(gDude, v5) == -1) {
_obj_look_at(gDude, v5);
}
break;
}
}
return;
}
if (gGameMouseMode == GAME_MOUSE_MODE_CROSSHAIR) {
Object* v7 = gameMouseGetObjectUnderCursor(OBJ_TYPE_CRITTER, false, gElevation);
if (v7 == NULL) {
v7 = gameMouseGetObjectUnderCursor(-1, false, gElevation);
if (!objectIsDoor(v7)) {
v7 = NULL;
}
}
if (v7 != NULL) {
_combat_attack_this(v7);
_gmouse_3d_hover_test = true;
gGameMouseLastY = mouseY;
gGameMouseLastX = mouseX;
_gmouse_3d_last_move_time = _get_time() - 250;
}
return;
}
if (gGameMouseMode == GAME_MOUSE_MODE_USE_CROSSHAIR) {
Object* object = gameMouseGetObjectUnderCursor(-1, true, gElevation);
if (object != NULL) {
Object* weapon;
if (interfaceGetActiveItem(&weapon) != -1) {
if (isInCombat()) {
int hitMode = interfaceGetCurrentHand()
? HIT_MODE_RIGHT_WEAPON_PRIMARY
: HIT_MODE_LEFT_WEAPON_PRIMARY;
int actionPointsRequired = _item_mp_cost(gDude, hitMode, false);
if (actionPointsRequired <= gDude->data.critter.combat.ap) {
if (_action_use_an_item_on_object(gDude, object, weapon) != -1) {
int actionPoints = gDude->data.critter.combat.ap;
if (actionPointsRequired > actionPoints) {
gDude->data.critter.combat.ap = 0;
} else {
gDude->data.critter.combat.ap -= actionPointsRequired;
}
interfaceRenderActionPoints(gDude->data.critter.combat.ap, _combat_free_move);
}
}
} else {
_action_use_an_item_on_object(gDude, object, weapon);
}
}
}
gameMouseSetCursor(MOUSE_CURSOR_NONE);
gameMouseSetMode(GAME_MOUSE_MODE_MOVE);
return;
}
if (gGameMouseMode == GAME_MOUSE_MODE_USE_FIRST_AID
|| gGameMouseMode == GAME_MOUSE_MODE_USE_DOCTOR
|| gGameMouseMode == GAME_MOUSE_MODE_USE_LOCKPICK
|| gGameMouseMode == GAME_MOUSE_MODE_USE_STEAL
|| gGameMouseMode == GAME_MOUSE_MODE_USE_TRAPS
|| gGameMouseMode == GAME_MOUSE_MODE_USE_SCIENCE
|| gGameMouseMode == GAME_MOUSE_MODE_USE_REPAIR) {
Object* object = gameMouseGetObjectUnderCursor(-1, 1, gElevation);
if (object == NULL || actionUseSkill(gDude, object, gGameMouseModeSkills[gGameMouseMode - FIRST_GAME_MOUSE_MODE_SKILL]) != -1) {
gameMouseSetCursor(MOUSE_CURSOR_NONE);
gameMouseSetMode(GAME_MOUSE_MODE_MOVE);
}
return;
}
}
if ((mouseState & MOUSE_EVENT_LEFT_BUTTON_DOWN_REPEAT) == MOUSE_EVENT_LEFT_BUTTON_DOWN_REPEAT && gGameMouseMode == GAME_MOUSE_MODE_ARROW) {
Object* v16 = gameMouseGetObjectUnderCursor(-1, true, gElevation);
if (v16 != NULL) {
int actionMenuItemsCount = 0;
int actionMenuItems[6];
switch ((v16->fid & 0xF000000) >> 24) {
case OBJ_TYPE_ITEM:
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_USE;
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_LOOK;
if (itemGetType(v16) == ITEM_TYPE_CONTAINER) {
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_INVENTORY;
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_USE_SKILL;
}
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_CANCEL;
break;
case OBJ_TYPE_CRITTER:
if (v16 == gDude) {
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_ROTATE;
} else {
if (_obj_action_can_talk_to(v16)) {
if (!isInCombat()) {
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_TALK;
}
} else {
if (!_critter_flag_check(v16->pid, 32)) {
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_USE;
}
}
if (actionCheckPush(gDude, v16)) {
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_PUSH;
}
}
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_LOOK;
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_INVENTORY;
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_USE_SKILL;
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_CANCEL;
break;
case OBJ_TYPE_SCENERY:
if (_obj_action_can_use(v16)) {
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_USE;
}
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_LOOK;
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_INVENTORY;
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_USE_SKILL;
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_CANCEL;
break;
case OBJ_TYPE_WALL:
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_LOOK;
if (_obj_action_can_use(v16)) {
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_INVENTORY;
}
actionMenuItems[actionMenuItemsCount++] = GAME_MOUSE_ACTION_MENU_ITEM_CANCEL;
break;
}
if (gameMouseRenderActionMenuItems(mouseX, mouseY, actionMenuItems, actionMenuItemsCount, _scr_size.right - _scr_size.left + 1, _scr_size.bottom - _scr_size.top - 99) == 0) {
Rect v43;
int fid = buildFid(6, 283, 0, 0, 0);
if (objectSetFid(gGameMouseHexCursor, fid, &v43) == 0 && _gmouse_3d_move_to(mouseX, mouseY, gElevation, &v43) == 0) {
tileWindowRefreshRect(&v43, gElevation);
isoDisable();
int v33 = mouseY;
int actionIndex = 0;
while ((mouseGetEvent() & MOUSE_EVENT_LEFT_BUTTON_UP) == 0) {
_get_input();
if (_game_user_wants_to_quit != 0) {
actionMenuItems[actionIndex] = 0;
}
int v48;
int v47;
mouseGetPosition(&v48, &v47);
if (abs(v47 - v33) > 10) {
if (v33 >= v47) {
actionIndex -= 1;
} else {
actionIndex += 1;
}
if (gameMouseHighlightActionMenuItemAtIndex(actionIndex) == 0) {
tileWindowRefreshRect(&v43, gElevation);
}
v33 = v47;
}
}
isoEnable();
_gmouse_3d_hover_test = false;
gGameMouseLastX = mouseX;
gGameMouseLastY = mouseY;
_gmouse_3d_last_move_time = _get_time();
_mouse_set_position(mouseX, v33);
if (gameMouseUpdateHexCursorFid(&v43) == 0) {
tileWindowRefreshRect(&v43, gElevation);
}
switch (actionMenuItems[actionIndex]) {
case GAME_MOUSE_ACTION_MENU_ITEM_INVENTORY:
inventoryOpenUseItemOn(v16);
break;
case GAME_MOUSE_ACTION_MENU_ITEM_LOOK:
if (_obj_examine(gDude, v16) == -1) {
_obj_look_at(gDude, v16);
}
break;
case GAME_MOUSE_ACTION_MENU_ITEM_ROTATE:
if (objectRotateClockwise(v16, &v43) == 0) {
tileWindowRefreshRect(&v43, v16->elevation);
}
break;
case GAME_MOUSE_ACTION_MENU_ITEM_TALK:
actionTalk(gDude, v16);
break;
case GAME_MOUSE_ACTION_MENU_ITEM_USE:
switch ((v16->fid & 0xF000000) >> 24) {
case OBJ_TYPE_SCENERY:
_action_use_an_object(gDude, v16);
break;
case OBJ_TYPE_CRITTER:
_action_loot_container(gDude, v16);
break;
default:
actionPickUp(gDude, v16);
break;
}
break;
case GAME_MOUSE_ACTION_MENU_ITEM_USE_SKILL:
if (1) {
int skill = -1;
int rc = skilldexOpen();
switch (rc) {
case SKILLDEX_RC_SNEAK:
_action_skill_use(SKILL_SNEAK);
break;
case SKILLDEX_RC_LOCKPICK:
skill = SKILL_LOCKPICK;
break;
case SKILLDEX_RC_STEAL:
skill = SKILL_STEAL;
break;
case SKILLDEX_RC_TRAPS:
skill = SKILL_TRAPS;
break;
case SKILLDEX_RC_FIRST_AID:
skill = SKILL_FIRST_AID;
break;
case SKILLDEX_RC_DOCTOR:
skill = SKILL_DOCTOR;
break;
case SKILLDEX_RC_SCIENCE:
skill = SKILL_SCIENCE;
break;
case SKILLDEX_RC_REPAIR:
skill = SKILL_REPAIR;
break;
}
if (skill != -1) {
actionUseSkill(gDude, v16, skill);
}
}
break;
case GAME_MOUSE_ACTION_MENU_ITEM_PUSH:
actionPush(gDude, v16);
break;
}
}
}
}
}
}
// 0x44C840
int gameMouseSetCursor(int cursor)
{
if (!gGameMouseInitialized) {
return -1;
}
if (cursor != MOUSE_CURSOR_ARROW && cursor == gGameMouseCursor && (gGameMouseCursor < 25 || gGameMouseCursor >= 27)) {
return -1;
}
CacheEntry* mouseCursorFrmHandle;
int fid = buildFid(6, gGameMouseCursorFrmIds[cursor], 0, 0, 0);
Art* mouseCursorFrm = artLock(fid, &mouseCursorFrmHandle);
if (mouseCursorFrm == NULL) {
return -1;
}
bool shouldUpdate = true;
int frame = 0;
if (cursor >= FIRST_GAME_MOUSE_ANIMATED_CURSOR) {
unsigned int tick = _get_time();
if ((gGameMouseHexCursor->flags & OBJECT_HIDDEN) == 0) {
gameMouseObjectsHide();
}
unsigned int delay = 1000 / artGetFramesPerSecond(mouseCursorFrm);
if (getTicksBetween(tick, gGameMouseAnimatedCursorLastUpdateTimestamp) < delay) {
shouldUpdate = false;
} else {
if (artGetFrameCount(mouseCursorFrm) <= gGameMouseAnimatedCursorNextFrame) {
gGameMouseAnimatedCursorNextFrame = 0;
}
frame = gGameMouseAnimatedCursorNextFrame;
gGameMouseAnimatedCursorLastUpdateTimestamp = tick;
gGameMouseAnimatedCursorNextFrame++;
}
}
if (!shouldUpdate) {
return -1;
}
int width = artGetWidth(mouseCursorFrm, frame, 0);
int height = artGetHeight(mouseCursorFrm, frame, 0);
int offsetX;
int offsetY;
artGetRotationOffsets(mouseCursorFrm, 0, &offsetX, &offsetY);
offsetX = width / 2 - offsetX;
offsetY = height - 1 - offsetY;
unsigned char* mouseCursorFrmData = artGetFrameData(mouseCursorFrm, frame, 0);
if (mouseSetFrame(mouseCursorFrmData, width, height, width, offsetX, offsetY, 0) != 0) {
return -1;
}
if (gGameMouseCursorFrmHandle != INVALID_CACHE_ENTRY) {
artUnlock(gGameMouseCursorFrmHandle);
}
gGameMouseCursor = cursor;
gGameMouseCursorFrmHandle = mouseCursorFrmHandle;
return 0;
}
// 0x44C9E8
int gameMouseGetCursor()
{
return gGameMouseCursor;
}
// 0x44C9F8
void _gmouse_3d_enable_modes()
{
_gmouse_3d_modes_enabled = 1;
}
// 0x44CA18
void gameMouseSetMode(int mode)
{
if (!gGameMouseInitialized) {
return;
}
if (!_gmouse_3d_modes_enabled) {
return;
}
if (mode == gGameMouseMode) {
return;
}
int fid = buildFid(6, 0, 0, 0, 0);
gameMouseSetBouncingCursorFid(fid);
fid = buildFid(6, gGameMouseModeFrmIds[mode], 0, 0, 0);
Rect rect;
if (objectSetFid(gGameMouseHexCursor, fid, &rect) == -1) {
return;
}
int mouseX;
int mouseY;
mouseGetPosition(&mouseX, &mouseY);
Rect r2;
if (_gmouse_3d_move_to(mouseX, mouseY, gElevation, &r2) == 0) {
rectUnion(&rect, &r2, &rect);
}
int v5 = 0;
if (gGameMouseMode == GAME_MOUSE_MODE_CROSSHAIR) {
v5 = -1;
}
if (mode != 0) {
if (mode == GAME_MOUSE_MODE_CROSSHAIR) {
v5 = 1;
}
if (gGameMouseMode == 0) {
if (objectDisableOutline(gGameMouseHexCursor, &r2) == 0) {
rectUnion(&rect, &r2, &rect);
}
}
} else {
if (objectEnableOutline(gGameMouseHexCursor, &r2) == 0) {
rectUnion(&rect, &r2, &rect);
}
}
gGameMouseMode = mode;
_gmouse_3d_hover_test = false;
_gmouse_3d_last_move_time = _get_time();
tileWindowRefreshRect(&rect, gElevation);
switch (v5) {
case 1:
_combat_outline_on();
break;
case -1:
_combat_outline_off();
break;
}
}
// 0x44CB6C
int gameMouseGetMode()
{
return gGameMouseMode;
}
// 0x44CB74
void gameMouseCycleMode()
{
int mode = (gGameMouseMode + 1) % 3;
if (isInCombat()) {
Object* item;
if (interfaceGetActiveItem(&item) == 0) {
if (item != NULL && itemGetType(item) != ITEM_TYPE_WEAPON && mode == GAME_MOUSE_MODE_CROSSHAIR) {
mode = GAME_MOUSE_MODE_MOVE;
}
}
} else {
if (mode == GAME_MOUSE_MODE_CROSSHAIR) {
mode = GAME_MOUSE_MODE_MOVE;
}
}
gameMouseSetMode(mode);
}
// 0x44CBD0
void _gmouse_3d_refresh()
{
gGameMouseLastX = -1;
gGameMouseLastY = -1;
_gmouse_3d_hover_test = false;
_gmouse_3d_last_move_time = 0;
gameMouseRefresh();
}
// 0x44CBFC
int gameMouseSetBouncingCursorFid(int fid)
{
if (!gGameMouseInitialized) {
return -1;
}
if (!artExists(fid)) {
return -1;
}
if (gGameMouseBouncingCursor->fid == fid) {
return -1;
}
if (!_gmouse_mapper_mode) {
return objectSetFid(gGameMouseBouncingCursor, fid, NULL);
}
int v1 = 0;
Rect oldRect;
if (gGameMouseBouncingCursor->fid != -1) {
objectGetRect(gGameMouseBouncingCursor, &oldRect);
v1 |= 1;
}
int rc = -1;
Rect rect;
if (objectSetFid(gGameMouseBouncingCursor, fid, &rect) == 0) {
rc = 0;
v1 |= 2;
}
if ((gGameMouseHexCursor->flags & OBJECT_HIDDEN) == 0) {
if (v1 == 1) {
tileWindowRefreshRect(&oldRect, gElevation);
} else if (v1 == 2) {
tileWindowRefreshRect(&rect, gElevation);
} else if (v1 == 3) {
rectUnion(&oldRect, &rect, &oldRect);
tileWindowRefreshRect(&oldRect, gElevation);
}
}
return rc;
}
// 0x44CD0C
void gameMouseResetBouncingCursorFid()
{
int fid = buildFid(6, 0, 0, 0, 0);
gameMouseSetBouncingCursorFid(fid);
}
// 0x44CD2C
void gameMouseObjectsShow()
{
if (!gGameMouseInitialized) {
return;
}
int v2 = 0;
Rect rect1;
if (objectShow(gGameMouseBouncingCursor, &rect1) == 0) {
v2 |= 1;
}
Rect rect2;
if (objectShow(gGameMouseHexCursor, &rect2) == 0) {
v2 |= 2;
}
Rect tmp;
if (gGameMouseMode != GAME_MOUSE_MODE_MOVE) {
if (objectDisableOutline(gGameMouseHexCursor, &tmp) == 0) {
if ((v2 & 2) != 0) {
rectUnion(&rect2, &tmp, &rect2);
} else {
memcpy(&rect2, &tmp, sizeof(rect2));
v2 |= 2;
}
}
}
if (gameMouseUpdateHexCursorFid(&tmp) == 0) {
if ((v2 & 2) != 0) {
rectUnion(&rect2, &tmp, &rect2);
} else {
memcpy(&rect2, &tmp, sizeof(rect2));
v2 |= 2;
}
}
if (v2 != 0) {
Rect* rect;
switch (v2) {
case 1:
rect = &rect1;
break;
case 2:
rect = &rect2;
break;
case 3:
rectUnion(&rect1, &rect2, &rect1);
rect = &rect1;
break;
default:
assert(false && "Should be unreachable");
}
tileWindowRefreshRect(rect, gElevation);
}
_gmouse_3d_hover_test = false;
_gmouse_3d_last_move_time = _get_time() - 250;
}
// 0x44CE34
void gameMouseObjectsHide()
{
if (!gGameMouseInitialized) {
return;
}
int v1 = 0;
Rect rect1;
if (objectHide(gGameMouseBouncingCursor, &rect1) == 0) {
v1 |= 1;
}
Rect rect2;
if (objectHide(gGameMouseHexCursor, &rect2) == 0) {
v1 |= 2;
}
if (v1 == 1) {
tileWindowRefreshRect(&rect1, gElevation);
} else if (v1 == 2) {
tileWindowRefreshRect(&rect2, gElevation);
} else if (v1 == 3) {
rectUnion(&rect1, &rect2, &rect1);
tileWindowRefreshRect(&rect1, gElevation);
}
}
// 0x44CEB0
bool gameMouseObjectsIsVisible()
{
return (gGameMouseHexCursor->flags & OBJECT_HIDDEN) == 0;
}
// 0x44CEC4
Object* gameMouseGetObjectUnderCursor(int objectType, bool a2, int elevation)
{
int mouseX;
int mouseY;
mouseGetPosition(&mouseX, &mouseY);
bool v13 = false;
if (objectType == -1) {
if (_square_roof_intersect(mouseX, mouseY, elevation)) {
if (_obj_intersects_with(gEgg, mouseX, mouseY) == 0) {
v13 = true;
}
}
}
Object* v4 = NULL;
if (!v13) {
ObjectWithFlags* entries;
int count = _obj_create_intersect_list(mouseX, mouseY, elevation, objectType, &entries);
for (int index = count - 1; index >= 0; index--) {
ObjectWithFlags* ptr = &(entries[index]);
if (a2 || gDude != ptr->object) {
v4 = ptr->object;
if ((ptr->flags & 0x01) != 0) {
if ((ptr->flags & 0x04) == 0) {
if ((ptr->object->fid & 0xF000000) >> 24 != OBJ_TYPE_CRITTER || (ptr->object->data.critter.combat.results & (DAM_KNOCKED_OUT | DAM_DEAD)) == 0) {
break;
}
}
}
}
}
if (count != 0) {
_obj_delete_intersect_list(&entries);
}
}
return v4;
}
// 0x44CFA0
int gameMouseRenderPrimaryAction(int x, int y, int menuItem, int width, int height)
{
CacheEntry* menuItemFrmHandle;
int menuItemFid = buildFid(6, gGameMouseActionMenuItemFrmIds[menuItem], 0, 0, 0);
Art* menuItemFrm = artLock(menuItemFid, &menuItemFrmHandle);
if (menuItemFrm == NULL) {
return -1;
}
CacheEntry* arrowFrmHandle;
int arrowFid = buildFid(6, gGameMouseModeFrmIds[GAME_MOUSE_MODE_ARROW], 0, 0, 0);
Art* arrowFrm = artLock(arrowFid, &arrowFrmHandle);
if (arrowFrm == NULL) {
artUnlock(menuItemFrmHandle);
// FIXME: Why this is success?
return 0;
}
unsigned char* arrowFrmData = artGetFrameData(arrowFrm, 0, 0);
int arrowFrmWidth = artGetWidth(arrowFrm, 0, 0);
int arrowFrmHeight = artGetHeight(arrowFrm, 0, 0);
unsigned char* menuItemFrmData = artGetFrameData(menuItemFrm, 0, 0);
int menuItemFrmWidth = artGetWidth(menuItemFrm, 0, 0);
int menuItemFrmHeight = artGetHeight(menuItemFrm, 0, 0);
unsigned char* arrowFrmDest = gGameMouseActionPickFrmData;
unsigned char* menuItemFrmDest = gGameMouseActionPickFrmData;
_gmouse_3d_pick_frame_hot_x = 0;
_gmouse_3d_pick_frame_hot_y = 0;
gGameMouseActionPickFrm->xOffsets[0] = gGameMouseActionPickFrmWidth / 2;
gGameMouseActionPickFrm->yOffsets[0] = gGameMouseActionPickFrmHeight - 1;
int maxX = x + menuItemFrmWidth + arrowFrmWidth - 1;
int maxY = y + menuItemFrmHeight - 1;
int shiftY = maxY - height + 2;
if (maxX < width) {
menuItemFrmDest += arrowFrmWidth;
if (maxY >= height) {
_gmouse_3d_pick_frame_hot_y = shiftY;
gGameMouseActionPickFrm->yOffsets[0] -= shiftY;
arrowFrmDest += gGameMouseActionPickFrmWidth * shiftY;
}
} else {
artUnlock(arrowFrmHandle);
arrowFid = buildFid(6, 285, 0, 0, 0);
arrowFrm = artLock(arrowFid, &arrowFrmHandle);
arrowFrmData = artGetFrameData(arrowFrm, 0, 0);
arrowFrmDest += menuItemFrmWidth;
gGameMouseActionPickFrm->xOffsets[0] = -gGameMouseActionPickFrm->xOffsets[0];
_gmouse_3d_pick_frame_hot_x += menuItemFrmWidth + arrowFrmWidth;
if (maxY >= height) {
_gmouse_3d_pick_frame_hot_y += shiftY;
gGameMouseActionPickFrm->yOffsets[0] -= shiftY;
arrowFrmDest += gGameMouseActionPickFrmWidth * shiftY;
}
}
memset(gGameMouseActionPickFrmData, 0, gGameMouseActionPickFrmDataSize);
blitBufferToBuffer(arrowFrmData, arrowFrmWidth, arrowFrmHeight, arrowFrmWidth, arrowFrmDest, gGameMouseActionPickFrmWidth);
blitBufferToBuffer(menuItemFrmData, menuItemFrmWidth, menuItemFrmHeight, menuItemFrmWidth, menuItemFrmDest, gGameMouseActionPickFrmWidth);
artUnlock(arrowFrmHandle);
artUnlock(menuItemFrmHandle);
return 0;
}
// 0x44D200
int _gmouse_3d_pick_frame_hot(int* a1, int* a2)
{
*a1 = _gmouse_3d_pick_frame_hot_x;
*a2 = _gmouse_3d_pick_frame_hot_y;
return 0;
}
// 0x44D214
int gameMouseRenderActionMenuItems(int x, int y, const int* menuItems, int menuItemsLength, int width, int height)
{
_gmouse_3d_menu_actions_start = NULL;
gGameMouseActionMenuHighlightedItemIndex = 0;
gGameMouseActionMenuItemsLength = 0;
if (menuItems == NULL) {
return -1;
}
if (menuItemsLength == 0 || menuItemsLength >= GAME_MOUSE_ACTION_MENU_ITEM_COUNT) {
return -1;
}
CacheEntry* menuItemFrmHandles[GAME_MOUSE_ACTION_MENU_ITEM_COUNT];
Art* menuItemFrms[GAME_MOUSE_ACTION_MENU_ITEM_COUNT];
for (int index = 0; index < menuItemsLength; index++) {
int frmId = gGameMouseActionMenuItemFrmIds[menuItems[index]] & 0xFFFF;
if (index == 0) {
frmId -= 1;
}
int fid = buildFid(6, frmId, 0, 0, 0);
menuItemFrms[index] = artLock(fid, &(menuItemFrmHandles[index]));
if (menuItemFrms[index] == NULL) {
while (--index >= 0) {
artUnlock(menuItemFrmHandles[index]);
}
return -1;
}
}
int fid = buildFid(6, gGameMouseModeFrmIds[GAME_MOUSE_MODE_ARROW], 0, 0, 0);
CacheEntry* arrowFrmHandle;
Art* arrowFrm = artLock(fid, &arrowFrmHandle);
if (arrowFrm == NULL) {
// FIXME: Unlock arts.
return -1;
}
int arrowWidth = artGetWidth(arrowFrm, 0, 0);
int arrowHeight = artGetHeight(arrowFrm, 0, 0);
int menuItemWidth = artGetWidth(menuItemFrms[0], 0, 0);
int menuItemHeight = artGetHeight(menuItemFrms[0], 0, 0);
_gmouse_3d_menu_frame_hot_x = 0;
_gmouse_3d_menu_frame_hot_y = 0;
gGameMouseActionMenuFrm->xOffsets[0] = gGameMouseActionMenuFrmWidth / 2;
gGameMouseActionMenuFrm->yOffsets[0] = gGameMouseActionMenuFrmHeight - 1;
int v60 = y + menuItemsLength * menuItemHeight - 1;
int v24 = v60 - height + 2;
unsigned char* v22 = gGameMouseActionMenuFrmData;
unsigned char* v58 = v22;
unsigned char* arrowData;
if (x + arrowWidth + menuItemWidth - 1 < width) {
arrowData = artGetFrameData(arrowFrm, 0, 0);
v58 = v22 + arrowWidth;
if (height <= v60) {
_gmouse_3d_menu_frame_hot_y += v24;
v22 += gGameMouseActionMenuFrmWidth * v24;
gGameMouseActionMenuFrm->yOffsets[0] -= v24;
}
} else {
// Mirrored arrow (from left to right).
fid = buildFid(6, 285, 0, 0, 0);
arrowFrm = artLock(fid, &arrowFrmHandle);
arrowData = artGetFrameData(arrowFrm, 0, 0);
gGameMouseActionMenuFrm->xOffsets[0] = -gGameMouseActionMenuFrm->xOffsets[0];
_gmouse_3d_menu_frame_hot_x += menuItemWidth + arrowWidth;
if (v60 >= height) {
_gmouse_3d_menu_frame_hot_y += v24;
gGameMouseActionMenuFrm->yOffsets[0] -= v24;
v22 += gGameMouseActionMenuFrmWidth * v24;
}
}
memset(gGameMouseActionMenuFrmData, 0, gGameMouseActionMenuFrmDataSize);
blitBufferToBuffer(arrowData, arrowWidth, arrowHeight, arrowWidth, v22, gGameMouseActionPickFrmWidth);
unsigned char* v38 = v58;
for (int index = 0; index < menuItemsLength; index++) {
unsigned char* data = artGetFrameData(menuItemFrms[index], 0, 0);
blitBufferToBuffer(data, menuItemWidth, menuItemHeight, menuItemWidth, v38, gGameMouseActionPickFrmWidth);
v38 += gGameMouseActionMenuFrmWidth * menuItemHeight;
}
artUnlock(arrowFrmHandle);
for (int index = 0; index < menuItemsLength; index++) {
artUnlock(menuItemFrmHandles[index]);
}
memcpy(gGameMouseActionMenuItems, menuItems, sizeof(*gGameMouseActionMenuItems) * menuItemsLength);
gGameMouseActionMenuItemsLength = menuItemsLength;
_gmouse_3d_menu_actions_start = v58;
Sound* sound = soundEffectLoad("iaccuxx1", NULL);
if (sound != NULL) {
soundEffectPlay(sound);
}
return 0;
}
// 0x44D630
int gameMouseHighlightActionMenuItemAtIndex(int menuItemIndex)
{
if (menuItemIndex < 0 || menuItemIndex >= gGameMouseActionMenuItemsLength) {
return -1;
}
CacheEntry* handle;
int fid = buildFid(6, gGameMouseActionMenuItemFrmIds[gGameMouseActionMenuItems[gGameMouseActionMenuHighlightedItemIndex]], 0, 0, 0);
Art* art = artLock(fid, &handle);
if (art == NULL) {
return -1;
}
int width = artGetWidth(art, 0, 0);
int height = artGetHeight(art, 0, 0);
unsigned char* data = artGetFrameData(art, 0, 0);
blitBufferToBuffer(data, width, height, width, _gmouse_3d_menu_actions_start + gGameMouseActionMenuFrmWidth * height * gGameMouseActionMenuHighlightedItemIndex, gGameMouseActionMenuFrmWidth);
artUnlock(handle);
fid = buildFid(6, gGameMouseActionMenuItemFrmIds[gGameMouseActionMenuItems[menuItemIndex]] - 1, 0, 0, 0);
art = artLock(fid, &handle);
if (art == NULL) {
return -1;
}
data = artGetFrameData(art, 0, 0);
blitBufferToBuffer(data, width, height, width, _gmouse_3d_menu_actions_start + gGameMouseActionMenuFrmWidth * height * menuItemIndex, gGameMouseActionMenuFrmWidth);
artUnlock(handle);
gGameMouseActionMenuHighlightedItemIndex = menuItemIndex;
return 0;
}
// 0x44D774
int gameMouseRenderAccuracy(const char* string, int color)
{
CacheEntry* crosshairFrmHandle;
int fid = buildFid(6, gGameMouseModeFrmIds[GAME_MOUSE_MODE_CROSSHAIR], 0, 0, 0);
Art* crosshairFrm = artLock(fid, &crosshairFrmHandle);
if (crosshairFrm == NULL) {
return -1;
}
memset(gGameMouseActionHitFrmData, 0, gGameMouseActionHitFrmDataSize);
int crosshairFrmWidth = artGetWidth(crosshairFrm, 0, 0);
int crosshairFrmHeight = artGetHeight(crosshairFrm, 0, 0);
unsigned char* crosshairFrmData = artGetFrameData(crosshairFrm, 0, 0);
blitBufferToBuffer(crosshairFrmData,
crosshairFrmWidth,
crosshairFrmHeight,
crosshairFrmWidth,
gGameMouseActionHitFrmData,
gGameMouseActionHitFrmWidth);
int oldFont = fontGetCurrent();
fontSetCurrent(101);
fontDrawText(gGameMouseActionHitFrmData + gGameMouseActionHitFrmWidth + crosshairFrmWidth + 1,
string,
gGameMouseActionHitFrmWidth - crosshairFrmWidth,
gGameMouseActionHitFrmWidth,
color);
bufferOutline(gGameMouseActionHitFrmData + crosshairFrmWidth,
gGameMouseActionHitFrmWidth - crosshairFrmWidth,
gGameMouseActionHitFrmHeight,
gGameMouseActionHitFrmWidth,
_colorTable[0]);
fontSetCurrent(oldFont);
artUnlock(crosshairFrmHandle);
return 0;
}
// 0x44D878
int gameMouseRenderActionPoints(const char* string, int color)
{
memset(gGameMouseHexCursorFrmData, 0, gGameMouseHexCursorFrmWidth * gGameMouseHexCursorHeight);
if (*string == '\0') {
return 0;
}
int oldFont = fontGetCurrent();
fontSetCurrent(101);
int length = fontGetStringWidth(string);
fontDrawText(gGameMouseHexCursorFrmData + gGameMouseHexCursorFrmWidth * (gGameMouseHexCursorHeight - fontGetLineHeight()) / 2 + (gGameMouseHexCursorFrmWidth - length) / 2, string, gGameMouseHexCursorFrmWidth, gGameMouseHexCursorFrmWidth, color);
bufferOutline(gGameMouseHexCursorFrmData, gGameMouseHexCursorFrmWidth, gGameMouseHexCursorHeight, gGameMouseHexCursorFrmWidth, _colorTable[0]);
fontSetCurrent(oldFont);
int fid = buildFid(6, 1, 0, 0, 0);
gameMouseSetBouncingCursorFid(fid);
return 0;
}
// 0x44D954
void gameMouseLoadItemHighlight()
{
bool itemHighlight;
if (configGetBool(&gGameConfig, GAME_CONFIG_PREFERENCES_KEY, GAME_CONFIG_ITEM_HIGHLIGHT_KEY, &itemHighlight)) {
gGameMouseItemHighlightEnabled = itemHighlight;
}
}
// 0x44D984
int gameMouseObjectsInit()
{
int fid;
if (gGameMouseObjectsInitialized) {
return -1;
}
fid = buildFid(6, 0, 0, 0, 0);
if (objectCreateWithFidPid(&gGameMouseBouncingCursor, fid, -1) != 0) {
return -1;
}
fid = buildFid(6, 1, 0, 0, 0);
if (objectCreateWithFidPid(&gGameMouseHexCursor, fid, -1) != 0) {
return -1;
}
if (objectSetOutline(gGameMouseHexCursor, OUTLINE_PALETTED | OUTLINE_TYPE_2, NULL) != 0) {
return -1;
}
if (gameMouseActionMenuInit() != 0) {
return -1;
}
gGameMouseBouncingCursor->flags |= OBJECT_FLAG_0x20000000;
gGameMouseBouncingCursor->flags |= OBJECT_TEMPORARY;
gGameMouseBouncingCursor->flags |= OBJECT_FLAG_0x400;
gGameMouseBouncingCursor->flags |= OBJECT_FLAG_0x80000000;
gGameMouseBouncingCursor->flags |= OBJECT_NO_BLOCK;
gGameMouseHexCursor->flags |= OBJECT_FLAG_0x400;
gGameMouseHexCursor->flags |= OBJECT_TEMPORARY;
gGameMouseHexCursor->flags |= OBJECT_FLAG_0x20000000;
gGameMouseHexCursor->flags |= OBJECT_FLAG_0x80000000;
gGameMouseHexCursor->flags |= OBJECT_NO_BLOCK;
_obj_toggle_flat(gGameMouseHexCursor, NULL);
int x;
int y;
mouseGetPosition(&x, &y);
Rect v9;
_gmouse_3d_move_to(x, y, gElevation, &v9);
gGameMouseObjectsInitialized = true;
gameMouseLoadItemHighlight();
return 0;
}
// NOTE: Inlined.
//
// 0x44DAC0
int gameMouseObjectsReset()
{
if (!gGameMouseObjectsInitialized) {
return -1;
}
// NOTE: Uninline.
_gmouse_3d_enable_modes();
// NOTE: Uninline.
gameMouseResetBouncingCursorFid();
gameMouseSetMode(GAME_MOUSE_MODE_MOVE);
gameMouseObjectsShow();
gGameMouseLastX = -1;
gGameMouseLastY = -1;
_gmouse_3d_hover_test = false;
_gmouse_3d_last_move_time = _get_time();
gameMouseLoadItemHighlight();
return 0;
}
// NOTE: Inlined.
//
// 0x44DB34
void gameMouseObjectsFree()
{
if (gGameMouseObjectsInitialized) {
gameMouseActionMenuFree();
gGameMouseBouncingCursor->flags &= ~OBJECT_TEMPORARY;
gGameMouseHexCursor->flags &= ~OBJECT_TEMPORARY;
objectDestroy(gGameMouseBouncingCursor, NULL);
objectDestroy(gGameMouseHexCursor, NULL);
gGameMouseObjectsInitialized = false;
}
}
// 0x44DB78
int gameMouseActionMenuInit()
{
int fid;
// actmenu.frm - action menu
fid = buildFid(6, 283, 0, 0, 0);
gGameMouseActionMenuFrm = artLock(fid, &gGameMouseActionMenuFrmHandle);
if (gGameMouseActionMenuFrm == NULL) {
goto err;
}
// actpick.frm - action pick
fid = buildFid(6, 282, 0, 0, 0);
gGameMouseActionPickFrm = artLock(fid, &gGameMouseActionPickFrmHandle);
if (gGameMouseActionPickFrm == NULL) {
goto err;
}
// acttohit.frm - action to hit
fid = buildFid(6, 284, 0, 0, 0);
gGameMouseActionHitFrm = artLock(fid, &gGameMouseActionHitFrmHandle);
if (gGameMouseActionHitFrm == NULL) {
goto err;
}
// blank.frm - used be mset000.frm for top of bouncing mouse cursor
fid = buildFid(6, 0, 0, 0, 0);
gGameMouseBouncingCursorFrm = artLock(fid, &gGameMouseBouncingCursorFrmHandle);
if (gGameMouseBouncingCursorFrm == NULL) {
goto err;
}
// msef000.frm - hex mouse cursor
fid = buildFid(6, 1, 0, 0, 0);
gGameMouseHexCursorFrm = artLock(fid, &gGameMouseHexCursorFrmHandle);
if (gGameMouseHexCursorFrm == NULL) {
goto err;
}
gGameMouseActionMenuFrmWidth = artGetWidth(gGameMouseActionMenuFrm, 0, 0);
gGameMouseActionMenuFrmHeight = artGetHeight(gGameMouseActionMenuFrm, 0, 0);
gGameMouseActionMenuFrmDataSize = gGameMouseActionMenuFrmWidth * gGameMouseActionMenuFrmHeight;
gGameMouseActionMenuFrmData = artGetFrameData(gGameMouseActionMenuFrm, 0, 0);
gGameMouseActionPickFrmWidth = artGetWidth(gGameMouseActionPickFrm, 0, 0);
gGameMouseActionPickFrmHeight = artGetHeight(gGameMouseActionPickFrm, 0, 0);
gGameMouseActionPickFrmDataSize = gGameMouseActionPickFrmWidth * gGameMouseActionPickFrmHeight;
gGameMouseActionPickFrmData = artGetFrameData(gGameMouseActionPickFrm, 0, 0);
gGameMouseActionHitFrmWidth = artGetWidth(gGameMouseActionHitFrm, 0, 0);
gGameMouseActionHitFrmHeight = artGetHeight(gGameMouseActionHitFrm, 0, 0);
gGameMouseActionHitFrmDataSize = gGameMouseActionHitFrmWidth * gGameMouseActionHitFrmHeight;
gGameMouseActionHitFrmData = artGetFrameData(gGameMouseActionHitFrm, 0, 0);
gGameMouseBouncingCursorFrmWidth = artGetWidth(gGameMouseBouncingCursorFrm, 0, 0);
gGameMouseBouncingCursorFrmHeight = artGetHeight(gGameMouseBouncingCursorFrm, 0, 0);
gGameMouseBouncingCursorFrmDataSize = gGameMouseBouncingCursorFrmWidth * gGameMouseBouncingCursorFrmHeight;
gGameMouseBouncingCursorFrmData = artGetFrameData(gGameMouseBouncingCursorFrm, 0, 0);
gGameMouseHexCursorFrmWidth = artGetWidth(gGameMouseHexCursorFrm, 0, 0);
gGameMouseHexCursorHeight = artGetHeight(gGameMouseHexCursorFrm, 0, 0);
gGameMouseHexCursorDataSize = gGameMouseHexCursorFrmWidth * gGameMouseHexCursorHeight;
gGameMouseHexCursorFrmData = artGetFrameData(gGameMouseHexCursorFrm, 0, 0);
return 0;
err:
// NOTE: Original code is different. There is no call to this function.
// Instead it either use deep nesting or bunch of goto's to unwind
// locked frms from the point of failure.
gameMouseActionMenuFree();
return -1;
}
// 0x44DE44
void gameMouseActionMenuFree()
{
if (gGameMouseBouncingCursorFrmHandle != INVALID_CACHE_ENTRY) {
artUnlock(gGameMouseBouncingCursorFrmHandle);
}
gGameMouseBouncingCursorFrm = NULL;
gGameMouseBouncingCursorFrmHandle = INVALID_CACHE_ENTRY;
if (gGameMouseHexCursorFrmHandle != INVALID_CACHE_ENTRY) {
artUnlock(gGameMouseHexCursorFrmHandle);
}
gGameMouseHexCursorFrm = NULL;
gGameMouseHexCursorFrmHandle = INVALID_CACHE_ENTRY;
if (gGameMouseActionHitFrmHandle != INVALID_CACHE_ENTRY) {
artUnlock(gGameMouseActionHitFrmHandle);
}
gGameMouseActionHitFrm = NULL;
gGameMouseActionHitFrmHandle = INVALID_CACHE_ENTRY;
if (gGameMouseActionMenuFrmHandle != INVALID_CACHE_ENTRY) {
artUnlock(gGameMouseActionMenuFrmHandle);
}
gGameMouseActionMenuFrm = NULL;
gGameMouseActionMenuFrmHandle = INVALID_CACHE_ENTRY;
if (gGameMouseActionPickFrmHandle != INVALID_CACHE_ENTRY) {
artUnlock(gGameMouseActionPickFrmHandle);
}
gGameMouseActionPickFrm = NULL;
gGameMouseActionPickFrmHandle = INVALID_CACHE_ENTRY;
gGameMouseActionPickFrmData = NULL;
gGameMouseActionPickFrmWidth = 0;
gGameMouseActionPickFrmHeight = 0;
gGameMouseActionPickFrmDataSize = 0;
}
// 0x44DF40
int gameMouseUpdateHexCursorFid(Rect* rect)
{
int fid = buildFid(6, gGameMouseModeFrmIds[gGameMouseMode], 0, 0, 0);
if (gGameMouseHexCursor->fid == fid) {
return -1;
}
return objectSetFid(gGameMouseHexCursor, fid, rect);
}
// 0x44DF94
int _gmouse_3d_move_to(int x, int y, int elevation, Rect* a4)
{
if (_gmouse_mapper_mode == 0) {
if (gGameMouseMode != GAME_MOUSE_MODE_MOVE) {
int offsetX = 0;
int offsetY = 0;
CacheEntry* hexCursorFrmHandle;
Art* hexCursorFrm = artLock(gGameMouseHexCursor->fid, &hexCursorFrmHandle);
if (hexCursorFrm != NULL) {
artGetRotationOffsets(hexCursorFrm, 0, &offsetX, &offsetY);
int frameOffsetX;
int frameOffsetY;
artGetFrameOffsets(hexCursorFrm, 0, 0, &frameOffsetX, &frameOffsetY);
offsetX += frameOffsetX;
offsetY += frameOffsetY;
artUnlock(hexCursorFrmHandle);
}
_obj_move(gGameMouseHexCursor, x + offsetX, y + offsetY, elevation, a4);
} else {
int tile = tileFromScreenXY(x, y, 0);
if (tile != -1) {
int screenX;
int screenY;
bool v1 = false;
Rect rect1;
if (tileToScreenXY(tile, &screenX, &screenY, 0) == 0) {
if (_obj_move(gGameMouseBouncingCursor, screenX + 16, screenY + 15, 0, &rect1) == 0) {
v1 = true;
}
}
Rect rect2;
if (objectSetLocation(gGameMouseHexCursor, tile, elevation, &rect2) == 0) {
if (v1) {
rectUnion(&rect1, &rect2, &rect1);
} else {
rectCopy(&rect1, &rect2);
}
rectCopy(a4, &rect1);
}
}
}
return 0;
}
int tile;
int x1 = 0;
int y1 = 0;
int fid = gGameMouseBouncingCursor->fid;
if ((fid & 0xF000000) >> 24 == OBJ_TYPE_TILE) {
int squareTile = _square_num(x, y, elevation);
if (squareTile == -1) {
tile = HEX_GRID_WIDTH * (2 * (squareTile / SQUARE_GRID_WIDTH) + 1) + 2 * (squareTile % SQUARE_GRID_WIDTH) + 1;
x1 = -8;
y1 = 13;
char* executable;
configGetString(&gGameConfig, GAME_CONFIG_SYSTEM_KEY, GAME_CONFIG_EXECUTABLE_KEY, &executable);
if (stricmp(executable, "mapper") == 0) {
if (_tile_roof_visible()) {
if ((gDude->flags & OBJECT_HIDDEN) == 0) {
y1 = -83;
}
}
}
} else {
tile = -1;
}
} else {
tile = tileFromScreenXY(x, y, elevation);
}
if (tile != -1) {
bool v1 = false;
Rect rect1;
Rect rect2;
if (objectSetLocation(gGameMouseBouncingCursor, tile, elevation, &rect1) == 0) {
if (x1 != 0 || y1 != 0) {
if (_obj_offset(gGameMouseBouncingCursor, x1, y1, &rect2) == 0) {
rectUnion(&rect1, &rect2, &rect1);
}
}
v1 = true;
}
if (gGameMouseMode != GAME_MOUSE_MODE_MOVE) {
int offsetX = 0;
int offsetY = 0;
CacheEntry* hexCursorFrmHandle;
Art* hexCursorFrm = artLock(gGameMouseHexCursor->fid, &hexCursorFrmHandle);
if (hexCursorFrm != NULL) {
artGetRotationOffsets(hexCursorFrm, 0, &offsetX, &offsetY);
int frameOffsetX;
int frameOffsetY;
artGetFrameOffsets(hexCursorFrm, 0, 0, &frameOffsetX, &frameOffsetY);
offsetX += frameOffsetX;
offsetY += frameOffsetY;
artUnlock(hexCursorFrmHandle);
}
if (_obj_move(gGameMouseHexCursor, x + offsetX, y + offsetY, elevation, &rect2) == 0) {
if (v1) {
rectUnion(&rect1, &rect2, &rect1);
} else {
rectCopy(&rect1, &rect2);
v1 = true;
}
}
} else {
if (objectSetLocation(gGameMouseHexCursor, tile, elevation, &rect2) == 0) {
if (v1) {
rectUnion(&rect1, &rect2, &rect1);
} else {
rectCopy(&rect1, &rect2);
v1 = true;
}
}
}
if (v1) {
rectCopy(a4, &rect1);
}
}
return 0;
}
// 0x44E42C
int gameMouseHandleScrolling(int x, int y, int cursor)
{
if (!_gmouse_scrolling_enabled) {
return -1;
}
int flags = 0;
if (x <= _scr_size.left) {
flags |= SCROLLABLE_W;
}
if (x >= _scr_size.right) {
flags |= SCROLLABLE_E;
}
if (y <= _scr_size.top) {
flags |= SCROLLABLE_N;
}
if (y >= _scr_size.bottom) {
flags |= SCROLLABLE_S;
}
int dx = 0;
int dy = 0;
switch (flags) {
case SCROLLABLE_W:
dx = -1;
cursor = MOUSE_CURSOR_SCROLL_W;
break;
case SCROLLABLE_E:
dx = 1;
cursor = MOUSE_CURSOR_SCROLL_E;
break;
case SCROLLABLE_N:
dy = -1;
cursor = MOUSE_CURSOR_SCROLL_N;
break;
case SCROLLABLE_N | SCROLLABLE_W:
dx = -1;
dy = -1;
cursor = MOUSE_CURSOR_SCROLL_NW;
break;
case SCROLLABLE_N | SCROLLABLE_E:
dx = 1;
dy = -1;
cursor = MOUSE_CURSOR_SCROLL_NE;
break;
case SCROLLABLE_S:
dy = 1;
cursor = MOUSE_CURSOR_SCROLL_S;
break;
case SCROLLABLE_S | SCROLLABLE_W:
dx = -1;
dy = 1;
cursor = MOUSE_CURSOR_SCROLL_SW;
break;
case SCROLLABLE_S | SCROLLABLE_E:
dx = 1;
dy = 1;
cursor = MOUSE_CURSOR_SCROLL_SE;
break;
}
if (dx == 0 && dy == 0) {
return -1;
}
int rc = mapScroll(dx, dy);
switch (rc) {
case -1:
// Scrolling is blocked for whatever reason, upgrade cursor to
// appropriate blocked version.
cursor += 8;
// FALLTHROUGH
case 0:
gameMouseSetCursor(cursor);
break;
}
return 0;
}
// 0x44E544
void _gmouse_remove_item_outline(Object* object)
{
if (gGameMouseHighlightedItem != NULL && gGameMouseHighlightedItem == object) {
Rect rect;
if (objectClearOutline(object, &rect) == 0) {
tileWindowRefreshRect(&rect, gElevation);
}
gGameMouseHighlightedItem = NULL;
}
}
// 0x44E580
int objectIsDoor(Object* object)
{
if (object == NULL) {
return false;
}
if ((object->pid >> 24) != OBJ_TYPE_SCENERY) {
return false;
}
Proto* proto;
if (protoGetProto(object->pid, &proto) == -1) {
return false;
}
return proto->scenery.type == SCENERY_TYPE_DOOR;
}