madcow/scummvm-cursorfix
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity
Files
main
scummvm-cursorfix/engines/scumm/he/logic/basketball_logic.cpp
Leon Krieg 5b11698731 Initial commit
2026-02-02 04:50:13 +01:00

676 lines
21 KiB
C++
Raw Permalink Blame History

/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include "scumm/he/intern_he.h"
#include "scumm/he/logic_he.h"
#include "scumm/he/basketball/basketball.h"
#include "scumm/he/basketball/collision/bball_collision.h"
#include "scumm/he/basketball/geo_translations.h"
namespace Scumm {
// Opcodes
#define WORLD_TO_SCREEN_TRANSLATION 1006
#define WORLD_TO_SCREEN_TRANSLATION_PARAMS 3
#define SCREEN_TO_WORLD_TRANSLATION 1010
#define SCREEN_TO_WORLD_TRANSLATION_PARAMS 2
#define INIT_SCREEN_TRANSLATIONS 1011
#define INIT_SCREEN_TRANSLATIONS_PARAMS 0
#define GET_COURT_DIMENSIONS 1012
#define GET_COURT_DIMENSIONS_PARAMS 0
#define COMPUTE_INITIAL_SHOT_VELOCITY 1030
#define COMPUTE_INITIAL_SHOT_VELOCITY_PARAMS 4
#define COMPUTE_TRAJECTORY_TO_TARGET 1031
#define COMPUTE_TRAJECTORY_TO_TARGET_PARAMS 7
#define COMPUTE_LAUNCH_TRAJECTORY 1032
#define COMPUTE_LAUNCH_TRAJECTORY_PARAMS 6
#define COMPUTE_ANGLE_OF_SHOT 1033
#define COMPUTE_ANGLE_OF_SHOT_PARAMS 2
#define COMPUTE_ANGLE_OF_PASS 1034
#define COMPUTE_ANGLE_OF_PASS_PARAMS 4
#define COMPUTE_POINTS_FOR_PIXELS 1035
#define COMPUTE_POINTS_FOR_PIXELS_PARAMS 2
#define COMPUTE_ANGLE_OF_BOUNCE_PASS 1036
#define COMPUTE_ANGLE_OF_BOUNCE_PASS_PARAMS 5
#define COMPUTE_BANK_SHOT_TARGET 1037
#define COMPUTE_BANK_SHOT_TARGET_PARAMS 4
#define COMPUTE_SWOOSH_TARGET 1038
#define COMPUTE_SWOOSH_TARGET_PARAMS 4
#define DETECT_SHOT_MADE 1039
#define DETECT_SHOT_MADE_PARAMS 9
#define COMPUTE_ANGLE_BETWEEN_VECTORS 1040
#define COMPUTE_ANGLE_BETWEEN_VECTORS_PARAMS 6
#define HIT_MOVING_TARGET 1041
#define HIT_MOVING_TARGET_PARAMS 7
#define GET_PASS_TARGET 1042
#define GET_PASS_TARGET_PARAMS 3
#define DETECT_PASS_BLOCKER 1043
#define DETECT_PASS_BLOCKER_PARAMS 3
#define GET_BALL_INTERCEPT 1044
#define GET_BALL_INTERCEPT_PARAMS 4
#define INIT_COURT 1050
#define INIT_COURT_PARAMS 1
#define INIT_BALL 1051
#define INIT_BALL_PARAMS 8
#define INIT_PLAYER 1052
#define INIT_PLAYER_PARAMS 7
#define DEINIT_COURT 1053
#define DEINIT_COURT_PARAMS 0
#define DEINIT_BALL 1054
#define DEINIT_BALL_PARAMS 0
#define DEINIT_PLAYER 1055
#define DEINIT_PLAYER_PARAMS 1
#define DETECT_BALL_COLLISION 1056
#define DETECT_BALL_COLLISION_PARAMS 8
#define DETECT_PLAYER_COLLISION 1057
#define DETECT_PLAYER_COLLISION_PARAMS 8
#define GET_LAST_BALL_COLLISION 1058
#define GET_LAST_BALL_COLLISION_PARAMS 1
#define GET_LAST_PLAYER_COLLISION 1059
#define GET_LAST_PLAYER_COLLISION_PARAMS 1
#define INIT_VIRTUAL_BALL 1060
#define INIT_VIRTUAL_BALL_PARAMS 8
#define DEINIT_VIRTUAL_BALL 1061
#define DEINIT_VIRTUAL_BALL_PARAMS 0
#define PLAYER_OFF 1062
#define PLAYER_OFF_PARAMS 1
#define PLAYER_ON 1063
#define PLAYER_ON_PARAMS 1
#define RAISE_SHIELDS 1064
#define RAISE_SHIELDS_PARAMS 1
#define LOWER_SHIELDS 1065
#define LOWER_SHIELDS_PARAMS 1
#define FIND_PLAYER_CLOSEST_TO_BALL 1066
#define FIND_PLAYER_CLOSEST_TO_BALL_PARAMS 1
#define IS_PLAYER_IN_BOUNDS 1067
#define IS_PLAYER_IN_BOUNDS_PARAMS 1
#define ARE_SHIELDS_CLEAR 1068
#define ARE_SHIELDS_CLEAR_PARAMS 0
#define SHIELD_PLAYER 1069
#define SHIELD_PLAYER_PARAMS 2
#define CLEAR_PLAYER_SHIELD 1070
#define CLEAR_PLAYER_SHIELD_PARAMS 1
#define IS_BALL_IN_BOUNDS 1071
#define IS_BALL_IN_BOUNDS_PARAMS 0
#define GET_AVOIDANCE_PATH 1072
#define GET_AVOIDANCE_PATH_PARAMS 4
#define SET_BALL_LOCATION 1073
#define SET_BALL_LOCATION_PARAMS 4
#define GET_BALL_LOCATION 1074
#define GET_BALL_LOCATION_PARAMS 1
#define SET_PLAYER_LOCATION 1075
#define SET_PLAYER_LOCATION_PARAMS 4
#define GET_PLAYER_LOCATION 1076
#define GET_PLAYER_LOCATION_PARAMS 1
#define START_BLOCK 1077
#define START_BLOCK_PARAMS 3
#define HOLD_BLOCK 1078
#define HOLD_BLOCK_PARAMS 1
#define END_BLOCK 1079
#define END_BLOCK_PARAMS 1
#define IS_PLAYER_IN_GAME 1080
#define IS_PLAYER_IN_GAME_PARAMS 1
#define IS_BALL_IN_GAME 1081
#define IS_BALL_IN_GAME_PARAMS 1
#define UPDATE_CURSOR_POS 1090
#define UPDATE_CURSOR_POS_PARAMS 2
#define MAKE_CURSOR_STICKY 1091
#define MAKE_CURSOR_STICKY_PARAMS 2
#define CURSOR_TRACK_MOVING_OBJECT 1092
#define CURSOR_TRACK_MOVING_OBJECT_PARAMS 2
#define GET_CURSOR_POSITION 1093
#define GET_CURSOR_POSITION_PARAMS 0
#define AI_GET_OPEN_SPOT 1100
#define AI_GET_OPEN_SPOT_PARAMS 10
#define AI_GET_OPPONENTS_IN_CONE 1101
#define AI_GET_OPPONENTS_IN_CONE_PARAMS 6
#define U32_CLEAN_UP_OFF_HEAP 1102
#define U32_CLEAN_UP_OFF_HEAP_PARAMS 0
#define DRAW_DEBUG_LINES 1500
#define DRAW_DEBUG_LINES_PARAMS 0
#define ADD_DEBUG_GEOM 1501
int LogicHEBasketball::versionID() {
return 1;
}
int32 LogicHEBasketball::dispatch(int cmdID, int paramCount, int32 *params) {
U32FltPoint3D flt3DPoint1, flt3DPoint2;
U32FltPoint2D flt2DPoint1, flt2DPoint2;
U32IntVector3D int3DVector1;
U32FltVector3D flt3DVector1, flt3DVector2;
U32FltVector2D flt2DVector1;
U32Sphere sphere1;
int retValue = 0;
switch (cmdID) {
case INIT_SCREEN_TRANSLATIONS:
assert(paramCount == INIT_SCREEN_TRANSLATIONS_PARAMS);
retValue = u32_userInitScreenTranslations();
break;
case WORLD_TO_SCREEN_TRANSLATION:
assert(paramCount == WORLD_TO_SCREEN_TRANSLATION_PARAMS);
flt3DPoint1.x = (float)params[0];
flt3DPoint1.y = (float)params[1];
flt3DPoint1.z = (float)params[2];
retValue = u32_userWorldToScreenTranslation(flt3DPoint1);
break;
case SCREEN_TO_WORLD_TRANSLATION:
assert(paramCount == SCREEN_TO_WORLD_TRANSLATION_PARAMS);
flt2DPoint1.x = (float)params[0];
flt2DPoint1.y = (float)params[1];
retValue = u32_userScreenToWorldTranslation(flt2DPoint1);
break;
case GET_COURT_DIMENSIONS:
assert(paramCount == GET_COURT_DIMENSIONS_PARAMS);
retValue = u32_userGetCourtDimensions();
break;
case COMPUTE_TRAJECTORY_TO_TARGET:
assert(paramCount == COMPUTE_TRAJECTORY_TO_TARGET_PARAMS);
flt3DPoint1.x = (float)params[0];
flt3DPoint1.y = (float)params[1];
flt3DPoint1.z = (float)params[2];
flt3DPoint2.x = (float)params[3];
flt3DPoint2.y = (float)params[4];
flt3DPoint2.z = (float)params[5];
retValue = u32_userComputeTrajectoryToTarget(flt3DPoint1, flt3DPoint2, params[6]);
break;
case COMPUTE_LAUNCH_TRAJECTORY:
assert(paramCount == COMPUTE_LAUNCH_TRAJECTORY_PARAMS);
flt2DPoint1.x = (float)params[0];
flt2DPoint1.y = (float)params[1];
flt2DPoint2.x = (float)params[2];
flt2DPoint2.y = (float)params[3];
retValue = u32_userComputeLaunchTrajectory(flt2DPoint1, flt2DPoint2, params[4], params[5]);
break;
case COMPUTE_ANGLE_BETWEEN_VECTORS:
assert(paramCount == COMPUTE_ANGLE_BETWEEN_VECTORS_PARAMS);
flt3DVector1.x = (float)params[0];
flt3DVector1.y = (float)params[1];
flt3DVector1.z = (float)params[2];
flt3DVector2.x = (float)params[3];
flt3DVector2.y = (float)params[4];
flt3DVector2.z = (float)params[5];
retValue = u32_userComputeAngleBetweenVectors(flt3DVector1, flt3DVector2);
break;
case COMPUTE_INITIAL_SHOT_VELOCITY:
assert(paramCount == COMPUTE_INITIAL_SHOT_VELOCITY_PARAMS);
retValue = u32_userComputeInitialShotVelocity(params[0], params[1], params[2], params[3]);
break;
case COMPUTE_ANGLE_OF_SHOT:
assert(paramCount == COMPUTE_ANGLE_OF_SHOT_PARAMS);
retValue = u32_userComputeAngleOfShot(params[0], params[1]);
break;
case COMPUTE_ANGLE_OF_PASS:
assert(paramCount == COMPUTE_ANGLE_OF_PASS_PARAMS);
retValue = u32_userComputeAngleOfPass(params[0], params[1], params[2], params[3]);
break;
case COMPUTE_ANGLE_OF_BOUNCE_PASS:
assert(paramCount == COMPUTE_ANGLE_OF_BOUNCE_PASS_PARAMS);
retValue = u32_userComputeAngleOfBouncePass(params[0], params[1], params[2], params[3], params[4]);
break;
case HIT_MOVING_TARGET:
assert(paramCount == HIT_MOVING_TARGET_PARAMS);
flt2DPoint1.x = (float)params[0];
flt2DPoint1.y = (float)params[1];
flt2DPoint2.x = (float)params[2];
flt2DPoint2.y = (float)params[3];
flt2DVector1.x = (float)params[4];
flt2DVector1.y = (float)params[5];
retValue = u32_userHitMovingTarget(flt2DPoint1, flt2DPoint2, flt2DVector1, params[6]);
break;
case GET_PASS_TARGET:
assert(paramCount == GET_PASS_TARGET_PARAMS);
flt3DVector1.x = (float)params[1];
flt3DVector1.y = (float)params[2];
retValue = u32_userGetPassTarget(params[0], flt3DVector1);
break;
case DETECT_PASS_BLOCKER:
assert(paramCount == DETECT_PASS_BLOCKER_PARAMS);
flt3DVector1.x = (float)params[1];
flt3DVector1.y = (float)params[2];
retValue = u32_userDetectPassBlocker(params[0], flt3DVector1);
break;
case GET_BALL_INTERCEPT:
assert(paramCount == GET_BALL_INTERCEPT_PARAMS);
retValue = u32_userGetBallIntercept(params[0], params[1], params[2], params[3]);
break;
case COMPUTE_POINTS_FOR_PIXELS:
assert(paramCount == COMPUTE_POINTS_FOR_PIXELS_PARAMS);
retValue = u32_userComputePointsForPixels(params[0], params[1]);
break;
case COMPUTE_BANK_SHOT_TARGET:
assert(paramCount == COMPUTE_BANK_SHOT_TARGET_PARAMS);
flt3DPoint1.x = (float)params[0];
flt3DPoint1.y = (float)params[1];
flt3DPoint1.z = (float)params[2];
retValue = u32_userComputeBankShotTarget(flt3DPoint1, params[3]);
break;
case COMPUTE_SWOOSH_TARGET:
assert(paramCount == COMPUTE_SWOOSH_TARGET_PARAMS);
flt3DPoint1.x = (float)params[0];
flt3DPoint1.y = (float)params[1];
flt3DPoint1.z = (float)params[2];
retValue = u32_userComputeSwooshTarget(flt3DPoint1, params[3]);
break;
case INIT_COURT:
assert(paramCount == INIT_COURT_PARAMS);
retValue = u32_userInitCourt(params[0]);
break;
case DEINIT_COURT:
assert(paramCount == DEINIT_COURT_PARAMS);
retValue = u32_userDeinitCourt();
break;
case INIT_BALL:
assert(paramCount == INIT_BALL_PARAMS);
flt3DPoint1.x = (float)params[0];
flt3DPoint1.y = (float)params[1];
flt3DPoint1.z = (float)params[2];
flt3DVector1.x = (float)params[3];
flt3DVector1.y = (float)params[4];
flt3DVector1.z = (float)params[5];
retValue = u32_userInitBall(flt3DPoint1, flt3DVector1, params[6], params[7]);
break;
case DEINIT_BALL:
assert(paramCount == DEINIT_BALL_PARAMS);
retValue = u32_userDeinitBall();
break;
case INIT_VIRTUAL_BALL:
assert(paramCount == INIT_VIRTUAL_BALL_PARAMS);
flt3DPoint1.x = (float)params[0];
flt3DPoint1.y = (float)params[1];
flt3DPoint1.z = (float)params[2];
flt3DVector1.x = (float)params[3];
flt3DVector1.y = (float)params[4];
flt3DVector1.z = (float)params[5];
retValue = u32_userInitVirtualBall(flt3DPoint1, flt3DVector1, params[6], params[7]);
break;
case DEINIT_VIRTUAL_BALL:
assert(paramCount == DEINIT_VIRTUAL_BALL_PARAMS);
retValue = u32_userDeinitVirtualBall();
break;
case INIT_PLAYER:
assert(paramCount == INIT_PLAYER_PARAMS);
flt3DPoint1.x = (float)params[1];
flt3DPoint1.y = (float)params[2];
flt3DPoint1.z = (float)params[3];
retValue = u32_userInitPlayer(params[0], flt3DPoint1, params[4], params[5], (params[6] != 0));
break;
case DEINIT_PLAYER:
assert(paramCount == DEINIT_PLAYER_PARAMS);
retValue = u32_userDeinitPlayer(params[0]);
break;
case PLAYER_OFF:
assert(paramCount == PLAYER_OFF_PARAMS);
retValue = u32_userPlayerOff(params[0]);
break;
case PLAYER_ON:
assert(paramCount == PLAYER_ON_PARAMS);
retValue = u32_userPlayerOn(params[0]);
break;
case SET_BALL_LOCATION:
assert(paramCount == SET_BALL_LOCATION_PARAMS);
flt3DPoint1.x = (float)params[0];
flt3DPoint1.y = (float)params[1];
flt3DPoint1.z = (float)params[2];
_vm->_basketball->_court->getBallPtr(params[3])->center = flt3DPoint1;
retValue = 1;
break;
case GET_BALL_LOCATION:
assert(paramCount == GET_BALL_LOCATION_PARAMS);
flt3DPoint1 = _vm->_basketball->_court->getBallPtr(params[0])->center;
writeScummVar(_vm1->VAR_U32_USER_VAR_A, _vm->_basketball->u32FloatToInt(flt3DPoint1.x));
writeScummVar(_vm1->VAR_U32_USER_VAR_B, _vm->_basketball->u32FloatToInt(flt3DPoint1.y));
writeScummVar(_vm1->VAR_U32_USER_VAR_C, _vm->_basketball->u32FloatToInt(flt3DPoint1.z));
retValue = 1;
break;
case SET_PLAYER_LOCATION:
assert(paramCount == SET_PLAYER_LOCATION_PARAMS);
flt3DPoint1.x = (float)params[0];
flt3DPoint1.y = (float)params[1];
flt3DPoint1.z = (float)params[2];
flt3DPoint1.z += (_vm->_basketball->_court->getPlayerPtr(params[3])->height / 2);
_vm->_basketball->_court->getPlayerPtr(params[3])->center = flt3DPoint1;
retValue = 1;
break;
case GET_PLAYER_LOCATION:
assert(paramCount == GET_PLAYER_LOCATION_PARAMS);
flt3DPoint1 = _vm->_basketball->_court->getPlayerPtr(params[0])->center;
flt3DPoint1.z -= (_vm->_basketball->_court->getPlayerPtr(params[0])->height / 2);
writeScummVar(_vm1->VAR_U32_USER_VAR_A, _vm->_basketball->u32FloatToInt(flt3DPoint1.x));
writeScummVar(_vm1->VAR_U32_USER_VAR_B, _vm->_basketball->u32FloatToInt(flt3DPoint1.y));
writeScummVar(_vm1->VAR_U32_USER_VAR_C, _vm->_basketball->u32FloatToInt(flt3DPoint1.z));
retValue = 1;
break;
case DETECT_BALL_COLLISION:
assert(paramCount == DETECT_BALL_COLLISION_PARAMS);
flt3DPoint1.x = (float)params[0];
flt3DPoint1.y = (float)params[1];
flt3DPoint1.z = (float)params[2];
flt3DVector1.x = (float)params[3];
flt3DVector1.y = (float)params[4];
flt3DVector1.z = (float)params[5];
retValue = u32_userDetectBallCollision(flt3DPoint1, flt3DVector1, params[6], params[7]);
break;
case DETECT_PLAYER_COLLISION:
assert(paramCount == DETECT_PLAYER_COLLISION_PARAMS);
flt3DPoint1.x = (float)params[1];
flt3DPoint1.y = (float)params[2];
flt3DPoint1.z = (float)params[3];
flt3DVector1.x = (float)params[4];
flt3DVector1.y = (float)params[5];
flt3DVector1.z = (float)params[6];
retValue = u32_userDetectPlayerCollision(params[0], flt3DPoint1, flt3DVector1, (params[7] != 0));
break;
case GET_LAST_BALL_COLLISION:
assert(paramCount == GET_LAST_BALL_COLLISION_PARAMS);
retValue = u32_userGetLastBallCollision(params[0]);
break;
case GET_LAST_PLAYER_COLLISION:
assert(paramCount == GET_LAST_PLAYER_COLLISION_PARAMS);
retValue = u32_userGetLastPlayerCollision(params[0]);
break;
case DETECT_SHOT_MADE:
assert(paramCount == DETECT_SHOT_MADE_PARAMS);
sphere1.center.x = (float)params[0];
sphere1.center.y = (float)params[1];
sphere1.center.z = (float)params[2];
sphere1.radius = (float)params[6];
int3DVector1.x = params[3];
int3DVector1.y = params[4];
int3DVector1.z = params[5];
retValue = u32_userDetectShotMade(sphere1, int3DVector1, params[7], params[8]);
break;
case RAISE_SHIELDS:
assert(paramCount == RAISE_SHIELDS_PARAMS);
retValue = u32_userRaiseShields(params[0]);
break;
case LOWER_SHIELDS:
assert(paramCount == LOWER_SHIELDS_PARAMS);
retValue = u32_userLowerShields(params[0]);
break;
case FIND_PLAYER_CLOSEST_TO_BALL:
assert((paramCount == 0) || (paramCount == FIND_PLAYER_CLOSEST_TO_BALL_PARAMS));
if (paramCount == 0) {
retValue = u32_userGetPlayerClosestToBall();
} else {
retValue = u32_userGetPlayerClosestToBall(params[0]);
}
break;
case IS_PLAYER_IN_BOUNDS:
assert(paramCount == IS_PLAYER_IN_BOUNDS_PARAMS);
retValue = u32_userIsPlayerInBounds(params[0]);
break;
case IS_BALL_IN_BOUNDS:
assert(paramCount == IS_BALL_IN_BOUNDS_PARAMS);
retValue = u32_userIsBallInBounds();
break;
case ARE_SHIELDS_CLEAR:
assert(paramCount == ARE_SHIELDS_CLEAR_PARAMS);
retValue = u32_userAreShieldsClear();
break;
case SHIELD_PLAYER:
assert(paramCount == SHIELD_PLAYER_PARAMS);
retValue = u32_userShieldPlayer(params[0], params[1]);
break;
case CLEAR_PLAYER_SHIELD:
assert(paramCount == CLEAR_PLAYER_SHIELD_PARAMS);
retValue = u32_userClearPlayerShield(params[0]);
break;
case GET_AVOIDANCE_PATH:
assert(paramCount == GET_AVOIDANCE_PATH_PARAMS);
flt2DPoint1.x = (float)params[1];
flt2DPoint1.y = (float)params[2];
retValue = u32_userGetAvoidancePath(params[0], flt2DPoint1, (EAvoidanceType)params[3]);
break;
case START_BLOCK:
assert(paramCount == START_BLOCK_PARAMS);
assert((FIRST_PLAYER <= params[0]) && (params[0] <= LAST_PLAYER));
(_vm->_basketball->_court->getPlayerPtr(params[0]))->startBlocking(params[1], params[2]);
retValue = 1;
break;
case HOLD_BLOCK:
assert(paramCount == HOLD_BLOCK_PARAMS);
assert((FIRST_PLAYER <= params[0]) && (params[0] <= LAST_PLAYER));
(_vm->_basketball->_court->getPlayerPtr(params[0]))->holdBlocking();
retValue = 1;
break;
case END_BLOCK:
assert(paramCount == END_BLOCK_PARAMS);
assert((FIRST_PLAYER <= params[0]) && (params[0] <= LAST_PLAYER));
(_vm->_basketball->_court->getPlayerPtr(params[0]))->endBlocking();
retValue = 1;
break;
case IS_PLAYER_IN_GAME:
assert(paramCount == IS_PLAYER_IN_GAME_PARAMS);
assert((FIRST_PLAYER <= params[0]) && (params[0] <= LAST_PLAYER));
writeScummVar(_vm1->VAR_U32_USER_VAR_A, ((_vm->_basketball->_court->getPlayerPtr(params[0]))->_playerIsInGame) ? 1 : 0);
retValue = 1;
break;
case IS_BALL_IN_GAME:
assert(paramCount == IS_BALL_IN_GAME_PARAMS);
writeScummVar(_vm1->VAR_U32_USER_VAR_A, ((_vm->_basketball->_court->getBallPtr(params[0]))->_ignore) ? 0 : 1);
retValue = 1;
break;
case UPDATE_CURSOR_POS:
assert(paramCount == UPDATE_CURSOR_POS_PARAMS);
retValue = u32_userUpdateCursorPos(params[0], params[1]);
break;
case MAKE_CURSOR_STICKY:
assert(paramCount == MAKE_CURSOR_STICKY_PARAMS);
retValue = u32_userMakeCursorSticky(params[0], params[1]);
break;
case CURSOR_TRACK_MOVING_OBJECT:
assert(paramCount == CURSOR_TRACK_MOVING_OBJECT_PARAMS);
retValue = u32_userCursorTrackMovingObject(params[0], params[1]);
break;
case GET_CURSOR_POSITION:
assert(paramCount == GET_CURSOR_POSITION_PARAMS);
retValue = u32_userGetCursorPos();
break;
case AI_GET_OPEN_SPOT:
assert(paramCount == AI_GET_OPEN_SPOT_PARAMS);
retValue = u32_userGetOpenSpot(
params[0],
U32FltVector2D((float)params[1], (float)params[2]),
U32FltVector2D((float)params[3], (float)params[4]),
U32FltVector2D((float)params[5], (float)params[6]),
(params[7] != 0),
U32FltVector2D((float)params[8], (float)params[9]));
break;
case AI_GET_OPPONENTS_IN_CONE:
assert(paramCount == AI_GET_OPPONENTS_IN_CONE_PARAMS);
retValue = _vm->_basketball->numOpponentsInCone(
params[0],
(((float)params[1]) / 65536),
U32FltVector2D((float)params[2], (float)params[3]),
U32FltVector2D((float)params[4], (float)params[5]));
break;
case U32_CLEAN_UP_OFF_HEAP:
// No-op
retValue = 1;
break;
default:
break;
}
return retValue;
}
LogicHE *makeLogicHEbasketball(ScummEngine_v100he *vm) {
return new LogicHEBasketball(vm);
}
} // End of namespace Scumm
Reference in New Issue View Git Blame Copy Permalink