/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

//=============================================================================
//
// 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) {
		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]);

		if (wasStepFrac > 0.f) {
			_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 Bitmap *, 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_on_another(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 has walked onto character ww
int is_char_on_another(int sourceChar, int ww, int *fromxptr, int *cwidptr) {

	int fromx, cwidth;
	int y1, y2;
	get_char_blocking_rect(ww, &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<CharacterInfo *>(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