/* 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 .
*
*/
//=============================================================================
//
// AGS Character functions
//
//=============================================================================
#include "ags/engine/ac/character.h"
#include "ags/shared/ac/common.h"
#include "ags/shared/ac/game_setup_struct.h"
#include "ags/shared/ac/view.h"
#include "ags/engine/ac/display.h"
#include "ags/engine/ac/draw.h"
#include "ags/engine/ac/event.h"
#include "ags/engine/ac/game.h"
#include "ags/engine/ac/global_audio.h"
#include "ags/engine/ac/global_character.h"
#include "ags/engine/ac/global_game.h"
#include "ags/engine/ac/global_object.h"
#include "ags/engine/ac/global_region.h"
#include "ags/engine/ac/global_room.h"
#include "ags/engine/ac/global_translation.h"
#include "ags/engine/ac/gui.h"
#include "ags/engine/ac/lip_sync.h"
#include "ags/engine/ac/mouse.h"
#include "ags/engine/ac/object.h"
#include "ags/engine/ac/overlay.h"
#include "ags/engine/ac/properties.h"
#include "ags/engine/ac/room.h"
#include "ags/engine/ac/screen_overlay.h"
#include "ags/engine/ac/string.h"
#include "ags/engine/ac/system.h"
#include "ags/engine/ac/view_frame.h"
#include "ags/engine/ac/walkable_area.h"
#include "ags/shared/gui/gui_main.h"
#include "ags/engine/ac/route_finder.h"
#include "ags/engine/ac/game_state.h"
#include "ags/engine/debugging/debug_log.h"
#include "ags/engine/main/game_run.h"
#include "ags/engine/main/update.h"
#include "ags/shared/ac/sprite_cache.h"
#include "ags/shared/util/string_compat.h"
#include "ags/engine/gfx/graphics_driver.h"
#include "ags/engine/script/runtime_script_value.h"
#include "ags/engine/ac/dynobj/cc_character.h"
#include "ags/engine/ac/dynobj/cc_inventory.h"
#include "ags/engine/ac/dynobj/dynobj_manager.h"
#include "ags/engine/script/script_runtime.h"
#include "ags/shared/gfx/gfx_def.h"
#include "ags/engine/media/audio/audio_system.h"
#include "ags/engine/ac/move_list.h"
#include "ags/shared/debugging/out.h"
#include "ags/engine/script/script_api.h"
#include "ags/engine/script/script_runtime.h"
#include "ags/engine/ac/dynobj/script_string.h"
#include "ags/globals.h"
namespace AGS3 {
using namespace AGS::Shared;
bool is_valid_character(int char_id) {
return ((char_id >= 0) && (char_id < _GP(game).numcharacters));
}
// Checks if character is currently playing idle anim, and reset it
static void stop_character_idling(CharacterInfo *chi) {
if (chi->idleleft < 0) {
Character_UnlockView(chi);
chi->idleleft = chi->idletime;
}
}
bool AssertCharacter(const char *apiname, int char_id) {
if ((char_id >= 0) && (char_id < _GP(game).numcharacters))
return true;
debug_script_warn("%s: invalid character id %d (range is 0..%d)", apiname, char_id, _GP(game).numcharacters - 1);
return false;
}
void Character_AddInventory(CharacterInfo *chaa, ScriptInvItem *invi, int addIndex) {
int ee;
if (invi == nullptr)
quit("!AddInventoryToCharacter: invalid inventory number");
int inum = invi->id;
if (chaa->inv[inum] >= 32000)
quit("!AddInventory: cannot carry more than 32000 of one inventory item");
chaa->inv[inum]++;
int charid = chaa->index_id;
if (_GP(game).options[OPT_DUPLICATEINV] == 0) {
// Ensure it is only in the list once
for (ee = 0; ee < _GP(charextra)[charid].invorder_count; ee++) {
if (_GP(charextra)[charid].invorder[ee] == inum) {
// They already have the item, so don't add it to the list
if (chaa == _G(playerchar))
run_on_event(GE_ADD_INV, RuntimeScriptValue().SetInt32(inum));
return;
}
}
}
if (_GP(charextra)[charid].invorder_count >= MAX_INVORDER)
quit("!Too many inventory items added, max 500 display at one time");
if ((addIndex == SCR_NO_VALUE) ||
(addIndex >= _GP(charextra)[charid].invorder_count) ||
(addIndex < 0)) {
// add new item at end of list
_GP(charextra)[charid].invorder[_GP(charextra)[charid].invorder_count] = inum;
} else {
// insert new item at index
for (ee = _GP(charextra)[charid].invorder_count - 1; ee >= addIndex; ee--)
_GP(charextra)[charid].invorder[ee + 1] = _GP(charextra)[charid].invorder[ee];
_GP(charextra)[charid].invorder[addIndex] = inum;
}
_GP(charextra)[charid].invorder_count++;
GUI::MarkInventoryForUpdate(charid, charid == _GP(game).playercharacter);
if (chaa == _G(playerchar))
run_on_event(GE_ADD_INV, RuntimeScriptValue().SetInt32(inum));
}
void Character_AddWaypoint(CharacterInfo *chaa, int x, int y) {
if (chaa->room != _G(displayed_room))
quitprintf("!MoveCharacterPath: character %s is not in current room %d (it is in room %d)",
chaa->scrname, _G(displayed_room), chaa->room);
// not already walking, so just do a normal move
if (chaa->walking <= 0) {
Character_Walk(chaa, x, y, IN_BACKGROUND, ANYWHERE);
return;
}
MoveList *cmls = &_GP(mls)[chaa->walking % TURNING_AROUND];
if (cmls->numstage >= MAXNEEDSTAGES) {
debug_script_warn("Character::AddWaypoint: move is too complex, cannot add any further paths");
return;
}
// They're already walking there anyway
const Point &last_pos = cmls->GetLastPos();
if (last_pos == Point(x, y))
return;
int move_speed_x, move_speed_y;
chaa->get_effective_walkspeeds(move_speed_x, move_speed_y);
if ((move_speed_x == 0) && (move_speed_y == 0)) {
debug_script_warn("Character::AddWaypoint: called for '%s' with walk speed 0", chaa->scrname);
}
// There's an issue: the existing movelist is converted to room resolution,
// so we do this trick: convert last step to mask resolution, before calling
// a pathfinder api, and then we'll convert old and new last step back.
// TODO: figure out a better way of processing this!
const int last_stage = cmls->numstage - 1;
cmls->pos[last_stage] = { room_to_mask_coord(cmls->pos[last_stage].X), room_to_mask_coord(cmls->pos[last_stage].Y) };
const int dst_x = room_to_mask_coord(x);
const int dst_y = room_to_mask_coord(y);
if(add_waypoint_direct(cmls, dst_x, dst_y, move_speed_x, move_speed_y))
convert_move_path_to_room_resolution(cmls, last_stage, last_stage + 1);
}
void Character_Animate(CharacterInfo *chaa, int loop, int delay, int repeat,
int blocking, int direction, int sframe, int volume) {
// If idle view in progress for the character, stop the idle anim;
// do this prior to the loop check, as the view may switch back to defview here
stop_character_idling(chaa);
ValidateViewAnimVLF("Character.Animate", chaa->view, loop, sframe);
ValidateViewAnimParams("Character.Animate", repeat, blocking, direction);
animate_character(chaa, loop, delay, repeat, direction, sframe, volume);
if (blocking != 0)
GameLoopUntilValueIsZero(&chaa->animating);
}
void Character_Animate5(CharacterInfo *chaa, int loop, int delay, int repeat, int blocking, int direction) {
Character_Animate(chaa, loop, delay, repeat, blocking, direction, 0 /* first frame */, 100 /* full volume */);
}
void Character_Animate6(CharacterInfo *chaa, int loop, int delay, int repeat, int blocking, int direction, int sframe) {
Character_Animate(chaa, loop, delay, repeat, blocking, direction, sframe, 100 /* full volume */);
}
void Character_ChangeRoomAutoPosition(CharacterInfo *chaa, int room, int newPos) {
if (chaa->index_id != _GP(game).playercharacter) {
quit("!Character.ChangeRoomAutoPosition can only be used with the player character.");
}
_G(new_room_pos) = newPos;
if (_G(new_room_pos) == 0) {
// auto place on other side of screen
if (chaa->x <= _GP(thisroom).Edges.Left + 10)
_G(new_room_pos) = 2000;
else if (chaa->x >= _GP(thisroom).Edges.Right - 10)
_G(new_room_pos) = 1000;
else if (chaa->y <= _GP(thisroom).Edges.Top + 10)
_G(new_room_pos) = 3000;
else if (chaa->y >= _GP(thisroom).Edges.Bottom - 10)
_G(new_room_pos) = 4000;
if (_G(new_room_pos) < 3000)
_G(new_room_pos) += chaa->y;
else
_G(new_room_pos) += chaa->x;
}
NewRoom(room);
}
void Character_ChangeRoom(CharacterInfo *chaa, int room, int x, int y) {
Character_ChangeRoomSetLoop(chaa, room, x, y, SCR_NO_VALUE);
}
void Character_ChangeRoomSetLoop(CharacterInfo *chaa, int room, int x, int y, int direction) {
if (chaa->index_id != _GP(game).playercharacter) {
// NewRoomNPC
if ((x != SCR_NO_VALUE) && (y != SCR_NO_VALUE)) {
chaa->x = x;
chaa->y = y;
if (direction != SCR_NO_VALUE && direction >= 0) chaa->loop = direction;
}
chaa->prevroom = chaa->room;
chaa->room = room;
debug_script_log("%s moved to room %d, location %d,%d, loop %d",
chaa->scrname, room, chaa->x, chaa->y, chaa->loop);
return;
}
if ((x != SCR_NO_VALUE) && (y != SCR_NO_VALUE)) {
// We cannot set character position right away,
// because room switch will occur only after the script end,
// and character position may be still changing meanwhile.
_G(new_room_pos) = 0;
// don't check X or Y bounds, so that they can do a
// walk-in animation if they want
_G(new_room_x) = x;
_G(new_room_y) = y;
if (direction != SCR_NO_VALUE)
_G(new_room_loop) = direction;
}
NewRoom(room);
}
void Character_ChangeView(CharacterInfo *chap, int vii) {
vii--;
if ((vii < 0) || (vii >= _GP(game).numviews))
quit("!ChangeCharacterView: invalid view number specified");
// if animating, but not idle view, give warning message
if ((chap->flags & CHF_FIXVIEW) && (chap->idleleft >= 0))
debug_script_warn("Warning: ChangeCharacterView was used while the view was fixed - call ReleaseCharView first");
// if the idle animation is playing we should release the view
stop_character_idling(chap);
debug_script_log("%s: Change view to %d", chap->scrname, vii + 1);
chap->defview = vii;
chap->view = vii;
stop_character_anim(chap);
chap->frame = 0;
chap->wait = 0;
chap->walkwait = 0;
_GP(charextra)[chap->index_id].animwait = 0;
FindReasonableLoopForCharacter(chap);
}
enum DirectionalLoop {
kDirLoop_Down = 0,
kDirLoop_Left = 1,
kDirLoop_Right = 2,
kDirLoop_Up = 3,
kDirLoop_DownRight = 4,
kDirLoop_UpRight = 5,
kDirLoop_DownLeft = 6,
kDirLoop_UpLeft = 7,
kDirLoop_Default = kDirLoop_Down,
kDirLoop_LastOrthogonal = kDirLoop_Up,
kDirLoop_Last = kDirLoop_UpLeft,
};
// Internal direction-facing functions
DirectionalLoop GetDirectionalLoop(CharacterInfo *chinfo, int x_diff, int y_diff) {
DirectionalLoop next_loop = kDirLoop_Left; // NOTE: default loop was Left for some reason
const ViewStruct &chview = _GP(views)[chinfo->view];
const bool new_version = _G(loaded_game_file_version) > kGameVersion_272;
const bool has_down_loop = ((chview.numLoops > kDirLoop_Down) && (chview.loops[kDirLoop_Down].numFrames > 0));
const bool has_up_loop = ((chview.numLoops > kDirLoop_Up) && (chview.loops[kDirLoop_Up].numFrames > 0));
// NOTE: 3.+ games required left & right loops to be present at all times
const bool has_left_loop = new_version ||
((chview.numLoops > kDirLoop_Left) && (chview.loops[kDirLoop_Left].numFrames > 0));
const bool has_right_loop = new_version ||
((chview.numLoops > kDirLoop_Right) && (chview.loops[kDirLoop_Right].numFrames > 0));
const bool has_diagonal_loops = useDiagonal(chinfo) == 0; // NOTE: useDiagonal returns 0 for "true"
const bool want_horizontal = (abs(y_diff) < abs(x_diff)) ||
(new_version && (!has_down_loop || !has_up_loop)) ||
// NOTE: <= 2.72 games switch to horizontal loops only if both vertical ones are missing
(!new_version && (!has_down_loop && !has_up_loop));
if (want_horizontal) {
const bool want_diagonal = has_diagonal_loops && (abs(y_diff) > abs(x_diff) / 2);
if (!has_left_loop && !has_right_loop) {
next_loop = kDirLoop_Down;
} else if (has_right_loop && (x_diff > 0)) {
next_loop = want_diagonal ? (y_diff < 0 ? kDirLoop_UpRight : kDirLoop_DownRight) :
kDirLoop_Right;
} else if (has_left_loop && (x_diff <= 0)) {
next_loop = want_diagonal ? (y_diff < 0 ? kDirLoop_UpLeft : kDirLoop_DownLeft) :
kDirLoop_Left;
}
} else {
const bool want_diagonal = has_diagonal_loops && (abs(x_diff) > abs(y_diff) / 2);
if (y_diff > 0 || !has_up_loop) {
next_loop = want_diagonal ? (x_diff < 0 ? kDirLoop_DownLeft : kDirLoop_DownRight) :
kDirLoop_Down;
} else {
next_loop = want_diagonal ? (x_diff < 0 ? kDirLoop_UpLeft : kDirLoop_UpRight) :
kDirLoop_Up;
}
}
return next_loop;
}
void FaceDirectionalLoop(CharacterInfo *char1, int direction, int blockingStyle) {
// Change facing only if the desired direction is different
if (direction != char1->loop) {
if ((_GP(game).options[OPT_TURNTOFACELOC] != 0) &&
(_G(in_enters_screen) == 0)) {
const int no_diagonal = useDiagonal(char1);
const int highestLoopForTurning = no_diagonal != 1 ? kDirLoop_Last : kDirLoop_LastOrthogonal;
if ((char1->loop <= highestLoopForTurning)) {
// Turn to face new direction
Character_StopMoving(char1);
if (char1->on == 1) {
// only do the turning if the character is not hidden
// (otherwise GameLoopUntilNotMoving will never return)
start_character_turning(char1, direction, no_diagonal);
if ((blockingStyle == BLOCKING) || (blockingStyle == 1))
GameLoopUntilNotMoving(&char1->walking);
} else
char1->loop = direction;
} else
char1->loop = direction;
} else
char1->loop = direction;
}
char1->frame = 0;
}
void FaceLocationXY(CharacterInfo *char1, int xx, int yy, int blockingStyle) {
debug_script_log("%s: Face location %d,%d", char1->scrname, xx, yy);
const int diffrx = xx - char1->x;
const int diffry = yy - char1->y;
if ((diffrx == 0) && (diffry == 0)) {
// FaceLocation called on their current position - do nothing
return;
}
FaceDirectionalLoop(char1, GetDirectionalLoop(char1, diffrx, diffry), blockingStyle);
}
// External direction-facing functions with validation
void Character_FaceDirection(CharacterInfo *char1, int direction, int blockingStyle) {
if (char1 == nullptr)
quit("!FaceDirection: invalid character specified");
if (direction != SCR_NO_VALUE) {
if (direction < 0 || direction > kDirLoop_Last)
quit("!FaceDirection: invalid direction specified");
FaceDirectionalLoop(char1, direction, blockingStyle);
}
}
void Character_FaceLocation(CharacterInfo *char1, int xx, int yy, int blockingStyle) {
if (char1 == nullptr)
quit("!FaceLocation: invalid character specified");
FaceLocationXY(char1, xx, yy, blockingStyle);
}
void Character_FaceObject(CharacterInfo *char1, ScriptObject *obj, int blockingStyle) {
if (obj == nullptr)
quit("!FaceObject: invalid object specified");
FaceLocationXY(char1, _G(objs)[obj->id].x, _G(objs)[obj->id].y, blockingStyle);
}
void Character_FaceCharacter(CharacterInfo *char1, CharacterInfo *char2, int blockingStyle) {
if (char2 == nullptr)
quit("!FaceCharacter: invalid character specified");
if (char1->room != char2->room)
quitprintf("!FaceCharacter: characters %s and %s are in different rooms (room %d and room %d respectively)",
char1->scrname, char2->scrname, char1->room, char2->room);
FaceLocationXY(char1, char2->x, char2->y, blockingStyle);
}
void Character_FollowCharacter(CharacterInfo *chaa, CharacterInfo *tofollow, int distaway, int eagerness) {
if ((eagerness < 0) || (eagerness > 250))
quit("!FollowCharacterEx: invalid eagerness: must be 0-250");
if ((chaa->index_id == _GP(game).playercharacter) && (tofollow != nullptr) &&
(tofollow->room != chaa->room))
quitprintf("!FollowCharacterEx: you cannot tell the player character %s, who is in room %d, to follow a character %s who is in another room %d",
chaa->scrname, chaa->room, tofollow->scrname, tofollow->room);
if (tofollow != nullptr) {
debug_script_log("%s: Start following %s (dist %d, eager %d)", chaa->scrname, tofollow->scrname, distaway, eagerness);
} else {
debug_script_log("%s: Stop following other character", chaa->scrname);
}
if ((chaa->following >= 0) &&
(chaa->followinfo == FOLLOW_ALWAYSONTOP)) {
// if this character was following always-on-top, its baseline will
// have been changed, so release it.
chaa->baseline = -1;
}
if (tofollow == nullptr)
chaa->following = -1;
else
chaa->following = tofollow->index_id;
chaa->followinfo = (distaway << 8) | eagerness;
chaa->flags &= ~CHF_BEHINDSHEPHERD;
// special case for Always On Other Character
if (distaway == FOLLOW_ALWAYSONTOP) {
chaa->followinfo = FOLLOW_ALWAYSONTOP;
if (eagerness == 1)
chaa->flags |= CHF_BEHINDSHEPHERD;
}
if (chaa->animating & CHANIM_REPEAT)
debug_script_warn("Warning: FollowCharacter called but the sheep is currently animating looped. It may never start to follow.");
}
int Character_IsCollidingWithChar(CharacterInfo *char1, CharacterInfo *char2) {
if (char2 == nullptr)
quit("!AreCharactersColliding: invalid char2");
if (char1->room != char2->room)
return 0; // not colliding
if ((char1->y > char2->y - 5) && (char1->y < char2->y + 5))
;
else
return 0;
int w1 = game_to_data_coord(GetCharacterWidth(char1->index_id));
int w2 = game_to_data_coord(GetCharacterWidth(char2->index_id));
int xps1 = char1->x - w1 / 2;
int xps2 = char2->x - w2 / 2;
if ((xps1 >= xps2 - w1) && (xps1 <= xps2 + w2))
return 1;
return 0;
}
int Character_IsCollidingWithObject(CharacterInfo *chin, ScriptObject *objid) {
if (objid == nullptr)
quit("!AreCharObjColliding: invalid object number");
if (chin->room != _G(displayed_room))
return 0;
if (_G(objs)[objid->id].on != 1)
return 0;
Bitmap *checkblk = GetObjectImage(objid->id);
int objWidth = checkblk->GetWidth();
int objHeight = checkblk->GetHeight();
int o1x = _G(objs)[objid->id].x;
int o1y = _G(objs)[objid->id].y - game_to_data_coord(objHeight);
Bitmap *charpic = GetCharacterImage(chin->index_id);
int charWidth = charpic->GetWidth();
int charHeight = charpic->GetHeight();
int o2x = chin->x - game_to_data_coord(charWidth) / 2;
int o2y = _GP(charextra)[chin->index_id].GetEffectiveY(chin) - 5; // only check feet
if ((o2x >= o1x - game_to_data_coord(charWidth)) &&
(o2x <= o1x + game_to_data_coord(objWidth)) &&
(o2y >= o1y - 8) &&
(o2y <= o1y + game_to_data_coord(objHeight))) {
// the character's feet are on the object
if (_GP(game).options[OPT_PIXPERFECT] == 0)
return 1;
// check if they're on a transparent bit of the object
int stxp = data_to_game_coord(o2x - o1x);
int styp = data_to_game_coord(o2y - o1y);
int maskcol = checkblk->GetMaskColor();
int maskcolc = charpic->GetMaskColor();
int thispix, thispixc;
// check each pixel of the object along the char's feet
for (int i = 0; i < charWidth; i += get_fixed_pixel_size(1)) {
for (int j = 0; j < get_fixed_pixel_size(6); j += get_fixed_pixel_size(1)) {
thispix = my_getpixel(checkblk, i + stxp, j + styp);
thispixc = my_getpixel(charpic, i, j + (charHeight - get_fixed_pixel_size(5)));
if ((thispix != -1) && (thispix != maskcol) &&
(thispixc != -1) && (thispixc != maskcolc))
return 1;
}
}
}
return 0;
}
bool Character_IsInteractionAvailable(CharacterInfo *cchar, int mood) {
_GP(play).check_interaction_only = 1;
RunCharacterInteraction(cchar->index_id, mood);
int ciwas = _GP(play).check_interaction_only;
_GP(play).check_interaction_only = 0;
return (ciwas == 2);
}
void Character_LockView(CharacterInfo *chap, int vii) {
Character_LockViewEx(chap, vii, STOP_MOVING);
}
void Character_LockViewEx(CharacterInfo *chap, int vii, int stopMoving) {
vii--; // convert to 0-based
AssertView("SetCharacterView", vii);
stop_character_idling(chap);
if (stopMoving != KEEP_MOVING) {
Character_StopMoving(chap);
}
chap->view = vii;
stop_character_anim(chap);
FindReasonableLoopForCharacter(chap);
chap->frame = 0;
chap->wait = 0;
chap->flags |= CHF_FIXVIEW;
chap->pic_xoffs = 0;
chap->pic_yoffs = 0;
debug_script_log("%s: View locked to %d", chap->scrname, vii + 1);
}
void Character_LockViewAligned_Old(CharacterInfo *chap, int vii, int loop, int align) {
Character_LockViewAlignedEx(chap, vii, loop, ConvertLegacyScriptAlignment((LegacyScriptAlignment)align), STOP_MOVING);
}
void Character_LockViewAlignedEx_Old(CharacterInfo *chap, int vii, int loop, int align, int stopMoving) {
Character_LockViewAlignedEx(chap, vii, loop, ConvertLegacyScriptAlignment((LegacyScriptAlignment)align), stopMoving);
}
void Character_LockViewAligned(CharacterInfo *chap, int vii, int loop, int align) {
Character_LockViewAlignedEx(chap, vii, loop, align, STOP_MOVING);
}
void Character_LockViewAlignedEx(CharacterInfo *chap, int vii, int loop, int align, int stopMoving) {
if (chap->view < 0)
quit("!SetCharacterLoop: character has invalid old view number");
int sppic = _GP(views)[chap->view].loops[chap->loop].frames[chap->frame].pic;
int leftSide = data_to_game_coord(chap->x) - _GP(game).SpriteInfos[sppic].Width / 2;
Character_LockViewEx(chap, vii, stopMoving);
AssertLoop("SetCharacterViewEx", chap->view, loop);
chap->loop = loop;
chap->frame = 0;
int newpic = _GP(views)[chap->view].loops[chap->loop].frames[chap->frame].pic;
int newLeft = data_to_game_coord(chap->x) - _GP(game).SpriteInfos[newpic].Width / 2;
int xdiff = 0;
if (align & kMAlignLeft)
xdiff = leftSide - newLeft;
else if (align & kMAlignHCenter)
xdiff = 0;
else if (align & kMAlignRight)
xdiff = (leftSide + _GP(game).SpriteInfos[sppic].Width) - (newLeft + _GP(game).SpriteInfos[newpic].Width);
else
quit("!SetCharacterViewEx: invalid alignment type specified");
chap->pic_xoffs = xdiff;
chap->pic_yoffs = 0;
}
void Character_LockViewFrame(CharacterInfo *chaa, int view, int loop, int frame) {
Character_LockViewFrameEx(chaa, view, loop, frame, STOP_MOVING);
}
void Character_LockViewFrameEx(CharacterInfo *chaa, int view, int loop, int frame, int stopMoving) {
Character_LockViewEx(chaa, view, stopMoving);
AssertFrame("SetCharacterFrame", view - 1, loop, frame);
chaa->loop = loop;
chaa->frame = frame;
}
void Character_LockViewOffset(CharacterInfo *chap, int vii, int xoffs, int yoffs) {
Character_LockViewOffsetEx(chap, vii, xoffs, yoffs, STOP_MOVING);
}
void Character_LockViewOffsetEx(CharacterInfo *chap, int vii, int xoffs, int yoffs, int stopMoving) {
Character_LockViewEx(chap, vii, stopMoving);
// This function takes offsets in real game coordinates as opposed to script coordinates
defgame_to_finalgame_coords(xoffs, yoffs);
chap->pic_xoffs = xoffs;
chap->pic_yoffs = yoffs;
}
void Character_LoseInventory(CharacterInfo *chap, ScriptInvItem *invi) {
if (invi == nullptr)
quit("!LoseInventoryFromCharacter: invalid inventory number");
int inum = invi->id;
if (chap->inv[inum] > 0)
chap->inv[inum]--;
if ((chap->activeinv == inum) && (chap->inv[inum] < 1)) {
chap->activeinv = -1;
if ((chap == _G(playerchar)) && (GetCursorMode() == MODE_USE))
set_cursor_mode(0);
}
int charid = chap->index_id;
if ((chap->inv[inum] == 0) || (_GP(game).options[OPT_DUPLICATEINV] > 0)) {
int xx, tt;
for (xx = 0; xx < _GP(charextra)[charid].invorder_count; xx++) {
if (_GP(charextra)[charid].invorder[xx] == inum) {
_GP(charextra)[charid].invorder_count--;
for (tt = xx; tt < _GP(charextra)[charid].invorder_count; tt++)
_GP(charextra)[charid].invorder[tt] = _GP(charextra)[charid].invorder[tt + 1];
break;
}
}
}
GUI::MarkInventoryForUpdate(charid, charid == _GP(game).playercharacter);
if (chap == _G(playerchar))
run_on_event(GE_LOSE_INV, RuntimeScriptValue().SetInt32(inum));
}
void Character_PlaceOnWalkableArea(CharacterInfo *chap) {
if (_G(displayed_room) < 0)
quit("!Character.PlaceOnWalkableArea: no room is currently loaded");
find_nearest_walkable_area(&chap->x, &chap->y);
}
void Character_RemoveTint(CharacterInfo *chaa) {
if (chaa->flags & (CHF_HASTINT | CHF_HASLIGHT)) {
debug_script_log("Un-tint %s", chaa->scrname);
chaa->flags &= ~(CHF_HASTINT | CHF_HASLIGHT);
} else {
debug_script_warn("Character.RemoveTint called but character was not tinted");
}
}
int Character_GetHasExplicitTint_Old(CharacterInfo *ch) {
return ch->has_explicit_tint() || ch->has_explicit_light();
}
int Character_GetHasExplicitTint(CharacterInfo *ch) {
return ch->has_explicit_tint();
}
void Character_Say(CharacterInfo *chaa, const char *text) {
_DisplaySpeechCore(chaa->index_id, text);
}
void Character_SayAt(CharacterInfo *chaa, int x, int y, int width, const char *texx) {
DisplaySpeechAt(x, y, width, chaa->index_id, texx);
}
ScriptOverlay *Character_SayBackground(CharacterInfo *chaa, const char *texx) {
int ovltype = DisplaySpeechBackground(chaa->index_id, texx);
auto *over = get_overlay(ovltype);
if (!over)
quit("!SayBackground internal error: no overlay");
// Create script object with an internal ref, keep at least until internal timeout
return create_scriptoverlay(*over, true);
}
void Character_SetAsPlayer(CharacterInfo *chaa) {
// Set to same character, so ignore.
// But only on versions > 2.61. The relevant entry in the 2.62 changelog is:
// - Fixed SetPlayerCharacter to do nothing at all if you pass the current
// player character to it (previously it was resetting the inventory layout)
if ((_G(loaded_game_file_version) > kGameVersion_261) && (_GP(game).playercharacter == chaa->index_id))
return;
setup_player_character(chaa->index_id);
GUI::MarkInventoryForUpdate(_GP(game).playercharacter, true);
debug_script_log("%s is new player character", _G(playerchar)->scrname);
// Within game_start, return now
if (_G(displayed_room) < 0)
return;
// Ignore invalid room numbers for the character and just place him in
// the current room for 2.x. Following script calls to NewRoom() will
// make sure this still works as intended.
if ((_G(loaded_game_file_version) <= kGameVersion_272) && (_G(playerchar)->room < 0))
_G(playerchar)->room = _G(displayed_room);
if (_G(displayed_room) != _G(playerchar)->room)
NewRoom(_G(playerchar)->room);
else // make sure it doesn't run the region interactions
_GP(play).player_on_region = GetRegionIDAtRoom(_G(playerchar)->x, _G(playerchar)->y);
if ((_G(playerchar)->activeinv >= 0) && (_G(playerchar)->inv[_G(playerchar)->activeinv] < 1))
_G(playerchar)->activeinv = -1;
// They had inv selected, so change the cursor
if (_G(cur_mode) == MODE_USE) {
if (_G(playerchar)->activeinv < 0)
SetNextCursor();
else
SetActiveInventory(_G(playerchar)->activeinv);
}
}
void Character_SetIdleView(CharacterInfo *chaa, int iview, int itime) {
if (iview == 1)
quit("!SetCharacterIdle: view 1 cannot be used as an idle view, sorry.");
// if an idle anim is currently playing, release it
stop_character_idling(chaa);
chaa->idleview = iview - 1;
// make sure they don't appear idle while idle anim is disabled
if (iview < 1)
itime = 10;
chaa->idletime = itime;
chaa->idleleft = itime;
// if not currently animating, reset the wait counter
if ((chaa->animating == 0) && (chaa->walking == 0))
chaa->wait = 0;
if (iview >= 1) {
debug_script_log("Set %s idle view to %d (time %d)", chaa->scrname, iview, itime);
} else {
debug_script_log("%s idle view disabled", chaa->scrname);
}
if (chaa->flags & CHF_FIXVIEW) {
debug_script_warn("SetCharacterIdle called while character view locked with SetCharacterView; idle ignored");
debug_script_log("View locked, idle will not kick in until Released");
}
// if they switch to a swimming animation, kick it off immediately
if (itime == 0)
_GP(charextra)[chaa->index_id].process_idle_this_time = 1;
}
bool Character_GetHasExplicitLight(CharacterInfo *ch) {
return ch->has_explicit_light();
}
int Character_GetLightLevel(CharacterInfo *ch) {
return ch->has_explicit_light() ? _GP(charextra)[ch->index_id].tint_light : 0;
}
void Character_SetLightLevel(CharacterInfo *chaa, int light_level) {
light_level = Math::Clamp(light_level, -100, 100);
_GP(charextra)[chaa->index_id].tint_light = light_level;
chaa->flags &= ~CHF_HASTINT;
chaa->flags |= CHF_HASLIGHT;
}
int Character_GetTintRed(CharacterInfo *ch) {
return ch->has_explicit_tint() ? _GP(charextra)[ch->index_id].tint_r : 0;
}
int Character_GetTintGreen(CharacterInfo *ch) {
return ch->has_explicit_tint() ? _GP(charextra)[ch->index_id].tint_g : 0;
}
int Character_GetTintBlue(CharacterInfo *ch) {
return ch->has_explicit_tint() ? _GP(charextra)[ch->index_id].tint_b : 0;
}
int Character_GetTintSaturation(CharacterInfo *ch) {
return ch->has_explicit_tint() ? _GP(charextra)[ch->index_id].tint_level : 0;
}
int Character_GetTintLuminance(CharacterInfo *ch) {
return ch->has_explicit_tint() ? ((_GP(charextra)[ch->index_id].tint_light * 10) / 25) : 0;
}
void Character_SetOption(CharacterInfo *chaa, int flag, int yesorno) {
if ((yesorno < 0) || (yesorno > 1))
quit("!SetCharacterProperty: last parameter must be 0 or 1");
if (flag & CHF_MANUALSCALING) {
// backwards compatibility fix
Character_SetIgnoreScaling(chaa, yesorno);
} else {
chaa->flags &= ~flag;
if (yesorno)
chaa->flags |= flag;
}
}
void Character_SetSpeed(CharacterInfo *chaa, int xspeed, int yspeed) {
if ((xspeed == 0) || (yspeed == 0))
quit("!SetCharacterSpeedEx: invalid speed value");
if ((chaa->walking > 0) && (_G(loaded_game_file_version) < kGameVersion_361)) {
debug_script_warn("Character_SetSpeed: cannot change speed while walking");
return;
}
xspeed = Math::Clamp(xspeed, (int)INT16_MIN, (int)INT16_MAX);
yspeed = Math::Clamp(yspeed, (int)INT16_MIN, (int)INT16_MAX);
uint16_t old_speedx = chaa->walkspeed;
uint16_t old_speedy = ((chaa->walkspeed_y == UNIFORM_WALK_SPEED) ? chaa->walkspeed : chaa->walkspeed_y);
chaa->walkspeed = xspeed;
if (yspeed == xspeed)
chaa->walkspeed_y = UNIFORM_WALK_SPEED;
else
chaa->walkspeed_y = yspeed;
if (chaa->walking > 0 && (old_speedx != xspeed || old_speedy != yspeed)) {
recalculate_move_speeds(&_GP(mls)[chaa->walking % TURNING_AROUND], old_speedx, old_speedy, xspeed, yspeed);
}
}
void Character_StopMoving(CharacterInfo *charp) {
int chaa = charp->index_id;
if (chaa == _GP(play).skip_until_char_stops)
EndSkippingUntilCharStops();
if (_GP(charextra)[chaa].xwas != INVALID_X) {
charp->x = _GP(charextra)[chaa].xwas;
charp->y = _GP(charextra)[chaa].ywas;
_GP(charextra)[chaa].xwas = INVALID_X;
}
if ((charp->walking > 0) && (charp->walking < TURNING_AROUND)) {
// if it's not a MoveCharDirect, make sure they end up on a walkable area
if ((_GP(mls)[charp->walking].direct == 0) && (charp->room == _G(displayed_room)))
Character_PlaceOnWalkableArea(charp);
debug_script_log("%s: stop moving", charp->scrname);
charp->idleleft = charp->idletime;
// restart the idle animation straight away
_GP(charextra)[chaa].process_idle_this_time = 1;
}
if (charp->walking) {
// If the character is currently moving, stop them and reset their frame
charp->walking = 0;
if ((charp->flags & CHF_MOVENOTWALK) == 0)
charp->frame = 0;
}
}
void Character_Tint(CharacterInfo *chaa, int red, int green, int blue, int opacity, int luminance) {
if ((red < 0) || (green < 0) || (blue < 0) ||
(red > 255) || (green > 255) || (blue > 255) ||
(opacity < 0) || (opacity > 100) ||
(luminance < 0) || (luminance > 100))
quit("!Character.Tint: invalid parameter. R,G,B must be 0-255, opacity & luminance 0-100");
debug_script_log("Set %s tint RGB(%d,%d,%d) %d%%", chaa->scrname, red, green, blue, opacity);
_GP(charextra)[chaa->index_id].tint_r = red;
_GP(charextra)[chaa->index_id].tint_g = green;
_GP(charextra)[chaa->index_id].tint_b = blue;
_GP(charextra)[chaa->index_id].tint_level = opacity;
_GP(charextra)[chaa->index_id].tint_light = (luminance * 25) / 10;
chaa->flags &= ~CHF_HASLIGHT;
chaa->flags |= CHF_HASTINT;
}
void Character_Think(CharacterInfo *chaa, const char *text) {
_DisplayThoughtCore(chaa->index_id, text);
}
void Character_UnlockView(CharacterInfo *chaa) {
Character_UnlockViewEx(chaa, STOP_MOVING);
}
void Character_UnlockViewEx(CharacterInfo *chaa, int stopMoving) {
if (chaa->flags & CHF_FIXVIEW) {
debug_script_log("%s: Released view back to default", chaa->scrname);
}
chaa->flags &= ~CHF_FIXVIEW;
chaa->view = chaa->defview;
chaa->frame = 0;
if (stopMoving != KEEP_MOVING) {
Character_StopMoving(chaa);
}
if (chaa->view >= 0) {
int maxloop = _GP(views)[chaa->view].numLoops;
if (((chaa->flags & CHF_NODIAGONAL) != 0) && (maxloop > 4))
maxloop = 4;
FindReasonableLoopForCharacter(chaa);
}
stop_character_anim(chaa);
chaa->idleleft = chaa->idletime;
chaa->pic_xoffs = 0;
chaa->pic_yoffs = 0;
// restart the idle animation straight away
_GP(charextra)[chaa->index_id].process_idle_this_time = 1;
}
void Character_Walk(CharacterInfo *chaa, int x, int y, int blocking, int direct) {
walk_or_move_character(chaa, x, y, blocking, direct, true);
}
void Character_Move(CharacterInfo *chaa, int x, int y, int blocking, int direct) {
walk_or_move_character(chaa, x, y, blocking, direct, false);
}
void Character_WalkStraight(CharacterInfo *chaa, int xx, int yy, int blocking) {
if (chaa->room != _G(displayed_room))
quitprintf("!MoveCharacterStraight: character %s is not in current room %d (it is in room %d)",
chaa->scrname, _G(displayed_room), chaa->room);
int movetox = xx, movetoy = yy;
set_wallscreen(prepare_walkable_areas(chaa->index_id));
int fromXLowres = room_to_mask_coord(chaa->x);
int fromYLowres = room_to_mask_coord(chaa->y);
int toXLowres = room_to_mask_coord(xx);
int toYLowres = room_to_mask_coord(yy);
if (!can_see_from(fromXLowres, fromYLowres, toXLowres, toYLowres)) {
int lastcx, lastcy;
get_lastcpos(lastcx, lastcy);
movetox = mask_to_room_coord(lastcx);
movetoy = mask_to_room_coord(lastcy);
}
walk_or_move_character(chaa, movetox, movetoy, blocking, 1 /* use ANYWHERE */, true);
}
void Character_RunInteraction(CharacterInfo *chaa, int mood) {
RunCharacterInteraction(chaa->index_id, mood);
}
// **** CHARACTER: PROPERTIES ****
int Character_GetProperty(CharacterInfo *chaa, const char *property) {
if (!AssertCharacter("Character.GetProperty", chaa->index_id))
return 0;
return get_int_property(_GP(game).charProps[chaa->index_id], _GP(play).charProps[chaa->index_id], property);
}
void Character_GetPropertyText(CharacterInfo *chaa, const char *property, char *bufer) {
if (!AssertCharacter("Character.GetPropertyText", chaa->index_id))
return;
get_text_property(_GP(game).charProps[chaa->index_id], _GP(play).charProps[chaa->index_id], property, bufer);
}
const char *Character_GetTextProperty(CharacterInfo *chaa, const char *property) {
if (!AssertCharacter("Character.GetTextProperty", chaa->index_id))
return nullptr;
return get_text_property_dynamic_string(_GP(game).charProps[chaa->index_id], _GP(play).charProps[chaa->index_id], property);
}
bool Character_SetProperty(CharacterInfo *chaa, const char *property, int value) {
if (!AssertCharacter("Character.SetProperty", chaa->index_id))
return false;
return set_int_property(_GP(play).charProps[chaa->index_id], property, value);
}
bool Character_SetTextProperty(CharacterInfo *chaa, const char *property, const char *value) {
if (!AssertCharacter("Character.SetTextProperty", chaa->index_id))
return false;
return set_text_property(_GP(play).charProps[chaa->index_id], property, value);
}
ScriptInvItem *Character_GetActiveInventory(CharacterInfo *chaa) {
if (chaa->activeinv <= 0)
return nullptr;
return &_G(scrInv)[chaa->activeinv];
}
void Character_SetActiveInventory(CharacterInfo *chaa, ScriptInvItem *iit) {
if (iit == nullptr) {
chaa->activeinv = -1;
if (chaa->index_id == _GP(game).playercharacter) {
if (GetCursorMode() == MODE_USE)
set_cursor_mode(0);
}
GUI::MarkInventoryForUpdate(chaa->index_id, chaa->index_id == _GP(game).playercharacter);
return;
}
if (chaa->inv[iit->id] < 1) {
debug_script_warn("SetActiveInventory: character doesn't have any of that inventory");
return;
}
chaa->activeinv = iit->id;
if (chaa->index_id == _GP(game).playercharacter) {
// if it's the player character, update mouse cursor
update_inv_cursor(iit->id);
set_cursor_mode(MODE_USE);
}
GUI::MarkInventoryForUpdate(chaa->index_id, chaa->index_id == _GP(game).playercharacter);
}
int Character_GetAnimating(CharacterInfo *chaa) {
if (chaa->animating)
return 1;
return 0;
}
int Character_GetAnimationSpeed(CharacterInfo *chaa) {
return chaa->animspeed;
}
void Character_SetAnimationSpeed(CharacterInfo *chaa, int newval) {
chaa->animspeed = newval;
if (_G(loaded_game_file_version) < kGameVersion_360_16)
chaa->idle_anim_speed = chaa->animspeed + 5;
}
int Character_GetAnimationVolume(CharacterInfo *chaa) {
return _GP(charextra)[chaa->index_id].anim_volume;
}
void Character_SetAnimationVolume(CharacterInfo *chaa, int newval) {
_GP(charextra)[chaa->index_id].anim_volume = Math::Clamp(newval, 0, 100);
}
int Character_GetBaseline(CharacterInfo *chaa) {
if (chaa->baseline < 1)
return 0;
return chaa->baseline;
}
void Character_SetBaseline(CharacterInfo *chaa, int basel) {
chaa->baseline = basel;
}
int Character_GetBlinkInterval(CharacterInfo *chaa) {
return chaa->blinkinterval;
}
void Character_SetBlinkInterval(CharacterInfo *chaa, int interval) {
if (interval < 0)
quit("!SetCharacterBlinkView: invalid blink interval");
chaa->blinkinterval = interval;
if (chaa->blinktimer > 0)
chaa->blinktimer = chaa->blinkinterval;
}
int Character_GetBlinkView(CharacterInfo *chaa) {
return chaa->blinkview + 1;
}
void Character_SetBlinkView(CharacterInfo *chaa, int vii) {
if (((vii < 2) || (vii > _GP(game).numviews)) && (vii != -1))
quit("!SetCharacterBlinkView: invalid view number");
chaa->blinkview = vii - 1;
}
int Character_GetBlinkWhileThinking(CharacterInfo *chaa) {
if (chaa->flags & CHF_NOBLINKANDTHINK)
return 0;
return 1;
}
void Character_SetBlinkWhileThinking(CharacterInfo *chaa, int yesOrNo) {
chaa->flags &= ~CHF_NOBLINKANDTHINK;
if (yesOrNo == 0)
chaa->flags |= CHF_NOBLINKANDTHINK;
}
int Character_GetBlockingHeight(CharacterInfo *chaa) {
return chaa->blocking_height;
}
void Character_SetBlockingHeight(CharacterInfo *chaa, int hit) {
chaa->blocking_height = hit;
}
int Character_GetBlockingWidth(CharacterInfo *chaa) {
return chaa->blocking_width;
}
void Character_SetBlockingWidth(CharacterInfo *chaa, int wid) {
chaa->blocking_width = wid;
}
int Character_GetDiagonalWalking(CharacterInfo *chaa) {
if (chaa->flags & CHF_NODIAGONAL)
return 0;
return 1;
}
void Character_SetDiagonalWalking(CharacterInfo *chaa, int yesorno) {
chaa->flags &= ~CHF_NODIAGONAL;
if (!yesorno)
chaa->flags |= CHF_NODIAGONAL;
}
int Character_GetClickable(CharacterInfo *chaa) {
if (chaa->flags & CHF_NOINTERACT)
return 0;
return 1;
}
void Character_SetClickable(CharacterInfo *chaa, int clik) {
chaa->flags &= ~CHF_NOINTERACT;
// if they don't want it clickable, set the relevant bit
if (clik == 0)
chaa->flags |= CHF_NOINTERACT;
}
int Character_GetID(CharacterInfo *chaa) {
return chaa->index_id;
}
const char *Character_GetScriptName(CharacterInfo *chin) {
return CreateNewScriptString(_GP(game).chars2[chin->index_id].scrname_new);
}
int Character_GetFrame(CharacterInfo *chaa) {
return chaa->frame;
}
void Character_SetFrame(CharacterInfo *chaa, int newval) {
chaa->frame = newval;
}
int Character_GetIdleView(CharacterInfo *chaa) {
if (chaa->idleview < 1)
return -1;
return chaa->idleview + 1;
}
int Character_GetIInventoryQuantity(CharacterInfo *chaa, int index) {
if ((index < 1) || (index >= _GP(game).numinvitems))
quitprintf("!Character.InventoryQuantity: invalid inventory index %d", index);
return chaa->inv[index];
}
int Character_HasInventory(CharacterInfo *chaa, ScriptInvItem *invi) {
if (invi == nullptr)
quit("!Character.HasInventory: NULL inventory item supplied");
return (chaa->inv[invi->id] > 0) ? 1 : 0;
}
void Character_SetIInventoryQuantity(CharacterInfo *chaa, int index, int quant) {
if ((index < 1) || (index >= _GP(game).numinvitems))
quitprintf("!Character.InventoryQuantity: invalid inventory index %d", index);
if ((quant < 0) || (quant > 32000))
quitprintf("!Character.InventoryQuantity: invalid quantity %d", quant);
chaa->inv[index] = quant;
}
int Character_GetIgnoreLighting(CharacterInfo *chaa) {
if (chaa->flags & CHF_NOLIGHTING)
return 1;
return 0;
}
void Character_SetIgnoreLighting(CharacterInfo *chaa, int yesorno) {
chaa->flags &= ~CHF_NOLIGHTING;
if (yesorno)
chaa->flags |= CHF_NOLIGHTING;
}
int Character_GetIgnoreScaling(CharacterInfo *chaa) {
if (chaa->flags & CHF_MANUALSCALING)
return 1;
return 0;
}
void Character_SetIgnoreScaling(CharacterInfo *chaa, int yesorno) {
if (yesorno) {
// when setting IgnoreScaling to 1, should reset zoom level
// like it used to in pre-2.71
_GP(charextra)[chaa->index_id].zoom = 100;
}
Character_SetManualScaling(chaa, yesorno);
}
void Character_SetManualScaling(CharacterInfo *chaa, int yesorno) {
chaa->flags &= ~CHF_MANUALSCALING;
if (yesorno)
chaa->flags |= CHF_MANUALSCALING;
}
int Character_GetIgnoreWalkbehinds(CharacterInfo *chaa) {
if (chaa->flags & CHF_NOWALKBEHINDS)
return 1;
return 0;
}
void Character_SetIgnoreWalkbehinds(CharacterInfo *chaa, int yesorno) {
if (_GP(game).options[OPT_BASESCRIPTAPI] >= kScriptAPI_v350)
debug_script_warn("IgnoreWalkbehinds is not recommended for use, consider other solutions");
chaa->flags &= ~CHF_NOWALKBEHINDS;
if (yesorno)
chaa->flags |= CHF_NOWALKBEHINDS;
}
int Character_GetMovementLinkedToAnimation(CharacterInfo *chaa) {
if (chaa->flags & CHF_ANTIGLIDE)
return 1;
return 0;
}
void Character_SetMovementLinkedToAnimation(CharacterInfo *chaa, int yesorno) {
chaa->flags &= ~CHF_ANTIGLIDE;
if (yesorno)
chaa->flags |= CHF_ANTIGLIDE;
}
int Character_GetLoop(CharacterInfo *chaa) {
return chaa->loop;
}
void Character_SetLoop(CharacterInfo *chaa, int newval) {
AssertLoop("Character.Loop", chaa->view, newval);
chaa->loop = newval;
if (chaa->frame >= _GP(views)[chaa->view].loops[chaa->loop].numFrames)
chaa->frame = 0;
}
int Character_GetMoving(CharacterInfo *chaa) {
if (chaa->walking)
return 1;
return 0;
}
int Character_GetDestinationX(CharacterInfo *chaa) {
if (chaa->walking) {
MoveList *cmls = &_GP(mls)[chaa->walking % TURNING_AROUND];
return cmls->pos[cmls->numstage - 1].X;
} else
return chaa->x;
}
int Character_GetDestinationY(CharacterInfo *chaa) {
if (chaa->walking) {
MoveList *cmls = &_GP(mls)[chaa->walking % TURNING_AROUND];
return cmls->pos[cmls->numstage - 1].Y;
} else
return chaa->y;
}
const char *Character_GetName(CharacterInfo *chaa) {
return CreateNewScriptString(_GP(game).chars2[chaa->index_id].name_new.GetCStr());
}
void Character_SetName(CharacterInfo *chaa, const char *newName) {
_GP(game).chars2[chaa->index_id].name_new = newName;
// Fill legacy name fields, for compatibility with old scripts and plugins
snprintf(chaa->name, LEGACY_MAX_CHAR_NAME_LEN, "%s", newName);
GUI::MarkSpecialLabelsForUpdate(kLabelMacro_Overhotspot);
}
int Character_GetNormalView(CharacterInfo *chaa) {
return chaa->defview + 1;
}
int Character_GetPreviousRoom(CharacterInfo *chaa) {
return chaa->prevroom;
}
int Character_GetRoom(CharacterInfo *chaa) {
return chaa->room;
}
int Character_GetScaleMoveSpeed(CharacterInfo *chaa) {
if (chaa->flags & CHF_SCALEMOVESPEED)
return 1;
return 0;
}
void Character_SetScaleMoveSpeed(CharacterInfo *chaa, int yesorno) {
if ((yesorno < 0) || (yesorno > 1))
quit("Character.ScaleMoveSpeed: value must be true or false (1 or 0)");
chaa->flags &= ~CHF_SCALEMOVESPEED;
if (yesorno)
chaa->flags |= CHF_SCALEMOVESPEED;
}
int Character_GetScaleVolume(CharacterInfo *chaa) {
if (chaa->flags & CHF_SCALEVOLUME)
return 1;
return 0;
}
void Character_SetScaleVolume(CharacterInfo *chaa, int yesorno) {
if ((yesorno < 0) || (yesorno > 1))
quit("Character.ScaleVolume: value must be true or false (1 or 0)");
chaa->flags &= ~CHF_SCALEVOLUME;
if (yesorno)
chaa->flags |= CHF_SCALEVOLUME;
}
int Character_GetScaling(CharacterInfo *chaa) {
return _GP(charextra)[chaa->index_id].zoom;
}
void Character_SetScaling(CharacterInfo *chaa, int zoomlevel) {
if ((chaa->flags & CHF_MANUALSCALING) == 0) {
debug_script_warn("Character.Scaling: cannot set property unless ManualScaling is enabled");
return;
}
int zoom_fixed = Math::Clamp(zoomlevel, 1, (int)(INT16_MAX)); // CharacterExtras.zoom is int16
if (zoomlevel != zoom_fixed)
debug_script_warn("Character.Scaling: scaling level must be between 1 and %d%%, asked for: %d",
(int)(INT16_MAX), zoomlevel);
_GP(charextra)[chaa->index_id].zoom = zoom_fixed;
}
int Character_GetSolid(CharacterInfo *chaa) {
if (chaa->flags & CHF_NOBLOCKING)
return 0;
return 1;
}
void Character_SetSolid(CharacterInfo *chaa, int yesorno) {
chaa->flags &= ~CHF_NOBLOCKING;
if (!yesorno)
chaa->flags |= CHF_NOBLOCKING;
}
int Character_GetSpeaking(CharacterInfo *chaa) {
if (get_character_currently_talking() == chaa->index_id)
return 1;
return 0;
}
int Character_GetSpeechColor(CharacterInfo *chaa) {
return chaa->talkcolor;
}
void Character_SetSpeechColor(CharacterInfo *chaa, int ncol) {
chaa->talkcolor = ncol;
}
void Character_SetSpeechAnimationDelay(CharacterInfo *chaa, int newDelay) {
if (_GP(game).options[OPT_GLOBALTALKANIMSPD] != 0) {
debug_script_warn("Character.SpeechAnimationDelay cannot be set when global speech animation speed is enabled");
return;
}
chaa->speech_anim_speed = newDelay;
}
int Character_GetIdleAnimationDelay(CharacterInfo *chaa) {
return chaa->idle_anim_speed;
}
void Character_SetIdleAnimationDelay(CharacterInfo *chaa, int newDelay) {
chaa->idle_anim_speed = newDelay;
}
int Character_GetSpeechView(CharacterInfo *chaa) {
return chaa->talkview + 1;
}
void Character_SetSpeechView(CharacterInfo *chaa, int vii) {
if (vii == -1) {
chaa->talkview = -1;
return;
}
if ((vii < 1) || (vii > _GP(game).numviews))
quit("!SetCharacterSpeechView: invalid view number");
chaa->talkview = vii - 1;
}
bool Character_GetThinking(CharacterInfo *chaa) {
return _G(char_thinking) == chaa->index_id;
}
int Character_GetThinkingFrame(CharacterInfo *chaa) {
if (_G(char_thinking) == chaa->index_id)
return chaa->thinkview > 0 ? chaa->frame : -1;
debug_script_warn("Character.ThinkingFrame: character is not currently thinking");
return -1;
}
int Character_GetThinkView(CharacterInfo *chaa) {
return chaa->thinkview + 1;
}
void Character_SetThinkView(CharacterInfo *chaa, int vii) {
if (((vii < 2) || (vii > _GP(game).numviews)) && (vii != -1))
quit("!SetCharacterThinkView: invalid view number");
chaa->thinkview = vii - 1;
}
int Character_GetTransparency(CharacterInfo *chaa) {
return GfxDef::LegacyTrans255ToTrans100(chaa->transparency);
}
void Character_SetTransparency(CharacterInfo *chaa, int trans) {
if ((trans < 0) || (trans > 100))
quit("!SetCharTransparent: transparency value must be between 0 and 100");
chaa->transparency = GfxDef::Trans100ToLegacyTrans255(trans);
}
int Character_GetTurnBeforeWalking(CharacterInfo *chaa) {
if (chaa->flags & CHF_NOTURNING)
return 0;
return 1;
}
void Character_SetTurnBeforeWalking(CharacterInfo *chaa, int yesorno) {
chaa->flags &= ~CHF_NOTURNING;
if (!yesorno)
chaa->flags |= CHF_NOTURNING;
}
int Character_GetView(CharacterInfo *chaa) {
return chaa->view + 1;
}
int Character_GetWalkSpeedX(CharacterInfo *chaa) {
return chaa->walkspeed;
}
int Character_GetWalkSpeedY(CharacterInfo *chaa) {
if (chaa->walkspeed_y != UNIFORM_WALK_SPEED)
return chaa->walkspeed_y;
return chaa->walkspeed;
}
int Character_GetX(CharacterInfo *chaa) {
return chaa->x;
}
void Character_SetX(CharacterInfo *chaa, int newval) {
chaa->x = newval;
}
int Character_GetY(CharacterInfo *chaa) {
return chaa->y;
}
void Character_SetY(CharacterInfo *chaa, int newval) {
chaa->y = newval;
}
int Character_GetZ(CharacterInfo *chaa) {
return chaa->z;
}
void Character_SetZ(CharacterInfo *chaa, int newval) {
chaa->z = newval;
}
int Character_GetSpeakingFrame(CharacterInfo *chaa) {
if ((_G(face_talking) >= 0) && (_G(facetalkrepeat))) {
if (_G(facetalkchar)->index_id == chaa->index_id) {
return _G(facetalkframe);
}
} else if (_G(char_speaking) >= 0) {
if (_G(char_speaking) == chaa->index_id) {
return chaa->frame;
}
}
debug_script_warn("Character.SpeakingFrame: character is not currently speaking");
return -1;
}
//=============================================================================
// order of loops to turn character in circle from down to down
int turnlooporder[8] = {0, 6, 1, 7, 3, 5, 2, 4};
void walk_character(int chac, int tox, int toy, int ignwal, bool autoWalkAnims) {
CharacterInfo *chin = &_GP(game).chars[chac];
if (chin->room != _G(displayed_room))
quitprintf("!MoveCharacter: character %s is not in current room %d (it is in room %d)",
chin->scrname, _G(displayed_room), chin->room);
chin->flags &= ~CHF_MOVENOTWALK;
if ((tox == chin->x) && (toy == chin->y)) {
StopMoving(chac);
debug_script_log("%s already at destination, not moving", chin->scrname);
return;
}
if ((chin->animating) && (autoWalkAnims))
stop_character_anim(chin);
// Stop idling anim
stop_character_idling(chin);
// stop them to make sure they're on a walkable area
// but save their frame first so that if they're already
// moving it looks smoother
int oldframe = chin->frame;
int waitWas = 0, animWaitWas = 0;
float wasStepFrac = 0.f;
// if they are currently walking, save the current Wait
if (chin->walking) {
waitWas = chin->walkwait;
animWaitWas = _GP(charextra)[chac].animwait;
const auto &movelist = _GP(mls)[chin->walking % TURNING_AROUND];
// We set (fraction + 1), because movelist is always +1 ahead of current character pos;
if (movelist.onpart > 0.f)
wasStepFrac = movelist.GetPixelUnitFraction() + movelist.GetStepLength();
}
StopMoving(chac);
chin->frame = oldframe;
// use toxPassedIn cached variable so the hi-res co-ordinates
// are still displayed as such
debug_script_log("%s: Start move to %d,%d", chin->scrname, tox, toy);
int move_speed_x, move_speed_y;
chin->get_effective_walkspeeds(move_speed_x, move_speed_y);
if ((move_speed_x == 0) && (move_speed_y == 0)) {
debug_script_warn("MoveCharacter: called for '%s' with walk speed 0", chin->scrname);
}
// Convert src and dest coords to the mask resolution, for pathfinder
const int src_x = room_to_mask_coord(chin->x);
const int src_y = room_to_mask_coord(chin->y);
const int dst_x = room_to_mask_coord(tox);
const int dst_y = room_to_mask_coord(toy);
int mslot = find_route(src_x, src_y, dst_x, dst_y, move_speed_x, move_speed_y, prepare_walkable_areas(chac), chac + CHMLSOFFS, 1, ignwal);
if (mslot > 0) {
chin->walking = mslot;
_GP(mls)[mslot].direct = ignwal;
convert_move_path_to_room_resolution(&_GP(mls)[mslot]);
// NOTE: unfortunately, some old game scripts might break because of smooth walk transition
if (wasStepFrac > 0.f && (_G(loaded_game_file_version) >= kGameVersion_361)) {
_GP(mls)[mslot].SetPixelUnitFraction(wasStepFrac);
}
// cancel any pending waits on current animations
// or if they were already moving, keep the current wait -
// this prevents a glitch if MoveCharacter is called when they
// are already moving
if (autoWalkAnims) {
chin->walkwait = waitWas;
_GP(charextra)[chac].animwait = animWaitWas;
if (_GP(mls)[mslot].pos[0] != _GP(mls)[mslot].pos[1]) {
fix_player_sprite(&_GP(mls)[mslot], chin);
}
} else
chin->flags |= CHF_MOVENOTWALK;
} else if (autoWalkAnims) // pathfinder couldn't get a route, stand them still
chin->frame = 0;
}
int find_looporder_index(int curloop) {
int rr;
for (rr = 0; rr < 8; rr++) {
if (turnlooporder[rr] == curloop)
return rr;
}
return 0;
}
// returns 0 to use diagonal, 1 to not
int useDiagonal(CharacterInfo *char1) {
if ((_GP(views)[char1->view].numLoops < 8) || ((char1->flags & CHF_NODIAGONAL) != 0))
return 1;
// If they have just provided standing frames for loops 4-7, to
// provide smoother turning
if (_GP(views)[char1->view].loops[4].numFrames < 2)
return 2;
return 0;
}
// returns 1 normally, or 0 if they only have horizontal animations
int hasUpDownLoops(CharacterInfo *char1) {
// if no loops in the Down animation
// or no loops in the Up animation
if ((_GP(views)[char1->view].loops[0].numFrames < 1) ||
(_GP(views)[char1->view].numLoops < 4) ||
(_GP(views)[char1->view].loops[3].numFrames < 1)) {
return 0;
}
return 1;
}
void start_character_turning(CharacterInfo *chinf, int useloop, int no_diagonal) {
// work out how far round they have to turn
int fromidx = find_looporder_index(chinf->loop);
int toidx = find_looporder_index(useloop);
//Display("Curloop: %d, needloop: %d",chinf->loop, useloop);
int ii, go_anticlock = 0;
// work out whether anticlockwise is quicker or not
if ((toidx > fromidx) && ((toidx - fromidx) > 4))
go_anticlock = 1;
if ((toidx < fromidx) && ((fromidx - toidx) < 4))
go_anticlock = 1;
// strip any current turning_around stages
chinf->walking = chinf->walking % TURNING_AROUND;
if (go_anticlock)
chinf->walking += TURNING_BACKWARDS;
else
go_anticlock = -1;
// Allow the diagonal frames just for turning
if (no_diagonal == 2)
no_diagonal = 0;
for (ii = fromidx; ii != toidx; ii -= go_anticlock) {
// Wrap the loop order into range [0-7]
if (ii < 0)
ii = 7;
if (ii >= 8)
ii = 0;
if (ii == toidx)
break;
if ((turnlooporder[ii] >= 4) && (no_diagonal > 0))
continue; // there are no diagonal loops
if (turnlooporder[ii] >= _GP(views)[chinf->view].numLoops)
continue; // no such loop
if (_GP(views)[chinf->view].loops[turnlooporder[ii]].numFrames < 1)
continue; // no frames in such loop
chinf->walking += TURNING_AROUND;
}
}
void fix_player_sprite(MoveList *cmls, CharacterInfo *chinf) {
const fixed xpmove = cmls->xpermove[cmls->onstage];
const fixed ypmove = cmls->ypermove[cmls->onstage];
// if not moving, do nothing
if ((xpmove == 0) && (ypmove == 0))
return;
const int useloop = GetDirectionalLoop(chinf, xpmove, ypmove);
if ((_GP(game).options[OPT_ROTATECHARS] == 0) || ((chinf->flags & CHF_NOTURNING) != 0)) {
chinf->loop = useloop;
return;
}
if ((chinf->loop > kDirLoop_LastOrthogonal) && ((chinf->flags & CHF_NODIAGONAL) != 0)) {
// They've just been playing an animation with an extended loop number,
// so don't try and rotate using it
chinf->loop = useloop;
return;
}
if ((chinf->loop >= _GP(views)[chinf->view].numLoops) ||
(_GP(views)[chinf->view].loops[chinf->loop].numFrames < 1) ||
(hasUpDownLoops(chinf) == 0)) {
// Character is not currently on a valid loop, so don't try to rotate
// eg. left/right only view, but current loop 0
chinf->loop = useloop;
return;
}
const int no_diagonal = useDiagonal(chinf);
start_character_turning(chinf, useloop, no_diagonal);
}
// Check whether two characters have walked into each other
int has_hit_another_character(int sourceChar) {
// if the character who's moving doesn't block, don't bother checking
if (_GP(game).chars[sourceChar].flags & CHF_NOBLOCKING)
return -1;
for (int ww = 0; ww < _GP(game).numcharacters; ww++) {
if (_GP(game).chars[ww].on != 1) continue;
if (_GP(game).chars[ww].room != _G(displayed_room)) continue;
if (ww == sourceChar) continue;
if (_GP(game).chars[ww].flags & CHF_NOBLOCKING) continue;
if (is_char_in_blocking_rect(sourceChar, ww, nullptr, nullptr)) {
// we are now overlapping character 'ww'
if ((_GP(game).chars[ww].walking) &&
((_GP(game).chars[ww].flags & CHF_AWAITINGMOVE) == 0))
return ww;
}
}
return -1;
}
// Does the next move from the character's movelist.
// Returns 1 if they are now waiting for another char to move,
// otherwise returns 0
int doNextCharMoveStep(CharacterInfo *chi, int &char_index, CharacterExtras *chex) {
int ntf = 0, xwas = chi->x, ywas = chi->y;
if (do_movelist_move(chi->walking, chi->x, chi->y) == 2) {
if ((chi->flags & CHF_MOVENOTWALK) == 0)
fix_player_sprite(&_GP(mls)[chi->walking], chi);
}
ntf = has_hit_another_character(char_index);
if (ntf >= 0) {
chi->walkwait = 30;
if (_GP(game).chars[ntf].walkspeed < 5)
chi->walkwait += (5 - _GP(game).chars[ntf].walkspeed) * 5;
// we are now waiting for the other char to move, so
// make sure he doesn't stop for us too
chi->flags |= CHF_AWAITINGMOVE;
if ((chi->flags & CHF_MOVENOTWALK) == 0) {
chi->frame = 0;
chex->animwait = chi->walkwait;
}
if ((chi->walking < 1) || (chi->walking >= TURNING_AROUND)) ;
else if (_GP(mls)[chi->walking].onpart > 0.f) {
_GP(mls)[chi->walking].onpart -= 1.f;
chi->x = xwas;
chi->y = ywas;
}
debug_script_log("%s: Bumped into %s, waiting for them to move", chi->scrname, _GP(game).chars[ntf].scrname);
return 1;
}
return 0;
}
bool is_char_walking_ndirect(CharacterInfo *chi) {
return ((chi->walking > 0) && (chi->walking < TURNING_AROUND)) &&
(_GP(mls)[chi->walking].direct == 0);
}
int find_nearest_walkable_area_within(int *xx, int *yy, int range, int step) {
int ex, ey, nearest = 99999, thisis, nearx = 0, neary = 0;
int startx = 0, starty = 14;
int roomWidthLowRes = room_to_mask_coord(_GP(thisroom).Width);
int roomHeightLowRes = room_to_mask_coord(_GP(thisroom).Height);
int xwidth = roomWidthLowRes, yheight = roomHeightLowRes;
int xLowRes = room_to_mask_coord(xx[0]);
int yLowRes = room_to_mask_coord(yy[0]);
int rightEdge = room_to_mask_coord(_GP(thisroom).Edges.Right);
int leftEdge = room_to_mask_coord(_GP(thisroom).Edges.Left);
int topEdge = room_to_mask_coord(_GP(thisroom).Edges.Top);
int bottomEdge = room_to_mask_coord(_GP(thisroom).Edges.Bottom);
// tweak because people forget to move the edges sometimes
// if the player is already over the edge, ignore it
if (xLowRes >= rightEdge) rightEdge = roomWidthLowRes;
if (xLowRes <= leftEdge) leftEdge = 0;
if (yLowRes >= bottomEdge) bottomEdge = roomHeightLowRes;
if (yLowRes <= topEdge) topEdge = 0;
if (range > 0) {
startx = xLowRes - range;
starty = yLowRes - range;
xwidth = startx + range * 2;
yheight = starty + range * 2;
if (startx < 0) startx = 0;
if (starty < 10) starty = 10;
if (xwidth > roomWidthLowRes) xwidth = roomWidthLowRes;
if (yheight > roomHeightLowRes) yheight = roomHeightLowRes;
}
for (ex = startx; ex < xwidth; ex += step) {
for (ey = starty; ey < yheight; ey += step) {
// non-walkalbe, so don't go here
if (_GP(thisroom).WalkAreaMask->GetPixel(ex, ey) == 0) continue;
// off a screen edge, don't move them there
if ((ex <= leftEdge) || (ex >= rightEdge) ||
(ey <= topEdge) || (ey >= bottomEdge))
continue;
// otherwise, calculate distance from target
thisis = (int) ::sqrt((double)((ex - xLowRes) * (ex - xLowRes) + (ey - yLowRes) * (ey - yLowRes)));
if (thisis < nearest) {
nearest = thisis;
nearx = ex;
neary = ey;
}
}
}
if (nearest < 90000) {
xx[0] = mask_to_room_coord(nearx);
yy[0] = mask_to_room_coord(neary);
return 1;
}
return 0;
}
void find_nearest_walkable_area(int *xx, int *yy) {
int pixValue = _GP(thisroom).WalkAreaMask->GetPixel(room_to_mask_coord(xx[0]), room_to_mask_coord(yy[0]));
// only fix this code if the game was built with 2.61 or above
if (pixValue == 0 || (_G(loaded_game_file_version) >= kGameVersion_261 && pixValue < 1)) {
// First, check every 2 pixels within immediate area
if (!find_nearest_walkable_area_within(xx, yy, 20, 2)) {
// If not, check whole screen at 5 pixel intervals
find_nearest_walkable_area_within(xx, yy, -1, 5);
}
}
}
void FindReasonableLoopForCharacter(CharacterInfo *chap) {
if (chap->loop >= _GP(views)[chap->view].numLoops)
chap->loop = kDirLoop_Default;
if (_GP(views)[chap->view].numLoops < 1)
quitprintf("!View %d does not have any loops", chap->view + 1);
// if the current loop has no frames, find one that does
if (_GP(views)[chap->view].loops[chap->loop].numFrames < 1) {
for (int i = 0; i < _GP(views)[chap->view].numLoops; i++) {
if (_GP(views)[chap->view].loops[i].numFrames > 0) {
chap->loop = i;
break;
}
}
}
}
void walk_or_move_character(CharacterInfo *chaa, int x, int y, int blocking, int direct, bool isWalk) {
if (chaa->on != 1) {
debug_script_warn("MoveCharacterBlocking: character is turned off and cannot be moved");
return;
}
if ((direct == ANYWHERE) || (direct == 1))
walk_character(chaa->index_id, x, y, 1, isWalk);
else if ((direct == WALKABLE_AREAS) || (direct == 0))
walk_character(chaa->index_id, x, y, 0, isWalk);
else
quit("!Character.Walk: Direct must be ANYWHERE or WALKABLE_AREAS");
if ((blocking == BLOCKING) || (blocking == 1))
GameLoopUntilNotMoving(&chaa->walking);
else if ((blocking != IN_BACKGROUND) && (blocking != 0))
quit("!Character.Walk: Blocking must be BLOCKING or IN_BACKGROUND");
}
int wantMoveNow(CharacterInfo *chi, CharacterExtras *chex) {
// check most likely case first
if ((chex->zoom == 100) || ((chi->flags & CHF_SCALEMOVESPEED) == 0))
return 1;
// the % checks don't work when the counter is negative, so once
// it wraps round, correct it
while (chi->walkwaitcounter < 0) {
chi->walkwaitcounter += 12000;
}
// scaling 170-200%, move 175% speed
if (chex->zoom >= 170) {
if ((chi->walkwaitcounter % 4) >= 1)
return 2;
else
return 1;
}
// scaling 140-170%, move 150% speed
else if (chex->zoom >= 140) {
if ((chi->walkwaitcounter % 2) == 1)
return 2;
else
return 1;
}
// scaling 115-140%, move 125% speed
else if (chex->zoom >= 115) {
if ((chi->walkwaitcounter % 4) >= 3)
return 2;
else
return 1;
}
// scaling 80-120%, normal speed
else if (chex->zoom >= 80)
return 1;
// scaling 60-80%, move 75% speed
if (chex->zoom >= 60) {
if ((chi->walkwaitcounter % 4) >= 1)
return -1;
else if (chex->xwas != INVALID_X) {
// move the second half of the movement to make it smoother
chi->x = chex->xwas;
chi->y = chex->ywas;
chex->xwas = INVALID_X;
}
}
// scaling 30-60%, move 50% speed
else if (chex->zoom >= 30) {
if ((chi->walkwaitcounter % 2) == 1)
return -1;
else if (chex->xwas != INVALID_X) {
// move the second half of the movement to make it smoother
chi->x = chex->xwas;
chi->y = chex->ywas;
chex->xwas = INVALID_X;
}
}
// scaling 0-30%, move 25% speed
else {
if ((chi->walkwaitcounter % 4) >= 3)
return -1;
if (((chi->walkwaitcounter % 4) == 1) && (chex->xwas != INVALID_X)) {
// move the second half of the movement to make it smoother
chi->x = chex->xwas;
chi->y = chex->ywas;
chex->xwas = INVALID_X;
}
}
return 0;
}
void setup_player_character(int charid) {
_GP(game).playercharacter = charid;
_G(playerchar) = &_GP(game).chars[charid];
_G(sc_PlayerCharPtr) = ccGetObjectHandleFromAddress(_G(playerchar));
if (_G(loaded_game_file_version) < kGameVersion_270) {
ccAddExternalScriptObject("player", _G(playerchar), &_GP(ccDynamicCharacter));
}
}
// Animate character internal implementation;
// this function may be called by the game logic too, so we assume
// the arguments must be correct, and do not fix them up as we do for API functions.
void animate_character(CharacterInfo *chap, int loopn, int sppd, int rept, int direction, int sframe, int volume) {
if ((chap->view < 0) || (chap->view > _GP(game).numviews) ||
(loopn < 0) || (loopn >= _GP(views)[chap->view].numLoops)) {
quitprintf("!AnimateCharacter: invalid view and/or loop\n"
"(trying to animate '%s' using view %d (range is 1..%d) and loop %d (view has %d loops)).",
chap->scrname, chap->view + 1, _GP(game).numviews, loopn, _GP(views)[chap->view].numLoops);
}
// NOTE: there's always frame 0 allocated for safety
sframe = std::max(0, std::min(sframe, _GP(views)[chap->view].loops[loopn].numFrames - 1));
debug_script_log("%s: Start anim view %d loop %d, spd %d, repeat %d, frame: %d",
chap->scrname, chap->view + 1, loopn, sppd, rept, sframe);
Character_StopMoving(chap);
chap->set_animating(rept != 0, direction == 0, sppd);
chap->loop = loopn;
chap->frame = SetFirstAnimFrame(chap->view, loopn, sframe, direction);
chap->wait = sppd + _GP(views)[chap->view].loops[loopn].frames[chap->frame].speed;
_GP(charextra)[chap->index_id].cur_anim_volume = Math::Clamp(volume, 0, 100);
_GP(charextra)[chap->index_id].CheckViewFrame(chap);
}
void stop_character_anim(CharacterInfo *chap) { // TODO: may expand with resetting more properties,
// but have to be careful to not break logic somewhere
chap->animating = 0;
_GP(charextra)[chap->index_id].cur_anim_volume = 100;
}
int GetCharacterFrameVolume(CharacterInfo *chi) {
// We view the audio property relation as the relation of the entities:
// system -> audio type -> audio emitter (character) -> animation's audio
// therefore the sound volume is a multiplication of factors.
int frame_vol = 100; // default to full volume
// Try the active animation volume
if (_GP(charextra)[chi->index_id].cur_anim_volume >= 0)
frame_vol = _GP(charextra)[chi->index_id].cur_anim_volume;
// Try the character's own animation volume property
if (_GP(charextra)[chi->index_id].anim_volume >= 0)
frame_vol = frame_vol * _GP(charextra)[chi->index_id].anim_volume / 100;
// Try the character's zoom volume scaling (optional)
// NOTE: historically scales only in 0-100 range :/
if (chi->flags & CHF_SCALEVOLUME) {
int zoom_level = _GP(charextra)[chi->index_id].zoom;
if (zoom_level <= 0)
zoom_level = 100;
else
zoom_level = std::min(zoom_level, 100);
frame_vol = frame_vol * zoom_level / 100;
}
return frame_vol;
}
Bitmap *GetCharacterImage(int charid, bool *is_original) {
// NOTE: the cached image will only be present in software render mode
Bitmap *actsp = get_cached_character_image(charid);
if (is_original)
*is_original = !actsp; // no cached means we use original sprite
if (actsp)
return actsp;
CharacterInfo *chin = &_GP(game).chars[charid];
int sppic = _GP(views)[chin->view].loops[chin->loop].frames[chin->frame].pic;
return _GP(spriteset)[sppic];
}
CharacterInfo *GetCharacterAtScreen(int xx, int yy) {
int hsnum = GetCharIDAtScreen(xx, yy);
if (hsnum < 0)
return nullptr;
return &_GP(game).chars[hsnum];
}
CharacterInfo *GetCharacterAtRoom(int x, int y) {
int hsnum = is_pos_on_character(x, y);
if (hsnum < 0)
return nullptr;
return &_GP(game).chars[hsnum];
}
void update_character_scale(int charid) {
// Test for valid view and loop
CharacterInfo &chin = _GP(game).chars[charid];
if (chin.on == 0 || chin.room != _G(displayed_room))
return; // not enabled, or in a different room
CharacterExtras &chex = _GP(charextra)[charid];
if (chin.view < 0) {
quitprintf("!The character '%s' was turned on in the current room (room %d) but has not been assigned a view number.",
chin.scrname, _G(displayed_room));
}
if (chin.loop >= _GP(views)[chin.view].numLoops) {
quitprintf("!The character '%s' could not be displayed because there was no loop %d of view %d.",
chin.scrname, chin.loop, chin.view + 1);
}
// If frame is too high -- fallback to the frame 0;
// there's always at least 1 dummy frame at index 0
if (chin.frame >= _GP(views)[chin.view].loops[chin.loop].numFrames) {
chin.frame = 0;
}
int zoom, zoom_offs, scale_width, scale_height;
update_object_scale(zoom, scale_width, scale_height,
chin.x, chin.y, _GP(views)[chin.view].loops[chin.loop].frames[chin.frame].pic,
chex.zoom, (chin.flags & CHF_MANUALSCALING) == 0);
zoom_offs = (_GP(game).options[OPT_SCALECHAROFFSETS] != 0) ? zoom : 100;
// Calculate the X & Y co-ordinates of where the sprite will be;
// for the character sprite's origin is at the bottom-mid of a sprite.
const int atxp = (data_to_game_coord(chin.x)) - scale_width / 2;
const int atyp = (data_to_game_coord(chin.y) - scale_height)
// adjust the Y positioning for the character's Z co-ord
- (data_to_game_coord(chin.z) * zoom_offs / 100);
// Save calculated properties
chex.width = scale_width;
chex.height = scale_height;
chin.actx = atxp;
chin.acty = atyp;
chex.zoom = zoom;
chex.zoom_offs = zoom_offs;
}
int is_pos_on_character(int xx, int yy) {
int cc, sppic, lowestyp = 0, lowestwas = -1;
for (cc = 0; cc < _GP(game).numcharacters; cc++) {
if (_GP(game).chars[cc].room != _G(displayed_room)) continue;
if (_GP(game).chars[cc].on == 0) continue;
if (_GP(game).chars[cc].flags & CHF_NOINTERACT) continue;
if (_GP(game).chars[cc].view < 0) continue;
CharacterInfo *chin = &_GP(game).chars[cc];
if ((chin->view < 0) ||
(chin->loop >= _GP(views)[chin->view].numLoops) ||
(chin->frame >= _GP(views)[chin->view].loops[chin->loop].numFrames)) {
continue;
}
sppic = _GP(views)[chin->view].loops[chin->loop].frames[chin->frame].pic;
int usewid = _GP(charextra)[cc].width;
int usehit = _GP(charextra)[cc].height;
if (usewid == 0) usewid = _GP(game).SpriteInfos[sppic].Width;
if (usehit == 0) usehit = _GP(game).SpriteInfos[sppic].Height;
int xxx = chin->x - game_to_data_coord(usewid) / 2;
int yyy = _GP(charextra)[cc].GetEffectiveY(chin) - game_to_data_coord(usehit);
int mirrored = _GP(views)[chin->view].loops[chin->loop].frames[chin->frame].flags & VFLG_FLIPSPRITE;
bool is_original;
Bitmap *theImage = GetCharacterImage(cc, &is_original);
if (!is_original)
mirrored = 0; // transformed image is already flipped
if (is_pos_in_sprite(xx, yy, xxx, yyy, theImage,
game_to_data_coord(usewid),
game_to_data_coord(usehit), mirrored, is_original) == FALSE)
continue;
int use_base = chin->get_baseline();
if (use_base < lowestyp) continue;
lowestyp = use_base;
lowestwas = cc;
}
_G(char_lowest_yp) = lowestyp;
return lowestwas;
}
void get_char_blocking_rect(int charid, int *x1, int *y1, int *width, int *y2) {
CharacterInfo *char1 = &_GP(game).chars[charid];
int cwidth, fromx;
if (char1->blocking_width < 1)
cwidth = game_to_data_coord(GetCharacterWidth(charid)) - 4;
else
cwidth = char1->blocking_width;
fromx = char1->x - cwidth / 2;
if (fromx < 0) {
cwidth += fromx;
fromx = 0;
}
if (fromx + cwidth >= mask_to_room_coord(_G(walkable_areas_temp)->GetWidth()))
cwidth = mask_to_room_coord(_G(walkable_areas_temp)->GetWidth()) - fromx;
if (x1)
*x1 = fromx;
if (width)
*width = cwidth;
if (y1)
*y1 = char1->get_blocking_top();
if (y2)
*y2 = char1->get_blocking_bottom();
}
// Check whether the source char is standing inside otherChar's blocking rectangle
int is_char_in_blocking_rect(int sourceChar, int otherChar, int *fromxptr, int *cwidptr) {
int fromx, cwidth;
int y1, y2;
get_char_blocking_rect(otherChar, &fromx, &y1, &cwidth, &y2);
if (fromxptr)
fromxptr[0] = fromx;
if (cwidptr)
cwidptr[0] = cwidth;
// if the character trying to move is already on top of
// this char somehow, allow them through
if ((sourceChar >= 0) &&
// x/width are left and width co-ords, so they need >= and <
(_GP(game).chars[sourceChar].x >= fromx) &&
(_GP(game).chars[sourceChar].x < fromx + cwidth) &&
// y1/y2 are the top/bottom co-ords, so they need >= / <=
(_GP(game).chars[sourceChar].y >= y1) &&
(_GP(game).chars[sourceChar].y <= y2))
return 1;
return 0;
}
int my_getpixel(Bitmap *blk, int x, int y) {
if ((x < 0) || (y < 0) || (x >= blk->GetWidth()) || (y >= blk->GetHeight()))
return -1;
// strip the alpha channel
// TODO: is there a way to do this vtable thing with Bitmap?
BITMAP *al_bmp = (BITMAP *)blk->GetAllegroBitmap();
return al_bmp->getpixel(x, y) & 0x00ffffff;
}
int check_click_on_character(int xx, int yy, int mood) {
int lowestwas = is_pos_on_character(xx, yy);
if (lowestwas >= 0) {
RunCharacterInteraction(lowestwas, mood);
return 1;
}
return 0;
}
void _DisplaySpeechCore(int chid, const char *displbuf) {
if (displbuf[0] == 0) {
// no text, just update the current character who's speaking
// this allows the portrait side to be switched with an empty
// speech line
_GP(play).swap_portrait_lastchar = chid;
return;
}
// adjust timing of text (so that DisplaySpeech("%s", str) pauses
// for the length of the string not 2 frames)
int len = (int)strlen(displbuf);
if (len > _G(source_text_length) + 3)
_G(source_text_length) = len;
DisplaySpeech(displbuf, chid);
}
void _DisplayThoughtCore(int chid, const char *displbuf) {
// adjust timing of text (so that DisplayThought("%s", str) pauses
// for the length of the string not 2 frames)
int len = (int)strlen(displbuf);
if (len > _G(source_text_length) + 3)
_G(source_text_length) = len;
int xpp = -1, ypp = -1, width = -1;
if ((_GP(game).options[OPT_SPEECHTYPE] == 0) || (_GP(game).chars[chid].thinkview <= 0)) {
// lucasarts-style, so we want a speech bubble actually above
// their head (or if they have no think anim in Sierra-style)
width = data_to_game_coord(_GP(play).speech_bubble_width);
xpp = _GP(play).RoomToScreenX(data_to_game_coord(_GP(game).chars[chid].x)) - width / 2;
if (xpp < 0)
xpp = 0;
// -1 will automatically put it above the char's head
ypp = -1;
}
_displayspeech(displbuf, chid, xpp, ypp, width, 1);
}
void _displayspeech(const char *texx, int aschar, int xx, int yy, int widd, int isThought) {
if (!is_valid_character(aschar))
quit("!DisplaySpeech: invalid character");
CharacterInfo *speakingChar = &_GP(game).chars[aschar];
if ((speakingChar->view < 0) || (speakingChar->view >= _GP(game).numviews))
quit("!DisplaySpeech: character has invalid view");
if (_GP(play).screen_is_faded_out > 0)
debug_script_warn("Warning: blocking Say call during fade-out.");
if (_GP(play).text_overlay_on > 0) {
debug_script_warn("DisplaySpeech: speech was already displayed (nested DisplaySpeech, perhaps room script and global script conflict?)");
return;
}
EndSkippingUntilCharStops();
_G(said_speech_line) = 1;
if (_GP(play).bgspeech_stay_on_display == 0) {
// remove any background speech
auto &overs = get_overlays();
for (auto &over : overs) {
if (over.timeout > 0)
remove_screen_overlay(over.type);
}
}
_G(said_text) = 1;
// the strings are pre-translated
//texx = get_translation(texx);
set_our_eip(150);
int isPause = 1;
// if the message is all .'s, don't display anything
for (size_t aa = 0; texx[aa] != 0; aa++) {
if (texx[aa] != '.') {
isPause = 0;
break;
}
}
_GP(play).messagetime = GetTextDisplayTime(texx);
_GP(play).speech_in_post_state = false;
if (isPause) {
postpone_scheduled_music_update_by(std::chrono::milliseconds(_GP(play).messagetime * 1000 / _G(frames_per_second)));
// Set a post-state right away, as we only need to wait for a messagetime timer
_GP(play).speech_in_post_state = true;
GameLoopUntilValueIsNegative(&_GP(play).messagetime);
post_display_cleanup();
return;
}
int textcol = speakingChar->talkcolor;
// if it's 0, it won't be recognised as speech
if (textcol == 0)
textcol = 16;
Rect ui_view = _GP(play).GetUIViewport();
int allowShrink = 0;
int bwidth = widd;
if (bwidth < 0)
bwidth = ui_view.GetWidth() / 2 + ui_view.GetWidth() / 4;
set_our_eip(151);
int useview = speakingChar->talkview;
if (isThought) {
useview = speakingChar->thinkview;
// view 0 is not valid for think views
if (useview == 0)
useview = -1;
// speech bubble can shrink to fit
allowShrink = 1;
if (speakingChar->room != _G(displayed_room)) {
// not in room, centre it
xx = -1;
yy = -1;
}
}
if (useview >= _GP(game).numviews)
quitprintf("!Character.Say: attempted to use view %d for animation, but it does not exist", useview + 1);
if (_GP(game).options[OPT_SPEECHTYPE] == 3)
remove_screen_overlay(OVER_COMPLETE);
set_our_eip(1500);
if (_GP(game).options[OPT_SPEECHTYPE] == 0)
allowShrink = 1;
// If has a valid speech view, and idle anim in progress for the character, then stop it
if (useview >= 0) {
stop_character_idling(speakingChar);
}
int tdxp = xx, tdyp = yy;
int oldview = -1, oldloop = -1;
int ovr_type = 0;
_G(text_lips_offset) = 0;
_G(text_lips_text) = texx;
Bitmap *closeupface = nullptr;
bool overlayPositionFixed = false;
int charFrameWas = 0;
int viewWasLocked = 0;
if (speakingChar->flags & CHF_FIXVIEW)
viewWasLocked = 1;
// Start voice-over, if requested by the tokens in speech text
try_auto_play_speech(texx, texx, aschar);
if (speakingChar->room == _G(displayed_room)) {
// If the character is in this room, go for it - otherwise
// run the "else" clause which does text in the middle of
// the screen.
set_our_eip(1501);
if (speakingChar->walking)
StopMoving(aschar);
// save the frame we need to go back to
// if they were moving, this will be 0 (because we just called
// StopMoving); otherwise, it might be a specific animation
// frame which we should return to
if (viewWasLocked)
charFrameWas = speakingChar->frame;
if ((speakingChar->view < 0) || _GP(views)[speakingChar->view].numLoops == 0)
quitprintf("!Character %s current view %d is invalid, or has no loops.", speakingChar->scrname, speakingChar->view + 1);
// If current view is missing a loop - use loop 0
if (speakingChar->loop >= _GP(views)[speakingChar->view].numLoops) {
debug_script_warn("WARNING: Character %s current view %d does not have necessary loop %d; switching to loop 0.",
speakingChar->scrname, speakingChar->view + 1, speakingChar->loop);
speakingChar->loop = 0;
}
set_our_eip(1504);
// Calculate speech position based on character's position on screen
auto view = FindNearestViewport(aschar);
if (tdxp < 0)
tdxp = view->RoomToScreen(data_to_game_coord(speakingChar->x), 0).first.X;
if (tdxp < 2)
tdxp = 2;
tdxp = -tdxp; // tell it to centre it ([ikm] not sure what's going on here... wrong comment?)
if (tdyp < 0) {
int sppic = _GP(views)[speakingChar->view].loops[speakingChar->loop].frames[0].pic;
int height = (_GP(charextra)[aschar].height < 1) ? _GP(game).SpriteInfos[sppic].Height : _GP(charextra)[aschar].height;
tdyp = view->RoomToScreen(0, data_to_game_coord(_GP(charextra)[aschar].GetEffectiveY(speakingChar)) - height).first.Y
- get_fixed_pixel_size(5);
if (isThought) // if it's a thought, lift it a bit further up
tdyp -= get_fixed_pixel_size(10);
}
if (tdyp < 5)
tdyp = 5;
set_our_eip(152);
if ((useview >= 0) && (_GP(game).options[OPT_SPEECHTYPE] > 0)) {
// Sierra-style close-up portrait
if (_GP(play).swap_portrait_lastchar != aschar) {
// if the portraits are set to Alternate, OR they are
// set to Left but swap_portrait has been set to 1 (the old
// method for enabling it), then swap them round
if ((_GP(game).options[OPT_PORTRAITSIDE] == PORTRAIT_ALTERNATE) ||
((_GP(game).options[OPT_PORTRAITSIDE] == 0) &&
(_GP(play).swap_portrait_side > 0))) {
if (_GP(play).swap_portrait_side == 2)
_GP(play).swap_portrait_side = 1;
else
_GP(play).swap_portrait_side = 2;
}
if (_GP(game).options[OPT_PORTRAITSIDE] == PORTRAIT_XPOSITION) {
// Portrait side based on character X-positions
if (_GP(play).swap_portrait_lastchar < 0) {
// No previous character been spoken to
// therefore, assume it's the player
if (_GP(game).playercharacter != aschar && _GP(game).chars[_GP(game).playercharacter].room == speakingChar->room && _GP(game).chars[_GP(game).playercharacter].on == 1)
_GP(play).swap_portrait_lastchar = _GP(game).playercharacter;
else
// The player's not here. Find another character in this room
// that it could be
for (int ce = 0; ce < _GP(game).numcharacters; ce++) {
if ((_GP(game).chars[ce].room == speakingChar->room) &&
(_GP(game).chars[ce].on == 1) &&
(ce != aschar)) {
_GP(play).swap_portrait_lastchar = ce;
break;
}
}
}
if (_GP(play).swap_portrait_lastchar >= 0) {
// if this character is right of the one before, put the
// portrait on the right
if (speakingChar->x > _GP(game).chars[_GP(play).swap_portrait_lastchar].x)
_GP(play).swap_portrait_side = -1;
else
_GP(play).swap_portrait_side = 0;
}
}
_GP(play).swap_portrait_lastlastchar = _GP(play).swap_portrait_lastchar;
_GP(play).swap_portrait_lastchar = aschar;
} else
// If the portrait side is based on the character's X position and the same character is
// speaking, compare against the previous *previous* character to see where the speech should be
if (_GP(game).options[OPT_PORTRAITSIDE] == PORTRAIT_XPOSITION && _GP(play).swap_portrait_lastlastchar >= 0) {
if (speakingChar->x > _GP(game).chars[_GP(play).swap_portrait_lastlastchar].x)
_GP(play).swap_portrait_side = -1;
else
_GP(play).swap_portrait_side = 0;
}
// Determine whether to display the portrait on the left or right
int portrait_on_right = 0;
if (_GP(game).options[OPT_SPEECHTYPE] == 3) {
} // always on left with QFG-style speech
else if ((_GP(play).swap_portrait_side == 1) ||
(_GP(play).swap_portrait_side == -1) ||
(_GP(game).options[OPT_PORTRAITSIDE] == PORTRAIT_RIGHT))
portrait_on_right = 1;
int bigx = 0, bigy = 0, kk;
ViewStruct *viptr = &_GP(views)[useview];
for (kk = 0; kk < viptr->loops[0].numFrames; kk++) {
int tw = _GP(game).SpriteInfos[viptr->loops[0].frames[kk].pic].Width;
if (tw > bigx) bigx = tw;
tw = _GP(game).SpriteInfos[viptr->loops[0].frames[kk].pic].Height;
if (tw > bigy) bigy = tw;
}
// if they accidentally used a large full-screen image as the sierra-style
// talk view, correct it
if ((_GP(game).options[OPT_SPEECHTYPE] != 3) && (bigx > ui_view.GetWidth() - get_fixed_pixel_size(50)))
bigx = ui_view.GetWidth() - get_fixed_pixel_size(50);
if (widd > 0)
bwidth = widd - bigx;
set_our_eip(153);
int ovr_yp = get_fixed_pixel_size(20);
int view_frame_x = 0;
int view_frame_y = 0;
_G(facetalk_qfg4_override_placement_x) = false;
_G(facetalk_qfg4_override_placement_y) = false;
if (_GP(game).options[OPT_SPEECHTYPE] == 3) {
// QFG4-style whole screen picture
closeupface = BitmapHelper::CreateBitmap(ui_view.GetWidth(), ui_view.GetHeight());
closeupface->Clear(0);
if (xx < 0 && _GP(play).speech_portrait_placement) {
_G(facetalk_qfg4_override_placement_x) = true;
view_frame_x = _GP(play).speech_portrait_x;
}
if (yy < 0 && _GP(play).speech_portrait_placement) {
_G(facetalk_qfg4_override_placement_y) = true;
view_frame_y = _GP(play).speech_portrait_y;
} else {
view_frame_y = ui_view.GetHeight() / 2 - _GP(game).SpriteInfos[viptr->loops[0].frames[0].pic].Height / 2;
}
bigx = ui_view.GetWidth() / 2 - get_fixed_pixel_size(20);
ovr_type = OVER_COMPLETE;
ovr_yp = 0;
tdyp = -1; // center vertically
} else {
// KQ6-style close-up face picture
if (yy < 0 && _GP(play).speech_portrait_placement) {
ovr_yp = _GP(play).speech_portrait_y;
} else if (yy < 0)
ovr_yp = adjust_y_for_guis(ovr_yp, true /* displayspeech is always blocking */);
else
ovr_yp = yy;
closeupface = BitmapHelper::CreateTransparentBitmap(bigx + 1, bigy + 1);
ovr_type = OVER_PICTURE;
if (yy < 0)
tdyp = ovr_yp + get_textwindow_top_border_height(_GP(play).speech_textwindow_gui);
}
const ViewFrame *vf = &viptr->loops[0].frames[0];
const bool closeupface_has_alpha = (_GP(game).SpriteInfos[vf->pic].Flags & SPF_ALPHACHANNEL) != 0;
DrawViewFrame(closeupface, vf, view_frame_x, view_frame_y);
int overlay_x = get_fixed_pixel_size(10);
if (xx < 0) {
tdxp = bigx + get_textwindow_border_width(_GP(play).speech_textwindow_gui) / 2;
if (_GP(play).speech_portrait_placement) {
overlay_x = _GP(play).speech_portrait_x;
tdxp += overlay_x + get_fixed_pixel_size(6);
} else {
tdxp += get_fixed_pixel_size(16);
}
int maxWidth = (ui_view.GetWidth() - tdxp) - get_fixed_pixel_size(5) -
get_textwindow_border_width(_GP(play).speech_textwindow_gui) / 2;
if (bwidth > maxWidth)
bwidth = maxWidth;
} else {
tdxp = xx + bigx + get_fixed_pixel_size(8);
overlay_x = xx;
}
// allow the text box to be shrunk to fit the text
allowShrink = 1;
// if the portrait's on the right, swap it round
if (portrait_on_right) {
if ((xx < 0) || (widd < 0)) {
tdxp = get_fixed_pixel_size(9);
if (_GP(play).speech_portrait_placement) {
overlay_x = (ui_view.GetWidth() - bigx) - _GP(play).speech_portrait_x;
int maxWidth = overlay_x - tdxp - get_fixed_pixel_size(9) -
get_textwindow_border_width(_GP(play).speech_textwindow_gui) / 2;
if (bwidth > maxWidth)
bwidth = maxWidth;
} else {
overlay_x = (ui_view.GetWidth() - bigx) - get_fixed_pixel_size(5);
}
} else {
overlay_x = (xx + widd - bigx) - get_fixed_pixel_size(5);
tdxp = xx;
}
tdxp += get_textwindow_border_width(_GP(play).speech_textwindow_gui) / 2;
allowShrink = 2;
}
if (_GP(game).options[OPT_SPEECHTYPE] == 3)
overlay_x = 0;
_G(face_talking) = add_screen_overlay(false, overlay_x, ovr_yp, ovr_type, closeupface, closeupface_has_alpha);
_G(facetalkview) = useview;
_G(facetalkloop) = 0;
_G(facetalkframe) = 0;
_G(facetalkwait) = viptr->loops[0].frames[0].speed + GetCharacterSpeechAnimationDelay(speakingChar);
_G(facetalkrepeat) = (isThought) ? 0 : 1;
_G(facetalkBlinkLoop) = 0;
_G(facetalkAllowBlink) = 1;
if ((isThought) && (speakingChar->flags & CHF_NOBLINKANDTHINK))
_G(facetalkAllowBlink) = 0;
_G(facetalkchar) = &_GP(game).chars[aschar];
if (_G(facetalkchar)->blinktimer < 0)
_G(facetalkchar)->blinktimer = _G(facetalkchar)->blinkinterval;
textcol = -textcol;
overlayPositionFixed = true;
// Process the first portrait view frame
const int frame_vol = _GP(charextra)[_G(facetalkchar)->index_id].GetFrameSoundVolume(_G(facetalkchar));
CheckViewFrame(_G(facetalkview), _G(facetalkloop), _G(facetalkframe), frame_vol);
} else if (useview >= 0) {
// Lucasarts-style speech
set_our_eip(154);
oldview = speakingChar->view;
oldloop = speakingChar->loop;
speakingChar->set_animating(!isThought, // only repeat if speech, not thought
true, // always forwards
GetCharacterSpeechAnimationDelay(speakingChar));
speakingChar->view = useview;
speakingChar->frame = 0;
speakingChar->flags |= CHF_FIXVIEW;
if ((speakingChar->view < 0) || _GP(views)[speakingChar->view].numLoops == 0)
quitprintf("!Character %s speech view %d is invalid, or has no loops.", speakingChar->scrname, speakingChar->view + 1);
// If speech view is missing a loop - use loop 0
if (speakingChar->loop >= _GP(views)[speakingChar->view].numLoops) {
debug_script_warn("WARNING: Character %s speech view %d does not have necessary loop %d; switching to loop 0.",
speakingChar->scrname, speakingChar->view + 1, speakingChar->loop);
speakingChar->loop = 0;
}
_G(facetalkBlinkLoop) = speakingChar->loop;
// set up the speed of the first frame
speakingChar->wait = GetCharacterSpeechAnimationDelay(speakingChar) +
_GP(views)[speakingChar->view].loops[speakingChar->loop].frames[0].speed;
if (widd < 0) {
bwidth = ui_view.GetWidth() / 2 + ui_view.GetWidth() / 6;
// If they are close to the screen edge, make the text narrower
int relx = _GP(play).RoomToScreenX(data_to_game_coord(speakingChar->x));
if ((relx < ui_view.GetWidth() / 4) || (relx > ui_view.GetWidth() - (ui_view.GetWidth() / 4)))
bwidth -= ui_view.GetWidth() / 5;
}
/* this causes the text to bob up and down as they talk
tdxp = OVR_AUTOPLACE;
tdyp = aschar;*/
if (!isThought) // set up the lip sync if not thinking
_G(char_speaking) = aschar;
}
} else
allowShrink = 1;
// it wants the centred position, so make it so
if ((xx >= 0) && (tdxp < 0))
tdxp -= widd / 2;
// if they used DisplaySpeechAt, then use the supplied width
if ((widd > 0) && (isThought == 0))
allowShrink = 0;
if (isThought)
_G(char_thinking) = aschar;
set_our_eip(155);
display_main(tdxp, tdyp, bwidth, texx, DISPLAYTEXT_SPEECH, FONT_SPEECH, textcol, isThought, allowShrink, overlayPositionFixed);
if (_G(abort_engine))
return;
set_our_eip(156);
if ((_GP(play).in_conversation > 0) && (_GP(game).options[OPT_SPEECHTYPE] == 3))
closeupface = nullptr;
if (closeupface != nullptr)
remove_screen_overlay(ovr_type);
mark_screen_dirty();
_G(face_talking) = -1;
_G(facetalkchar) = nullptr;
set_our_eip(157);
if (oldview >= 0) {
speakingChar->flags &= ~CHF_FIXVIEW;
if (viewWasLocked)
speakingChar->flags |= CHF_FIXVIEW;
speakingChar->view = oldview;
// Don't reset the loop in 2.x games
if (_G(loaded_game_file_version) > kGameVersion_272)
speakingChar->loop = oldloop;
stop_character_anim(speakingChar);
speakingChar->frame = charFrameWas;
speakingChar->wait = 0;
speakingChar->idleleft = speakingChar->idletime;
// restart the idle animation straight away
_GP(charextra)[aschar].process_idle_this_time = 1;
}
_G(char_speaking) = -1;
_G(char_thinking) = -1;
// Stop any blocking voice-over, if was started by this function
if (_GP(play).IsBlockingVoiceSpeech())
stop_voice_speech();
}
int get_character_currently_talking() {
if ((_G(face_talking) >= 0) && (_G(facetalkrepeat)))
return _G(facetalkchar)->index_id;
else if (_G(char_speaking) >= 0)
return _G(char_speaking);
return -1;
}
void DisplaySpeech(const char *texx, int aschar) {
_displayspeech(texx, aschar, -1, -1, -1, 0);
}
// Calculate which frame of the loop to use for this character of
// speech
int GetLipSyncFrame(const char *curtex, int *stroffs) {
/*char *frameletters[MAXLIPSYNCFRAMES] =
{"./,/ ", "A", "O", "F/V", "D/N/G/L/R", "B/P/M",
"Y/H/K/Q/C", "I/T/E/X/th", "U/W", "S/Z/J/ch", NULL,
NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};*/
int bestfit_len = 0, bestfit = _GP(game).default_lipsync_frame;
for (int aa = 0; aa < MAXLIPSYNCFRAMES; aa++) {
char *tptr = _GP(game).lipSyncFrameLetters[aa];
while (tptr[0] != 0) {
int lenthisbit = strlen(tptr);
if (strchr(tptr, '/'))
lenthisbit = strchr(tptr, '/') - tptr;
if ((ags_strnicmp(curtex, tptr, lenthisbit) == 0) && (lenthisbit > bestfit_len)) {
bestfit = aa;
bestfit_len = lenthisbit;
}
tptr += lenthisbit;
while (tptr[0] == '/')
tptr++;
}
}
// If it's an unknown character, use the default frame
if (bestfit_len == 0)
bestfit_len = 1;
*stroffs += bestfit_len;
return bestfit;
}
int update_lip_sync(int talkview, int talkloop, int *talkframeptr) {
int talkframe = talkframeptr[0];
int talkwait = 0;
// lip-sync speech
const char *nowsaying = &_G(text_lips_text)[_G(text_lips_offset)];
// if it's an apostraphe, skip it (we'll, I'll, etc)
if (nowsaying[0] == '\'') {
_G(text_lips_offset)++;
nowsaying++;
}
if (_G(text_lips_offset) >= (int)strlen(_G(text_lips_text)))
talkframe = 0;
else {
talkframe = GetLipSyncFrame(nowsaying, &_G(text_lips_offset));
if (talkframe >= _GP(views)[talkview].loops[talkloop].numFrames)
talkframe = 0;
}
talkwait = _G(loops_per_character) + _GP(views)[talkview].loops[talkloop].frames[talkframe].speed;
talkframeptr[0] = talkframe;
return talkwait;
}
void restore_characters() {
for (int i = 0; i < _GP(game).numcharacters; ++i) {
_GP(charextra)[i].zoom_offs = (_GP(game).options[OPT_SCALECHAROFFSETS] != 0) ? _GP(charextra)[i].zoom : 100;
}
}
Rect GetCharacterRoomBBox(int charid, bool use_frame_0) {
int width, height;
const CharacterExtras &chex = _GP(charextra)[charid];
const CharacterInfo &chin = _GP(game).chars[charid];
int frame = use_frame_0 ? 0 : chin.frame;
int pic = _GP(views)[chin.view].loops[chin.loop].frames[frame].pic;
scale_sprite_size(pic, chex.zoom, &width, &height);
return RectWH(chin.x - width / 2, chin.y - height, width, height);
}
PViewport FindNearestViewport(int charid) {
Rect bbox = GetCharacterRoomBBox(charid, true);
float min_dist = -1.f;
PViewport nearest_view;
for (int i = 0; i < _GP(play).GetRoomViewportCount(); ++i) {
auto view = _GP(play).GetRoomViewport(i);
if (!view->IsVisible())
continue;
auto cam = view->GetCamera();
if (!cam)
continue;
Rect camr = cam->GetRect();
float dist = DistanceBetween(bbox, camr);
if (dist == 0.f)
return view;
if (min_dist < 0.f || dist < min_dist) {
min_dist = dist;
nearest_view = view;
}
}
return nearest_view ? nearest_view : _GP(play).GetRoomViewport(0);
}
//=============================================================================
//
// Script API Functions
//
//=============================================================================
CharacterInfo *Character_GetByName(const char *name) {
return static_cast(ccGetScriptObjectAddress(name, _GP(ccDynamicCharacter).GetType()));
}
RuntimeScriptValue Sc_Character_GetByName(const RuntimeScriptValue *params, int32_t param_count) {
API_SCALL_OBJ_POBJ(CharacterInfo, _GP(ccDynamicCharacter), Character_GetByName, const char);
}
// void | CharacterInfo *chaa, ScriptInvItem *invi, int addIndex
RuntimeScriptValue Sc_Character_AddInventory(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_POBJ_PINT(CharacterInfo, Character_AddInventory, ScriptInvItem);
}
// void | CharacterInfo *chaa, int x, int y
RuntimeScriptValue Sc_Character_AddWaypoint(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT2(CharacterInfo, Character_AddWaypoint);
}
// void | CharacterInfo *chaa, int loop, int delay, int repeat, int blocking, int direction
RuntimeScriptValue Sc_Character_Animate5(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT5(CharacterInfo, Character_Animate5);
}
RuntimeScriptValue Sc_Character_Animate6(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT6(CharacterInfo, Character_Animate6);
}
RuntimeScriptValue Sc_Character_Animate(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT7(CharacterInfo, Character_Animate);
}
// void | CharacterInfo *chaa, int room, int x, int y
RuntimeScriptValue Sc_Character_ChangeRoom(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT3(CharacterInfo, Character_ChangeRoom);
}
RuntimeScriptValue Sc_Character_ChangeRoomSetLoop(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT4(CharacterInfo, Character_ChangeRoomSetLoop);
}
// void | CharacterInfo *chaa, int room, int newPos
RuntimeScriptValue Sc_Character_ChangeRoomAutoPosition(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT2(CharacterInfo, Character_ChangeRoomAutoPosition);
}
// void | CharacterInfo *chap, int vii
RuntimeScriptValue Sc_Character_ChangeView(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_ChangeView);
}
// void | CharacterInfo *char1, CharacterInfo *char2, int blockingStyle
RuntimeScriptValue Sc_Character_FaceCharacter(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_POBJ_PINT(CharacterInfo, Character_FaceCharacter, CharacterInfo);
}
// void | CharacterInfo *char1, int direction, int blockingStyle
RuntimeScriptValue Sc_Character_FaceDirection(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT2(CharacterInfo, Character_FaceDirection);
}
// void | CharacterInfo *char1, int xx, int yy, int blockingStyle
RuntimeScriptValue Sc_Character_FaceLocation(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT3(CharacterInfo, Character_FaceLocation);
}
// void | CharacterInfo *char1, ScriptObject *obj, int blockingStyle
RuntimeScriptValue Sc_Character_FaceObject(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_POBJ_PINT(CharacterInfo, Character_FaceObject, ScriptObject);
}
// void | CharacterInfo *chaa, CharacterInfo *tofollow, int distaway, int eagerness
RuntimeScriptValue Sc_Character_FollowCharacter(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_POBJ_PINT2(CharacterInfo, Character_FollowCharacter, CharacterInfo);
}
// int (CharacterInfo *chaa, const char *property)
RuntimeScriptValue Sc_Character_GetProperty(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT_POBJ(CharacterInfo, Character_GetProperty, const char);
}
// void (CharacterInfo *chaa, const char *property, char *bufer)
RuntimeScriptValue Sc_Character_GetPropertyText(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_POBJ2(CharacterInfo, Character_GetPropertyText, const char, char);
}
// const char* (CharacterInfo *chaa, const char *property)
RuntimeScriptValue Sc_Character_GetTextProperty(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_OBJ_POBJ(CharacterInfo, const char, _GP(myScriptStringImpl), Character_GetTextProperty, const char);
}
RuntimeScriptValue Sc_Character_SetProperty(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_BOOL_POBJ_PINT(CharacterInfo, Character_SetProperty, const char);
}
RuntimeScriptValue Sc_Character_SetTextProperty(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_BOOL_POBJ2(CharacterInfo, Character_SetTextProperty, const char, const char);
}
// int (CharacterInfo *chaa, ScriptInvItem *invi)
RuntimeScriptValue Sc_Character_HasInventory(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT_POBJ(CharacterInfo, Character_HasInventory, ScriptInvItem);
}
// int (CharacterInfo *char1, CharacterInfo *char2)
RuntimeScriptValue Sc_Character_IsCollidingWithChar(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT_POBJ(CharacterInfo, Character_IsCollidingWithChar, CharacterInfo);
}
// int (CharacterInfo *chin, ScriptObject *objid)
RuntimeScriptValue Sc_Character_IsCollidingWithObject(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT_POBJ(CharacterInfo, Character_IsCollidingWithObject, ScriptObject);
}
RuntimeScriptValue Sc_Character_IsInteractionAvailable(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_BOOL_PINT(CharacterInfo, Character_IsInteractionAvailable);
}
// void (CharacterInfo *chap, int vii)
RuntimeScriptValue Sc_Character_LockView(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_LockView);
}
// void (CharacterInfo *chap, int vii, int stopMoving)
RuntimeScriptValue Sc_Character_LockViewEx(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT2(CharacterInfo, Character_LockViewEx);
}
// void (CharacterInfo *chap, int vii, int loop, int align)
RuntimeScriptValue Sc_Character_LockViewAligned_Old(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT3(CharacterInfo, Character_LockViewAligned_Old);
}
// void (CharacterInfo *chap, int vii, int loop, int align, int stopMoving)
RuntimeScriptValue Sc_Character_LockViewAlignedEx_Old(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT4(CharacterInfo, Character_LockViewAlignedEx_Old);
}
RuntimeScriptValue Sc_Character_LockViewAligned(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT3(CharacterInfo, Character_LockViewAligned);
}
RuntimeScriptValue Sc_Character_LockViewAlignedEx(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT4(CharacterInfo, Character_LockViewAlignedEx);
}
// void (CharacterInfo *chaa, int view, int loop, int frame)
RuntimeScriptValue Sc_Character_LockViewFrame(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT3(CharacterInfo, Character_LockViewFrame);
}
// void (CharacterInfo *chaa, int view, int loop, int frame, int stopMoving)
RuntimeScriptValue Sc_Character_LockViewFrameEx(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT4(CharacterInfo, Character_LockViewFrameEx);
}
// void (CharacterInfo *chap, int vii, int xoffs, int yoffs)
RuntimeScriptValue Sc_Character_LockViewOffset(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT3(CharacterInfo, Character_LockViewOffset);
}
// void (CharacterInfo *chap, int vii, int xoffs, int yoffs, int stopMoving)
RuntimeScriptValue Sc_Character_LockViewOffsetEx(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT4(CharacterInfo, Character_LockViewOffsetEx);
}
// void (CharacterInfo *chap, ScriptInvItem *invi)
RuntimeScriptValue Sc_Character_LoseInventory(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_POBJ(CharacterInfo, Character_LoseInventory, ScriptInvItem);
}
// void (CharacterInfo *chaa, int x, int y, int blocking, int direct)
RuntimeScriptValue Sc_Character_Move(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT4(CharacterInfo, Character_Move);
}
// void (CharacterInfo *chap)
RuntimeScriptValue Sc_Character_PlaceOnWalkableArea(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID(CharacterInfo, Character_PlaceOnWalkableArea);
}
// void (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_RemoveTint(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID(CharacterInfo, Character_RemoveTint);
}
// void (CharacterInfo *chaa, int mood)
RuntimeScriptValue Sc_Character_RunInteraction(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_RunInteraction);
}
// void (CharacterInfo *chaa, const char *texx, ...)
RuntimeScriptValue Sc_Character_Say(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_SCRIPT_SPRINTF(Character_Say, 1);
Character_Say((CharacterInfo *)self, scsf_buffer);
return RuntimeScriptValue((int32_t)0);
}
RuntimeScriptValue Sc_Character_SayAt(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_SCRIPT_SPRINTF(Character_SayAt, 4);
Character_SayAt((CharacterInfo *)self, params[0].IValue, params[1].IValue, params[2].IValue, scsf_buffer);
return RuntimeScriptValue((int32_t)0);
}
RuntimeScriptValue Sc_Character_SayBackground(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_SCRIPT_SPRINTF(Character_SayBackground, 1);
auto *ret_obj = Character_SayBackground((CharacterInfo *)self, scsf_buffer);
return RuntimeScriptValue().SetScriptObject(ret_obj, ret_obj);
}
// void (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_SetAsPlayer(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID(CharacterInfo, Character_SetAsPlayer);
}
// void (CharacterInfo *chaa, int iview, int itime)
RuntimeScriptValue Sc_Character_SetIdleView(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT2(CharacterInfo, Character_SetIdleView);
}
RuntimeScriptValue Sc_Character_GetHasExplicitLight(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_BOOL(CharacterInfo, Character_GetHasExplicitLight);
}
RuntimeScriptValue Sc_Character_GetLightLevel(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetLightLevel);
}
RuntimeScriptValue Sc_Character_SetLightLevel(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetLightLevel);
}
RuntimeScriptValue Sc_Character_GetTintBlue(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetTintBlue);
}
RuntimeScriptValue Sc_Character_GetTintGreen(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetTintGreen);
}
RuntimeScriptValue Sc_Character_GetTintRed(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetTintRed);
}
RuntimeScriptValue Sc_Character_GetTintSaturation(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetTintSaturation);
}
RuntimeScriptValue Sc_Character_GetTintLuminance(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetTintLuminance);
}
// void (CharacterInfo *chaa, int xspeed, int yspeed)
RuntimeScriptValue Sc_Character_SetSpeed(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT2(CharacterInfo, Character_SetSpeed);
}
// void (CharacterInfo *charp)
RuntimeScriptValue Sc_Character_StopMoving(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID(CharacterInfo, Character_StopMoving);
}
// void (CharacterInfo *chaa, const char *texx, ...)
RuntimeScriptValue Sc_Character_Think(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_SCRIPT_SPRINTF(Character_Think, 1);
Character_Think((CharacterInfo *)self, scsf_buffer);
return RuntimeScriptValue((int32_t)0);
}
//void (CharacterInfo *chaa, int red, int green, int blue, int opacity, int luminance)
RuntimeScriptValue Sc_Character_Tint(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT5(CharacterInfo, Character_Tint);
}
// void (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_UnlockView(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID(CharacterInfo, Character_UnlockView);
}
// void (CharacterInfo *chaa, int stopMoving)
RuntimeScriptValue Sc_Character_UnlockViewEx(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_UnlockViewEx);
}
// void (CharacterInfo *chaa, int x, int y, int blocking, int direct)
RuntimeScriptValue Sc_Character_Walk(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT4(CharacterInfo, Character_Walk);
}
// void (CharacterInfo *chaa, int xx, int yy, int blocking)
RuntimeScriptValue Sc_Character_WalkStraight(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT3(CharacterInfo, Character_WalkStraight);
}
RuntimeScriptValue Sc_GetCharacterAtRoom(const RuntimeScriptValue *params, int32_t param_count) {
API_SCALL_OBJ_PINT2(CharacterInfo, _GP(ccDynamicCharacter), GetCharacterAtRoom);
}
// CharacterInfo *(int xx, int yy)
RuntimeScriptValue Sc_GetCharacterAtScreen(const RuntimeScriptValue *params, int32_t param_count) {
API_SCALL_OBJ_PINT2(CharacterInfo, _GP(ccDynamicCharacter), GetCharacterAtScreen);
}
// ScriptInvItem* (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetActiveInventory(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_OBJ(CharacterInfo, ScriptInvItem, _GP(ccDynamicInv), Character_GetActiveInventory);
}
// void (CharacterInfo *chaa, ScriptInvItem* iit)
RuntimeScriptValue Sc_Character_SetActiveInventory(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_POBJ(CharacterInfo, Character_SetActiveInventory, ScriptInvItem);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetAnimating(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetAnimating);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetAnimationSpeed(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetAnimationSpeed);
}
// void (CharacterInfo *chaa, int newval)
RuntimeScriptValue Sc_Character_SetAnimationSpeed(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetAnimationSpeed);
}
RuntimeScriptValue Sc_Character_GetAnimationVolume(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetAnimationVolume);
}
RuntimeScriptValue Sc_Character_SetAnimationVolume(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetAnimationVolume);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetBaseline(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetBaseline);
}
// void (CharacterInfo *chaa, int basel)
RuntimeScriptValue Sc_Character_SetBaseline(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetBaseline);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetBlinkInterval(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetBlinkInterval);
}
// void (CharacterInfo *chaa, int interval)
RuntimeScriptValue Sc_Character_SetBlinkInterval(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetBlinkInterval);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetBlinkView(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetBlinkView);
}
// void (CharacterInfo *chaa, int vii)
RuntimeScriptValue Sc_Character_SetBlinkView(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetBlinkView);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetBlinkWhileThinking(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetBlinkWhileThinking);
}
// void (CharacterInfo *chaa, int yesOrNo)
RuntimeScriptValue Sc_Character_SetBlinkWhileThinking(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetBlinkWhileThinking);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetBlockingHeight(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetBlockingHeight);
}
// void (CharacterInfo *chaa, int hit)
RuntimeScriptValue Sc_Character_SetBlockingHeight(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetBlockingHeight);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetBlockingWidth(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetBlockingWidth);
}
// void (CharacterInfo *chaa, int wid)
RuntimeScriptValue Sc_Character_SetBlockingWidth(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetBlockingWidth);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetClickable(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetClickable);
}
// void (CharacterInfo *chaa, int clik)
RuntimeScriptValue Sc_Character_SetClickable(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetClickable);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetDiagonalWalking(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetDiagonalWalking);
}
// void (CharacterInfo *chaa, int yesorno)
RuntimeScriptValue Sc_Character_SetDiagonalWalking(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetDiagonalWalking);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetFrame(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetFrame);
}
// void (CharacterInfo *chaa, int newval)
RuntimeScriptValue Sc_Character_SetFrame(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetFrame);
}
RuntimeScriptValue Sc_Character_GetHasExplicitTint_Old(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetHasExplicitTint_Old);
}
RuntimeScriptValue Sc_Character_GetHasExplicitTint(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetHasExplicitTint);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetID(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetID);
}
RuntimeScriptValue Sc_Character_GetScriptName(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_OBJ(CharacterInfo, const char, _GP(myScriptStringImpl), Character_GetScriptName);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetIdleView(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetIdleView);
}
// int (CharacterInfo *chaa, int index)
RuntimeScriptValue Sc_Character_GetIInventoryQuantity(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT_PINT(CharacterInfo, Character_GetIInventoryQuantity);
}
// void (CharacterInfo *chaa, int index, int quant)
RuntimeScriptValue Sc_Character_SetIInventoryQuantity(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT2(CharacterInfo, Character_SetIInventoryQuantity);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetIgnoreLighting(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetIgnoreLighting);
}
// void (CharacterInfo *chaa, int yesorno)
RuntimeScriptValue Sc_Character_SetIgnoreLighting(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetIgnoreLighting);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetIgnoreScaling(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetIgnoreScaling);
}
// void (CharacterInfo *chaa, int yesorno)
RuntimeScriptValue Sc_Character_SetIgnoreScaling(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetIgnoreScaling);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetIgnoreWalkbehinds(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetIgnoreWalkbehinds);
}
// void (CharacterInfo *chaa, int yesorno)
RuntimeScriptValue Sc_Character_SetIgnoreWalkbehinds(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetIgnoreWalkbehinds);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetLoop(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetLoop);
}
// void (CharacterInfo *chaa, int newval)
RuntimeScriptValue Sc_Character_SetLoop(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetLoop);
}
// void (CharacterInfo *chaa, int yesorno)
RuntimeScriptValue Sc_Character_SetManualScaling(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetManualScaling);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetMovementLinkedToAnimation(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetMovementLinkedToAnimation);
}
// void (CharacterInfo *chaa, int yesorno)
RuntimeScriptValue Sc_Character_SetMovementLinkedToAnimation(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetMovementLinkedToAnimation);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetMoving(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetMoving);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetDestinationX(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetDestinationX);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetDestinationY(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetDestinationY);
}
// const char* (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetName(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_OBJ(CharacterInfo, const char, _GP(myScriptStringImpl), Character_GetName);
}
// void (CharacterInfo *chaa, const char *newName)
RuntimeScriptValue Sc_Character_SetName(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_POBJ(CharacterInfo, Character_SetName, const char);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetNormalView(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetNormalView);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetPreviousRoom(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetPreviousRoom);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetRoom(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetRoom);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetScaleMoveSpeed(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetScaleMoveSpeed);
}
// void (CharacterInfo *chaa, int yesorno)
RuntimeScriptValue Sc_Character_SetScaleMoveSpeed(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetScaleMoveSpeed);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetScaleVolume(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetScaleVolume);
}
// void (CharacterInfo *chaa, int yesorno)
RuntimeScriptValue Sc_Character_SetScaleVolume(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetScaleVolume);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetScaling(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetScaling);
}
// void (CharacterInfo *chaa, int zoomlevel)
RuntimeScriptValue Sc_Character_SetScaling(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetScaling);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetSolid(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetSolid);
}
// void (CharacterInfo *chaa, int yesorno)
RuntimeScriptValue Sc_Character_SetSolid(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetSolid);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetSpeaking(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetSpeaking);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetSpeakingFrame(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetSpeakingFrame);
}
// int (CharacterInfo *cha)
RuntimeScriptValue Sc_GetCharacterSpeechAnimationDelay(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, GetCharacterSpeechAnimationDelay);
}
// void (CharacterInfo *chaa, int newDelay)
RuntimeScriptValue Sc_Character_SetSpeechAnimationDelay(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetSpeechAnimationDelay);
}
RuntimeScriptValue Sc_Character_GetIdleAnimationDelay(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetIdleAnimationDelay);
}
// void (CharacterInfo *chaa, int newDelay)
RuntimeScriptValue Sc_Character_SetIdleAnimationDelay(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetIdleAnimationDelay);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetSpeechColor(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetSpeechColor);
}
// void (CharacterInfo *chaa, int ncol)
RuntimeScriptValue Sc_Character_SetSpeechColor(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetSpeechColor);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetSpeechView(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetSpeechView);
}
// void (CharacterInfo *chaa, int vii)
RuntimeScriptValue Sc_Character_SetSpeechView(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetSpeechView);
}
RuntimeScriptValue Sc_Character_GetThinking(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_BOOL(CharacterInfo, Character_GetThinking);
}
RuntimeScriptValue Sc_Character_GetThinkingFrame(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetThinkingFrame);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetThinkView(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetThinkView);
}
// void (CharacterInfo *chaa, int vii)
RuntimeScriptValue Sc_Character_SetThinkView(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetThinkView);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetTransparency(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetTransparency);
}
// void (CharacterInfo *chaa, int trans)
RuntimeScriptValue Sc_Character_SetTransparency(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetTransparency);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetTurnBeforeWalking(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetTurnBeforeWalking);
}
// void (CharacterInfo *chaa, int yesorno)
RuntimeScriptValue Sc_Character_SetTurnBeforeWalking(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetTurnBeforeWalking);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetView(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetView);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetWalkSpeedX(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetWalkSpeedX);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetWalkSpeedY(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetWalkSpeedY);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetX(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetX);
}
// void (CharacterInfo *chaa, int newval)
RuntimeScriptValue Sc_Character_SetX(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetX);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetY(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetY);
}
// void (CharacterInfo *chaa, int newval)
RuntimeScriptValue Sc_Character_SetY(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetY);
}
// int (CharacterInfo *chaa)
RuntimeScriptValue Sc_Character_GetZ(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_INT(CharacterInfo, Character_GetZ);
}
// void (CharacterInfo *chaa, int newval)
RuntimeScriptValue Sc_Character_SetZ(void *self, const RuntimeScriptValue *params, int32_t param_count) {
API_OBJCALL_VOID_PINT(CharacterInfo, Character_SetZ);
}
//=============================================================================
//
// Exclusive variadic API implementation for Plugins
//
//=============================================================================
void ScPl_Character_Say(CharacterInfo *chaa, const char *texx, ...) {
API_PLUGIN_SCRIPT_SPRINTF(texx);
Character_Say(chaa, scsf_buffer);
}
void ScPl_Character_SayAt(CharacterInfo *chaa, int x, int y, int width, const char *texx, ...) {
API_PLUGIN_SCRIPT_SPRINTF(texx);
Character_SayAt(chaa, x, y, width, scsf_buffer);
}
ScriptOverlay *ScPl_Character_SayBackground(CharacterInfo *chaa, const char *texx, ...) {
API_PLUGIN_SCRIPT_SPRINTF(texx);
return Character_SayBackground(chaa, scsf_buffer);
}
void ScPl_Character_Think(CharacterInfo *chaa, const char *texx, ...) {
API_PLUGIN_SCRIPT_SPRINTF(texx);
Character_Think(chaa, scsf_buffer);
}
void RegisterCharacterAPI(ScriptAPIVersion base_api, ScriptAPIVersion /* compat_api */) {
ScFnRegister character_api[] = {
{"Character::GetAtRoomXY^2", API_FN_PAIR(GetCharacterAtRoom)},
{"Character::GetAtScreenXY^2", API_FN_PAIR(GetCharacterAtScreen)},
{"Character::GetByName", API_FN_PAIR(Character_GetByName)},
{"Character::AddInventory^2", API_FN_PAIR(Character_AddInventory)},
{"Character::AddWaypoint^2", API_FN_PAIR(Character_AddWaypoint)},
{"Character::Animate^5", API_FN_PAIR(Character_Animate5)},
{"Character::Animate^6", API_FN_PAIR(Character_Animate6)},
{"Character::Animate^7", API_FN_PAIR(Character_Animate)},
{"Character::ChangeRoom^3", API_FN_PAIR(Character_ChangeRoom)},
{"Character::ChangeRoom^4", API_FN_PAIR(Character_ChangeRoomSetLoop)},
{"Character::ChangeRoomAutoPosition^2", API_FN_PAIR(Character_ChangeRoomAutoPosition)},
{"Character::ChangeView^1", API_FN_PAIR(Character_ChangeView)},
{"Character::FaceCharacter^2", API_FN_PAIR(Character_FaceCharacter)},
{"Character::FaceDirection^2", API_FN_PAIR(Character_FaceDirection)},
{"Character::FaceLocation^3", API_FN_PAIR(Character_FaceLocation)},
{"Character::FaceObject^2", API_FN_PAIR(Character_FaceObject)},
{"Character::FollowCharacter^3", API_FN_PAIR(Character_FollowCharacter)},
{"Character::GetProperty^1", API_FN_PAIR(Character_GetProperty)},
{"Character::GetPropertyText^2", API_FN_PAIR(Character_GetPropertyText)},
{"Character::GetTextProperty^1", API_FN_PAIR(Character_GetTextProperty)},
{"Character::SetProperty^2", API_FN_PAIR(Character_SetProperty)},
{"Character::SetTextProperty^2", API_FN_PAIR(Character_SetTextProperty)},
{"Character::HasInventory^1", API_FN_PAIR(Character_HasInventory)},
{"Character::IsCollidingWithChar^1", API_FN_PAIR(Character_IsCollidingWithChar)},
{"Character::IsCollidingWithObject^1", API_FN_PAIR(Character_IsCollidingWithObject)},
{"Character::IsInteractionAvailable^1", API_FN_PAIR(Character_IsInteractionAvailable)},
{"Character::LockView^1", API_FN_PAIR(Character_LockView)},
{"Character::LockView^2", API_FN_PAIR(Character_LockViewEx)},
{"Character::LockViewFrame^3", API_FN_PAIR(Character_LockViewFrame)},
{"Character::LockViewFrame^4", API_FN_PAIR(Character_LockViewFrameEx)},
{"Character::LockViewOffset^3", API_FN_PAIR(Character_LockViewOffset)},
{"Character::LockViewOffset^4", API_FN_PAIR(Character_LockViewOffsetEx)},
{"Character::LoseInventory^1", API_FN_PAIR(Character_LoseInventory)},
{"Character::Move^4", API_FN_PAIR(Character_Move)},
{"Character::PlaceOnWalkableArea^0", API_FN_PAIR(Character_PlaceOnWalkableArea)},
{"Character::RemoveTint^0", API_FN_PAIR(Character_RemoveTint)},
{"Character::RunInteraction^1", API_FN_PAIR(Character_RunInteraction)},
{"Character::Say^101", Sc_Character_Say},
// old non-variadic variants
{"Character::SayAt^4", API_FN_PAIR(Character_SayAt)},
{"Character::SayBackground^1", API_FN_PAIR(Character_SayBackground)},
// newer variadic variants
{"Character::SayAt^104", Sc_Character_SayAt},
{"Character::SayBackground^101", Sc_Character_SayBackground},
{"Character::SetAsPlayer^0", API_FN_PAIR(Character_SetAsPlayer)},
{"Character::SetIdleView^2", API_FN_PAIR(Character_SetIdleView)},
{"Character::SetLightLevel^1", API_FN_PAIR(Character_SetLightLevel)},
{"Character::SetWalkSpeed^2", API_FN_PAIR(Character_SetSpeed)},
{"Character::StopMoving^0", API_FN_PAIR(Character_StopMoving)},
{"Character::Think^101", Sc_Character_Think},
{"Character::Tint^5", API_FN_PAIR(Character_Tint)},
{"Character::UnlockView^0", API_FN_PAIR(Character_UnlockView)},
{"Character::UnlockView^1", API_FN_PAIR(Character_UnlockViewEx)},
{"Character::Walk^4", API_FN_PAIR(Character_Walk)},
{"Character::WalkStraight^3", API_FN_PAIR(Character_WalkStraight)},
{"Character::get_ActiveInventory", API_FN_PAIR(Character_GetActiveInventory)},
{"Character::set_ActiveInventory", API_FN_PAIR(Character_SetActiveInventory)},
{"Character::get_Animating", API_FN_PAIR(Character_GetAnimating)},
{"Character::get_AnimationSpeed", API_FN_PAIR(Character_GetAnimationSpeed)},
{"Character::set_AnimationSpeed", API_FN_PAIR(Character_SetAnimationSpeed)},
{"Character::get_AnimationVolume", API_FN_PAIR(Character_GetAnimationVolume)},
{"Character::set_AnimationVolume", API_FN_PAIR(Character_SetAnimationVolume)},
{"Character::get_Baseline", API_FN_PAIR(Character_GetBaseline)},
{"Character::set_Baseline", API_FN_PAIR(Character_SetBaseline)},
{"Character::get_BlinkInterval", API_FN_PAIR(Character_GetBlinkInterval)},
{"Character::set_BlinkInterval", API_FN_PAIR(Character_SetBlinkInterval)},
{"Character::get_BlinkView", API_FN_PAIR(Character_GetBlinkView)},
{"Character::set_BlinkView", API_FN_PAIR(Character_SetBlinkView)},
{"Character::get_BlinkWhileThinking", API_FN_PAIR(Character_GetBlinkWhileThinking)},
{"Character::set_BlinkWhileThinking", API_FN_PAIR(Character_SetBlinkWhileThinking)},
{"Character::get_BlockingHeight", API_FN_PAIR(Character_GetBlockingHeight)},
{"Character::set_BlockingHeight", API_FN_PAIR(Character_SetBlockingHeight)},
{"Character::get_BlockingWidth", API_FN_PAIR(Character_GetBlockingWidth)},
{"Character::set_BlockingWidth", API_FN_PAIR(Character_SetBlockingWidth)},
{"Character::get_Clickable", API_FN_PAIR(Character_GetClickable)},
{"Character::set_Clickable", API_FN_PAIR(Character_SetClickable)},
{"Character::get_DestinationX", API_FN_PAIR(Character_GetDestinationX)},
{"Character::get_DestinationY", API_FN_PAIR(Character_GetDestinationY)},
{"Character::get_DiagonalLoops", API_FN_PAIR(Character_GetDiagonalWalking)},
{"Character::set_DiagonalLoops", API_FN_PAIR(Character_SetDiagonalWalking)},
{"Character::get_Frame", API_FN_PAIR(Character_GetFrame)},
{"Character::set_Frame", API_FN_PAIR(Character_SetFrame)},
{"Character::get_ID", API_FN_PAIR(Character_GetID)},
{"Character::get_IdleView", API_FN_PAIR(Character_GetIdleView)},
{"Character::get_IdleAnimationDelay", API_FN_PAIR(Character_GetIdleAnimationDelay)},
{"Character::set_IdleAnimationDelay", API_FN_PAIR(Character_SetIdleAnimationDelay)},
{"Character::geti_InventoryQuantity", API_FN_PAIR(Character_GetIInventoryQuantity)},
{"Character::seti_InventoryQuantity", API_FN_PAIR(Character_SetIInventoryQuantity)},
{"Character::get_IgnoreLighting", API_FN_PAIR(Character_GetIgnoreLighting)},
{"Character::set_IgnoreLighting", API_FN_PAIR(Character_SetIgnoreLighting)},
{"Character::get_IgnoreScaling", API_FN_PAIR(Character_GetIgnoreScaling)},
{"Character::set_IgnoreScaling", API_FN_PAIR(Character_SetIgnoreScaling)},
{"Character::get_IgnoreWalkbehinds", API_FN_PAIR(Character_GetIgnoreWalkbehinds)},
{"Character::set_IgnoreWalkbehinds", API_FN_PAIR(Character_SetIgnoreWalkbehinds)},
{"Character::get_Loop", API_FN_PAIR(Character_GetLoop)},
{"Character::set_Loop", API_FN_PAIR(Character_SetLoop)},
{"Character::get_ManualScaling", API_FN_PAIR(Character_GetIgnoreScaling)},
{"Character::set_ManualScaling", API_FN_PAIR(Character_SetManualScaling)},
{"Character::get_MovementLinkedToAnimation", API_FN_PAIR(Character_GetMovementLinkedToAnimation)},
{"Character::set_MovementLinkedToAnimation", API_FN_PAIR(Character_SetMovementLinkedToAnimation)},
{"Character::get_Moving", API_FN_PAIR(Character_GetMoving)},
{"Character::get_Name", API_FN_PAIR(Character_GetName)},
{"Character::set_Name", API_FN_PAIR(Character_SetName)},
{"Character::get_NormalView", API_FN_PAIR(Character_GetNormalView)},
{"Character::get_PreviousRoom", API_FN_PAIR(Character_GetPreviousRoom)},
{"Character::get_Room", API_FN_PAIR(Character_GetRoom)},
{"Character::get_ScaleMoveSpeed", API_FN_PAIR(Character_GetScaleMoveSpeed)},
{"Character::set_ScaleMoveSpeed", API_FN_PAIR(Character_SetScaleMoveSpeed)},
{"Character::get_ScaleVolume", API_FN_PAIR(Character_GetScaleVolume)},
{"Character::set_ScaleVolume", API_FN_PAIR(Character_SetScaleVolume)},
{"Character::get_Scaling", API_FN_PAIR(Character_GetScaling)},
{"Character::set_Scaling", API_FN_PAIR(Character_SetScaling)},
{"Character::get_ScriptName", API_FN_PAIR(Character_GetScriptName)},
{"Character::get_Solid", API_FN_PAIR(Character_GetSolid)},
{"Character::set_Solid", API_FN_PAIR(Character_SetSolid)},
{"Character::get_Speaking", API_FN_PAIR(Character_GetSpeaking)},
{"Character::get_SpeakingFrame", API_FN_PAIR(Character_GetSpeakingFrame)},
{"Character::get_SpeechAnimationDelay", API_FN_PAIR(GetCharacterSpeechAnimationDelay)},
{"Character::set_SpeechAnimationDelay", API_FN_PAIR(Character_SetSpeechAnimationDelay)},
{"Character::get_SpeechColor", API_FN_PAIR(Character_GetSpeechColor)},
{"Character::set_SpeechColor", API_FN_PAIR(Character_SetSpeechColor)},
{"Character::get_SpeechView", API_FN_PAIR(Character_GetSpeechView)},
{"Character::set_SpeechView", API_FN_PAIR(Character_SetSpeechView)},
{"Character::get_Thinking", API_FN_PAIR(Character_GetThinking)},
{"Character::get_ThinkingFrame", API_FN_PAIR(Character_GetThinkingFrame)},
{"Character::get_ThinkView", API_FN_PAIR(Character_GetThinkView)},
{"Character::set_ThinkView", API_FN_PAIR(Character_SetThinkView)},
{"Character::get_Transparency", API_FN_PAIR(Character_GetTransparency)},
{"Character::set_Transparency", API_FN_PAIR(Character_SetTransparency)},
{"Character::get_TurnBeforeWalking", API_FN_PAIR(Character_GetTurnBeforeWalking)},
{"Character::set_TurnBeforeWalking", API_FN_PAIR(Character_SetTurnBeforeWalking)},
{"Character::get_View", API_FN_PAIR(Character_GetView)},
{"Character::get_WalkSpeedX", API_FN_PAIR(Character_GetWalkSpeedX)},
{"Character::get_WalkSpeedY", API_FN_PAIR(Character_GetWalkSpeedY)},
{"Character::get_X", API_FN_PAIR(Character_GetX)},
{"Character::set_X", API_FN_PAIR(Character_SetX)},
{"Character::get_x", API_FN_PAIR(Character_GetX)},
{"Character::set_x", API_FN_PAIR(Character_SetX)},
{"Character::get_Y", API_FN_PAIR(Character_GetY)},
{"Character::set_Y", API_FN_PAIR(Character_SetY)},
{"Character::get_y", API_FN_PAIR(Character_GetY)},
{"Character::set_y", API_FN_PAIR(Character_SetY)},
{"Character::get_Z", API_FN_PAIR(Character_GetZ)},
{"Character::set_Z", API_FN_PAIR(Character_SetZ)},
{"Character::get_z", API_FN_PAIR(Character_GetZ)},
{"Character::set_z", API_FN_PAIR(Character_SetZ)},
{"Character::get_HasExplicitLight", API_FN_PAIR(Character_GetHasExplicitLight)},
{"Character::get_LightLevel", API_FN_PAIR(Character_GetLightLevel)},
{"Character::get_TintBlue", API_FN_PAIR(Character_GetTintBlue)},
{"Character::get_TintGreen", API_FN_PAIR(Character_GetTintGreen)},
{"Character::get_TintRed", API_FN_PAIR(Character_GetTintRed)},
{"Character::get_TintSaturation", API_FN_PAIR(Character_GetTintSaturation)},
{"Character::get_TintLuminance", API_FN_PAIR(Character_GetTintLuminance)},
};
ccAddExternalFunctions361(character_api);
// Few functions have to be selected based on API level
if (base_api < kScriptAPI_v350) {
ccAddExternalObjectFunction361("Character::LockViewAligned^3", API_FN_PAIR(Character_LockViewAligned_Old));
ccAddExternalObjectFunction361("Character::LockViewAligned^4", API_FN_PAIR(Character_LockViewAlignedEx_Old));
} else {
ccAddExternalObjectFunction361("Character::LockViewAligned^3", API_FN_PAIR(Character_LockViewAligned));
ccAddExternalObjectFunction361("Character::LockViewAligned^4", API_FN_PAIR(Character_LockViewAlignedEx));
}
if (base_api < kScriptAPI_v341) {
ccAddExternalObjectFunction361("Character::get_HasExplicitTint", API_FN_PAIR(Character_GetHasExplicitTint_Old));
} else {
ccAddExternalObjectFunction361("Character::get_HasExplicitTint", API_FN_PAIR(Character_GetHasExplicitTint));
}
}
} // namespace AGS3