World of Might and Magic  0.2.0
Open reimplementation of Might and Magic 6 7 8 game engine
Классы | Определения типов | Перечисления | Функции | Переменные
Файл Indoor.h

См. исходные тексты.

Классы

struct  LightsData
 
struct  DDM_DLV_Header
 
struct  stru315
 
struct  stru316
 
struct  stru141_actor_collision_object
 
struct  stru337_stru0
 
struct  stru337
 
struct  stru154
 
struct  stru352
 
struct  LocationTime_stru1
 
struct  SpawnPointMM6
 
struct  SpawnPointMM7
 
struct  BLVHeader
 
struct  BLVSectorMM8
 
struct  BLVLightMM6
 
struct  BLVLightMM7
 
struct  BLVLightMM8
 
struct  BLVDoor
 
struct  BLVMapOutline
 
struct  BLVFace
 
struct  BLVFaceExtra
 
struct  BLVSector
 
struct  BLVMapOutlines
 
struct  IndoorLocation
 
struct  BLVRenderParams
 
struct  BspRenderer_PortalViewportData
 
struct  BspRenderer_stru0
 
struct  BspFace
 
struct  BspRenderer
 

Определения типов

using EngineIoc = Engine_::IocContainer
 

Перечисления

enum  PolygonType : uint8_t {
  POLYGON_Invalid = 0x0, POLYGON_VerticalWall = 0x1, POLYGON_unk = 0x2, POLYGON_Floor = 0x3,
  POLYGON_InBetweenFloorAndWall = 0x4, POLYGON_Ceiling = 0x5, POLYGON_InBetweenCeilingAndWall = 0x6
}
 
enum  LEVEL_TYPE { LEVEL_null = 0, LEVEL_Indoor = 0x1, LEVEL_Outdoor = 0x2 }
 

Функции

int GetPortalScreenCoord (unsigned int uFaceID)
 
bool PortalFrustrum (int pNumVertices, struct BspRenderer_PortalViewportData *a2, struct BspRenderer_PortalViewportData *near_portal, int uFaceID)
 
void PrepareBspRenderList_BLV ()
 
void AddBspNodeToRenderList (unsigned int node_id)
 
void sub_4406BC (unsigned int node_id, unsigned int uFirstNode)
 
char DoInteractionWithTopmostZObject (int a1, int a2)
 
int sub_4AAEA6_transform (struct RenderVertexSoft *a1)
 
unsigned int FaceFlowTextureOffset (unsigned int uFaceID)
 
void BLV_UpdateUserInputAndOther ()
 
int BLV_GetFloorLevel (int x, int y, int z, unsigned int uSectorID, unsigned int *pFaceID)
 
void BLV_UpdateDoors ()
 
void UpdateActors_BLV ()
 
void BLV_ProcessPartyActions ()
 
void Door_switch_animation (unsigned int uDoorID, int a2)
 
int sub_4088E9 (int a1, int a2, int a3, int a4, int a5, int a6)
 
void PrepareDrawLists_BLV ()
 
void PrepareToLoadBLV (unsigned int bLoading)
 
int GetAlertStatus ()
 
int _45063B_spawn_some_monster (struct MapInfo *a1, int a2)
 
int sub_450521_ProllyDropItemAt (int ecx0, signed int a2, int a3, int a4, int a5, uint16_t a6)
 
bool sub_4075DB (int a1, int a2, int a3, struct BLVFace *face)
 
bool sub_4077F1 (int a1, int a2, int a3, struct ODMFace *face, struct BSPVertexBuffer *a5)
 
void FindBillboardsLightLevels_BLV ()
 
int collide_against_floor_approximate (int x, int y, int z, unsigned int *pSectorID, unsigned int *pFaceID)
 
bool sub_407A1C (int x, int z, int y, struct Vec3_int_ v)
 

Переменные

LightsData Lights
 
stru141_actor_collision_object stru_721530
 
stru337 stru_F81018
 
LEVEL_TYPE uCurrentlyLoadedLevelType
 
IndoorLocation * pIndoor
 
BLVRenderParams * pBLVRenderParams
 
BspRenderer_PortalViewportData stru_F8A590
 
struct BspRenderer * pBspRenderer
 

Типы

◆ EngineIoc

using EngineIoc = Engine_::IocContainer

См. определение в файле Indoor.h строка 12

Перечисления

◆ PolygonType

enum PolygonType : uint8_t
Элементы перечислений
POLYGON_Invalid 
POLYGON_VerticalWall 
POLYGON_unk 
POLYGON_Floor 
POLYGON_InBetweenFloorAndWall 
POLYGON_Ceiling 
POLYGON_InBetweenCeilingAndWall 

См. определение в файле Indoor.h строка 216

216  : uint8_t {
217  POLYGON_Invalid = 0x0,
218  POLYGON_VerticalWall = 0x1,
219  POLYGON_unk = 0x2,
220  POLYGON_Floor = 0x3,
221  POLYGON_InBetweenFloorAndWall = 0x4,
222  POLYGON_Ceiling = 0x5,
223  POLYGON_InBetweenCeilingAndWall = 0x6,
224 };

◆ LEVEL_TYPE

enum LEVEL_TYPE
Элементы перечислений
LEVEL_null 
LEVEL_Indoor 
LEVEL_Outdoor 

См. определение в файле Indoor.h строка 284

284  {
285  LEVEL_null = 0,
286  LEVEL_Indoor = 0x1,
287  LEVEL_Outdoor = 0x2,
288 };

Функции

◆ GetPortalScreenCoord()

int GetPortalScreenCoord ( unsigned int  uFaceID)

См. определение в файле Indoor.cpp строка 4045

4045  {
4046  BLVFace *pFace; // ebx@1
4047  int pNextVertices; // edx@11
4048  int t; // ST28_4@12
4049  int pScreenX; // eax@22
4050  int pScreenY; // eax@27
4051  int left_num_vertices; // edi@31
4052  int right_num_vertices; // ebx@41
4053  int top_num_vertices; // edi@51
4054  int bottom_num_vertices; // ebx@61
4055  bool current_vertices_flag; // [sp+18h] [bp-10h]@9
4056  int depth_num_vertices; // [sp+1Ch] [bp-Ch]@9
4057  bool next_vertices_flag; // [sp+20h] [bp-8h]@10
4058 
4059  //Доп инфо "Программирование трёхмерных игр для windows" Ламот стр 910
4060 
4061  pFace = &pIndoor->pFaces[uFaceID];
4062  memset(&PortalFace, 0, sizeof(stru367));
4063 
4064  // get direction the face(определение направленности
4065  // фейса)*********************************************************************************
4066  if (pFace->pFacePlane_old.vNormal.x *
4067  (pIndoor->pVertices[pIndoor->pFaces[uFaceID].pVertexIDs[0]].x -
4068  pIndoorCameraD3D->vPartyPos.x) +
4069  pFace->pFacePlane_old.vNormal.y *
4070  (pIndoor->pVertices[pIndoor->pFaces[uFaceID].pVertexIDs[0]].y -
4071  pIndoorCameraD3D->vPartyPos.y) +
4072  pFace->pFacePlane_old.vNormal.z *
4073  (pIndoor->pVertices[pIndoor->pFaces[uFaceID].pVertexIDs[0]].z -
4074  pIndoorCameraD3D->vPartyPos.z) <
4075  0) {
4076  PortalFace.direction = true;
4077  } else {
4078  PortalFace.direction = false;
4079  if (!(pFace->Portal())) return 0;
4080  }
4081  //*****************************************************************************************************************************************
4082  // transform to camera coordinates (генерация/конвертирование в координаты
4083  // пространства камеры)
4084 
4085  if ((signed int)pFace->uNumVertices > 0) {
4086  for (uint i = 0; i < pFace->uNumVertices; ++i) {
4087  pIndoorCameraD3D->ApplyViewTransform_TrueIfStillVisible_BLV(
4088  pIndoor->pVertices[pFace->pVertexIDs[i]].x,
4089  pIndoor->pVertices[pFace->pVertexIDs[i]].y,
4090  pIndoor->pVertices[pFace->pVertexIDs[i]].z,
4091  (fixed *)&PortalFace._view_transformed_z[i + 3],
4092  (fixed *)&PortalFace._view_transformed_x[i + 3],
4093  (fixed *)&PortalFace._view_transformed_y[i + 3], false); // xyz wrong order?
4094 
4095  /*pIndoorCameraD3D->ViewClip(pIndoor->pVertices[pFace->pVertexIDs[i]].x,
4096  pIndoor->pVertices[pFace->pVertexIDs[i]].y,
4097  pIndoor->pVertices[pFace->pVertexIDs[i]].z,
4098  &PortalFace._view_transformed_z[i + 3],
4099  &PortalFace._view_transformed_x[i + 3],
4100  &PortalFace._view_transformed_y[i + 3], true);*/
4101  }
4102  }
4103 
4104  //*****************************************************************************************************************************************
4105  // check vertices for the nearest plane(проверка вершин есть ли в области за
4106  // ближайшей плоскостью)
4107  if (pFace->uNumVertices <= 0) return 0;
4108  bool bFound = false;
4109  for (uint i = 0; i < pFace->uNumVertices; ++i) {
4110  if (PortalFace._view_transformed_z[i + 3] >=
4111  0x80000) { // 8.0(0x80000) 0x196A9FF >=0x80000
4112  bFound = true;
4113  break;
4114  }
4115  }
4116  if (!bFound) return 0;
4117  //*****************************************************************************************************************************************
4118  // check for near clip plane(проверка по ближней границе)
4119  //
4120  // v0 v1
4121  // ._________________.
4122  // / \
4123  // / \
4124  // v5. . v2
4125  // | |
4126  // | |
4127  // | |
4128  // ---------------------------- 8.0(near_clip)
4129  // | |
4130  // ._______________________.
4131  // v4 v3
4132  depth_num_vertices = 0;
4133  PortalFace._view_transformed_z[pFace->uNumVertices + 3] =
4134  PortalFace._view_transformed_z[3];
4135  PortalFace._view_transformed_x[pFace->uNumVertices + 3] =
4136  PortalFace._view_transformed_x[3];
4137  PortalFace._view_transformed_y[pFace->uNumVertices + 3] =
4138  PortalFace._view_transformed_y[3];
4139  current_vertices_flag =
4140  PortalFace._view_transformed_z[3] >= 0x80000; // 524288
4141  if (pFace->uNumVertices >= 1) {
4142  for (uint i = 1; i <= pFace->uNumVertices; ++i) {
4143  next_vertices_flag = PortalFace._view_transformed_z[i + 3] >=
4144  0x80000; // 524288;// 8.0
4145  if (current_vertices_flag ^
4146  next_vertices_flag) { // current or next vertex is near-clipped /
4147  // или текущая или следующая вершина за
4148  // ближней границей - v5
4149  if (next_vertices_flag) { // next vertex is near-clipped /
4150  // следующая вершина за ближней
4151  // границей
4152  // t = near_clip - v4.z / v5.z - v4.z
4153  t = fixpoint_div(
4154  0x80000 - PortalFace._view_transformed_z[i + 2],
4155  PortalFace._view_transformed_z[i + 3] -
4156  PortalFace._view_transformed_z[i + 2]);
4157  // New_x = (v5.x - v4.x)*t + v4.x
4158  PortalFace._view_transformed_x[depth_num_vertices] =
4159  PortalFace._view_transformed_x[i + 2] +
4160  fixpoint_mul(t,
4161  (PortalFace._view_transformed_x[i + 3] -
4162  PortalFace._view_transformed_x[i + 2]));
4163  // New_y = (v5.y - v4.y)*t + v4.y
4164  PortalFace._view_transformed_y[depth_num_vertices] =
4165  PortalFace._view_transformed_y[i + 2] +
4166  fixpoint_mul(t,
4167  (PortalFace._view_transformed_y[i + 3] -
4168  PortalFace._view_transformed_y[i + 2]));
4169  // New_z = 8.0(0x80000)
4170  PortalFace._view_transformed_z[depth_num_vertices] =
4171  0x80000; // 524288
4172 
4173  // test new code
4174  auto _t =
4175  (fixed::FromInt(8) -
4176  fixed::Raw(PortalFace._view_transformed_z[i + 2])) /
4177  (fixed::Raw(PortalFace._view_transformed_z[i + 3]) -
4178  fixed::Raw(PortalFace._view_transformed_z[i + 2]));
4179  auto _x =
4180  fixed::Raw(PortalFace._view_transformed_x[i + 2]) +
4181  _t *
4182  (fixed::Raw(PortalFace._view_transformed_x[i + 3]) -
4183  fixed::Raw(PortalFace._view_transformed_x[i + 2]));
4184  auto _y =
4185  fixed::Raw(PortalFace._view_transformed_y[i + 2]) +
4186  _t *
4187  (fixed::Raw(PortalFace._view_transformed_y[i + 3]) -
4188  fixed::Raw(PortalFace._view_transformed_y[i + 2]));
4189  auto _z = fixed::FromInt(8);
4190 
4191  assert(_t._internal == t);
4192  assert(_x._internal ==
4193  PortalFace._view_transformed_x[depth_num_vertices]);
4194  assert(_y._internal ==
4195  PortalFace._view_transformed_y[depth_num_vertices]);
4196  assert(_z._internal ==
4197  PortalFace._view_transformed_z[depth_num_vertices]);
4198  } else { // current vertex is near-clipped / текущая вершина за
4199  // ближней границей
4200  // t = near_clip - v1.z / v0.z - v1.z
4201  t = fixpoint_div(
4202  524288 - PortalFace._view_transformed_z[i + 3],
4203  PortalFace._view_transformed_z[i + 2] -
4204  PortalFace._view_transformed_z[i + 3]);
4205  // New_x = (v0.x - v1.x)*t + v1.x
4206  PortalFace._view_transformed_x[depth_num_vertices] =
4207  PortalFace._view_transformed_x[i + 3] +
4208  fixpoint_mul(t,
4209  (PortalFace._view_transformed_x[i + 2] -
4210  PortalFace._view_transformed_x[i + 3]));
4211  // New_y = (v0.x - v1.y)*t + v1.y
4212  PortalFace._view_transformed_y[depth_num_vertices] =
4213  PortalFace._view_transformed_y[i + 3] +
4214  fixpoint_mul(t,
4215  (PortalFace._view_transformed_y[i + 2] -
4216  PortalFace._view_transformed_y[i + 3]));
4217  // New_z = 8.0(0x80000)
4218  PortalFace._view_transformed_z[depth_num_vertices] =
4219  0x80000; // 524288
4220 
4221  // test new code
4222  auto _t =
4223  (fixed::FromInt(8) -
4224  fixed::Raw(PortalFace._view_transformed_z[i + 3])) /
4225  (fixed::Raw(PortalFace._view_transformed_z[i + 2]) -
4226  fixed::Raw(PortalFace._view_transformed_z[i + 3]));
4227  auto _x =
4228  fixed::Raw(PortalFace._view_transformed_x[i + 3]) +
4229  _t *
4230  (fixed::Raw(PortalFace._view_transformed_x[i + 2]) -
4231  fixed::Raw(PortalFace._view_transformed_x[i + 3]));
4232  auto _y =
4233  fixed::Raw(PortalFace._view_transformed_y[i + 3]) +
4234  _t *
4235  (fixed::Raw(PortalFace._view_transformed_y[i + 2]) -
4236  fixed::Raw(PortalFace._view_transformed_y[i + 3]));
4237  auto _z = fixed::FromInt(8);
4238 
4239  // test new projection against old
4240  // assert(_t._internal == t);
4241  // assert(_x._internal ==
4242  // PortalFace._view_transformed_x[depth_num_vertices]);
4243  // assert(_y._internal ==
4244  // PortalFace._view_transformed_y[depth_num_vertices]);
4245  // assert(_z._internal ==
4246  // PortalFace._view_transformed_z[depth_num_vertices]);
4247  }
4248  depth_num_vertices++;
4249  }
4250  if (next_vertices_flag) { //если следующая вершина за ближней
4251  //границей
4252  pNextVertices = depth_num_vertices++;
4253  PortalFace._view_transformed_z[pNextVertices] =
4254  PortalFace._view_transformed_z[i + 3];
4255  PortalFace._view_transformed_x[pNextVertices] =
4256  PortalFace._view_transformed_x[i + 3];
4257  PortalFace._view_transformed_y[pNextVertices] =
4258  PortalFace._view_transformed_y[i + 3];
4259  }
4260  current_vertices_flag = next_vertices_flag;
4261  }
4262  }
4263 
4264  //результат: нет моргания на границе портала(когда проходим сквозь портал)
4265  //************************************************************************************************************************************
4266  // convertion in screen coordinates(конвертирование в координаты экрана)
4267  PortalFace._view_transformed_z[depth_num_vertices] =
4268  PortalFace._view_transformed_z[0];
4269  PortalFace._view_transformed_x[depth_num_vertices] =
4270  PortalFace._view_transformed_x[0];
4271  PortalFace._view_transformed_y[depth_num_vertices] =
4272  PortalFace._view_transformed_y[0];
4273  for (uint i = 0; i < depth_num_vertices; ++i) {
4274  if ((abs(PortalFace._view_transformed_x[i]) >> 13) <=
4275  abs(PortalFace._view_transformed_z[i])) {
4276  pScreenX = fixpoint_div(PortalFace._view_transformed_x[i],
4277  PortalFace._view_transformed_z[i]);
4278  } else {
4279  if (PortalFace._view_transformed_x[i] >= 0) {
4280  if (PortalFace._view_transformed_z[i] >= 0)
4281  pScreenX = 0x400000; // 64.0
4282  else
4283  pScreenX = 0xFFC00000; // -63.0
4284  } else {
4285  if (PortalFace._view_transformed_z[i] >= 0)
4286  pScreenX = 0xFFC00000; // -63.0
4287  else
4288  pScreenX = 0x400000; // 64.0
4289  }
4290  }
4291 
4292  if ((abs(PortalFace._view_transformed_y[i]) >> 13) <=
4293  abs(PortalFace._view_transformed_z[i])) {
4294  pScreenY = fixpoint_div(PortalFace._view_transformed_y[i],
4295  PortalFace._view_transformed_z[i]);
4296  } else {
4297  if (PortalFace._view_transformed_y[i] >= 0) {
4298  if (PortalFace._view_transformed_z[i] >= 0)
4299  pScreenY = 0x400000; // 64.0
4300  else
4301  pScreenY = 0xFFC00000; // -63.0
4302  } else {
4303  if (PortalFace._view_transformed_z[i] >= 0)
4304  pScreenY = 0xFFC00000; // -63.0
4305  else
4306  pScreenY = 0x400000; // 64.0
4307  }
4308  }
4309  PortalFace._screen_space_x[i + 12] =
4310  pBLVRenderParams->uViewportCenterX -
4311  fixpoint_mul(HEXRAYS_SHIWORD(pBLVRenderParams->bsp_fov_rad),
4312  pScreenX);
4313  PortalFace._screen_space_y[i + 12] =
4314  pBLVRenderParams->uViewportCenterY -
4315  fixpoint_mul(HEXRAYS_SHIWORD(pBLVRenderParams->bsp_fov_rad),
4316  pScreenY);
4317 
4318  // test new projection against old
4319  auto _x =
4320  pBLVRenderParams->uViewportCenterX -
4321  (fixed::Raw(pBLVRenderParams->bsp_fov_rad) * fixed::Raw(pScreenX))
4322  .GetInt();
4323  auto _y =
4324  pBLVRenderParams->uViewportCenterY -
4325  (fixed::Raw(pBLVRenderParams->bsp_fov_rad) * fixed::Raw(pScreenY))
4326  .GetInt();
4327  // assert(PortalFace._screen_space_x[i + 12] == _x);
4328  // assert(PortalFace._screen_space_y[i + 12] == _y);
4329  }
4330  // результат: при повороте камеры, когда граница портала сдвигается к краю
4331  // экрана, портал остается прозрачным(видимым)
4332 
4333  //******************************************************************************************************************************************
4334  // координаты как в Ида-базе игры так и в данном проекте перевёрнутые,т.е.
4335  // портал который в правой части экрана имеет экранные координаты которые для
4336  // левой части экрана. Например, x(оригинал) = 8, у нас х =
4337  // 468(противоположный край экрана), точно также и с у.
4338  // coordinates (original and here) are flipped horizontaly, e.g. portal on
4339  // right side of the screen x(original) = 8 becomes x = 468 (opposite side
4340  // of the screen). the same holds true for y
4341  //
4342  // check for left_clip plane(порверка по левой границе)
4343  left_num_vertices = 0;
4344  PortalFace._screen_space_x[depth_num_vertices + 12] =
4345  PortalFace._screen_space_x[12];
4346  PortalFace._screen_space_y[depth_num_vertices + 12] =
4347  PortalFace._screen_space_y[12];
4348  current_vertices_flag = PortalFace._screen_space_x[12] >=
4349  (signed int)pBLVRenderParams->uViewportX; // 8.0
4350  if (depth_num_vertices < 1) return 0;
4351  for (uint i = 1; i <= depth_num_vertices; ++i) {
4352  next_vertices_flag = PortalFace._screen_space_x[i + 12] >=
4353  (signed int)pBLVRenderParams->uViewportX;
4354  if (current_vertices_flag ^ next_vertices_flag) {
4355  if (next_vertices_flag) {
4356  // t = left_clip - v0.x / v1.x - v0.x
4357  t = fixpoint_div(pBLVRenderParams->uViewportX -
4358  PortalFace._screen_space_x[i + 11],
4359  PortalFace._screen_space_x[i + 12] -
4360  PortalFace._screen_space_x[i + 11]);
4361  // New_y = (v1.y - v0.y)*t + v0.y
4362  PortalFace._screen_space_y[left_num_vertices + 9] =
4363  PortalFace._screen_space_y[i + 11] +
4364  fixpoint_mul(t, (PortalFace._screen_space_y[i + 12] -
4365  PortalFace._screen_space_y[i + 11]));
4366  // New_x = left_clip
4367  PortalFace._screen_space_x[left_num_vertices + 9] =
4368  pBLVRenderParams->uViewportX;
4369 
4370  auto _t = (fixed::FromInt(pBLVRenderParams->uViewportX) -
4371  fixed::FromInt(PortalFace._screen_space_x[i + 11])) /
4372  (fixed::FromInt(PortalFace._screen_space_x[i + 12]) -
4373  fixed::FromInt(PortalFace._screen_space_x[i + 11]));
4374  auto _x = fixed::FromInt(pBLVRenderParams->uViewportX);
4375  auto _y =
4376  fixed::FromInt(PortalFace._screen_space_y[i + 11]) +
4377  _t * (fixed::FromInt(PortalFace._screen_space_y[i + 12]) -
4378  fixed::FromInt(PortalFace._screen_space_y[i + 11]));
4379 
4380  // assert(_t._internal == t);
4381  // assert(_x.GetInt() ==
4382  // PortalFace._screen_space_x[left_num_vertices + 9]);
4383  // assert(_y.GetInt() ==
4384  // PortalFace._screen_space_y[left_num_vertices + 9]);
4385  } else {
4386  // t = left_clip - v1.x / v0.x - v1.x
4387  t = fixpoint_div(pBLVRenderParams->uViewportX -
4388  PortalFace._screen_space_x[i + 12],
4389  PortalFace._screen_space_x[i + 11] -
4390  PortalFace._screen_space_x[i + 12]);
4391  // New_y = (v0.y - v1.y)*t + v1.y
4392  PortalFace._screen_space_y[left_num_vertices + 9] =
4393  PortalFace._screen_space_y[i + 12] +
4394  fixpoint_mul(t, (PortalFace._screen_space_y[i + 11] -
4395  PortalFace._screen_space_y[i + 12]));
4396  // New_x = left_clip
4397  PortalFace._screen_space_x[left_num_vertices + 9] =
4398  pBLVRenderParams->uViewportX;
4399 
4400  auto _t = (fixed::FromInt(pBLVRenderParams->uViewportX) -
4401  fixed::FromInt(PortalFace._screen_space_x[i + 12])) /
4402  (fixed::FromInt(PortalFace._screen_space_x[i + 11]) -
4403  fixed::FromInt(PortalFace._screen_space_x[i + 12]));
4404  auto _x = fixed::FromInt(pBLVRenderParams->uViewportX);
4405  auto _y =
4406  fixed::FromInt(PortalFace._screen_space_y[i + 12]) +
4407  _t * (fixed::FromInt(PortalFace._screen_space_y[i + 11]) -
4408  fixed::FromInt(PortalFace._screen_space_y[i + 12]));
4409 
4410  // test new projection against old
4411  // assert(_t._internal == t);
4412  // assert(_x.GetInt() ==
4413  // PortalFace._screen_space_x[left_num_vertices + 9]);
4414  // assert(_y.GetInt() ==
4415  // PortalFace._screen_space_y[left_num_vertices + 9]);
4416  }
4417  left_num_vertices++;
4418  }
4419  if (next_vertices_flag) {
4420  pNextVertices = left_num_vertices++;
4421  PortalFace._screen_space_x[pNextVertices + 9] =
4422  PortalFace._screen_space_x[i + 12];
4423  PortalFace._screen_space_y[pNextVertices + 9] =
4424  PortalFace._screen_space_y[i + 12];
4425  }
4426  current_vertices_flag = next_vertices_flag;
4427  }
4428  //*********************************************************************************************************************************
4429  // for right_clip plane(проверка по правой плоскости)
4430  right_num_vertices = 0;
4431  PortalFace._screen_space_x[left_num_vertices + 9] =
4432  PortalFace._screen_space_x[9];
4433  PortalFace._screen_space_y[left_num_vertices + 9] =
4434  PortalFace._screen_space_y[9];
4435  current_vertices_flag = PortalFace._screen_space_x[9] <=
4436  (signed int)pBLVRenderParams->uViewportZ; // 468.0
4437  if (left_num_vertices < 1) return 0;
4438  for (uint i = 1; i <= left_num_vertices; ++i) {
4439  next_vertices_flag = PortalFace._screen_space_x[i + 9] <=
4440  (signed int)pBLVRenderParams->uViewportZ;
4441  if (current_vertices_flag ^ next_vertices_flag) {
4442  if (next_vertices_flag) {
4443  // t = right_clip - v1.x / v0.x - v1.x
4444  t = fixpoint_div(pBLVRenderParams->uViewportZ -
4445  PortalFace._screen_space_x[i + 8],
4446  PortalFace._screen_space_x[i + 9] -
4447  PortalFace._screen_space_x[i + 8]);
4448  // New_y = (v0.y - v1.y)*t + v1.y
4449  PortalFace._screen_space_y[right_num_vertices + 6] =
4450  fixpoint_mul((PortalFace._screen_space_y[i + 9] -
4451  PortalFace._screen_space_y[i + 8]),
4452  t) +
4453  PortalFace._screen_space_y[i + 8];
4454  // New_x = right_clip
4455  PortalFace._screen_space_x[right_num_vertices + 6] =
4456  pBLVRenderParams->uViewportZ;
4457  } else {
4458  // t = right_clip - v0.x / v1.x - v0.x
4459  t = fixpoint_div(pBLVRenderParams->uViewportZ -
4460  PortalFace._screen_space_x[i + 9],
4461  PortalFace._screen_space_x[i + 8] -
4462  PortalFace._screen_space_x[i + 9]);
4463  // New_y = (v1.y - v0.y)*t + v0.y
4464  PortalFace._screen_space_y[right_num_vertices + 6] =
4465  fixpoint_mul((PortalFace._screen_space_y[i + 8] -
4466  PortalFace._screen_space_y[i + 9]),
4467  t) +
4468  PortalFace._screen_space_y[i + 9];
4469  // New_x = right_clip
4470  PortalFace._screen_space_x[right_num_vertices + 6] =
4471  pBLVRenderParams->uViewportZ;
4472  }
4473  right_num_vertices++;
4474  }
4475  if (next_vertices_flag) {
4476  pNextVertices = right_num_vertices++;
4477  PortalFace._screen_space_x[pNextVertices + 6] =
4478  PortalFace._screen_space_x[i + 9];
4479  PortalFace._screen_space_y[pNextVertices + 6] =
4480  PortalFace._screen_space_y[i + 9];
4481  }
4482  current_vertices_flag = next_vertices_flag;
4483  }
4484  //************************************************************************************************************************************
4485  // for top clip plane
4486  top_num_vertices = 0;
4487  PortalFace._screen_space_x[right_num_vertices + 6] =
4488  PortalFace._screen_space_x[6];
4489  PortalFace._screen_space_y[right_num_vertices + 6] =
4490  PortalFace._screen_space_y[6];
4491 
4492  current_vertices_flag = PortalFace._screen_space_y[6] >=
4493  (signed int)pBLVRenderParams->uViewportY; // 8.0
4494  if (right_num_vertices < 1) return 0;
4495  for (uint i = 1; i <= right_num_vertices; ++i) {
4496  next_vertices_flag = PortalFace._screen_space_y[i + 6] >=
4497  (signed int)pBLVRenderParams->uViewportY;
4498  if (current_vertices_flag ^ next_vertices_flag) {
4499  if (next_vertices_flag) {
4500  t = fixpoint_div(pBLVRenderParams->uViewportY -
4501  PortalFace._screen_space_y[i + 5],
4502  PortalFace._screen_space_y[i + 6] -
4503  PortalFace._screen_space_y[i + 5]);
4504  PortalFace._screen_space_x[top_num_vertices + 3] =
4505  ((signed int)((PortalFace._screen_space_x[i + 6] -
4506  PortalFace._screen_space_x[i + 5]) *
4507  t) >>
4508  16) +
4509  PortalFace._screen_space_x[i + 5];
4510  PortalFace._screen_space_y[top_num_vertices + 3] =
4511  pBLVRenderParams->uViewportY;
4512  } else {
4513  t = fixpoint_div(pBLVRenderParams->uViewportY -
4514  PortalFace._screen_space_y[i + 6],
4515  PortalFace._screen_space_y[i + 5] -
4516  PortalFace._screen_space_y[i + 6]);
4517  PortalFace._screen_space_x[top_num_vertices + 3] =
4518  fixpoint_mul((PortalFace._screen_space_x[i + 5] -
4519  PortalFace._screen_space_x[i + 6]),
4520  t) +
4521  PortalFace._screen_space_x[i + 6];
4522  PortalFace._screen_space_y[top_num_vertices + 3] =
4523  pBLVRenderParams->uViewportY;
4524  }
4525  top_num_vertices++;
4526  }
4527  current_vertices_flag = next_vertices_flag;
4528  if (next_vertices_flag) {
4529  pNextVertices = top_num_vertices++;
4530  PortalFace._screen_space_x[pNextVertices + 3] =
4531  PortalFace._screen_space_x[i + 6];
4532  PortalFace._screen_space_y[pNextVertices + 3] =
4533  PortalFace._screen_space_y[i + 6];
4534  }
4535  }
4536  //**********************************************************************************************************************************
4537  // for bottom_clip plane(проверка по нижней плоскости)
4538  bottom_num_vertices = 0;
4539  PortalFace._screen_space_x[top_num_vertices + 3] =
4540  PortalFace._screen_space_x[3];
4541  PortalFace._screen_space_y[top_num_vertices + 3] =
4542  PortalFace._screen_space_y[3];
4543  current_vertices_flag = PortalFace._screen_space_y[3] <=
4544  (signed int)pBLVRenderParams->uViewportW; // 351.0
4545  if (top_num_vertices < 1) return 0;
4546  for (uint i = 1; i <= top_num_vertices; ++i) {
4547  next_vertices_flag = PortalFace._screen_space_y[i + 3] <=
4548  (signed int)pBLVRenderParams->uViewportW;
4549  if (current_vertices_flag ^ next_vertices_flag) {
4550  if (next_vertices_flag) {
4551  t = fixpoint_div(pBLVRenderParams->uViewportW -
4552  PortalFace._screen_space_y[i + 2],
4553  PortalFace._screen_space_y[i + 3] -
4554  PortalFace._screen_space_y[i + 2]);
4555  PortalFace._screen_space_x[bottom_num_vertices] =
4556  fixpoint_mul((PortalFace._screen_space_x[i + 3] -
4557  PortalFace._screen_space_x[i + 2]),
4558  t) +
4559  PortalFace._screen_space_x[i + 2];
4560  PortalFace._screen_space_y[bottom_num_vertices] =
4561  pBLVRenderParams->uViewportW;
4562  } else {
4563  t = fixpoint_div(pBLVRenderParams->uViewportW -
4564  PortalFace._screen_space_y[i + 3],
4565  PortalFace._screen_space_y[i + 2] -
4566  PortalFace._screen_space_y[i + 3]);
4567  PortalFace._screen_space_x[bottom_num_vertices] =
4568  fixpoint_mul((PortalFace._screen_space_x[i + 2] -
4569  PortalFace._screen_space_x[i + 3]),
4570  t) +
4571  PortalFace._screen_space_x[i + 3];
4572  PortalFace._screen_space_y[bottom_num_vertices] =
4573  pBLVRenderParams->uViewportW;
4574  }
4575  bottom_num_vertices++;
4576  }
4577  if (next_vertices_flag) {
4578  pNextVertices = bottom_num_vertices++;
4579  PortalFace._screen_space_x[pNextVertices] =
4580  PortalFace._screen_space_x[i + 3];
4581  PortalFace._screen_space_y[pNextVertices] =
4582  PortalFace._screen_space_y[i + 3];
4583  }
4584  current_vertices_flag = next_vertices_flag;
4585  }
4586  //***************************************************************************************************************************************
4587 
4588  if (!bottom_num_vertices) return 0;
4589  PortalFace._screen_space_x[bottom_num_vertices] =
4590  PortalFace._screen_space_x[0];
4591  PortalFace._screen_space_y[bottom_num_vertices] =
4592  PortalFace._screen_space_y[0];
4593  // check for software(проверка для софтвар)
4594  /*if ( !render->pRenderD3D && bottom_num_vertices > 3 )
4595  {
4596  PortalFace._screen_space_x[bottom_num_vertices + 1] =
4597  PortalFace._screen_space_x[1];
4598  PortalFace._screen_space_y[bottom_num_vertices + 1] =
4599  PortalFace._screen_space_y[1]; thisf = PortalFace.direction == true ? 1 : -
4600  1; if ( bottom_num_vertices > 0 )
4601  {
4602  v62 = 1;
4603  v71 = 1;
4604  do
4605  {
4606  v63 = v62 - 1;
4607  v64 = v62 + 1;
4608  v80 = v62 + 1;
4609  if ( v62 - 1 >= bottom_num_vertices )
4610  v63 -= bottom_num_vertices;
4611  if ( v62 >= bottom_num_vertices )
4612  v62 -= bottom_num_vertices;
4613  if ( v64 >= bottom_num_vertices )
4614  v64 -= bottom_num_vertices;
4615  if ( thisf * ((PortalFace._screen_space_y[v64] -
4616  PortalFace._screen_space_y[v63])
4617  * (PortalFace._screen_space_x[v62] -
4618  PortalFace._screen_space_x[v63])
4619  - (PortalFace._screen_space_y[v62] -
4620  PortalFace._screen_space_y[v63])
4621  * (PortalFace._screen_space_x[v64] -
4622  PortalFace._screen_space_x[v63])) < 0 )
4623  {
4624  v62 = v80;
4625  v71 = v80;
4626  }
4627  else
4628  {
4629  v62 = v71;
4630  v65 = v71;
4631  if ( v71 < bottom_num_vertices || (v65 = v71 - bottom_num_vertices,
4632  v71 - bottom_num_vertices < bottom_num_vertices) )
4633  {
4634  memcpy(&PortalFace._screen_space_y[v65],
4635  &PortalFace._screen_space_y[v65 + 1], 4 * ((unsigned int)(4 *
4636  (bottom_num_vertices - v65)) >> 2));
4637  memcpy(&PortalFace._screen_space_x[v65],
4638  &PortalFace._screen_space_x[v65 + 1], 4 * ((unsigned int)(4 *
4639  (bottom_num_vertices - v65)) >> 2));
4640  }
4641  --bottom_num_vertices;
4642  }
4643  }
4644  while ( v62 - 1 < bottom_num_vertices );
4645  }
4646  PortalFace._screen_space_x[bottom_num_vertices] =
4647  PortalFace._screen_space_x[0];
4648  PortalFace._screen_space_y[bottom_num_vertices] =
4649  PortalFace._screen_space_y[0];
4650  }*/
4651  return bottom_num_vertices;
4652 }

Перекрестные ссылки stru367::_screen_space_x, stru367::_screen_space_y, stru367::_view_transformed_x, stru367::_view_transformed_y, stru367::_view_transformed_z, IndoorCameraD3D::ApplyViewTransform_TrueIfStillVisible_BLV(), BLVRenderParams::bsp_fov_rad, stru367::direction, fixpoint_div(), fixpoint_mul(), fixed::FromInt(), pBLVRenderParams, BLVFace::pFacePlane_old, IndoorLocation::pFaces, pIndoor, pIndoorCameraD3D, BLVFace::Portal(), PortalFace, BLVFace::pVertexIDs, IndoorLocation::pVertices, fixed::Raw(), BLVFace::uNumVertices, BLVRenderParams::uViewportCenterX, BLVRenderParams::uViewportCenterY, BLVRenderParams::uViewportW, BLVRenderParams::uViewportX, BLVRenderParams::uViewportY, BLVRenderParams::uViewportZ, Plane_int_::vNormal, IndoorCameraD3D::vPartyPos, Vec2< T >::x, Vec2< T >::y и Vec3< T >::z.

Используется в BspRenderer::AddFaceToRenderList_d3d().

+ Граф вызовов:
+ Граф вызова функции:

◆ PortalFrustrum()

bool PortalFrustrum ( int  pNumVertices,
struct BspRenderer_PortalViewportData *  a2,
struct BspRenderer_PortalViewportData *  near_portal,
int  uFaceID 
)

См. определение в файле Indoor.cpp строка 3788

3790  {
3791  int min_y; // esi@5
3792  int max_y; // edx@5
3793  int current_ID; // eax@12
3794  int v13; // eax@22
3795  int v15; // ecx@29
3796  int v18; // eax@39
3797  int v19; // eax@44
3798  int v20; // ecx@44
3799  int v22; // edi@46
3800  int v24; // edx@48
3801  int v26; // eax@55
3802  int v29; // edx@57
3803  int v31; // eax@64
3804  __int16 v36; // dx@67
3805  __int16 v38; // dx@67
3806  int v46; // edx@87
3807  int v49; // esi@93
3808  int v53 = 0; // [sp+Ch] [bp-34h]@44
3809  int v54 = 0; // [sp+10h] [bp-30h]@0
3810  int min_y_ID2; // [sp+14h] [bp-2Ch]@12
3811  int v59; // [sp+14h] [bp-2Ch]@87
3812  int v61; // [sp+1Ch] [bp-24h]@29
3813  int v62; // [sp+20h] [bp-20h]@0
3814  signed int direction1; // [sp+24h] [bp-1Ch]@3
3815  signed int direction2; // [sp+28h] [bp-18h]@3
3816  int min_y_ID; // [sp+2Ch] [bp-14h]@5
3817  int v69; // [sp+34h] [bp-Ch]@29
3818  int v70; // [sp+34h] [bp-Ch]@46
3819 
3820  if (pNumVertices <= 1) return false;
3821  min_y = PortalFace._screen_space_y[0];
3822  min_y_ID = 0;
3823  max_y = PortalFace._screen_space_y[0];
3824  // face direction(направление фейса)
3825  if (!PortalFace.direction) {
3826  direction1 = 1;
3827  direction2 = -1;
3828  } else {
3829  direction1 = -1;
3830  direction2 = 1;
3831  }
3832 
3833  // get min and max y for portal(дать минимальное и максимальное значение y
3834  // для портала)
3835  for (uint i = 1; i < pNumVertices; ++i) {
3836  if (PortalFace._screen_space_y[i] < min_y) {
3837  min_y_ID = i;
3838  min_y = PortalFace._screen_space_y[i];
3839  } else if (PortalFace._screen_space_y[i] > max_y) {
3840  max_y = PortalFace._screen_space_y[i];
3841  }
3842  }
3843  if (max_y == min_y) return false;
3844 
3845  //*****************************************************************************************************************************
3846  far_portal->_viewport_space_y = min_y;
3847  far_portal->_viewport_space_w = max_y;
3848  current_ID = min_y_ID;
3849  min_y_ID2 = min_y_ID;
3850 
3851  for (uint i = 0; i < pNumVertices; ++i) {
3852  current_ID += direction2;
3853  if (current_ID < pNumVertices) {
3854  if (current_ID < 0) current_ID += pNumVertices;
3855  } else {
3856  current_ID -= pNumVertices;
3857  }
3858  if (PortalFace._screen_space_y[current_ID] <=
3859  PortalFace._screen_space_y[min_y_ID]) { // определение минимальной у
3860  min_y_ID2 = current_ID;
3861  min_y_ID = current_ID;
3862  }
3863  if (PortalFace._screen_space_y[current_ID] == max_y) break;
3864  }
3865 
3866  v13 = min_y_ID2 + direction2;
3867  if (v13 < pNumVertices) {
3868  if (v13 < 0) v13 += pNumVertices;
3869  } else {
3870  v13 -= pNumVertices;
3871  }
3872  if (PortalFace._screen_space_y[v13] !=
3873  PortalFace._screen_space_y[min_y_ID2]) {
3874  v62 = PortalFace._screen_space_x[min_y_ID2] << 16;
3875  v54 = ((PortalFace._screen_space_x[v13] -
3876  PortalFace._screen_space_x[min_y_ID2])
3877  << 16) /
3878  (PortalFace._screen_space_y[v13] -
3879  PortalFace._screen_space_y[min_y_ID2]);
3880  far_portal->viewport_left_side[min_y] =
3881  (short)PortalFace._screen_space_x[min_y_ID2];
3882  }
3883  //****************************************************************************************************************************************
3884  //
3885  v15 = min_y_ID;
3886  v61 = min_y_ID;
3887  for (v69 = 0; v69 < pNumVertices; ++v69) {
3888  v15 += direction1;
3889  if (v15 < pNumVertices) {
3890  if (v15 < 0) v15 += pNumVertices;
3891  } else {
3892  v15 -= pNumVertices;
3893  }
3894  if (PortalFace._screen_space_y[v15] <=
3895  PortalFace._screen_space_y[min_y_ID]) {
3896  v61 = v15;
3897  min_y_ID = v15;
3898  }
3899  if (PortalFace._screen_space_y[v15] == max_y) break;
3900  }
3901  v18 = direction1 + v61;
3902  if (v18 < pNumVertices) {
3903  if (v18 < 0) v18 += pNumVertices;
3904  } else {
3905  v18 -= pNumVertices;
3906  }
3907  v19 = v18;
3908  v20 = v61;
3909  if (PortalFace._screen_space_y[v19] != PortalFace._screen_space_y[v61]) {
3910  v61 = PortalFace._screen_space_x[v20] << 16;
3911  v53 =
3912  ((PortalFace._screen_space_x[v19] - PortalFace._screen_space_x[v20])
3913  << 16) /
3914  (PortalFace._screen_space_y[v19] - PortalFace._screen_space_y[v20]);
3915  far_portal->viewport_right_side[max_y] =
3916  (short)PortalFace._screen_space_x[v20];
3917  }
3918  //****************************************************************************************************************************************
3919  v22 = min_y;
3920  if (min_y <= max_y) {
3921  for (v70 = min_y; v70 <= max_y; ++v70) {
3922  v24 = v13;
3923  if (v22 >= PortalFace._screen_space_y[v13] && v22 != max_y) {
3924  v13 = direction2 + v13;
3925  if (v13 < pNumVertices) {
3926  if (v13 < 0) v13 += pNumVertices;
3927  } else {
3928  v13 -= pNumVertices;
3929  }
3930  v26 = v13;
3931  if (PortalFace._screen_space_y[v26] -
3932  PortalFace._screen_space_y[v24] >
3933  0) {
3934  v54 = ((PortalFace._screen_space_x[v26] -
3935  PortalFace._screen_space_x[v24])
3936  << 16) /
3937  (PortalFace._screen_space_y[v26] -
3938  PortalFace._screen_space_y[v24]);
3939  v62 = PortalFace._screen_space_x[v24] << 16;
3940  }
3941  }
3942  v29 = v18;
3943  if (v70 >= PortalFace._screen_space_y[v18] && v70 != max_y) {
3944  v18 += direction1;
3945  if (v18 < pNumVertices) {
3946  if (v18 < 0) v18 += pNumVertices;
3947  } else {
3948  v18 -= pNumVertices;
3949  }
3950  v31 = v18;
3951  if (PortalFace._screen_space_y[v31] -
3952  PortalFace._screen_space_y[v29] >
3953  0) {
3954  v53 = ((PortalFace._screen_space_x[v31] -
3955  PortalFace._screen_space_x[v29])
3956  << 16) /
3957  (PortalFace._screen_space_y[v31] -
3958  PortalFace._screen_space_y[v29]);
3959  v61 = PortalFace._screen_space_x[v29] << 16;
3960  }
3961  }
3962  far_portal->viewport_left_side[v70] = HEXRAYS_HIWORD(v62);
3963  far_portal->viewport_right_side[v70] = HEXRAYS_HIWORD(v61);
3964  if (far_portal->viewport_left_side[v70] >
3965  far_portal->viewport_right_side[v70]) {
3966  v36 = far_portal->viewport_left_side[v70] ^
3967  far_portal->viewport_right_side[v70];
3968  // v37 = far_portal->viewport_right_side[v70];
3969  far_portal->viewport_left_side[v70] = v36;
3970  v38 = far_portal->viewport_right_side[v70] ^ v36;
3971  far_portal->viewport_left_side[v70] ^= v38;
3972  far_portal->viewport_right_side[v70] = v38;
3973  }
3974  v62 += v54;
3975  v22 = v70 + 1;
3976  v61 += v53;
3977  }
3978  }
3979  //*****************************************************************************************************************************
3980  // check portals coordinates and determine max, min(проверка координат
3981  // порталов и определение макс, мин-ой у)
3982  if (max_y < near_portal->_viewport_space_y) return false;
3983  if (min_y > near_portal->_viewport_space_w) return false;
3984  if (min_y < near_portal->_viewport_space_y)
3985  min_y = near_portal->_viewport_space_y;
3986  if (max_y > near_portal->_viewport_space_w)
3987  max_y = near_portal->_viewport_space_w;
3988  if (min_y <= max_y) {
3989  for (min_y; min_y <= max_y; ++min_y) {
3990  if (far_portal->viewport_right_side[min_y] >=
3991  near_portal->viewport_left_side[min_y] &&
3992  far_portal->viewport_left_side[min_y] <=
3993  near_portal->viewport_right_side[min_y])
3994  break;
3995  }
3996  }
3997  if (max_y < min_y) return false;
3998  for (max_y; max_y >= min_y; --max_y) {
3999  if (far_portal->viewport_right_side[max_y] >=
4000  near_portal->viewport_left_side[max_y] &&
4001  far_portal->viewport_left_side[max_y] <=
4002  near_portal->viewport_right_side[max_y])
4003  break;
4004  }
4005  if (min_y >= max_y) return false;
4006  //*************************************************************************************************************************************
4007  v59 = min_y;
4008  for (v46 = max_y - min_y + 1; v46; --v46) {
4009  if (far_portal->viewport_left_side[v59] <
4010  near_portal->viewport_left_side[v59])
4011  far_portal->viewport_left_side[v59] =
4012  near_portal->viewport_left_side[v59];
4013  if (far_portal->viewport_right_side[v59] >
4014  near_portal->viewport_right_side[v59])
4015  far_portal->viewport_right_side[v59] =
4016  near_portal->viewport_right_side[v59];
4017  ++v59;
4018  }
4019  far_portal->_viewport_space_y = min_y;
4020  far_portal->_viewport_space_w = max_y;
4021  far_portal->_viewport_space_x = far_portal->viewport_left_side[min_y];
4022  far_portal->_viewport_space_z = far_portal->viewport_right_side[min_y];
4023  far_portal->_viewport_x_minID = min_y;
4024  far_portal->_viewport_z_maxID = min_y;
4025  v49 = min_y + 1;
4026  if (v49 <= max_y) {
4027  for (v49; v49 <= max_y; ++v49) {
4028  if (far_portal->viewport_left_side[v49] <
4029  far_portal->_viewport_space_x) {
4030  far_portal->_viewport_space_x =
4031  far_portal->viewport_left_side[v49];
4032  far_portal->_viewport_x_minID = v49;
4033  }
4034  if (far_portal->viewport_right_side[v49] >
4035  far_portal->_viewport_space_z) {
4036  far_portal->_viewport_space_z =
4037  far_portal->viewport_right_side[v49];
4038  far_portal->_viewport_z_maxID = v49;
4039  }
4040  }
4041  }
4042  return true;
4043 }

Перекрестные ссылки stru367::_screen_space_x, stru367::_screen_space_y, BspRenderer_PortalViewportData::_viewport_space_w, BspRenderer_PortalViewportData::_viewport_space_x, BspRenderer_PortalViewportData::_viewport_space_y, BspRenderer_PortalViewportData::_viewport_space_z, BspRenderer_PortalViewportData::_viewport_x_minID, BspRenderer_PortalViewportData::_viewport_z_maxID, stru367::direction, PortalFace, BspRenderer_PortalViewportData::viewport_left_side и BspRenderer_PortalViewportData::viewport_right_side.

Используется в BspRenderer::AddFaceToRenderList_d3d().

+ Граф вызова функции:

◆ PrepareBspRenderList_BLV()

void PrepareBspRenderList_BLV ( )

См. определение в файле Indoor.cpp строка 3159

3159  {
3160  pBspRenderer->num_faces = 0;
3161 
3162  if (pBLVRenderParams->uPartySectorID) {
3163  pBspRenderer->nodes[0].uSectorID = pBLVRenderParams->uPartySectorID;
3164  pBspRenderer->nodes[0].uViewportX = pBLVRenderParams->uViewportX;
3165  pBspRenderer->nodes[0].uViewportY = pBLVRenderParams->uViewportY;
3166  pBspRenderer->nodes[0].uViewportZ = pBLVRenderParams->uViewportZ;
3167  pBspRenderer->nodes[0].uViewportW = pBLVRenderParams->uViewportW;
3168  pBspRenderer->nodes[0].PortalScreenData.GetViewportData(
3169  pBLVRenderParams->uViewportX, pBLVRenderParams->uViewportY,
3170  pBLVRenderParams->uViewportZ, pBLVRenderParams->uViewportW);
3171  pBspRenderer->nodes[0].uFaceID = -1;
3172  pBspRenderer->nodes[0].viewing_portal_id = -1;
3173  pBspRenderer->num_nodes = 1;
3174  AddBspNodeToRenderList(0);
3175  }
3176 
3177  pBspRenderer->MakeVisibleSectorList();
3178 }

Перекрестные ссылки AddBspNodeToRenderList(), BspRenderer_PortalViewportData::GetViewportData(), BspRenderer::MakeVisibleSectorList(), BspRenderer::nodes, BspRenderer::num_faces, BspRenderer::num_nodes, pBLVRenderParams, pBspRenderer, BspRenderer_stru0::PortalScreenData, BspRenderer_stru0::uFaceID, BLVRenderParams::uPartySectorID, BspRenderer_stru0::uSectorID, BLVRenderParams::uViewportW, BspRenderer_stru0::uViewportW, BLVRenderParams::uViewportX, BspRenderer_stru0::uViewportX, BLVRenderParams::uViewportY, BspRenderer_stru0::uViewportY, BLVRenderParams::uViewportZ, BspRenderer_stru0::uViewportZ и BspRenderer_stru0::viewing_portal_id.

Используется в PrepareDrawLists_BLV().

+ Граф вызовов:
+ Граф вызова функции:

◆ AddBspNodeToRenderList()

void AddBspNodeToRenderList ( unsigned int  node_id)

См. определение в файле Indoor.cpp строка 2970

2970  {
2971  BLVSector *pSector = &pIndoor->pSectors[pBspRenderer->nodes[node_id].uSectorID];
2972  // if ( render->pRenderD3D )
2973  {
2974  for (uint i = 0; i < pSector->uNumNonBSPFaces; ++i)
2975  // logger->Warning(L"Non-BSP face: %X", v3->pFaceIDs[v2]);
2976  pBspRenderer->AddFaceToRenderList_d3d(node_id, pSector->pFaceIDs[i]); // рекурсия\recursion
2977  }
2978  /*else
2979  {
2980  for (uint i = 0; i < pSector->uNumNonBSPFaces; ++i)
2981  pBspRenderer->AddFaceToRenderList_sw(node_id, pSector->pFaceIDs[i]);
2982  }*/
2983  if (pSector->field_0 & 0x10) sub_4406BC(node_id, pSector->uFirstBSPNode);
2984 }

Перекрестные ссылки BspRenderer::AddFaceToRenderList_d3d(), BLVSector::field_0, BspRenderer::nodes, pBspRenderer, BLVSector::pFaceIDs, pIndoor, IndoorLocation::pSectors, sub_4406BC(), BLVSector::uFirstBSPNode, BLVSector::uNumNonBSPFaces и BspRenderer_stru0::uSectorID.

Используется в BspRenderer::AddFaceToRenderList_d3d() и PrepareBspRenderList_BLV().

+ Граф вызовов:
+ Граф вызова функции:

◆ sub_4406BC()

void sub_4406BC ( unsigned int  node_id,
unsigned int  uFirstNode 
)

См. определение в файле Indoor.cpp строка 2987

2987  {
2988  BLVSector *pSector; // esi@2
2989  BSPNode *pNode; // edi@2
2990  BLVFace *pFace; // eax@2
2991  int v5; // ecx@2
2992  __int16 v6; // ax@6
2993  int v7; // ebp@10
2994  int v8; // ebx@10
2995  __int16 v9; // di@18
2996  BspRenderer_stru0 *node; // [sp+18h] [bp-4h]@1
2997 
2998  // logger->Warning(L"sub_4406BC(%u, %u)", a1, uFirstNode);
2999 
3000  // v10 = a1;
3001  node = &pBspRenderer->nodes[node_id];
3002  while (1) {
3003  pSector = &pIndoor->pSectors[node->uSectorID];
3004  pNode = &pIndoor->pNodes[uFirstNode];
3005  pFace = &pIndoor->pFaces[pSector->pFaceIDs[pNode->uCoplanarOffset]];
3006  v5 = pFace->pFacePlane_old.dist +
3007  pIndoorCameraD3D->vPartyPos.x * pFace->pFacePlane_old.vNormal.x +
3008  pIndoorCameraD3D->vPartyPos.y * pFace->pFacePlane_old.vNormal.y +
3009  pIndoorCameraD3D->vPartyPos.z *
3010  pFace->pFacePlane_old.vNormal.z; // plane equation
3011  if (pFace->Portal() && pFace->uSectorID != node->uSectorID) v5 = -v5;
3012  // v11 = v5 > 0;
3013  if (v5 <= 0)
3014  v6 = pNode->uFront;
3015  else
3016  v6 = pNode->uBack;
3017  if (v6 != -1) sub_4406BC(node_id, v6);
3018  v7 = pNode->uCoplanarOffset;
3019  v8 = v7 + pNode->uCoplanarSize;
3020 
3021  // logger->Warning(L"Node %u: %X to %X (%hX)", uFirstNode, v7, v8,
3022  // v2->pFaceIDs[v7]);
3023 
3024  // if ( render->pRenderD3D )
3025  {
3026  while (v7 < v8)
3027  pBspRenderer->AddFaceToRenderList_d3d(node_id,
3028  pSector->pFaceIDs[v7++]);
3029  }
3030  /*else
3031  {
3032  while ( v7 < v8 )
3033  pBspRenderer->AddFaceToRenderList_sw(node_id,
3034  pSector->pFaceIDs[v7++]);
3035  }*/
3036  v9 = v5 > 0 ? pNode->uFront : pNode->uBack;
3037  if (v9 == -1) break;
3038  uFirstNode = v9;
3039  }
3040 }

Перекрестные ссылки BspRenderer::AddFaceToRenderList_d3d(), Plane_int_::dist, BspRenderer::nodes, pBspRenderer, BLVSector::pFaceIDs, BLVFace::pFacePlane_old, IndoorLocation::pFaces, pIndoor, pIndoorCameraD3D, IndoorLocation::pNodes, BLVFace::Portal(), IndoorLocation::pSectors, sub_4406BC(), BSPNode::uBack, BSPNode::uCoplanarOffset, BSPNode::uCoplanarSize, BSPNode::uFront, BLVFace::uSectorID, BspRenderer_stru0::uSectorID, Plane_int_::vNormal, IndoorCameraD3D::vPartyPos, Vec2< T >::x, Vec2< T >::y и Vec3< T >::z.

Используется в AddBspNodeToRenderList() и sub_4406BC().

+ Граф вызовов:
+ Граф вызова функции:

◆ DoInteractionWithTopmostZObject()

char DoInteractionWithTopmostZObject ( int  a1,
int  a2 
)

См. определение в файле Indoor.cpp строка 3716

3716  {
3717  uint32_t v17 = PID_ID(a1);
3718  switch (PID_TYPE(a1)) {
3719  case OBJECT_Item: { // take the item
3720  if (pSpriteObjects[v17].IsUnpickable() || v17 >= 1000 || !pSpriteObjects[v17].uObjectDescID) {
3721  return 1;
3722  }
3723 
3724  extern void ItemInteraction(unsigned int item_id);
3725  ItemInteraction(v17);
3726  break;
3727  }
3728 
3729  case OBJECT_Actor:
3730  if (pActors[v17].uAIState == Dying || pActors[v17].uAIState == Summoned)
3731  return 1;
3732  if (pActors[v17].uAIState == Dead) {
3733  pActors[v17].LootActor();
3734  } else {
3735  extern bool ActorInteraction(unsigned int id);
3736  ActorInteraction(v17);
3737  }
3738  break;
3739 
3740  case OBJECT_Decoration:
3741  extern void DecorationInteraction(unsigned int id, unsigned int pid);
3742  DecorationInteraction(v17, a1);
3743  break;
3744 
3745  default:
3746  logger->Warning(L"Warning: Invalid ID reached!");
3747  return 1;
3748 
3749  case OBJECT_BModel:
3750  if (uCurrentlyLoadedLevelType == LEVEL_Outdoor) {
3751  int bmodel_id = a1 >> 9;
3752  int face_id = v17 & 0x3F;
3753  if (bmodel_id >= pOutdoor->pBModels.size()) {
3754  return 1;
3755  }
3756  if (pOutdoor->pBModels[bmodel_id].pFaces[face_id].uAttributes & FACE_HAS_EVENT ||
3757  pOutdoor->pBModels[bmodel_id].pFaces[face_id].sCogTriggeredID == 0)
3758  return 1;
3759  EventProcessor((int16_t)pOutdoor->pBModels[bmodel_id].pFaces[face_id].sCogTriggeredID,
3760  a1, 1);
3761  } else {
3762  if (!(pIndoor->pFaces[v17].uAttributes & FACE_CLICKABLE)) {
3763  GameUI_StatusBar_NothingHere();
3764  return 1;
3765  }
3766  if (pIndoor->pFaces[v17].uAttributes & FACE_HAS_EVENT ||
3767  !pIndoor->pFaceExtras[pIndoor->pFaces[v17].uFaceExtraID].uEventID)
3768  return 1;
3769  if (current_screen_type != CURRENT_SCREEN::SCREEN_BRANCHLESS_NPC_DIALOG)
3770  EventProcessor((int16_t)pIndoor->pFaceExtras[pIndoor->pFaces[v17].uFaceExtraID].uEventID,
3771  a1, 1);
3772  }
3773  return 0;
3774  break;
3775  }
3776  return 0;
3777 }

Перекрестные ссылки ActorInteraction(), current_screen_type, Dead, DecorationInteraction(), Dying, EventProcessor(), GameUI_StatusBar_NothingHere(), ItemInteraction(), LEVEL_Outdoor, logger, OBJECT_Actor, OBJECT_BModel, OBJECT_Decoration, OBJECT_Item, pActors, OutdoorLocation::pBModels, IndoorLocation::pFaceExtras, IndoorLocation::pFaces, pIndoor, pOutdoor, pSpriteObjects, SCREEN_BRANCHLESS_NPC_DIALOG, Summoned, BLVFace::uAttributes, uCurrentlyLoadedLevelType, BLVFaceExtra::uEventID, BLVFace::uFaceExtraID и Log::Warning().

Используется в Application::Game::OnPressSpace().

+ Граф вызовов:
+ Граф вызова функции:

◆ sub_4AAEA6_transform()

int sub_4AAEA6_transform ( struct RenderVertexSoft *  a1)

◆ FaceFlowTextureOffset()

unsigned int FaceFlowTextureOffset ( unsigned int  uFaceID)

См. определение в файле Indoor.cpp строка 562

562  { // time texture offset
563  Lights.pDeltaUV[0] = pIndoor->pFaceExtras[pIndoor->pFaces[uFaceID].uFaceExtraID].sTextureDeltaU;
564  Lights.pDeltaUV[1] = pIndoor->pFaceExtras[pIndoor->pFaces[uFaceID].uFaceExtraID].sTextureDeltaV;
565 
566  unsigned int offset = OS_GetTime() >> 3;
567 
568  if (pIndoor->pFaces[uFaceID].uAttributes & FACE_FLOW_DIAGONAL) {
569  Lights.pDeltaUV[1] -= offset & (((Texture *)pIndoor->pFaces[uFaceID].resource)->GetHeight() - 1); // pBitmaps_LOD->GetTexture(pIndoor->pFaces[uFaceID].uBitmapID)->uHeightMinus1;
570  } else if (pIndoor->pFaces[uFaceID].uAttributes & FACE_FLOW_VERTICAL) {
571  Lights.pDeltaUV[1] += offset & (((Texture *)pIndoor->pFaces[uFaceID].resource)->GetHeight() - 1); // pBitmaps_LOD->GetTexture(pIndoor->pFaces[uFaceID].uBitmapID)->uHeightMinus1;
572  }
573 
574  if (pIndoor->pFaces[uFaceID].uAttributes & FACE_FLOW_HORIZONTAL) {
575  Lights.pDeltaUV[0] -= offset & (((Texture *)pIndoor->pFaces[uFaceID].resource)->GetWidth() - 1); // pBitmaps_LOD->GetTexture(pIndoor->pFaces[uFaceID].uBitmapID)->uWidthMinus1;
576  } else if (pIndoor->pFaces[uFaceID].uAttributes & FACE_DONT_CACHE_TEXTURE) {
577  Lights.pDeltaUV[0] += offset & (((Texture *)pIndoor->pFaces[uFaceID].resource)->GetWidth() - 1); // pBitmaps_LOD->GetTexture(pIndoor->pFaces[uFaceID].uBitmapID)->uWidthMinus1;
578  }
579 
580  return offset;
581 }

Перекрестные ссылки Lights, OS_GetTime(), LightsData::pDeltaUV, IndoorLocation::pFaceExtras, IndoorLocation::pFaces, pIndoor, BLVFace::resource, BLVFaceExtra::sTextureDeltaU, BLVFaceExtra::sTextureDeltaV, BLVFace::uAttributes и BLVFace::uFaceExtraID.

Используется в IndoorLocation::ExecDraw_d3d().

+ Граф вызовов:
+ Граф вызова функции:

◆ BLV_UpdateUserInputAndOther()

void BLV_UpdateUserInputAndOther ( )

См. определение в файле Indoor.cpp строка 3779

3779  {
3780  UpdateObjects();
3781  BLV_ProcessPartyActions();
3782  UpdateActors_BLV();
3783  BLV_UpdateDoors();
3784  check_event_triggers();
3785 }

Перекрестные ссылки BLV_ProcessPartyActions(), BLV_UpdateDoors(), check_event_triggers(), UpdateActors_BLV() и UpdateObjects().

Используется в UpdateUserInput_and_MapSpecificStuff().

+ Граф вызовов:
+ Граф вызова функции:

◆ BLV_GetFloorLevel()

int BLV_GetFloorLevel ( int  x,
int  y,
int  z,
unsigned int  uSectorID,
unsigned int *  pFaceID 
)

См. определение в файле Indoor.cpp строка 2530

2531  {
2532  int v13; // ecx@13
2533  signed int v14; // ebx@14
2534  int v15; // eax@16
2535  int v21; // eax@27
2536  signed int v28; // eax@45
2537  int v29; // ebx@47
2538  int v38; // edx@62
2539  bool v47; // [sp+24h] [bp-1Ch]@43
2540  bool current_vertices_Y; // [sp+28h] [bp-18h]@10
2541  bool v49; // [sp+28h] [bp-18h]@41
2542  bool next_vertices_Y; // [sp+2Ch] [bp-14h]@12
2543  int number_hits; // [sp+30h] [bp-10h]@10
2544  int v54; // [sp+30h] [bp-10h]@41
2545  int v55; // [sp+34h] [bp-Ch]@1
2546 
2547  static int blv_floor_id[50]; // 00721200
2548  static int blv_floor_level[50]; // 007212C8
2549 
2550  static __int16 blv_floor_face_vert_coord_Y[104]; // word_721390_ys
2551  static __int16 blv_floor_face_vert_coord_X[104]; // word_721460_xs
2552 
2553  BLVSector *pSector = &pIndoor->pSectors[uSectorID];
2554  v55 = 0;
2555  for (uint i = 0; i < pSector->uNumFloors; ++i) {
2556  BLVFace *pFloor = &pIndoor->pFaces[pSector->pFloors[i]];
2557  if (pFloor->Ethereal()) continue;
2558 
2559  assert(pFloor->uNumVertices);
2560  if (x <= pFloor->pBounding.x2 && x >= pFloor->pBounding.x1 &&
2561  y <= pFloor->pBounding.y2 && y >= pFloor->pBounding.y1) {
2562  for (uint j = 0; j < pFloor->uNumVertices; ++j) {
2563  blv_floor_face_vert_coord_X[2 * j] =
2564  pFloor->pXInterceptDisplacements[j] +
2565  pIndoor->pVertices[pFloor->pVertexIDs[j]].x;
2566  blv_floor_face_vert_coord_X[2 * j + 1] =
2567  pFloor->pXInterceptDisplacements[j] +
2568  pIndoor->pVertices[pFloor->pVertexIDs[j + 1]].x;
2569  blv_floor_face_vert_coord_Y[2 * j] =
2570  pFloor->pYInterceptDisplacements[j] +
2571  pIndoor->pVertices[pFloor->pVertexIDs[j]].y;
2572  blv_floor_face_vert_coord_Y[2 * j + 1] =
2573  pFloor->pYInterceptDisplacements[j] +
2574  pIndoor->pVertices[pFloor->pVertexIDs[j + 1]].y;
2575  }
2576  blv_floor_face_vert_coord_X[2 * pFloor->uNumVertices] =
2577  blv_floor_face_vert_coord_X[0];
2578  blv_floor_face_vert_coord_Y[2 * pFloor->uNumVertices] =
2579  blv_floor_face_vert_coord_Y[0];
2580 
2581  next_vertices_Y = blv_floor_face_vert_coord_Y[0] >= y;
2582  number_hits = 0;
2583 
2584  for (uint j = 0; j < 2 * pFloor->uNumVertices; ++j) {
2585  if (number_hits >= 2) break;
2586 
2587  current_vertices_Y = next_vertices_Y;
2588  next_vertices_Y = blv_floor_face_vert_coord_Y[j + 1] >= y;
2589 
2590  v13 = i;
2591  if (current_vertices_Y == next_vertices_Y) continue;
2592 
2593  v14 = blv_floor_face_vert_coord_X[j + 1] >= x ? 0 : 2;
2594  v15 = v14 | (blv_floor_face_vert_coord_X[j] < x);
2595 
2596  if (v15 == 3) {
2597  continue;
2598  } else if (!v15) {
2599  ++number_hits;
2600  } else {
2601  long long a_div_b =
2602  fixpoint_div(y - blv_floor_face_vert_coord_Y[j],
2603  blv_floor_face_vert_coord_Y[j + 1] -
2604  blv_floor_face_vert_coord_Y[j]);
2605  long long res = fixpoint_mul(
2606  (signed int)blv_floor_face_vert_coord_X[j + 1] -
2607  (signed int)blv_floor_face_vert_coord_X[j],
2608  a_div_b);
2609 
2610  if (res + blv_floor_face_vert_coord_X[j] >= x)
2611  ++number_hits;
2612  }
2613  }
2614 
2615  if (number_hits == 1) {
2616  if (v55 >= 50) break;
2617  if (pFloor->uPolygonType == POLYGON_Floor ||
2618  pFloor->uPolygonType == POLYGON_Ceiling)
2619  v21 = pIndoor->pVertices[pFloor->pVertexIDs[0]].z;
2620  else
2621  v21 = fixpoint_mul(pFloor->zCalc1, x) +
2622  fixpoint_mul(pFloor->zCalc2, y) +
2623  (short)(pFloor->zCalc3 >> 16);
2624  blv_floor_level[v55] = v21;
2625  blv_floor_id[v55] = pSector->pFloors[i];
2626  v55++;
2627  }
2628  }
2629  }
2630 
2631  if (pSector->field_0 & 8) {
2632  for (uint i = 0; i < pSector->uNumPortals; ++i) {
2633  BLVFace *portal = &pIndoor->pFaces[pSector->pPortals[i]];
2634  if (portal->uPolygonType != POLYGON_Floor) continue;
2635 
2636  if (!portal->uNumVertices) continue;
2637 
2638  if (x <= portal->pBounding.x2 && x >= portal->pBounding.x1 &&
2639  y <= portal->pBounding.y2 && y >= portal->pBounding.y1) {
2640  for (uint j = 0; j < portal->uNumVertices; ++j) {
2641  blv_floor_face_vert_coord_X[2 * j] =
2642  portal->pXInterceptDisplacements[j] +
2643  pIndoor->pVertices[portal->pVertexIDs[j]].x;
2644  blv_floor_face_vert_coord_X[2 * j + 1] =
2645  portal->pXInterceptDisplacements[j + 1] +
2646  pIndoor->pVertices[portal->pVertexIDs[j + 1]].x;
2647  blv_floor_face_vert_coord_Y[2 * j] =
2648  portal->pYInterceptDisplacements[j] +
2649  pIndoor->pVertices[portal->pVertexIDs[j]].y;
2650  blv_floor_face_vert_coord_Y[2 * j + 1] =
2651  portal->pYInterceptDisplacements[j + 1] +
2652  pIndoor->pVertices[portal->pVertexIDs[j + 1]].y;
2653  }
2654  blv_floor_face_vert_coord_X[2 * portal->uNumVertices] =
2655  blv_floor_face_vert_coord_X[0];
2656  blv_floor_face_vert_coord_Y[2 * portal->uNumVertices] =
2657  blv_floor_face_vert_coord_Y[0];
2658  v54 = 0;
2659  v47 = blv_floor_face_vert_coord_Y[0] >= y;
2660 
2661  for (uint j = 0; j < 2 * portal->uNumVertices; ++j) {
2662  v49 = v47;
2663  if (v54 >= 2) break;
2664  v47 = blv_floor_face_vert_coord_Y[j + 1] >= y;
2665  if (v49 != v47) {
2666  v28 = blv_floor_face_vert_coord_X[j + 1] >= x ? 0 : 2;
2667  v29 = v28 | (blv_floor_face_vert_coord_X[j] < x);
2668  if (v29 != 3) {
2669  if (!v29) {
2670  ++v54;
2671  } else {
2672  long long a_div_b = fixpoint_div(
2673  y - blv_floor_face_vert_coord_Y[j],
2674  blv_floor_face_vert_coord_Y[j + 1] -
2675  blv_floor_face_vert_coord_Y[j]);
2676  long long res = fixpoint_mul(
2677  blv_floor_face_vert_coord_X[j + 1] -
2678  blv_floor_face_vert_coord_X[j],
2679  a_div_b);
2680  if (res + blv_floor_face_vert_coord_X[j] >= x)
2681  ++v54;
2682  }
2683  }
2684  }
2685  }
2686  if (v54 == 1) {
2687  if (v55 >= 50) break;
2688  blv_floor_level[v55] = -29000;
2689  blv_floor_id[v55] = pSector->pPortals[i];
2690  v55++;
2691  }
2692  }
2693  }
2694  }
2695  if (v55 == 1) {
2696  *pFaceID = blv_floor_id[0];
2697  if (blv_floor_level[0] <= -29000) __debugbreak();
2698  return blv_floor_level[0];
2699  }
2700  if (!v55) return -30000;
2701  *pFaceID = blv_floor_id[0];
2702  // result = blv_floor_level[0];
2703 
2704  /*for ( v35 = 1; v35 < v55; ++v35 )
2705  {
2706  if ( blv_floor_level[0] <= z + 5 )
2707  {
2708  if ( blv_floor_level[v35] >= blv_floor_level[0] || blv_floor_level[v35]
2709  > z + 5 ) continue; blv_floor_level[0] = blv_floor_level[v35]; *pFaceID =
2710  blv_floor_id[v35]; continue;
2711  }
2712  if ( blv_floor_level[v35] < blv_floor_level[0] )
2713  {
2714  blv_floor_level[0] = blv_floor_level[v35];
2715  *pFaceID = blv_floor_id[v35];
2716  }
2717  }*/
2718 
2719  int result = blv_floor_level[0];
2720  for (uint i = 1; i < v55; ++i) {
2721  v38 = blv_floor_level[i];
2722  if (result <= z + 5) {
2723  if (v38 > result && v38 <= z + 5) {
2724  result = blv_floor_level[i];
2725  if (blv_floor_level[i] <= -29000) __debugbreak();
2726  *pFaceID = blv_floor_id[i];
2727  }
2728  } else if (v38 < result) {
2729  result = blv_floor_level[i];
2730  if (blv_floor_level[i] < -29000) __debugbreak(); // crashes here when <=
2731  *pFaceID = blv_floor_id[i];
2732  }
2733  }
2734 
2735  return result;
2736 }

Перекрестные ссылки __debugbreak(), BLVFace::Ethereal(), BLVSector::field_0, fixpoint_div(), fixpoint_mul(), BLVFace::pBounding, IndoorLocation::pFaces, BLVSector::pFloors, pIndoor, POLYGON_Ceiling, POLYGON_Floor, BLVSector::pPortals, IndoorLocation::pSectors, BLVFace::pVertexIDs, IndoorLocation::pVertices, BLVFace::pXInterceptDisplacements, BLVFace::pYInterceptDisplacements, BLVSector::uNumFloors, BLVSector::uNumPortals, BLVFace::uNumVertices, BLVFace::uPolygonType, BBox_short_::x1, BBox_short_::y1, BLVFace::zCalc1, BLVFace::zCalc2 и BLVFace::zCalc3.

Используется в _45063B_spawn_some_monster(), collide_against_floor(), Engine::DrawGUI(), SpawnEncounter(), sub_44FA4C_spawn_light_elemental(), Actor::SummonMinion(), UpdateActors_BLV() и SpriteObject::UpdateObject_fn0_BLV().

+ Граф вызовов:
+ Граф вызова функции:

◆ BLV_UpdateDoors()

void BLV_UpdateDoors ( )

См. определение в файле Indoor.cpp строка 1506

1506  {
1507  BLVFace *face; // ebx@24
1508  Vec3_short_ *v17; // esi@24
1509  int v18; // eax@24
1510  int v19; // edx@24
1511  signed int v20; // eax@24
1512  int v24; // esi@25
1513  int v25; // eax@25
1514  signed __int64 v27; // qtt@27
1515  BLVFaceExtra *v28; // esi@32
1516  int v32; // eax@34
1517  Vec3_short_ *v34; // eax@35
1518  int v35; // ecx@35
1519  int v36; // edx@35
1520  signed int v37; // eax@35
1521  signed int v38; // edx@35
1522  int v39; // eax@35
1523  int v40; // edx@35
1524  Vec3_short_ *v43; // edi@36
1525  int v57; // eax@58
1526  Vec3_int_ v67;
1527  Vec3_int_ v70;
1528  int v73; // [sp+20h] [bp-44h]@24
1529  int v75; // [sp+28h] [bp-3Ch]@36
1530  int v76; // [sp+2Ch] [bp-38h]@36
1531  int v77; // [sp+30h] [bp-34h]@36
1532  int v82; // [sp+44h] [bp-20h]@35
1533  int v83; // [sp+48h] [bp-1Ch]@34
1534  int v84; // [sp+4Ch] [bp-18h]@34
1535  SoundID eDoorSoundID; // [sp+54h] [bp-10h]@1
1536  int v88; // [sp+5Ch] [bp-8h]@18
1537  int v89; // [sp+60h] [bp-4h]@6
1538 
1539  eDoorSoundID = (SoundID)
1540  pDoorSoundIDsByLocationID[dword_6BE13C_uCurrentlyLoadedLocationID];
1541  for (uint i = 0; i < pIndoor->uNumDoors; ++i) {
1542  BLVDoor *door = &pIndoor->pDoors[i];
1543  if (door->uState == BLVDoor::Closed || door->uState == BLVDoor::Open) {
1544  door->uAttributes &= 0xFFFFFFFDu; // ~0x2
1545  continue;
1546  }
1547  door->uTimeSinceTriggered += pEventTimer->uTimeElapsed;
1548  if (door->uState == BLVDoor::Opening) {
1549  v89 = (signed int)(door->uTimeSinceTriggered * door->uCloseSpeed) /
1550  128;
1551  if (v89 >= door->uMoveLength) {
1552  v89 = door->uMoveLength;
1553  door->uState = BLVDoor::Open;
1554  if (!(door->uAttributes & FACE_UNKNOW5) &&
1555  door->uNumVertices != 0)
1556  pAudioPlayer->PlaySound((SoundID)((int)eDoorSoundID + 1), PID(OBJECT_BLVDoor, i), 0, -1, 0, 0);
1557  // goto LABEL_18;
1558  } else if (!(door->uAttributes & FACE_UNKNOW5) &&
1559  door->uNumVertices) {
1560  pAudioPlayer->PlaySound(eDoorSoundID, PID(OBJECT_BLVDoor, i), 1,
1561  -1, 0, 0);
1562  }
1563  } else {
1564  signed int v5 =
1565  (signed int)(door->uTimeSinceTriggered * door->uOpenSpeed) /
1566  128;
1567  if (v5 >= door->uMoveLength) {
1568  v89 = 0;
1569  door->uState = BLVDoor::Closed;
1570  if (!(door->uAttributes & FACE_UNKNOW5) &&
1571  door->uNumVertices != 0)
1572  pAudioPlayer->PlaySound((SoundID)((int)eDoorSoundID + 1),
1573  PID(OBJECT_BLVDoor, i), 0, -1, 0, 0);
1574  // goto LABEL_18;
1575  } else {
1576  v89 = door->uMoveLength - v5;
1577  if (!(door->uAttributes & FACE_UNKNOW5) && door->uNumVertices)
1578  pAudioPlayer->PlaySound(eDoorSoundID,
1579  PID(OBJECT_BLVDoor, i), 1, -1, 0, 0);
1580  }
1581  }
1582 
1583  // LABEL_18:
1584  for (uint j = 0; j < door->uNumVertices; ++j) {
1585  pIndoor->pVertices[door->pVertexIDs[j]].x =
1586  fixpoint_mul(door->vDirection.x, v89) + door->pXOffsets[j];
1587  pIndoor->pVertices[door->pVertexIDs[j]].y =
1588  fixpoint_mul(door->vDirection.y, v89) + door->pYOffsets[j];
1589  pIndoor->pVertices[door->pVertexIDs[j]].z =
1590  fixpoint_mul(door->vDirection.z, v89) + door->pZOffsets[j];
1591  }
1592  for (v88 = 0; v88 < door->uNumFaces; ++v88) {
1593  face = &pIndoor->pFaces[door->pFaceIDs[v88]];
1594  v17 = &pIndoor->pVertices[face->pVertexIDs[0]];
1595  v18 = face->pFacePlane_old.vNormal.y;
1596  v73 = *(int *)&v17->x;
1597  v19 = face->pFacePlane_old.vNormal.z;
1598  v20 = -(v19 * (int)v17->z +
1599  (signed __int16)v73 * face->pFacePlane_old.vNormal.x +
1600  HEXRAYS_SHIWORD(v73) * v18);
1601  face->pFacePlane_old.dist = v20;
1602  face->pFacePlane.dist =
1603  -((double)v17->z * face->pFacePlane.vNormal.z +
1604  (double)v17->y * face->pFacePlane.vNormal.y +
1605  (double)v17->x * face->pFacePlane.vNormal.x);
1606  if (v19) {
1607  v24 = abs(v20 >> 15);
1608  v25 = abs(face->pFacePlane_old.vNormal.z);
1609  if (v24 > v25)
1610  Error(
1611  "Door Error\ndoor id: %i\nfacet no: %i\n\nOverflow "
1612  "dividing facet->d [%i] by facet->nz [%i]",
1613  door->uDoorID, door->pFaceIDs[v88],
1614  face->pFacePlane_old.dist,
1615  face->pFacePlane_old.vNormal.z);
1616  HEXRAYS_LODWORD(v27) = face->pFacePlane_old.dist << 16;
1617  HEXRAYS_HIDWORD(v27) = face->pFacePlane_old.dist >> 16;
1618  face->zCalc3 = -v27 / face->pFacePlane_old.vNormal.z;
1619  }
1620  // if ( face->uAttributes & FACE_TEXTURE_FLOW || render->pRenderD3D
1621  // )
1622  face->_get_normals(&v70, &v67);
1623  v28 = &pIndoor->pFaceExtras[face->uFaceExtraID];
1624  /*if ( !render->pRenderD3D )
1625  {
1626  if ( !(face->uAttributes & FACE_TEXTURE_FLOW) )
1627  continue;
1628  v83 = (unsigned __int64)(door->vDirection.x * (signed __int64)v70.x)
1629  >> 16; v85 = (unsigned __int64)(door->vDirection.y * (signed
1630  __int64)v70.y) >> 16; v84 = (unsigned __int64)(door->vDirection.z *
1631  (signed __int64)v70.z) >> 16; v29 = v89; v28->sTextureDeltaU =
1632  -((v83 + v85 + v84) * (signed __int64)v89) >> 16; v85 = (unsigned
1633  __int64)(door->vDirection.x * (signed __int64)v67.x) >> 16; v83 =
1634  (unsigned __int64)(door->vDirection.y * (signed __int64)v67.y) >>
1635  16; v84 = (unsigned __int64)(door->vDirection.z * (signed
1636  __int64)v67.z) >> 16; v31 = (v85 + v83 + v84) * (signed __int64)v29;
1637  v32 = v31 >> 16;
1638  v57 = -v32;
1639  v28->sTextureDeltaV = v57;
1640  v28->sTextureDeltaU += door->pDeltaUs[v88];
1641  v28->sTextureDeltaV = v57 + door->pDeltaVs[v88];
1642  continue;
1643  }*/
1644  v28->sTextureDeltaU = 0;
1645  v28->sTextureDeltaV = 0;
1646  v34 = &pIndoor->pVertices[face->pVertexIDs[0]];
1647  v35 = v34->z;
1648  v36 = v34->y;
1649  v82 = v34->x;
1650  v37 = v70.x * v82 + v70.y * v36 + v70.z * v35;
1651  v38 = v67.x * v82 + v67.y * v36 + v67.z * v35;
1652  v39 = v37 >> 16;
1653  *face->pVertexUIDs = v39;
1654  v40 = v38 >> 16;
1655  *face->pVertexVIDs = v40;
1656  v84 = v39;
1657  v82 = v40;
1658  for (uint j = 1; j < face->uNumVertices; ++j) {
1659  v43 = &pIndoor->pVertices[face->pVertexIDs[j]];
1660  v76 = ((__int64)v70.z * v43->z + (__int64)v70.x * v43->x +
1661  (__int64)v70.y * v43->y) >>
1662  16;
1663  v77 = ((__int64)v67.x * v43->x + (__int64)v67.y * v43->y +
1664  (__int64)v43->z * v67.z) >>
1665  16;
1666  if (v76 < v39) v39 = v76;
1667  if (v77 < v40) v40 = v77;
1668  if (v76 > v84) v84 = v76;
1669  if (v77 > v82) v82 = v77;
1670  face->pVertexUIDs[j] = v76;
1671  face->pVertexVIDs[j] = v77;
1672  }
1673  if (face->uAttributes & 0x00001000) {
1674  v28->sTextureDeltaU -= v39;
1675  } else {
1676  if (face->uAttributes & 0x8000) {
1677  if (face->resource) {
1678  // v28->sTextureDeltaU -= v84 +
1679  // pBitmaps_LOD->pTextures[face->uBitmapID].uTextureWidth;
1680  v28->sTextureDeltaU -=
1681  v84 + ((Texture *)face->resource)->GetWidth();
1682  }
1683  }
1684  }
1685  if (face->uAttributes & FACE_UNKNOW6) {
1686  v28->sTextureDeltaV -= v40;
1687  } else {
1688  if (face->uAttributes & FACE_INDOOR_DOOR) {
1689  v28->sTextureDeltaV -=
1690  v84 + ((Texture *)face->resource)->GetHeight();
1691  // if (face->uBitmapID != -1)
1692  // v28->sTextureDeltaV -= v82 +
1693  // pBitmaps_LOD->GetTexture(face->uBitmapID)->uTextureHeight;
1694  }
1695  }
1696  if (face->uAttributes & FACE_TEXTURE_FLOW) {
1697  v84 = fixpoint_mul(door->vDirection.x, v70.x);
1698  v82 = fixpoint_mul(door->vDirection.y, v70.y);
1699  v83 = fixpoint_mul(door->vDirection.z, v70.z);
1700  v75 = v84 + v82 + v83;
1701  v82 = fixpoint_mul(v75, v89);
1702  v28->sTextureDeltaU = -v82;
1703  v84 = fixpoint_mul(door->vDirection.x, v67.x);
1704  v82 = fixpoint_mul(door->vDirection.y, v67.y);
1705  v83 = fixpoint_mul(door->vDirection.z, v67.z);
1706  v75 = v84 + v82 + v83;
1707  v32 = fixpoint_mul(v75, v89);
1708  v57 = -v32;
1709  v28->sTextureDeltaV = v57;
1710  v28->sTextureDeltaU += door->pDeltaUs[v88];
1711  v28->sTextureDeltaV = v57 + door->pDeltaVs[v88];
1712  }
1713  }
1714  }
1715 }

Перекрестные ссылки BLVDoor::Closed, dword_6BE13C_uCurrentlyLoadedLocationID, fixpoint_mul(), OBJECT_BLVDoor, BLVDoor::Open, BLVDoor::Opening, pAudioPlayer, BLVDoor::pDeltaUs, BLVDoor::pDeltaVs, IndoorLocation::pDoors, pDoorSoundIDsByLocationID, pEventTimer, IndoorLocation::pFaceExtras, BLVDoor::pFaceIDs, IndoorLocation::pFaces, pIndoor, AudioPlayer::PlaySound(), BLVDoor::pVertexIDs, IndoorLocation::pVertices, BLVDoor::pXOffsets, BLVDoor::pYOffsets, BLVDoor::pZOffsets, BLVFaceExtra::sTextureDeltaU, BLVFaceExtra::sTextureDeltaV, BLVDoor::uAttributes, BLVDoor::uCloseSpeed, BLVDoor::uDoorID, BLVDoor::uMoveLength, IndoorLocation::uNumDoors, BLVDoor::uNumFaces, BLVDoor::uNumVertices, BLVDoor::uOpenSpeed, BLVDoor::uState, Timer::uTimeElapsed, BLVDoor::uTimeSinceTriggered и BLVDoor::vDirection.

Используется в BLV_UpdateUserInputAndOther().

+ Граф вызовов:
+ Граф вызова функции:

◆ UpdateActors_BLV()

void UpdateActors_BLV ( )

См. определение в файле Indoor.cpp строка 1718

1718  {
1719  int v2; // edi@6
1720  int v3; // eax@6
1721  int v4; // eax@8
1722  __int16 v5; // ax@11
1723  signed int v6; // ebx@14
1724  signed __int64 v10; // qax@18
1725  int v22; // edi@46
1726  unsigned int v24; // eax@51
1727  int v27; // ST08_4@54
1728  int v28; // edi@54
1729  int v29; // eax@54
1730  int v30; // ecx@62
1731  int v31; // ebx@62
1732  int v32; // eax@62
1733  int v33; // eax@64
1734  int v37; // ebx@85
1735  int v44; // ecx@96
1736  int v45; // edi@101
1737  AIDirection v52; // [sp+0h] [bp-60h]@75
1738  AIDirection v53; // [sp+1Ch] [bp-44h]@116
1739  unsigned int uSectorID; // [sp+3Ch] [bp-24h]@6
1740  int v56; // [sp+40h] [bp-20h]@6
1741  unsigned int _this; // [sp+44h] [bp-1Ch]@51
1742  int v58; // [sp+48h] [bp-18h]@51
1743  int v59; // [sp+4Ch] [bp-14h]@8
1744  unsigned int uFaceID; // [sp+50h] [bp-10h]@6
1745  int v61; // [sp+54h] [bp-Ch]@14
1746  int v62; // [sp+58h] [bp-8h]@6
1747  unsigned int actor_id; // [sp+5Ch] [bp-4h]@1
1748 
1749  if (engine->config->no_actors)
1750  return; // uNumActors = 0;
1751 
1752  for (actor_id = 0; actor_id < uNumActors; actor_id++) {
1753  if (pActors[actor_id].uAIState == Removed ||
1754  pActors[actor_id].uAIState == Disabled ||
1755  pActors[actor_id].uAIState == Summoned ||
1756  !pActors[actor_id].uMovementSpeed)
1757  continue;
1758  uSectorID = pActors[actor_id].uSectorID;
1759  v2 = collide_against_floor(
1760  pActors[actor_id].vPosition.x, pActors[actor_id].vPosition.y,
1761  pActors[actor_id].vPosition.z, &uSectorID, &uFaceID);
1762  pActors[actor_id].uSectorID = uSectorID;
1763  v3 = pActors[actor_id].pMonsterInfo.uFlying;
1764  v56 = v2;
1765  v62 = v3;
1766  if (!pActors[actor_id].CanAct()) v62 = 0;
1767  v4 = pActors[actor_id].vPosition.z;
1768  v59 = 0;
1769  if (pActors[actor_id].vPosition.z > v2 + 1) v59 = 1;
1770  if (v2 <= -30000) {
1771  v5 = pIndoor->GetSector(pActors[actor_id].vPosition.x,
1772  pActors[actor_id].vPosition.y, v4);
1773  pActors[actor_id].uSectorID = v5;
1774  v56 = BLV_GetFloorLevel(
1775  pActors[actor_id].vPosition.x, pActors[actor_id].vPosition.y,
1776  pActors[actor_id].vPosition.z, v5, &uFaceID);
1777  if (!v5 || v56 == -30000) continue;
1778  }
1779  if (pActors[actor_id].uCurrentActionAnimation ==
1780  ANIM_Walking) { //монстр двигается
1781  v6 = pActors[actor_id].uMovementSpeed;
1782  if (pActors[actor_id].pActorBuffs[ACTOR_BUFF_SLOWED].Active()) {
1783  if (pActors[actor_id].pActorBuffs[ACTOR_BUFF_SLOWED].uPower)
1784  HEXRAYS_LODWORD(v10) = pActors[actor_id].uMovementSpeed /
1785  (unsigned __int16)pActors[actor_id]
1786  .pActorBuffs[ACTOR_BUFF_SLOWED]
1787  .uPower;
1788  else
1789  v10 = (signed __int64)((double)pActors[actor_id]
1790  .uMovementSpeed *
1791  0.5);
1792  v6 = v10;
1793  }
1794  if (pActors[actor_id].uAIState == Pursuing ||
1795  pActors[actor_id].uAIState == Fleeing)
1796  v6 *= 2;
1797  if (pParty->bTurnBasedModeOn && pTurnEngine->turn_stage == TE_WAIT)
1798  v6 = (signed __int64)((double)v6 *
1799  flt_6BE3AC_debug_recmod1_x_1_6);
1800  if (v6 > 1000) v6 = 1000;
1801  pActors[actor_id].vVelocity.x =
1802  fixpoint_mul(stru_5C6E00->Cos(pActors[actor_id].uYawAngle), v6);
1803  pActors[actor_id].vVelocity.y =
1804  fixpoint_mul(stru_5C6E00->Sin(pActors[actor_id].uYawAngle), v6);
1805  if (v62)
1806  pActors[actor_id].vVelocity.z = fixpoint_mul(
1807  stru_5C6E00->Sin(pActors[actor_id].uPitchAngle), v6);
1808  } else { // actor is not moving(актор не двигается)
1809  pActors[actor_id].vVelocity.x =
1810  fixpoint_mul(55000, pActors[actor_id].vVelocity.x);
1811  pActors[actor_id].vVelocity.y =
1812  fixpoint_mul(55000, pActors[actor_id].vVelocity.y);
1813  if (v62)
1814  pActors[actor_id].vVelocity.z =
1815  fixpoint_mul(55000, pActors[actor_id].vVelocity.z);
1816  }
1817  if (pActors[actor_id].vPosition.z <= v56) {
1818  pActors[actor_id].vPosition.z = v56 + 1;
1819  if (pIndoor->pFaces[uFaceID].uPolygonType == 3) {
1820  if (pActors[actor_id].vVelocity.z < 0)
1821  pActors[actor_id].vVelocity.z = 0;
1822  } else {
1823  if (pIndoor->pFaces[uFaceID].pFacePlane_old.vNormal.z < 45000)
1824  pActors[actor_id].vVelocity.z -=
1825  (short)pEventTimer->uTimeElapsed * GetGravityStrength();
1826  }
1827  } else {
1828  if (v59 && !v62)
1829  pActors[actor_id].vVelocity.z +=
1830  -8 * (short)pEventTimer->uTimeElapsed *
1831  GetGravityStrength();
1832  }
1833  if (pActors[actor_id].vVelocity.x * pActors[actor_id].vVelocity.x +
1834  pActors[actor_id].vVelocity.y * pActors[actor_id].vVelocity.y +
1835  pActors[actor_id].vVelocity.z * pActors[actor_id].vVelocity.z >=
1836  400) {
1837  stru_721530.field_84 = -1;
1838  stru_721530.field_70 = 0;
1839  stru_721530.field_0 = 1;
1840  stru_721530.field_8_radius = pActors[actor_id].uActorRadius;
1841  stru_721530.prolly_normal_d = pActors[actor_id].uActorRadius;
1842  stru_721530.height = pActors[actor_id].uActorHeight;
1843  v22 = 0;
1844  for (uSectorID = 0; uSectorID < 100; uSectorID++) {
1845  stru_721530.position.x = pActors[actor_id].vPosition.x;
1846  stru_721530.normal.x = stru_721530.position.x;
1847  stru_721530.position.y = pActors[actor_id].vPosition.y;
1848  stru_721530.normal.y = stru_721530.position.y;
1849  stru_721530.normal.z = pActors[actor_id].vPosition.z +
1850  pActors[actor_id].uActorRadius + 1;
1851  stru_721530.position.z = pActors[actor_id].vPosition.z -
1852  pActors[actor_id].uActorRadius +
1853  stru_721530.height - 1;
1854  if (stru_721530.position.z < stru_721530.normal.z)
1855  stru_721530.position.z = pActors[actor_id].vPosition.z +
1856  pActors[actor_id].uActorRadius + 1;
1857  stru_721530.velocity.x = pActors[actor_id].vVelocity.x;
1858  stru_721530.velocity.y = pActors[actor_id].vVelocity.y;
1859  stru_721530.velocity.z = pActors[actor_id].vVelocity.z;
1860  stru_721530.uSectorID = pActors[actor_id].uSectorID;
1861  if (!stru_721530.CalcMovementExtents(v22)) {
1862  v58 = 0;
1863  v24 = 8 * actor_id;
1864  HEXRAYS_LOBYTE(v24) = PID(OBJECT_Actor, actor_id);
1865  for (v61 = 0; v61 < 100; ++v61) {
1866  _46E44E_collide_against_faces_and_portals(1);
1867  _46E0B2_collide_against_decorations();
1868  _46EF01_collision_chech_player(0);
1869  _46ED8A_collide_against_sprite_objects(v24);
1870  for (uint j = 0; j < ai_arrays_size; j++) {
1871  if (ai_near_actors_ids[j] != actor_id) {
1872  v27 = abs(
1873  pActors[ai_near_actors_ids[j]].vPosition.z -
1874  pActors[actor_id].vPosition.z);
1875  v28 = abs(
1876  pActors[ai_near_actors_ids[j]].vPosition.y -
1877  pActors[actor_id].vPosition.y);
1878  v29 = abs(
1879  pActors[ai_near_actors_ids[j]].vPosition.x -
1880  pActors[actor_id].vPosition.x);
1881  if (int_get_vector_length(v29, v28, v27) >=
1882  pActors[actor_id].uActorRadius +
1883  (signed int)
1884  pActors[ai_near_actors_ids[j]]
1885  .uActorRadius &&
1886  Actor::_46DF1A_collide_against_actor(
1887  ai_near_actors_ids[j], 40))
1888  ++v58;
1889  }
1890  }
1891  if (_46F04E_collide_against_portals()) break;
1892  }
1893  v56 = v58 > 1;
1894  if (stru_721530.field_7C >= stru_721530.field_6C) {
1895  v30 = stru_721530.normal2.x;
1896  v31 = stru_721530.normal2.y;
1897  v32 = stru_721530.normal2.z -
1898  stru_721530.prolly_normal_d - 1;
1899  } else {
1900  v30 = pActors[actor_id].vPosition.x +
1901  fixpoint_mul(stru_721530.field_7C,
1902  stru_721530.direction.x);
1903  v31 = pActors[actor_id].vPosition.y +
1904  fixpoint_mul(stru_721530.field_7C,
1905  stru_721530.direction.y);
1906  v32 = pActors[actor_id].vPosition.z +
1907  fixpoint_mul(stru_721530.field_7C,
1908  stru_721530.direction.z);
1909  }
1910  v33 = collide_against_floor(
1911  v30, v31, v32, &stru_721530.uSectorID, &uFaceID);
1912  if (pIndoor->pFaces[uFaceID].uAttributes &
1913  FACE_INDOOR_SKY &&
1914  pActors[actor_id].uAIState == Dead) {
1915  pActors[actor_id].uAIState = Removed;
1916  continue;
1917  }
1918  if (v59 || v62 ||
1919  !(pIndoor->pFaces[uFaceID].uAttributes &
1920  FACE_INDOOR_SKY)) {
1921  if (v33 == -30000) continue;
1922  if (pActors[actor_id].uCurrentActionAnimation != 1 ||
1923  v33 >= pActors[actor_id].vPosition.z - 100 || v59 ||
1924  v62) {
1925  if (stru_721530.field_7C < stru_721530.field_6C) {
1926  pActors[actor_id].vPosition.x +=
1927  fixpoint_mul(stru_721530.field_7C,
1928  stru_721530.direction.x);
1929  pActors[actor_id].vPosition.y +=
1930  fixpoint_mul(stru_721530.field_7C,
1931  stru_721530.direction.y);
1932  pActors[actor_id].vPosition.z +=
1933  fixpoint_mul(stru_721530.field_7C,
1934  stru_721530.direction.z);
1935  pActors[actor_id].uSectorID =
1936  (short)stru_721530.uSectorID;
1937  stru_721530.field_70 += stru_721530.field_7C;
1938  v37 = PID_ID(stru_721530.pid);
1939  if (PID_TYPE(stru_721530.pid) == OBJECT_Actor) {
1940  if (pParty->bTurnBasedModeOn &&
1941  (pTurnEngine->turn_stage == TE_ATTACK ||
1942  pTurnEngine->turn_stage == TE_MOVEMENT)) {
1943  pActors[actor_id].vVelocity.x =
1944  fixpoint_mul(58500, pActors[actor_id].vVelocity.x);
1945  pActors[actor_id].vVelocity.y =
1946  fixpoint_mul(58500, pActors[actor_id].vVelocity.y);
1947  pActors[actor_id].vVelocity.z =
1948  fixpoint_mul(
1949  58500,
1950  pActors[actor_id].vVelocity.z);
1951  v22 = 0;
1952  continue;
1953  }
1954  if (pActors[actor_id]
1955  .pMonsterInfo.uHostilityType) {
1956  if (!v56) {
1957  Actor::AI_Flee(actor_id,
1958  stru_721530.pid, v22,
1959  (AIDirection *)v22);
1960  pActors[actor_id]
1961  .vVelocity.x = fixpoint_mul(
1962  58500,
1963  pActors[actor_id].vVelocity.x);
1964  pActors[actor_id]
1965  .vVelocity.y = fixpoint_mul(
1966  58500,
1967  pActors[actor_id].vVelocity.y);
1968  pActors[actor_id]
1969  .vVelocity.z = fixpoint_mul(
1970  58500,
1971  pActors[actor_id].vVelocity.z);
1972  v22 = 0;
1973  continue;
1974  }
1975  } else {
1976  if (!v56) {
1977  if (!pActors[v37]
1978  .pMonsterInfo
1979  .uHostilityType) {
1980  Actor::AI_FaceObject(
1981  actor_id, stru_721530.pid,
1982  v22, (AIDirection *)v22);
1983  pActors[actor_id].vVelocity.x =
1984  fixpoint_mul(
1985  58500,
1986  pActors[actor_id]
1987  .vVelocity.x);
1988  pActors[actor_id].vVelocity.y =
1989  fixpoint_mul(
1990  58500,
1991  pActors[actor_id]
1992  .vVelocity.y);
1993  pActors[actor_id].vVelocity.z =
1994  fixpoint_mul(
1995  58500,
1996  pActors[actor_id]
1997  .vVelocity.z);
1998  v22 = 0;
1999  continue;
2000  }
2001  Actor::AI_Flee(actor_id,
2002  stru_721530.pid, v22,
2003  (AIDirection *)v22);
2004  pActors[actor_id]
2005  .vVelocity.x = fixpoint_mul(
2006  58500,
2007  pActors[actor_id].vVelocity.x);
2008  pActors[actor_id]
2009  .vVelocity.y = fixpoint_mul(
2010  58500,
2011  pActors[actor_id].vVelocity.y);
2012  pActors[actor_id]
2013  .vVelocity.z = fixpoint_mul(
2014  58500,
2015  pActors[actor_id].vVelocity.z);
2016  v22 = 0;
2017  continue;
2018  }
2019  }
2020  Actor::AI_StandOrBored(actor_id, 4, v22,
2021  &v53);
2022  pActors[actor_id].vVelocity.x =
2023  fixpoint_mul(
2024  58500,
2025  pActors[actor_id].vVelocity.x);
2026  pActors[actor_id].vVelocity.y =
2027  fixpoint_mul(
2028  58500,
2029  pActors[actor_id].vVelocity.y);
2030  pActors[actor_id].vVelocity.z =
2031  fixpoint_mul(
2032  58500,
2033  pActors[actor_id].vVelocity.z);
2034  v22 = 0;
2035  continue;
2036  }
2037  if (PID_TYPE(stru_721530.pid) ==
2038  OBJECT_Player) {
2039  if (pActors[actor_id].GetActorsRelation(
2040  0)) {
2041  // v51 =
2042  // __OFSUB__(HIDWORD(pParty->pPartyBuffs[PARTY_BUFF_INVISIBILITY].uExpireTime),
2043  // v22); v49 =
2044  // HIDWORD(pParty->pPartyBuffs[PARTY_BUFF_INVISIBILITY].uExpireTime)
2045  // == v22; v50 =
2046  // HIDWORD(pParty->pPartyBuffs[PARTY_BUFF_INVISIBILITY].uExpireTime)
2047  // - v22 < 0;
2048  pActors[actor_id].vVelocity.y = 0;
2049  pActors[actor_id].vVelocity.x = 0;
2050  if (pParty
2051  ->pPartyBuffs
2052  [PARTY_BUFF_INVISIBILITY]
2053  .Active()) {
2054  pParty
2055  ->pPartyBuffs
2056  [PARTY_BUFF_INVISIBILITY]
2057  .Reset();
2058  }
2059 
2060  viewparams->bRedrawGameUI = 1;
2061  pActors[actor_id].vVelocity.x =
2062  fixpoint_mul(
2063  58500,
2064  pActors[actor_id].vVelocity.x);
2065  pActors[actor_id].vVelocity.y =
2066  fixpoint_mul(
2067  58500,
2068  pActors[actor_id].vVelocity.y);
2069  pActors[actor_id].vVelocity.z =
2070  fixpoint_mul(
2071  58500,
2072  pActors[actor_id].vVelocity.z);
2073  continue;
2074  }
2075  Actor::AI_FaceObject(actor_id,
2076  stru_721530.pid, v22,
2077  (AIDirection *)v22);
2078  pActors[actor_id].vVelocity.x =
2079  fixpoint_mul(
2080  58500,
2081  pActors[actor_id].vVelocity.x);
2082  pActors[actor_id].vVelocity.y =
2083  fixpoint_mul(
2084  58500,
2085  pActors[actor_id].vVelocity.y);
2086  pActors[actor_id].vVelocity.z =
2087  fixpoint_mul(
2088  58500,
2089  pActors[actor_id].vVelocity.z);
2090  v22 = 0;
2091  continue;
2092  }
2093  if (PID_TYPE(stru_721530.pid) ==
2094  OBJECT_Decoration) {
2095  _this = integer_sqrt(
2096  pActors[actor_id].vVelocity.x *
2097  pActors[actor_id].vVelocity.x +
2098  pActors[actor_id].vVelocity.y *
2099  pActors[actor_id].vVelocity.y);
2100  v45 = stru_5C6E00->Atan2(
2101  pActors[actor_id].vPosition.x -
2102  pLevelDecorations[v37].vPosition.x,
2103  pActors[actor_id].vPosition.y -
2104  pLevelDecorations[v37].vPosition.y);
2105  pActors[actor_id].vVelocity.x =
2106  fixpoint_mul(stru_5C6E00->Cos(v45),
2107  _this);
2108  pActors[actor_id].vVelocity.y =
2109  fixpoint_mul(stru_5C6E00->Sin(v45),
2110  _this);
2111  pActors[actor_id].vVelocity.x =
2112  fixpoint_mul(
2113  58500,
2114  pActors[actor_id].vVelocity.x);
2115  pActors[actor_id].vVelocity.y =
2116  fixpoint_mul(
2117  58500,
2118  pActors[actor_id].vVelocity.y);
2119  pActors[actor_id].vVelocity.z =
2120  fixpoint_mul(
2121  58500,
2122  pActors[actor_id].vVelocity.z);
2123  v22 = 0;
2124  continue;
2125  }
2126  if (PID_TYPE(stru_721530.pid) ==
2127  OBJECT_BModel) {
2128  stru_721530.field_84 = stru_721530.pid >> 3;
2129  if (pIndoor->pFaces[v37].uPolygonType ==
2130  3) {
2131  pActors[actor_id].vVelocity.z = 0;
2132  pActors[actor_id].vPosition.z =
2133  pIndoor
2134  ->pVertices[*pIndoor
2135  ->pFaces[v37]
2136  .pVertexIDs]
2137  .z +
2138  1;
2139  if (pActors[actor_id].vVelocity.x *
2140  pActors[actor_id]
2141  .vVelocity.x +
2142  pActors[actor_id].vVelocity.y *
2143  pActors[actor_id]
2144  .vVelocity.y <
2145  400) {
2146  pActors[actor_id].vVelocity.y = 0;
2147  pActors[actor_id].vVelocity.x = 0;
2148  pActors[actor_id]
2149  .vVelocity.x = fixpoint_mul(
2150  58500,
2151  pActors[actor_id].vVelocity.x);
2152  pActors[actor_id]
2153  .vVelocity.y = fixpoint_mul(
2154  58500,
2155  pActors[actor_id].vVelocity.y);
2156  pActors[actor_id]
2157  .vVelocity.z = fixpoint_mul(
2158  58500,
2159  pActors[actor_id].vVelocity.z);
2160  v22 = 0;
2161  continue;
2162  }
2163  } else {
2164  v61 = abs(pIndoor->pFaces[v37]
2165  .pFacePlane_old
2166  .vNormal.x *
2167  pActors[actor_id]
2168  .vVelocity.x +
2169  pIndoor->pFaces[v37]
2170  .pFacePlane_old
2171  .vNormal.y *
2172  pActors[actor_id]
2173  .vVelocity.y +
2174  pIndoor->pFaces[v37]
2175  .pFacePlane_old
2176  .vNormal.z *
2177  pActors[actor_id]
2178  .vVelocity.z) >>
2179  16;
2180  if ((stru_721530.speed >> 3) > v61)
2181  v61 = stru_721530.speed >> 3;
2182  pActors[actor_id].vVelocity.x +=
2183  fixpoint_mul(
2184  v61,
2185  pIndoor->pFaces[v37]
2186  .pFacePlane_old.vNormal.x);
2187  pActors[actor_id].vVelocity.y +=
2188  fixpoint_mul(
2189  v61,
2190  pIndoor->pFaces[v37]
2191  .pFacePlane_old.vNormal.y);
2192  pActors[actor_id].vVelocity.z +=
2193  fixpoint_mul(
2194  v61,
2195  pIndoor->pFaces[v37]
2196  .pFacePlane_old.vNormal.z);
2197  if (pIndoor->pFaces[v37].uPolygonType !=
2198  4 &&
2199  pIndoor->pFaces[v37].uPolygonType !=
2200  3) {
2201  v44 = stru_721530.prolly_normal_d -
2202  ((pIndoor->pFaces[v37]
2203  .pFacePlane_old.dist +
2204  pIndoor->pFaces[v37]
2205  .pFacePlane_old
2206  .vNormal.z *
2207  pActors[actor_id]
2208  .vPosition.z +
2209  pIndoor->pFaces[v37]
2210  .pFacePlane_old
2211  .vNormal.y *
2212  pActors[actor_id]
2213  .vPosition.y +
2214  pIndoor->pFaces[v37]
2215  .pFacePlane_old
2216  .vNormal.x *
2217  pActors[actor_id]
2218  .vPosition.x) >>
2219  16);
2220  if (v44 > 0) {
2221  pActors[actor_id].vPosition.x +=
2222  fixpoint_mul(
2223  v44,
2224  pIndoor->pFaces[v37]
2225  .pFacePlane_old
2226  .vNormal.x);
2227  pActors[actor_id].vPosition.y +=
2228  fixpoint_mul(
2229  v44,
2230  pIndoor->pFaces[v37]
2231  .pFacePlane_old
2232  .vNormal.y);
2233  pActors[actor_id].vPosition.z +=
2234  fixpoint_mul(
2235  v44,
2236  pIndoor->pFaces[v37]
2237  .pFacePlane_old
2238  .vNormal.z);
2239  }
2240  pActors[actor_id]
2241  .uYawAngle = stru_5C6E00->Atan2(
2242  pActors[actor_id].vVelocity.x,
2243  pActors[actor_id].vVelocity.y);
2244  }
2245  }
2246  if (pIndoor->pFaces[v37].uAttributes &
2247  FACE_UNKNOW1)
2248  EventProcessor(
2249  pIndoor
2250  ->pFaceExtras[pIndoor
2251  ->pFaces[v37]
2252  .uFaceExtraID]
2253  .uEventID,
2254  0, 1);
2255  }
2256  pActors[actor_id].vVelocity.x = fixpoint_mul(
2257  58500, pActors[actor_id].vVelocity.x);
2258  pActors[actor_id].vVelocity.y = fixpoint_mul(
2259  58500, pActors[actor_id].vVelocity.y);
2260  pActors[actor_id].vVelocity.z = fixpoint_mul(
2261  58500, pActors[actor_id].vVelocity.z);
2262  v22 = 0;
2263  continue;
2264  } else {
2265  pActors[actor_id].vPosition.x =
2266  (short)stru_721530.normal2.x;
2267  pActors[actor_id].vPosition.y =
2268  (short)stru_721530.normal2.y;
2269  pActors[actor_id].vPosition.z =
2270  (short)stru_721530.normal2.z -
2271  (short)stru_721530.prolly_normal_d - 1;
2272  pActors[actor_id].uSectorID =
2273  (short)stru_721530.uSectorID;
2274  // goto LABEL_123;
2275  break;
2276  }
2277 
2278  } else if (pActors[actor_id].vPosition.x & 1) {
2279  pActors[actor_id].uYawAngle += 100;
2280  } else {
2281  pActors[actor_id].uYawAngle -= 100;
2282  }
2283  } else {
2284  if (pParty->bTurnBasedModeOn &&
2285  (pTurnEngine->turn_stage == TE_ATTACK ||
2286  pTurnEngine->turn_stage == TE_MOVEMENT))
2287  continue;
2288  if (!pActors[actor_id].pMonsterInfo.uHostilityType ||
2289  v56 != v22) {
2290  Actor::AI_StandOrBored(actor_id, 4, v22, &v52);
2291  continue;
2292  }
2293  }
2294  }
2295  }
2296  } else {
2297  pActors[actor_id].vVelocity.z = 0;
2298  pActors[actor_id].vVelocity.y = 0;
2299  pActors[actor_id].vVelocity.x = 0;
2300  if (pIndoor->pFaces[uFaceID].uAttributes & FACE_INDOOR_SKY) {
2301  if (pActors[actor_id].uAIState == Dead)
2302  pActors[actor_id].uAIState = Removed;
2303  }
2304  }
2305  // LABEL_123:
2306  }
2307 }

Перекрестные ссылки Actor::_46DF1A_collide_against_actor(), _46E0B2_collide_against_decorations(), _46E44E_collide_against_faces_and_portals(), _46ED8A_collide_against_sprite_objects(), _46EF01_collision_chech_player(), _46F04E_collide_against_portals(), ACTOR_BUFF_SLOWED, ai_arrays_size, Actor::AI_FaceObject(), Actor::AI_Flee(), ai_near_actors_ids, Actor::AI_StandOrBored(), ANIM_Walking, stru193_math::Atan2(), BLV_GetFloorLevel(), ViewingParams::bRedrawGameUI, Party::bTurnBasedModeOn, stru141_actor_collision_object::CalcMovementExtents(), collide_against_floor(), stru193_math::Cos(), Dead, stru141_actor_collision_object::direction, Disabled, Plane_int_::dist, engine, EventProcessor(), stru141_actor_collision_object::field_0, stru141_actor_collision_object::field_6C, stru141_actor_collision_object::field_70, stru141_actor_collision_object::field_7C, stru141_actor_collision_object::field_84, stru141_actor_collision_object::field_8_radius, fixpoint_mul(), Fleeing, flt_6BE3AC_debug_recmod1_x_1_6, GetGravityStrength(), IndoorLocation::GetSector(), stru141_actor_collision_object::height, int_get_vector_length(), integer_sqrt(), stru141_actor_collision_object::normal, stru141_actor_collision_object::normal2, OBJECT_Actor, OBJECT_BModel, OBJECT_Decoration, OBJECT_Player, pActors, PARTY_BUFF_INVISIBILITY, pEventTimer, BLVFace::pFacePlane_old, IndoorLocation::pFaces, stru141_actor_collision_object::pid, pIndoor, pLevelDecorations, stru141_actor_collision_object::position, pParty, Party::pPartyBuffs, stru141_actor_collision_object::prolly_normal_d, pTurnEngine, Pursuing, BLVFace::pVertexIDs, IndoorLocation::pVertices, Removed, stru193_math::Sin(), stru141_actor_collision_object::speed, stru_5C6E00, stru_721530, Summoned, TE_ATTACK, TE_MOVEMENT, TE_WAIT, stru262_TurnBased::turn_stage, BLVFace::uAttributes, uNumActors, BLVFace::uPolygonType, stru141_actor_collision_object::uSectorID, Timer::uTimeElapsed, stru141_actor_collision_object::velocity, viewparams и Plane_int_::vNormal.

Используется в BLV_UpdateUserInputAndOther().

+ Граф вызовов:
+ Граф вызова функции:

◆ BLV_ProcessPartyActions()

void BLV_ProcessPartyActions ( )

См. определение в файле Indoor.cpp строка 4655

4655  { // could this be combined with odm process actions?
4656  int v1; // ebx@1
4657  int v2; // edi@1
4658  double v10; // st7@27
4659  int new_party_z; // esi@96
4660  int v38; // eax@96
4661  int v39; // ecx@106
4662  int v40; // eax@106
4663  int v42; // eax@120
4664  BLVFace *pFace; // esi@126
4665  int v46; // ecx@133
4666  int v52; // eax@140
4667  int v54; // ebx@146
4668  unsigned int uFaceEvent; // [sp+14h] [bp-4Ch]@1
4669  bool party_running_flag; // [sp+1Ch] [bp-44h]@1
4670  bool bFeatherFall; // [sp+24h] [bp-3Ch]@15
4671  unsigned int uSectorID; // [sp+28h] [bp-38h]@1
4672  bool party_walking_flag; // [sp+2Ch] [bp-34h]@1
4673  unsigned int uFaceID; // [sp+30h] [bp-30h]@1
4674  int v80; // [sp+34h] [bp-2Ch]@1
4675  int v82; // [sp+3Ch] [bp-24h]@47
4676  int _view_angle; // [sp+40h] [bp-20h]@47
4677  bool hovering; // [sp+44h] [bp-1Ch]@1
4678  int new_party_y; // [sp+48h] [bp-18h]@1
4679  int new_party_x; // [sp+4Ch] [bp-14h]@1
4680  int party_z; // [sp+50h] [bp-10h]@1
4681  int angle; // [sp+5Ch] [bp-4h]@47
4682 
4683  uFaceEvent = 0;
4684  // v89 = pParty->uFallSpeed;
4685  v1 = 0;
4686  v2 = 0;
4687  new_party_x = pParty->vPosition.x;
4688  new_party_y = pParty->vPosition.y;
4689  party_z = pParty->vPosition.z;
4690  uSectorID = pIndoor->GetSector(pParty->vPosition.x, pParty->vPosition.y,
4691  pParty->vPosition.z);
4692  party_running_flag = false;
4693  party_walking_flag = false;
4694  hovering = false;
4695 
4696  uFaceID = -1;
4697  int floor_level =
4698  collide_against_floor(new_party_x, new_party_y, party_z + 40,
4699  &uSectorID, &uFaceID); //получить высоту пола
4700 
4701  if (pParty->bFlying) { // отключить полёт
4702  pParty->bFlying = false;
4703  if (pParty->FlyActive())
4704  pOtherOverlayList
4705  ->pOverlays[pParty->pPartyBuffs[PARTY_BUFF_FLY].uOverlayID - 1]
4706  .field_E |= 1;
4707  }
4708 
4709  if (floor_level == -30000 || uFaceID == -1) {
4710  floor_level = collide_against_floor_approximate(
4711  new_party_x, new_party_y, party_z + 40, &uSectorID, &uFaceID);
4712  if (floor_level == -30000 || uFaceID == -1) {
4713  __debugbreak(); // level built with errors
4714  pParty->vPosition.x = blv_prev_party_x;
4715  pParty->vPosition.y = blv_prev_party_z;
4716  pParty->vPosition.z = blv_prev_party_y;
4717  pParty->uFallStartY = blv_prev_party_y;
4718  return;
4719  }
4720  }
4721 
4722  blv_prev_party_x = pParty->vPosition.x;
4723  blv_prev_party_z = pParty->vPosition.y;
4724  blv_prev_party_y = pParty->vPosition.z;
4725  if (!pParty->bTurnBasedModeOn) {
4726  static int dword_720CDC = 0;
4727 
4728  int v67 = OS_GetTime() / 500;
4729  if (dword_720CDC != v67) {
4730  dword_4F8580[3 * dword_4F8580[1]] = pParty->vPosition.x;
4731  dword_4F8580[3 * dword_4F8580[2]] = pParty->vPosition.y;
4732  dword_4F8580[3 * dword_4F8580[3]] = pParty->vPosition.z;
4733  if (dword_4F8580[0] > 60) dword_4F8580[0] = 1;
4734 
4735  dword_720CDC = v67;
4736  }
4737  }
4738 
4739  int fall_start;
4740  /*
4741  if (!pParty->FeatherFallActive())// не активно падение пера
4742  {
4743  bFeatherFall = false;
4744  if (!pParty->pPlayers[0].WearsItemAnyWhere(ITEM_ARTIFACT_LADYS_ESCORT) &&
4745  // grants feather fall
4746  !pParty->pPlayers[1].WearsItemAnyWhere(ITEM_ARTIFACT_LADYS_ESCORT) &&
4747  !pParty->pPlayers[2].WearsItemAnyWhere(ITEM_ARTIFACT_LADYS_ESCORT) &&
4748  !pParty->pPlayers[3].WearsItemAnyWhere(ITEM_ARTIFACT_LADYS_ESCORT))
4749  {
4750  fall_start = pParty->uFallStartY;
4751  }
4752  else// was missing
4753  {
4754  fall_start = floor_level;
4755  bFeatherFall = true;
4756  pParty->uFallStartY = floor_level;
4757  }
4758  }
4759  else// активно падение пера
4760  {
4761  fall_start = floor_level;
4762  bFeatherFall = true;
4763  pParty->uFallStartY = floor_level;
4764  }
4765 
4766  Reworked condition below
4767  */
4768  if (pParty->FeatherFallActive() ||
4769  pParty->pPlayers[0].WearsItemAnyWhere(ITEM_ARTIFACT_LADYS_ESCORT) ||
4770  pParty->pPlayers[1].WearsItemAnyWhere(ITEM_ARTIFACT_LADYS_ESCORT) ||
4771  pParty->pPlayers[2].WearsItemAnyWhere(ITEM_ARTIFACT_LADYS_ESCORT) ||
4772  pParty->pPlayers[3].WearsItemAnyWhere(ITEM_ARTIFACT_LADYS_ESCORT)) {
4773  fall_start = floor_level;
4774  bFeatherFall = true;
4775  pParty->uFallStartY = floor_level;
4776  } else {
4777  bFeatherFall = false;
4778  fall_start = pParty->uFallStartY;
4779  }
4780 
4781  if (fall_start - party_z > 512 && !bFeatherFall &&
4782  party_z <= floor_level + 1) { // повреждение от падения с высоты
4783  assert(~pParty->uFlags & PARTY_FLAGS_1_LANDING); // why land in indoor?
4784  if (pParty->uFlags & PARTY_FLAGS_1_LANDING) {
4785  pParty->uFlags &= ~PARTY_FLAGS_1_LANDING;
4786  } else {
4787  for (uint i = 0; i < 4; ++i) { // receive falling damage
4788  if (!pParty->pPlayers[i].HasEnchantedItemEquipped(72) &&
4789  !pParty->pPlayers[i].WearsItem(ITEM_ARTIFACT_HERMES_SANDALS,
4790  EQUIP_BOOTS)) {
4791  pParty->pPlayers[i].ReceiveDamage(
4792  (pParty->uFallStartY - party_z) *
4793  (0.1f * pParty->pPlayers[i].GetMaxHealth()) / 256,
4794  DMGT_PHISYCAL);
4795  v10 = (double)(20 - pParty->pPlayers[i].GetParameterBonus(
4796  pParty->pPlayers[i]
4797  .GetActualEndurance())) *
4798  flt_6BE3A4_debug_recmod1 * 2.133333333333333;
4799  pParty->pPlayers[i].SetRecoveryTime((signed __int64)v10);
4800  }
4801  }
4802  }
4803  }
4804 
4805  if (party_z > floor_level + 1) hovering = true;
4806 
4807  bool not_high_fall = false;
4808 
4809  if (party_z - floor_level <= 32) {
4810  pParty->uFallStartY = party_z;
4811  not_high_fall = true;
4812  }
4813 
4814  if (!engine->config->NoWalkSound() && pParty->walk_sound_timer) { //таймеры для звуков передвижения
4815  if (pParty->walk_sound_timer > pEventTimer->uTimeElapsed)
4816  pParty->walk_sound_timer -= pEventTimer->uTimeElapsed;
4817  else
4818  pParty->walk_sound_timer = 0;
4819  }
4820 
4821  if (party_z <= floor_level + 1) { // группа ниже уровня пола
4822  party_z = floor_level + 1;
4823  pParty->uFallStartY = floor_level + 1;
4824 
4825  if (!hovering && pParty->floor_face_pid != uFaceID) { // не парящие и
4826  if (pIndoor->pFaces[uFaceID].uAttributes & FACE_PRESSURE_PLATE)
4827  uFaceEvent =
4828  pIndoor->pFaceExtras[pIndoor->pFaces[uFaceID].uFaceExtraID]
4829  .uEventID;
4830  }
4831  }
4832  if (!hovering) pParty->floor_face_pid = uFaceID;
4833 
4834  bool on_water = false;
4835  if (pIndoor->pFaces[uFaceID].Fluid()) // на воде
4836  on_water = true;
4837 
4838  // v81 = pParty->uWalkSpeed;
4839  angle = pParty->sRotationY;
4840  _view_angle = pParty->sRotationX;
4841  v82 =
4842  (unsigned __int64)(pEventTimer->dt_in_some_format *
4843  (signed __int64)((signed int)(pParty
4844  ->y_rotation_speed *
4845  stru_5C6E00
4846  ->uIntegerPi) /
4847  180)) >>
4848  16;
4849  while (pPartyActionQueue->uNumActions) {
4850  switch (pPartyActionQueue->Next()) {
4851  case PARTY_TurnLeft:
4852  if (engine->config->turn_speed > 0)
4853  angle = stru_5C6E00->uDoublePiMask & (angle + engine->config->turn_speed);
4854  else
4855  angle = stru_5C6E00->uDoublePiMask & (angle + (int)(v82 * fTurnSpeedMultiplier));
4856  break;
4857  case PARTY_TurnRight:
4858  if (engine->config->turn_speed > 0)
4859  angle = stru_5C6E00->uDoublePiMask & (angle - engine->config->turn_speed);
4860  else
4861  angle = stru_5C6E00->uDoublePiMask & (angle - (int)(v82 * fTurnSpeedMultiplier));
4862  break;
4863 
4864  case PARTY_FastTurnLeft:
4865  if (engine->config->turn_speed > 0)
4866  angle = stru_5C6E00->uDoublePiMask & (angle + engine->config->turn_speed);
4867  else
4868  angle = stru_5C6E00->uDoublePiMask & (angle + (int)(2.0f * fTurnSpeedMultiplier * (double)v82));
4869  break;
4870 
4871  case PARTY_FastTurnRight:
4872  if (engine->config->turn_speed > 0)
4873  angle = stru_5C6E00->uDoublePiMask & (angle - engine->config->turn_speed);
4874  else
4875  angle = stru_5C6E00->uDoublePiMask & (angle - (int)(2.0f * fTurnSpeedMultiplier * (double)v82));
4876  break;
4877 
4878  case PARTY_StrafeLeft:
4879  v2 -= fixpoint_mul(stru_5C6E00->Sin(angle), pParty->uWalkSpeed * fWalkSpeedMultiplier / 2);
4880  v1 += fixpoint_mul(stru_5C6E00->Cos(angle), pParty->uWalkSpeed * fWalkSpeedMultiplier / 2);
4881  party_walking_flag = true;
4882  break;
4883  case PARTY_StrafeRight:
4884  v2 += fixpoint_mul(stru_5C6E00->Sin(angle), pParty->uWalkSpeed * fWalkSpeedMultiplier / 2);
4885  v1 -= fixpoint_mul(stru_5C6E00->Cos(angle), pParty->uWalkSpeed * fWalkSpeedMultiplier / 2);
4886  party_walking_flag = true;
4887  break;
4888  case PARTY_WalkForward:
4889  v2 += fixpoint_mul(stru_5C6E00->Cos(angle), 2 * pParty->uWalkSpeed * fWalkSpeedMultiplier);
4890  v1 += fixpoint_mul(stru_5C6E00->Sin(angle), 2 * pParty->uWalkSpeed * fWalkSpeedMultiplier);
4891  party_walking_flag = true;
4892  break;
4893  case PARTY_WalkBackward:
4894  v2 -= fixpoint_mul(stru_5C6E00->Cos(angle), pParty->uWalkSpeed * fBackwardWalkSpeedMultiplier);
4895  v1 -= fixpoint_mul(stru_5C6E00->Sin(angle), pParty->uWalkSpeed * fBackwardWalkSpeedMultiplier);
4896  party_walking_flag = true;
4897  break;
4898  case PARTY_RunForward: //Бег вперёд
4899  v2 += fixpoint_mul(stru_5C6E00->Cos(angle), 5 * pParty->uWalkSpeed * fWalkSpeedMultiplier);
4900  v1 += fixpoint_mul(stru_5C6E00->Sin(angle), 5 * pParty->uWalkSpeed * fWalkSpeedMultiplier);
4901  party_running_flag = true;
4902  break;
4903  case PARTY_RunBackward:
4904  v2 -= fixpoint_mul(stru_5C6E00->Cos(angle), pParty->uWalkSpeed * fBackwardWalkSpeedMultiplier);
4905  v1 -= fixpoint_mul(stru_5C6E00->Sin(angle), pParty->uWalkSpeed * fBackwardWalkSpeedMultiplier);
4906  party_running_flag = true;
4907  break;
4908  case PARTY_LookDown:
4909  _view_angle += (signed __int64)(flt_6BE150_look_up_down_dangle * 25.0);
4910  if (_view_angle > 128)
4911  _view_angle = 128;
4912  if (uActiveCharacter)
4913  pPlayers[uActiveCharacter]->PlaySound((PlayerSpeech)SPEECH_63, 0);
4914  break;
4915  case PARTY_LookUp:
4916  _view_angle += (signed __int64)(flt_6BE150_look_up_down_dangle * -25.0);
4917  if (_view_angle < -128)
4918  _view_angle = -128;
4919  if (uActiveCharacter)
4920  pPlayers[uActiveCharacter]->PlaySound((PlayerSpeech)SPEECH_64, 0);
4921  break;
4922  case PARTY_CenterView:
4923  _view_angle = 0;
4924  break;
4925  case PARTY_Jump:
4926  if ((!hovering ||
4927  party_z <= floor_level + 6 && pParty->uFallSpeed <= 0) &&
4928  pParty->field_24) {
4929  hovering = true;
4930  pParty->uFallSpeed += pParty->field_24 * 96;
4931  }
4932  break;
4933  default:
4934  break;
4935  }
4936  }
4937  pParty->sRotationY = angle;
4938  pParty->sRotationX = _view_angle;
4939  if (hovering) { // парящие
4940  pParty->uFallSpeed += -2 * pEventTimer->uTimeElapsed *
4941  GetGravityStrength(); // расчёт скорости падения
4942  if (hovering && pParty->uFallSpeed <= 0) {
4943  if (pParty->uFallSpeed < -500 && !pParty->bFlying) {
4944  for (uint pl = 1; pl <= 4; pl++) {
4945  if (!pPlayers[pl]->HasEnchantedItemEquipped(72) &&
4946  !pPlayers[pl]->WearsItem(ITEM_ARTIFACT_HERMES_SANDALS,
4947  EQUIP_BOOTS)) // was 8
4948  pPlayers[pl]->PlayEmotion(CHARACTER_EXPRESSION_SCARED,
4949  0);
4950  }
4951  }
4952  } else {
4953  pParty->uFallStartY = party_z;
4954  }
4955  } else { // не парящие
4956  if (pIndoor->pFaces[uFaceID].pFacePlane_old.vNormal.z < 0x8000) {
4957  pParty->uFallSpeed -=
4958  pEventTimer->uTimeElapsed * GetGravityStrength();
4959  pParty->uFallStartY = party_z;
4960  } else {
4961  if (!(pParty->uFlags & PARTY_FLAGS_1_LANDING))
4962  pParty->uFallSpeed = 0;
4963  pParty->uFallStartY = party_z;
4964  }
4965  }
4966  if (v2 * v2 + v1 * v1 < 400) {
4967  v1 = 0;
4968  v2 = 0;
4969  }
4970 
4971  stru_721530.field_84 = -1;
4972  stru_721530.field_70 = 0;
4973  stru_721530.prolly_normal_d = pParty->field_14_radius;
4974  stru_721530.field_8_radius = pParty->field_14_radius / 2;
4975  stru_721530.field_0 = 1;
4976  stru_721530.height = pParty->uPartyHeight - 32;
4977  for (uint i = 0; i < 100; i++) {
4978  new_party_z = party_z;
4979  stru_721530.position.x = new_party_x;
4980  stru_721530.position.y = new_party_y;
4981  stru_721530.position.z = stru_721530.height + party_z + 1;
4982 
4983  stru_721530.normal.x = new_party_x;
4984  stru_721530.normal.y = new_party_y;
4985  stru_721530.normal.z = stru_721530.prolly_normal_d + party_z + 1;
4986 
4987  stru_721530.velocity.x = v2;
4988  stru_721530.velocity.y = v1;
4989  stru_721530.velocity.z = pParty->uFallSpeed;
4990 
4991  stru_721530.uSectorID = uSectorID;
4992  v38 = 0;
4993  if (pParty->bTurnBasedModeOn && pTurnEngine->turn_stage == TE_MOVEMENT) {
4994  v38 = 13312;
4995  }
4996  if (stru_721530.CalcMovementExtents(v38)) break;
4997  for (uint j = 0; j < 100; ++j) {
4998  _46E44E_collide_against_faces_and_portals(1);
4999  _46E0B2_collide_against_decorations(); //столкновения с декором
5000  for (v80 = 0; v80 < (signed int)uNumActors; ++v80)
5001  Actor::_46DF1A_collide_against_actor(
5002  v80, 0); //столкновения с монстрами
5003  if (_46F04E_collide_against_portals()) //столкновения с порталами
5004  break;
5005  }
5006  if (stru_721530.field_7C >= stru_721530.field_6C) {
5007  v39 = stru_721530.normal2.x;
5008  uSectorID = stru_721530.normal2.y;
5009  v40 = stru_721530.normal2.z - stru_721530.prolly_normal_d - 1;
5010  } else {
5011  v39 = new_party_x +
5012  fixpoint_mul(stru_721530.field_7C, stru_721530.direction.x);
5013  uSectorID = new_party_y + fixpoint_mul(stru_721530.field_7C,
5014  stru_721530.direction.y);
5015  v40 = new_party_z +
5016  fixpoint_mul(stru_721530.field_7C, stru_721530.direction.z);
5017  }
5018  v42 = collide_against_floor(v39, uSectorID, v40 + 40,
5019  &stru_721530.uSectorID, &uFaceID);
5020  if (v42 == -30000 || v42 - new_party_z > 128) return;
5021  if (stru_721530.field_7C >= stru_721530.field_6C) { // ???
5022  new_party_x = stru_721530.normal2.x;
5023  new_party_y = stru_721530.normal2.y;
5024  new_party_z =
5025  stru_721530.normal2.z - stru_721530.prolly_normal_d - 1;
5026  break;
5027  }
5028  new_party_x +=
5029  fixpoint_mul(stru_721530.field_7C, stru_721530.direction.x);
5030  new_party_y +=
5031  fixpoint_mul(stru_721530.field_7C, stru_721530.direction.y);
5032  uSectorID = stru_721530.uSectorID;
5033  stru_721530.field_70 += stru_721530.field_7C;
5034  unsigned long long v87 =
5035  new_party_z +
5036  fixpoint_mul(stru_721530.field_7C, stru_721530.direction.z);
5037  if (PID_TYPE(stru_721530.pid) ==
5038  OBJECT_Actor) { // invis break on actor collision / при
5039  // столкновении с монстром
5040  if (pParty->pPartyBuffs[PARTY_BUFF_INVISIBILITY].Active()) {
5041  pParty->pPartyBuffs[PARTY_BUFF_INVISIBILITY].Reset();
5042  }
5043  viewparams->bRedrawGameUI = true;
5044  } else if (PID_TYPE(stru_721530.pid) ==
5045  OBJECT_Decoration) { // decoration collision / при
5046  // столкновении с декорацией
5047  v54 = stru_5C6E00->Atan2(
5048  new_party_x -
5049  pLevelDecorations[stru_721530.pid >> 3].vPosition.x,
5050  new_party_y -
5051  pLevelDecorations[stru_721530.pid >> 3].vPosition.y);
5052  v2 = fixpoint_mul(stru_5C6E00->Cos(v54),
5053  integer_sqrt(v2 * v2 + v1 * v1));
5054  v1 = fixpoint_mul(stru_5C6E00->Sin(v54),
5055  integer_sqrt(v2 * v2 + v1 * v1));
5056  } else if (PID_TYPE(stru_721530.pid) ==
5057  OBJECT_BModel) { // при столкновении с bmodel
5058  pFace = &pIndoor->pFaces[(signed int)stru_721530.pid >> 3];
5059  if (pFace->uPolygonType == POLYGON_Floor) { // если bmodel - пол
5060  if (pParty->uFallSpeed < 0) pParty->uFallSpeed = 0;
5061  v87 = pIndoor->pVertices[*pFace->pVertexIDs].z + 1;
5062  if (pParty->uFallStartY - v87 < 512) pParty->uFallStartY = v87;
5063  if (v2 * v2 + v1 * v1 < 400) {
5064  v1 = 0;
5065  v2 = 0;
5066  }
5067  if (pParty->floor_face_pid != PID_ID(stru_721530.pid) &&
5068  pFace->Pressure_Plate())
5069  uFaceEvent =
5070  pIndoor->pFaceExtras[pFace->uFaceExtraID].uEventID;
5071  } else { // если не пол
5072  v46 = pParty->uFallSpeed * pFace->pFacePlane_old.vNormal.z;
5073  if (pFace->uPolygonType !=
5074  POLYGON_InBetweenFloorAndWall) { // полез на холм
5075  v80 = abs(v1 * pFace->pFacePlane_old.vNormal.y + v46 +
5076  v2 * pFace->pFacePlane_old.vNormal.x) >>
5077  16;
5078  if ((stru_721530.speed >> 3) > v80)
5079  v80 = stru_721530.speed >> 3;
5080  v2 += fixpoint_mul(v80, pFace->pFacePlane_old.vNormal.x);
5081  v1 += fixpoint_mul(v80, pFace->pFacePlane_old.vNormal.y);
5082  pParty->uFallSpeed +=
5083  fixpoint_mul(v80, pFace->pFacePlane_old.vNormal.z);
5084  // v80 = pFace->pFacePlane_old.vNormal.y;
5085  v52 = stru_721530.prolly_normal_d -
5086  ((pFace->pFacePlane_old.dist +
5087  v87 * pFace->pFacePlane_old.vNormal.z +
5088  new_party_y * pFace->pFacePlane_old.vNormal.y +
5089  new_party_x * pFace->pFacePlane_old.vNormal.x) >>
5090  16);
5091  if (v52 > 0) {
5092  new_party_x +=
5093  fixpoint_mul(v52, pFace->pFacePlane_old.vNormal.x);
5094  new_party_y +=
5095  fixpoint_mul(v52, pFace->pFacePlane_old.vNormal.y);
5096  v87 +=
5097  fixpoint_mul(v52, pFace->pFacePlane_old.vNormal.z);
5098  }
5099  if (pParty->floor_face_pid != PID_ID(stru_721530.pid) &&
5100  pFace->Pressure_Plate())
5101  uFaceEvent =
5102  pIndoor->pFaceExtras[pFace->uFaceExtraID].uEventID;
5103  }
5104  if (pFace->uPolygonType == POLYGON_InBetweenFloorAndWall) {
5105  v80 = abs(v1 * pFace->pFacePlane_old.vNormal.y + v46 +
5106  v2 * pFace->pFacePlane_old.vNormal.x) >>
5107  16;
5108  if ((stru_721530.speed >> 3) > v80)
5109  v80 = stru_721530.speed >> 3;
5110  v2 += fixpoint_mul(v80, pFace->pFacePlane_old.vNormal.x);
5111  v1 += fixpoint_mul(v80, pFace->pFacePlane_old.vNormal.y);
5112  pParty->uFallSpeed +=
5113  fixpoint_mul(v80, pFace->pFacePlane_old.vNormal.z);
5114  if (v2 * v2 + v1 * v1 >= 400) {
5115  if (pParty->floor_face_pid != PID_ID(stru_721530.pid) &&
5116  pFace->Pressure_Plate())
5117  uFaceEvent =
5118  pIndoor->pFaceExtras[pFace->uFaceExtraID]
5119  .uEventID;
5120  } else {
5121  v2 = 0;
5122  v1 = 0;
5123  pParty->uFallSpeed = 0;
5124  }
5125  }
5126  }
5127  }
5128  v2 = fixpoint_mul(58500, v2);
5129  v1 = fixpoint_mul(58500, v1);
5130  pParty->uFallSpeed = fixpoint_mul(58500, pParty->uFallSpeed);
5131  }
5132 
5133  // //Воспроизведение звуков ходьбы/бега-------------------------
5134  uint pX_ = abs(pParty->vPosition.x - new_party_x);
5135  uint pY_ = abs(pParty->vPosition.y - new_party_y);
5136  uint pZ_ = abs(pParty->vPosition.z - new_party_z);
5137  if (!engine->config->NoWalkSound() && pParty->walk_sound_timer <= 0) {
5138  pAudioPlayer->StopAll(804); // stop sound
5139  if (party_running_flag &&
5140  (!hovering || not_high_fall)) { // Бег и (не прыжок или не высокое падение )
5141  if (integer_sqrt(pX_ * pX_ + pY_ * pY_ + pZ_ * pZ_) >= 16) {
5142  if (on_water)
5143  pAudioPlayer->PlaySound(SOUND_RunWaterIndoor, 804, 1, -1, 0, 0);
5144  else if (pIndoor->pFaces[uFaceID].uAttributes & FACE_INDOOR_CARPET) //по ковру
5145  pAudioPlayer->PlaySound(SOUND_RunCarpet, -1 /*804*/, 1, -1, 0, 0);
5146  else
5147  pAudioPlayer->PlaySound(SOUND_RunWood, -1 /*804*/, 1, -1, 0, 0);
5148  pParty->walk_sound_timer = 96; // 64
5149  }
5150  } else if (party_walking_flag &&
5151  (!hovering || not_high_fall)) { // Ходьба и (не прыжок или не
5152  // высокое падение)
5153  if (integer_sqrt(pX_ * pX_ + pY_ * pY_ + pZ_ * pZ_) >= 8) {
5154  if (on_water)
5155  pAudioPlayer->PlaySound(SOUND_WalkWaterIndoor, 804, 1, -1, 0, 0);
5156  else if (pIndoor->pFaces[uFaceID].uAttributes & FACE_INDOOR_CARPET) //по ковру
5157  pAudioPlayer->PlaySound(SOUND_WalkCarpet, -1 /*804*/, 1, -1, 0, 0);
5158  else
5159  pAudioPlayer->PlaySound(SOUND_WalkWood, -1 /*804*/, 1, -1, 0, 0);
5160  pParty->walk_sound_timer = 144; // 64
5161  }
5162  }
5163  }
5164  if (integer_sqrt(pX_ * pX_ + pY_ * pY_ + pZ_ * pZ_) <
5165  8) //отключить звук ходьбы при остановке
5166  pAudioPlayer->StopAll(804);
5167  //-------------------------------------------------------------
5168  if (!hovering || !not_high_fall)
5169  pParty->uFlags &= ~PARTY_FLAGS_1_FALLING;
5170  else
5171  pParty->uFlags |= PARTY_FLAGS_1_FALLING;
5172  pParty->uFlags &= ~PARTY_FLAGS_1_BURNING;
5173  pParty->vPosition.x = new_party_x;
5174  pParty->vPosition.z = new_party_z;
5175  pParty->vPosition.y = new_party_y;
5176  // pParty->uFallSpeed = v89;
5177  if (!hovering && pIndoor->pFaces[uFaceID].uAttributes & FACE_INDOOR_LAVA)
5178  pParty->uFlags |= PARTY_FLAGS_1_BURNING; // 0x200
5179  if (uFaceEvent) EventProcessor(uFaceEvent, 0, 1);
5180 }

Перекрестные ссылки Actor::_46DF1A_collide_against_actor(), _46E0B2_collide_against_decorations(), _46E44E_collide_against_faces_and_portals(), _46F04E_collide_against_portals(), __debugbreak(), stru193_math::Atan2(), Party::bFlying, blv_prev_party_x, blv_prev_party_y, blv_prev_party_z, ViewingParams::bRedrawGameUI, Party::bTurnBasedModeOn, stru141_actor_collision_object::CalcMovementExtents(), CHARACTER_EXPRESSION_SCARED, collide_against_floor(), collide_against_floor_approximate(), stru193_math::Cos(), stru141_actor_collision_object::direction, Plane_int_::dist, DMGT_PHISYCAL, Timer::dt_in_some_format, dword_4F8580, engine, EQUIP_BOOTS, EventProcessor(), fBackwardWalkSpeedMultiplier, Party::FeatherFallActive(), stru141_actor_collision_object::field_0, Party::field_14_radius, Party::field_24, stru141_actor_collision_object::field_6C, stru141_actor_collision_object::field_70, stru141_actor_collision_object::field_7C, stru141_actor_collision_object::field_84, stru141_actor_collision_object::field_8_radius, OtherOverlay::field_E, fixpoint_mul(), Party::floor_face_pid, flt_6BE150_look_up_down_dangle, flt_6BE3A4_debug_recmod1, BLVFace::Fluid(), Party::FlyActive(), fTurnSpeedMultiplier, fWalkSpeedMultiplier, GetGravityStrength(), IndoorLocation::GetSector(), stru141_actor_collision_object::height, integer_sqrt(), ITEM_ARTIFACT_HERMES_SANDALS, ITEM_ARTIFACT_LADYS_ESCORT, ActionQueue::Next(), stru141_actor_collision_object::normal, stru141_actor_collision_object::normal2, OBJECT_Actor, OBJECT_BModel, OBJECT_Decoration, OS_GetTime(), PARTY_BUFF_FLY, PARTY_BUFF_INVISIBILITY, PARTY_CenterView, PARTY_FastTurnLeft, PARTY_FastTurnRight, PARTY_FLAGS_1_BURNING, PARTY_FLAGS_1_FALLING, PARTY_FLAGS_1_LANDING, PARTY_Jump, PARTY_LookDown, PARTY_LookUp, PARTY_RunBackward, PARTY_RunForward, PARTY_StrafeLeft, PARTY_StrafeRight, PARTY_TurnLeft, PARTY_TurnRight, PARTY_WalkBackward, PARTY_WalkForward, pAudioPlayer, pEventTimer, IndoorLocation::pFaceExtras, BLVFace::pFacePlane_old, IndoorLocation::pFaces, stru141_actor_collision_object::pid, pIndoor, AudioPlayer::PlaySound(), pLevelDecorations, POLYGON_Floor, POLYGON_InBetweenFloorAndWall, stru141_actor_collision_object::position, pOtherOverlayList, OtherOverlayList::pOverlays, pParty, pPartyActionQueue, Party::pPartyBuffs, pPlayers, Party::pPlayers, BLVFace::Pressure_Plate(), stru141_actor_collision_object::prolly_normal_d, pTurnEngine, BLVFace::pVertexIDs, IndoorLocation::pVertices, stru193_math::Sin(), SOUND_RunCarpet, SOUND_RunWaterIndoor, SOUND_RunWood, SOUND_WalkCarpet, SOUND_WalkWaterIndoor, SOUND_WalkWood, SPEECH_63, SPEECH_64, stru141_actor_collision_object::speed, Party::sRotationX, Party::sRotationY, AudioPlayer::StopAll(), stru_5C6E00, stru_721530, TE_MOVEMENT, stru262_TurnBased::turn_stage, uActiveCharacter, BLVFace::uAttributes, stru193_math::uDoublePiMask, BLVFaceExtra::uEventID, BLVFace::uFaceExtraID, Party::uFallSpeed, Party::uFallStartY, Party::uFlags, ActionQueue::uNumActions, uNumActors, Party::uPartyHeight, BLVFace::uPolygonType, stru141_actor_collision_object::uSectorID, Timer::uTimeElapsed, Party::uWalkSpeed, stru141_actor_collision_object::velocity, viewparams, Plane_int_::vNormal, Party::vPosition и Party::walk_sound_timer.

Используется в BLV_UpdateUserInputAndOther().

+ Граф вызовов:
+ Граф вызова функции:

◆ Door_switch_animation()

void Door_switch_animation ( unsigned int  uDoorID,
int  a2 
)

См. определение в файле Indoor.cpp строка 5183

5183  {
5184  int old_state; // eax@1
5185  signed int door_id; // esi@2
5186 
5187  if (!pIndoor->pDoors) return;
5188  for (door_id = 0; door_id < 200; ++door_id) {
5189  if (pIndoor->pDoors[door_id].uDoorID == uDoorID) break;
5190  }
5191  if (door_id >= 200) {
5192  Error("Unable to find Door ID: %i!", uDoorID);
5193  }
5194  old_state = pIndoor->pDoors[door_id].uState;
5195  // old_state: 0 - в нижнем положении/закрыто
5196  // 2 - в верхнем положении/открыто,
5197  // a2: 1 - открыть
5198  // 2 - опустить/поднять
5199  if (a2 == 2) {
5200  if (pIndoor->pDoors[door_id].uState == BLVDoor::Closing ||
5201  pIndoor->pDoors[door_id].uState == BLVDoor::Opening)
5202  return;
5203  if (pIndoor->pDoors[door_id].uState) {
5204  if (pIndoor->pDoors[door_id].uState != BLVDoor::Closed &&
5205  pIndoor->pDoors[door_id].uState != BLVDoor::Closing) {
5206  pIndoor->pDoors[door_id].uState = BLVDoor::Closing;
5207  if (old_state == BLVDoor::Open) {
5208  pIndoor->pDoors[door_id].uTimeSinceTriggered = 0;
5209  return;
5210  }
5211  if (pIndoor->pDoors[door_id].uTimeSinceTriggered != 15360) {
5212  pIndoor->pDoors[door_id].uTimeSinceTriggered =
5213  (pIndoor->pDoors[door_id].uMoveLength << 7) /
5214  pIndoor->pDoors[door_id].uOpenSpeed -
5215  ((signed int)(pIndoor->pDoors[door_id]
5216  .uTimeSinceTriggered *
5217  pIndoor->pDoors[door_id].uCloseSpeed) /
5218  128
5219  << 7) /
5220  pIndoor->pDoors[door_id].uOpenSpeed;
5221  return;
5222  }
5223  pIndoor->pDoors[door_id].uTimeSinceTriggered = 15360;
5224  }
5225  return;
5226  }
5227  } else {
5228  if (a2 == 0) {
5229  if (pIndoor->pDoors[door_id].uState != BLVDoor::Closed &&
5230  pIndoor->pDoors[door_id].uState != BLVDoor::Closing) {
5231  pIndoor->pDoors[door_id].uState = BLVDoor::Closing;
5232  if (old_state == BLVDoor::Open) {
5233  pIndoor->pDoors[door_id].uTimeSinceTriggered = 0;
5234  return;
5235  }
5236  if (pIndoor->pDoors[door_id].uTimeSinceTriggered != 15360) {
5237  pIndoor->pDoors[door_id].uTimeSinceTriggered =
5238  (pIndoor->pDoors[door_id].uMoveLength << 7) /
5239  pIndoor->pDoors[door_id].uOpenSpeed -
5240  ((signed int)(pIndoor->pDoors[door_id]
5241  .uTimeSinceTriggered *
5242  pIndoor->pDoors[door_id].uCloseSpeed) /
5243  128
5244  << 7) /
5245  pIndoor->pDoors[door_id].uOpenSpeed;
5246  return;
5247  }
5248  pIndoor->pDoors[door_id].uTimeSinceTriggered = 15360;
5249  }
5250  return;
5251  }
5252  if (a2 != 1) return;
5253  }
5254  if (old_state != BLVDoor::Open && old_state != BLVDoor::Opening) {
5255  pIndoor->pDoors[door_id].uState = BLVDoor::Opening;
5256  if (old_state == BLVDoor::Closed) {
5257  pIndoor->pDoors[door_id].uTimeSinceTriggered = 0;
5258  return;
5259  }
5260  if (pIndoor->pDoors[door_id].uTimeSinceTriggered != 15360) {
5261  pIndoor->pDoors[door_id].uTimeSinceTriggered =
5262  (pIndoor->pDoors[door_id].uMoveLength << 7) /
5263  pIndoor->pDoors[door_id].uCloseSpeed -
5264  ((signed int)(pIndoor->pDoors[door_id].uTimeSinceTriggered *
5265  pIndoor->pDoors[door_id].uOpenSpeed) /
5266  128
5267  << 7) /
5268  pIndoor->pDoors[door_id].uCloseSpeed;
5269  return;
5270  }
5271  pIndoor->pDoors[door_id].uTimeSinceTriggered = 15360;
5272  }
5273  return;
5274 }

Перекрестные ссылки BLVDoor::Closed, BLVDoor::Closing, BLVDoor::Open, BLVDoor::Opening, IndoorLocation::pDoors, pIndoor, BLVDoor::uCloseSpeed, BLVDoor::uDoorID, BLVDoor::uMoveLength, BLVDoor::uOpenSpeed, BLVDoor::uState и BLVDoor::uTimeSinceTriggered.

Используется в EventProcessor().

+ Граф вызова функции:

◆ sub_4088E9()

int sub_4088E9 ( int  a1,
int  a2,
int  a3,
int  a4,
int  a5,
int  a6 
)

См. определение в файле Indoor.cpp строка 5277

5277  {
5278  signed int result; // eax@1
5279 
5280  result =
5281  integer_sqrt(abs(x2 - x1) * abs(x2 - x1) + abs(y2 - y1) * abs(y2 - y1));
5282  if (result)
5283  result = abs(((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / result);
5284  return result;
5285 }

Перекрестные ссылки integer_sqrt().

Используется в sub_407A1C().

+ Граф вызовов:
+ Граф вызова функции:

◆ PrepareDrawLists_BLV()

void PrepareDrawLists_BLV ( )

См. определение в файле Indoor.cpp строка 102

102  {
103  int TorchLightPower; // eax@4
104  unsigned int v7; // ebx@8
105  BLVSector *v8; // esi@8
106 
107  pBLVRenderParams->Reset();
108  pMobileLightsStack->uNumLightsActive = 0;
109  // uNumMobileLightsApplied = 0;
110  uNumDecorationsDrawnThisFrame = 0;
111  uNumSpritesDrawnThisFrame = 0;
112  uNumBillboardsToDraw = 0;
113 
114  if (!_4D864C_force_sw_render_rules || !engine->config->TorchlightEffect()) { // lightspot around party
115  TorchLightPower = 800;
116  if (pParty->TorchlightActive()) {
117  // max is 800 * torchlight
118  // min is 800
119  int MinTorch = TorchLightPower;
120  int MaxTorch = TorchLightPower * pParty->pPartyBuffs[PARTY_BUFF_TORCHLIGHT].uPower;
121 
122  // TorchLightPower *= pParty->pPartyBuffs[PARTY_BUFF_TORCHLIGHT].uPower; // 2,3,4
123  int ran = rand();
124  int mod = ((ran - (RAND_MAX * .4)) / 200);
125  TorchLightPower = (pParty->TorchLightLastIntensity + mod);
126 
127  // clamp
128  if (TorchLightPower < MinTorch)
129  TorchLightPower = MinTorch;
130  if (TorchLightPower > MaxTorch)
131  TorchLightPower = MaxTorch;
132  }
133 
134  pParty->TorchLightLastIntensity = TorchLightPower;
135 
136  // double nexLightIntensity(lastIntensity)
137  // return clamp(0, 1, lastIntensity + (rand() - .3) / 100)
138 
139  pMobileLightsStack->AddLight(
140  pIndoorCameraD3D->vPartyPos.x, pIndoorCameraD3D->vPartyPos.y,
141  pIndoorCameraD3D->vPartyPos.z, pBLVRenderParams->uPartySectorID, TorchLightPower,
142  floorf(pParty->flt_TorchlightColorR + 0.5f),
143  floorf(pParty->flt_TorchlightColorG + 0.5f),
144  floorf(pParty->flt_TorchlightColorB + 0.5f), _4E94D0_light_type);
145  }
146 
147  PrepareBspRenderList_BLV();
148  pIndoor->PrepareItemsRenderList_BLV();
149  pIndoor->PrepareActorRenderList_BLV();
150 
151  for (uint i = 0; i < pBspRenderer->uNumVisibleNotEmptySectors; ++i) {
152  v7 = pBspRenderer->pVisibleSectorIDs_toDrawDecorsActorsEtcFrom[i];
153  v8 = &pIndoor->pSectors[pBspRenderer->pVisibleSectorIDs_toDrawDecorsActorsEtcFrom[i]];
154 
155  for (uint j = 0; j < v8->uNumDecorations; ++j)
156  pIndoor->PrepareDecorationsRenderList_BLV(v8->pDecorationIDs[j], v7);
157  }
158  FindBillboardsLightLevels_BLV();
159  // engine->PrepareBloodsplats();
160 }

Перекрестные ссылки _4D864C_force_sw_render_rules, _4E94D0_light_type, LightsStack_MobileLight_::AddLight(), engine, FindBillboardsLightLevels_BLV(), Party::flt_TorchlightColorB, Party::flt_TorchlightColorG, Party::flt_TorchlightColorR, PARTY_BUFF_TORCHLIGHT, pBLVRenderParams, pBspRenderer, BLVSector::pDecorationIDs, pIndoor, pIndoorCameraD3D, pMobileLightsStack, pParty, Party::pPartyBuffs, IndoorLocation::PrepareActorRenderList_BLV(), PrepareBspRenderList_BLV(), IndoorLocation::PrepareDecorationsRenderList_BLV(), IndoorLocation::PrepareItemsRenderList_BLV(), IndoorLocation::pSectors, BspRenderer::pVisibleSectorIDs_toDrawDecorsActorsEtcFrom, BLVRenderParams::Reset(), Party::TorchlightActive(), Party::TorchLightLastIntensity, uNumBillboardsToDraw, BLVSector::uNumDecorations, uNumDecorationsDrawnThisFrame, LightsStack_MobileLight_::uNumLightsActive, uNumSpritesDrawnThisFrame, BspRenderer::uNumVisibleNotEmptySectors, BLVRenderParams::uPartySectorID, IndoorCameraD3D::vPartyPos, Vec2< T >::x, Vec2< T >::y и Vec3< T >::z.

Используется в IndoorLocation::Draw().

+ Граф вызовов:
+ Граф вызова функции:

◆ PrepareToLoadBLV()

void PrepareToLoadBLV ( unsigned int  bLoading)

См. определение в файле Indoor.cpp строка 2310

2310  {
2311  unsigned int respawn_interval; // ebx@1
2312  unsigned int map_id; // eax@8
2313  MapInfo *map_info; // edi@9
2314  int v4; // eax@11
2315  char v28; // zf@81
2316  signed int v30; // edi@94
2317  int v34[4]; // [sp+3E8h] [bp-2Ch]@96
2318  int v35; // [sp+3F8h] [bp-1Ch]@1
2319  int v38; // [sp+404h] [bp-10h]@1
2320  int pDest; // [sp+40Ch] [bp-8h]@1
2321 
2322  respawn_interval = 0;
2323  pGameLoadingUI_ProgressBar->Reset(0x20u);
2324  bNoNPCHiring = false;
2325  pDest = 1;
2326  uCurrentlyLoadedLevelType = LEVEL_Indoor;
2327 
2328  engine->SetUnderwater(
2329  Is_out15odm_underwater());
2330 
2331  if ((pCurrentMapName == "out15.odm") || (pCurrentMapName == "d23.blv")) {
2332  bNoNPCHiring = true;
2333  }
2334  pPaletteManager->pPalette_tintColor[0] = 0;
2335  pPaletteManager->pPalette_tintColor[1] = 0;
2336  pPaletteManager->pPalette_tintColor[2] = 0;
2337  pPaletteManager->RecalculateAll();
2338  if (_A750D8_player_speech_timer) _A750D8_player_speech_timer = 0;
2339  map_id = pMapStats->GetMapInfo(pCurrentMapName);
2340  if (map_id) {
2341  map_info = &pMapStats->pInfos[map_id];
2342  respawn_interval = pMapStats->pInfos[map_id].uRespawnIntervalDays;
2343  v38 = GetAlertStatus();
2344  } else {
2345  map_info = (MapInfo *)bLoading;
2346  }
2347  dword_6BE13C_uCurrentlyLoadedLocationID = map_id;
2348 
2349  pStationaryLightsStack->uNumLightsActive = 0;
2350  v4 = pIndoor->Load(pCurrentMapName, pParty->GetPlayingTime().GetDays() + 1,
2351  respawn_interval, (char *)&pDest) -
2352  1;
2353  if (!v4) Error("Unable to open %s", pCurrentMapName.c_str());
2354 
2355  if (v4 == 1) Error("File %s is not a BLV File", pCurrentMapName.c_str());
2356 
2357  if (v4 == 2) Error("Attempt to open new level before clearing old");
2358  if (v4 == 3) Error("Out of memory loading indoor level");
2359  if (!(dword_6BE364_game_settings_1 & GAME_SETTINGS_2000)) {
2360  Actor::InitializeActors();
2361  SpriteObject::InitializeSpriteObjects();
2362  }
2363  dword_6BE364_game_settings_1 &= ~GAME_SETTINGS_2000;
2364  if (!map_id) pDest = 0;
2365  if (pDest == 1) {
2366  for (uint i = 0; i < pIndoor->uNumSpawnPoints; ++i) {
2367  auto spawn = pIndoor->pSpawnPoints + i;
2368  if (spawn->IsMonsterSpawn())
2369  SpawnEncounter(map_info, spawn, 0, 0, 0);
2370  else
2371  map_info->SpawnRandomTreasure(spawn);
2372  }
2373  RespawnGlobalDecorations();
2374  }
2375 
2376  for (uint i = 0; i < pIndoor->uNumDoors; ++i) {
2377  if (pIndoor->pDoors[i].uAttributes & 0x01) {
2378  pIndoor->pDoors[i].uState = BLVDoor::Opening;
2379  pIndoor->pDoors[i].uTimeSinceTriggered = 15360;
2380  pIndoor->pDoors[i].uAttributes = 2;
2381  }
2382 
2383  if (pIndoor->pDoors[i].uState == BLVDoor::Closed) {
2384  pIndoor->pDoors[i].uState = BLVDoor::Closing;
2385  pIndoor->pDoors[i].uTimeSinceTriggered = 15360;
2386  pIndoor->pDoors[i].uAttributes = 2;
2387  } else if (pIndoor->pDoors[i].uState == BLVDoor::Open) {
2388  pIndoor->pDoors[i].uState = BLVDoor::Opening;
2389  pIndoor->pDoors[i].uTimeSinceTriggered = 15360;
2390  pIndoor->pDoors[i].uAttributes = 2;
2391  }
2392  }
2393 
2394  /*for (uint i = 0; i < pIndoor->uNumFaces; ++i)
2395  {
2396  if (pIndoor->pFaces[i].uBitmapID != -1)
2397  pBitmaps_LOD->pTextures[pIndoor->pFaces[i].uBitmapID].palette_id2 =
2398  pPaletteManager->LoadPalette(pBitmaps_LOD->pTextures[pIndoor->pFaces[i].uBitmapID].palette_id1);
2399  }*/
2400 
2401  pGameLoadingUI_ProgressBar->Progress();
2402 
2403  v35 = 0;
2404  for (uint i = 0; i < uNumLevelDecorations; ++i) {
2405  pDecorationList->InitializeDecorationSprite(pLevelDecorations[i].uDecorationDescID);
2406 
2407  DecorationDesc *decoration = pDecorationList->GetDecoration(pLevelDecorations[i].uDecorationDescID);
2408 
2409  if (decoration->uSoundID && _6807E0_num_decorations_with_sounds_6807B8 < 9) {
2410  // pSoundList->LoadSound(decoration->uSoundID, 0);
2411  _6807B8_level_decorations_ids[_6807E0_num_decorations_with_sounds_6807B8++] = i;
2412  }
2413 
2414  if (!(pLevelDecorations[i].uFlags & LEVEL_DECORATION_INVISIBLE)) {
2415  if (!decoration->DontDraw()) {
2416  if (decoration->uLightRadius) {
2417  unsigned char r = 255, g = 255, b = 255;
2418  if (/*render->pRenderD3D*/ true &&
2419  render->config->is_using_colored_lights) {
2420  r = decoration->uColoredLightRed;
2421  g = decoration->uColoredLightGreen;
2422  b = decoration->uColoredLightBlue;
2423  }
2424  pStationaryLightsStack->AddLight(
2425  pLevelDecorations[i].vPosition.x,
2426  pLevelDecorations[i].vPosition.y,
2427  pLevelDecorations[i].vPosition.z +
2428  decoration->uDecorationHeight,
2429  decoration->uLightRadius, r, g, b, _4E94D0_light_type);
2430  }
2431  }
2432  }
2433 
2434  if (!pLevelDecorations[i].uEventID) {
2435  if (pLevelDecorations[i].IsInteractive()) {
2436  if (v35 < 124) {
2437  pLevelDecorations[i]._idx_in_stru123 = v35 + 75;
2438  if (!stru_5E4C90_MapPersistVars._decor_events[v35])
2439  pLevelDecorations[i].uFlags |=
2440  LEVEL_DECORATION_INVISIBLE;
2441  v35++;
2442  }
2443  }
2444  }
2445  }
2446 
2447  pGameLoadingUI_ProgressBar->Progress();
2448 
2449  for (uint i = 0; i < uNumSpriteObjects; ++i) {
2450  if (pSpriteObjects[i].uObjectDescID) {
2451  if (pSpriteObjects[i].containing_item.uItemID) {
2452  if (pSpriteObjects[i].containing_item.uItemID != 220 &&
2453  pItemsTable
2454  ->pItems[pSpriteObjects[i].containing_item.uItemID]
2455  .uEquipType == EQUIP_POTION &&
2456  !pSpriteObjects[i].containing_item.uEnchantmentType)
2457  pSpriteObjects[i].containing_item.uEnchantmentType =
2458  rand() % 15 + 5;
2459  pItemsTable->SetSpecialBonus(
2460  &pSpriteObjects[i].containing_item);
2461  }
2462  }
2463  }
2464 
2465  // INDOOR initialize actors
2466  v38 = 0;
2467 
2468  for (uint i = 0; i < uNumActors; ++i) {
2469  if (pActors[i].uAttributes & ACTOR_UNKNOW7) {
2470  if (!map_id) {
2471  pActors[i].pMonsterInfo.field_3E = 19;
2472  pActors[i].uAttributes |= ACTOR_UNKNOW11;
2473  continue;
2474  }
2475  v28 = v38 == 0;
2476  } else {
2477  v28 = v38 == 1;
2478  }
2479 
2480  if (!v28) {
2481  pActors[i].PrepareSprites(0);
2482  pActors[i].pMonsterInfo.uHostilityType =
2483  MonsterInfo::Hostility_Friendly;
2484  if (pActors[i].pMonsterInfo.field_3E != 11 &&
2485  pActors[i].pMonsterInfo.field_3E != 19 &&
2486  (!pActors[i].sCurrentHP || !pActors[i].pMonsterInfo.uHP)) {
2487  pActors[i].pMonsterInfo.field_3E = 5;
2488  pActors[i].UpdateAnimation();
2489  }
2490  } else {
2491  pActors[i].pMonsterInfo.field_3E = 19;
2492  pActors[i].uAttributes |= ACTOR_UNKNOW11;
2493  }
2494  }
2495 
2496  pGameLoadingUI_ProgressBar->Progress();
2497 
2498  // Party to start position
2499  Actor this_;
2500  this_.pMonsterInfo.uID = 45;
2501  this_.PrepareSprites(0);
2502  if (!bLoading) {
2503  pParty->sRotationX = 0;
2504  pParty->sRotationY = 0;
2505  pParty->vPosition.z = 0;
2506  pParty->vPosition.y = 0;
2507  pParty->vPosition.x = 0;
2508  pParty->uFallStartY = 0;
2509  pParty->uFallSpeed = 0;
2510  TeleportToStartingPoint(uLevel_StartingPointType);
2511  }
2512  viewparams->_443365();
2513  PlayLevelMusic();
2514  if (!bLoading) {
2515  v30 = 0;
2516  for (uint pl_id = 1; pl_id <= 4; ++pl_id) {
2517  if (pPlayers[pl_id]->CanAct()) v34[v30++] = pl_id;
2518  }
2519  if (v30) {
2520  if (pDest) {
2521  _A750D8_player_speech_timer = 256;
2522  PlayerSpeechID = SPEECH_46;
2523  uSpeakingCharacter = v34[rand() % v30];
2524  }
2525  }
2526  }
2527 }

Перекрестные ссылки ViewingParams::_443365(), _4E94D0_light_type, _6807B8_level_decorations_ids, _6807E0_num_decorations_with_sounds_6807B8, _A750D8_player_speech_timer, stru123::_decor_events, LightsStack_StationaryLight_::AddLight(), bNoNPCHiring, BLVDoor::Closed, BLVDoor::Closing, DecorationDesc_mm6::DontDraw(), dword_6BE13C_uCurrentlyLoadedLocationID, dword_6BE364_game_settings_1, engine, EQUIP_POTION, GetAlertStatus(), GameTime::GetDays(), DecorationList::GetDecoration(), MapStats::GetMapInfo(), Party::GetPlayingTime(), MonsterInfo::Hostility_Friendly, Actor::InitializeActors(), DecorationList::InitializeDecorationSprite(), SpriteObject::InitializeSpriteObjects(), Is_out15odm_underwater(), LEVEL_DECORATION_INVISIBLE, LEVEL_Indoor, IndoorLocation::Load(), BLVDoor::Open, BLVDoor::Opening, pActors, pCurrentMapName, pDecorationList, IndoorLocation::pDoors, pGameLoadingUI_ProgressBar, pIndoor, MapStats::pInfos, ItemsTable::pItems, pItemsTable, PlayerSpeechID, PlayLevelMusic(), pLevelDecorations, pMapStats, Actor::pMonsterInfo, PaletteManager::pPalette_tintColor, pPaletteManager, pParty, pPlayers, Actor::PrepareSprites(), GUIProgressBar::Progress(), IndoorLocation::pSpawnPoints, pSpriteObjects, pStationaryLightsStack, PaletteManager::RecalculateAll(), render, GUIProgressBar::Reset(), RespawnGlobalDecorations(), ItemsTable::SetSpecialBonus(), SpawnEncounter(), MapInfo::SpawnRandomTreasure(), SPEECH_46, Party::sRotationX, Party::sRotationY, stru_5E4C90_MapPersistVars, TeleportToStartingPoint(), BLVDoor::uAttributes, DecorationDesc::uColoredLightBlue, DecorationDesc::uColoredLightGreen, DecorationDesc::uColoredLightRed, uCurrentlyLoadedLevelType, DecorationDesc_mm6::uDecorationHeight, Party::uFallSpeed, Party::uFallStartY, MonsterInfo::uID, uLevel_StartingPointType, DecorationDesc_mm6::uLightRadius, uNumActors, IndoorLocation::uNumDoors, uNumLevelDecorations, LightsStack_StationaryLight_::uNumLightsActive, IndoorLocation::uNumSpawnPoints, uNumSpriteObjects, MapInfo::uRespawnIntervalDays, DecorationDesc_mm6::uSoundID, uSpeakingCharacter, BLVDoor::uState, BLVDoor::uTimeSinceTriggered, viewparams и Party::vPosition.

Используется в DoPrepareWorld().

+ Граф вызовов:
+ Граф вызова функции:

◆ GetAlertStatus()

int GetAlertStatus ( )

См. определение в файле Indoor.cpp строка 5287

5287  {
5288  int result;
5289 
5290  if (uCurrentlyLoadedLevelType == LEVEL_Indoor)
5291  result = pOutdoor->ddm.field_C_alert;
5292  else
5293  result = uCurrentlyLoadedLevelType == LEVEL_Outdoor ? pIndoor->dlv.field_C_alert : 0;
5294 
5295  return result;
5296 }

Перекрестные ссылки OutdoorLocation::ddm, IndoorLocation::dlv, DDM_DLV_Header::field_C_alert, LEVEL_Indoor, LEVEL_Outdoor, pIndoor, pOutdoor и uCurrentlyLoadedLevelType.

Используется в OutdoorLocation::InitalizeActors(), ODM_LoadAndInitialize(), PrepareToLoadBLV(), Actor::SearchActorByGroup(), Actor::SearchActorByID(), Actor::SearchActorByMonsterID() и Actor::SearchAliveActors().

+ Граф вызова функции:

◆ _45063B_spawn_some_monster()

int _45063B_spawn_some_monster ( struct MapInfo *  a1,
int  a2 
)

См. определение в файле Indoor.cpp строка 5298

5298  {
5299  int result = 0; // eax@8
5300  int v6; // edi@11
5301  int v7; // ebx@11
5302  int v9; // ebx@12
5303  int v10; // eax@12
5304  char v11 = 0; // zf@16
5305  int v12; // edi@20
5306  int v13; // eax@20
5307  int v14; // ebx@20
5308  int v15; // eax@20
5309  int v16; // eax@20
5310  int v17; // eax@20
5311  int v18; // eax@21
5312  SpawnPointMM7 v19; // [sp+Ch] [bp-38h]@1
5313  int v22; // [sp+2Ch] [bp-18h]@3
5314  unsigned int uFaceID; // [sp+38h] [bp-Ch]@10
5315  int v26 = 0; // [sp+3Ch] [bp-8h]@11
5316  int v27; // [sp+40h] [bp-4h]@11
5317 
5318  if (!uNumActors) return 0;
5319 
5320  for (uint mon_id = 0; mon_id < uNumActors; ++mon_id) {
5321  if ((pActors[mon_id].pMonsterInfo.uID < 121 ||
5322  pActors[mon_id].pMonsterInfo.uID > 123) && // Dwarf FemaleC A-C
5323  (pActors[mon_id].pMonsterInfo.uID < 124 ||
5324  pActors[mon_id].pMonsterInfo.uID > 126) && // Dwarf MaleA A-C
5325  (pActors[mon_id].pMonsterInfo.uID < 133 ||
5326  pActors[mon_id].pMonsterInfo.uID > 135) && // Peasant Elf FemaleA A-C
5327  pActors[mon_id].CanAct()) {
5328  if (uCurrentlyLoadedLevelType == LEVEL_Outdoor) {
5329  v22 = 0;
5330  uint face_id = 0;
5331  for (face_id; face_id < 100; ++face_id) {
5332  v6 = rand() % 1024 + 512;
5333  v7 = rand() % (signed int)stru_5C6E00->uIntegerDoublePi;
5334  v19.vPosition.x = pParty->vPosition.x + fixpoint_mul(stru_5C6E00->Cos(v7), v6);
5335  v19.uIndex = a2;
5336  v19.vPosition.y = fixpoint_mul(stru_5C6E00->Sin(v7), v6) + pParty->vPosition.y;
5337  v19.vPosition.z = pParty->vPosition.z;
5338  bool bInWater = false;
5339  v27 = 0;
5340  v19.vPosition.z = ODM_GetFloorLevel(
5341  v19.vPosition.x, v19.vPosition.y, pParty->vPosition.z,
5342  0, &bInWater, &v27, 0);
5343  for (BSPModel &model : pOutdoor->pBModels) {
5344  v9 = abs(v19.vPosition.y - model.vBoundingCenter.y);
5345  v10 = abs(v19.vPosition.x - model.vBoundingCenter.x);
5346  if (int_get_vector_length(v10, v9, 0) <
5347  model.sBoundingRadius + 256) {
5348  v22 = 1;
5349  break;
5350  }
5351  }
5352  if (v22) {
5353  v11 = face_id == 100;
5354  break;
5355  }
5356  }
5357  v11 = face_id == 100;
5358  } else if (uCurrentlyLoadedLevelType == LEVEL_Indoor) {
5359  v22 =
5360  pIndoor->GetSector(pParty->vPosition.x, pParty->vPosition.y,
5361  pParty->vPosition.z);
5362  for (uint i = 0; i < 100; ++i) {
5363  v12 = rand() % 512 + 256;
5364  v13 = rand();
5365  v14 = v13 % (int)stru_5C6E00->uIntegerDoublePi;
5366  v15 = stru_5C6E00->Cos(v13 % (int)stru_5C6E00->uIntegerDoublePi);
5367  v19.vPosition.x = pParty->vPosition.x + fixpoint_mul(v15, v12);
5368  v16 = stru_5C6E00->Sin(v13 % (int)stru_5C6E00->uIntegerDoublePi);
5369  v19.vPosition.y = fixpoint_mul(v16, v12) + pParty->vPosition.y;
5370  v19.vPosition.z = pParty->vPosition.z;
5371  v19.uIndex = a2;
5372  v17 = pIndoor->GetSector(v19.vPosition.x, v19.vPosition.y, pParty->vPosition.z);
5373  if (v17 == v22) {
5374  v18 = BLV_GetFloorLevel(v19.vPosition.x, v19.vPosition.y,
5375  v19.vPosition.z, v17, &uFaceID);
5376  v19.vPosition.z = v18;
5377  if (v18 != -30000) {
5378  if (abs(v18 - pParty->vPosition.z) <= 1024) break;
5379  }
5380  }
5381  }
5382  v11 = v26 == 100;
5383  }
5384 
5385  if (v11) {
5386  result = 0;
5387  } else {
5388  SpawnEncounter(a1, &v19, 0, 0, 1);
5389  result = a2;
5390  }
5391  }
5392 
5393  // break;
5394  // v22 = v3->pMonsterInfo.uID - 1;
5395  // v4 = (signed __int64)((double)v22 * 0.3333333333333333);
5396  // if ( (int)v4 != 40 )
5397  //{
5398  // if ( (int)v4 != 41 && (int)v4 != 44 && v3->CanAct() )
5399  // break;
5400  //}
5401  // ++v2;
5402  // ++v3;
5403  // if ( v2 >= (signed int)uNumActors )
5404  // goto LABEL_8;
5405  }
5406  return result;
5407 }

Перекрестные ссылки BLV_GetFloorLevel(), stru193_math::Cos(), fixpoint_mul(), IndoorLocation::GetSector(), int_get_vector_length(), LEVEL_Indoor, LEVEL_Outdoor, ODM_GetFloorLevel(), pActors, OutdoorLocation::pBModels, pIndoor, pOutdoor, pParty, BSPModel::sBoundingRadius, stru193_math::Sin(), SpawnEncounter(), stru_5C6E00, uCurrentlyLoadedLevelType, SpawnPointMM7::uIndex, stru193_math::uIntegerDoublePi, uNumActors, BSPModel::vBoundingCenter, Party::vPosition и SpawnPointMM7::vPosition.

Используется в Application::Game::EventLoop().

+ Граф вызовов:
+ Граф вызова функции:

◆ sub_450521_ProllyDropItemAt()

int sub_450521_ProllyDropItemAt ( int  ecx0,
signed int  a2,
int  a3,
int  a4,
int  a5,
uint16_t  a6 
)

◆ sub_4075DB()

bool sub_4075DB ( int  a1,
int  a2,
int  a3,
struct BLVFace *  face 
)

См. определение в файле Indoor.cpp строка 5424

5424  {
5425  int v8; // edi@2
5426  int v25; // eax@22
5427  bool result; // eax@25
5428  int a3a; // [sp+24h] [bp+8h]@14
5429  int a4a; // [sp+28h] [bp+Ch]@2
5430 
5431  std::array<int, 52> dword_4F5CC8_ys; // idb
5432  std::array<int, 52> dword_4F5D98_xs; // idb
5433 
5434  if (face->uAttributes & FACE_XY_PLANE) {
5435  a4a = x;
5436  v8 = y;
5437  for (int i = 0; i < face->uNumVertices; i++) {
5438  dword_4F5D98_xs[i] = pIndoor->pVertices[face->pVertexIDs[i]].x;
5439  dword_4F5CC8_ys[i] = pIndoor->pVertices[face->pVertexIDs[i]].y;
5440  }
5441  } else {
5442  v8 = z;
5443  if (face->uAttributes & FACE_XZ_PLANE) {
5444  a4a = x;
5445  for (int i = 0; i < face->uNumVertices; i++) {
5446  dword_4F5D98_xs[i] = pIndoor->pVertices[face->pVertexIDs[i]].x;
5447  dword_4F5CC8_ys[i] = pIndoor->pVertices[face->pVertexIDs[i]].z;
5448  }
5449  } else {
5450  a4a = y;
5451  for (int i = 0; i < face->uNumVertices; i++) {
5452  dword_4F5D98_xs[i] = pIndoor->pVertices[face->pVertexIDs[i]].y;
5453  dword_4F5CC8_ys[i] = pIndoor->pVertices[face->pVertexIDs[i]].z;
5454  }
5455  }
5456  }
5457  a3a = 0;
5458  dword_4F5D98_xs[face->uNumVertices] = dword_4F5D98_xs[0];
5459  dword_4F5CC8_ys[face->uNumVertices] = dword_4F5CC8_ys[0];
5460  for (int i = 0; i < face->uNumVertices && a3a < 2; i++) {
5461  if ((dword_4F5CC8_ys[i] >= v8) ^ (dword_4F5CC8_ys[i + 1] >= v8)) {
5462  // if( dword_4F5D98_xs[i + 1] >= a4a || dword_4F5D98_xs[i] >= a4a)
5463  if (!(dword_4F5D98_xs[i + 1] >= a4a && dword_4F5D98_xs[i] < a4a)) {
5464  if ((dword_4F5D98_xs[i + 1] < a4a && dword_4F5D98_xs[i] >= a4a)) {
5465  ++a3a;
5466  // || (v25 = dword_4F5D98_xs[i + 1] -
5467  // dword_4F5D98_xs[i],LODWORD(v26) = v25 << 16, HIDWORD(v26) =
5468  // v25 >> 16, dword_4F5D98_xs[i] + ((signed int)(((unsigned
5469  // __int64)(v26 / (dword_4F5CC4_ys[i + 2] - dword_4F5CC4_ys[i +
5470  // 1])* ((v8 - dword_4F5CC4_ys[i + 1]) << 16)) >> 16)
5471  // + 32768) >> 16) >= a4a) )
5472  } else {
5473  v25 = fixpoint_div(dword_4F5D98_xs[i + 1] - dword_4F5D98_xs[i],
5474  dword_4F5CC8_ys[i + 1] - dword_4F5CC8_ys[i]);
5475  if (dword_4F5D98_xs[i] + (fixpoint_mul(v25, (v8 - dword_4F5CC8_ys[i]) << 16) + 0x8000 >> 16) >= a4a)
5476  ++a3a;
5477  }
5478  }
5479  }
5480  }
5481  result = 1;
5482  if (a3a != 1) result = 0;
5483  return result;
5484 }

Перекрестные ссылки fixpoint_div(), fixpoint_mul(), pIndoor и IndoorLocation::pVertices.

Используется в sub_4070EF_prolly_detect_player() и sub_407A1C().

+ Граф вызовов:
+ Граф вызова функции:

◆ sub_4077F1()

bool sub_4077F1 ( int  a1,
int  a2,
int  a3,
struct ODMFace *  face,
struct BSPVertexBuffer *  a5 
)

См. определение в файле Indoor.cpp строка 5486

5486  {
5487  int a4a; // [sp+28h] [bp+Ch]@2
5488  int a5a; // [sp+2Ch] [bp+10h]@14
5489 
5490  std::array<int, 52> dword_4F5B24_ys; // idb
5491  std::array<int, 52> dword_4F5BF4_xs; // idb
5492 
5493  // __debugbreak(); // срабатывает при нападении стрекозавров с огнём
5494 
5495  if (face->uAttributes & FACE_XY_PLANE) {
5496  a4a = a1;
5497  a3 = a2;
5498  for (int i = 0; i < face->uNumVertices; i++) {
5499  dword_4F5BF4_xs[i + 1] = a5->pVertices[face->pVertexIDs[i]].x;
5500  dword_4F5B24_ys[i + 1] = a5->pVertices[face->pVertexIDs[i]].y;
5501  }
5502  } else {
5503  if (face->uAttributes & FACE_XY_PLANE) {
5504  a4a = a1;
5505  for (int i = 0; i < face->uNumVertices; i++) {
5506  dword_4F5BF4_xs[i + 1] = a5->pVertices[face->pVertexIDs[i]].x;
5507  dword_4F5B24_ys[i + 1] = a5->pVertices[face->pVertexIDs[i]].z;
5508  }
5509  } else {
5510  a4a = a2;
5511  for (int i = 0; i < face->uNumVertices; i++) {
5512  dword_4F5BF4_xs[i + 1] = a5->pVertices[face->pVertexIDs[i]].y;
5513  dword_4F5B24_ys[i + 1] = a5->pVertices[face->pVertexIDs[i]].z;
5514  }
5515  }
5516  }
5517  a5a = 0;
5518  dword_4F5BF4_xs[face->uNumVertices + 1] = dword_4F5BF4_xs[1];
5519  dword_4F5B24_ys[face->uNumVertices + 1] = dword_4F5B24_ys[1];
5520  for (int i = 0; i < face->uNumVertices; i++) {
5521  if (a5a >= 2) break;
5522  if ((dword_4F5B24_ys[i + 1] >= a3) ^ (dword_4F5B24_ys[i + 2] >= a3)) {
5523  if (dword_4F5BF4_xs[i + 2] >= a4a || dword_4F5BF4_xs[i] >= a4a) {
5524  if (dword_4F5BF4_xs[i + 2] >= a4a &&
5525  dword_4F5BF4_xs[i + 1] >= a4a) {
5526  ++a5a;
5527  } else {
5528  // v23 = (__int64)(dword_4F5BF4_xs[i + 2] -
5529  // dword_4F5BF4_xs[i + 1]) << 16;
5530  __int64 _a =
5531  dword_4F5B24_ys[i + 2] - dword_4F5B24_ys[i + 1];
5532  __int64 _b = (__int64)(a3 - dword_4F5B24_ys[i + 1]) << 16;
5533 
5534  if (dword_4F5BF4_xs[i + 1] +
5535  ((((((__int64)(dword_4F5BF4_xs[i + 2] -
5536  dword_4F5BF4_xs[i + 1])
5537  << 16) /
5538  _a * _b) >>
5539  16) +
5540  0x8000) >>
5541  16) >=
5542  a4a)
5543  ++a5a;
5544  }
5545  }
5546  }
5547  }
5548 
5549  if (a5a != 1) return false;
5550  return true;
5551 }

Перекрестные ссылки BSPVertexBuffer::pVertices.

Используется в sub_407A1C().

+ Граф вызова функции:

◆ FindBillboardsLightLevels_BLV()

void FindBillboardsLightLevels_BLV ( )

См. определение в файле Indoor.cpp строка 5654

5654  {
5655  for (uint i = 0; i < uNumBillboardsToDraw; ++i) {
5656  if (pBillboardRenderList[i].field_1E & 2 ||
5657  uCurrentlyLoadedLevelType == LEVEL_Indoor &&
5658  !pBillboardRenderList[i].uIndoorSectorID)
5659  pBillboardRenderList[i].dimming_level = 0;
5660  else
5661  pBillboardRenderList[i].dimming_level =
5662  _43F55F_get_billboard_light_level(&pBillboardRenderList[i], -1);
5663  }
5664 }

Перекрестные ссылки _43F55F_get_billboard_light_level(), RenderBillboard::dimming_level, LEVEL_Indoor, pBillboardRenderList, uCurrentlyLoadedLevelType и uNumBillboardsToDraw.

Используется в PrepareDrawLists_BLV().

+ Граф вызовов:
+ Граф вызова функции:

◆ collide_against_floor_approximate()

int collide_against_floor_approximate ( int  x,
int  y,
int  z,
unsigned int *  pSectorID,
unsigned int *  pFaceID 
)

См. определение в файле Indoor.cpp строка 5667

5669  {
5670  int result; // eax@1
5671 
5672  *pSectorID = pIndoor->GetSector(x - 2, y, z + 40);
5673  result = collide_against_floor(x - 2, y, z + 40, pSectorID, pFaceID);
5674  if (result == -30000 || !*pSectorID) {
5675  *pSectorID = pIndoor->GetSector(x + 2, y, z + 40);
5676  result = collide_against_floor(x + 2, y, z + 40, pSectorID, pFaceID);
5677  if (result == -30000 || !*pSectorID) {
5678  *pSectorID = pIndoor->GetSector(x, y - 2, z + 40);
5679  result =
5680  collide_against_floor(x, y - 2, z + 40, pSectorID, pFaceID);
5681  if (result == -30000 || !*pSectorID) {
5682  *pSectorID = pIndoor->GetSector(x, y + 2, z + 40);
5683  result =
5684  collide_against_floor(x, y + 2, z + 40, pSectorID, pFaceID);
5685  if (result == -30000 || !*pSectorID) {
5686  *pSectorID = pIndoor->GetSector(x, y, z + 140);
5687  result = collide_against_floor(x, y, z + 140, pSectorID,
5688  pFaceID);
5689  }
5690  }
5691  }
5692  }
5693  return result;
5694 }

Перекрестные ссылки collide_against_floor(), IndoorLocation::GetSector() и pIndoor.

Используется в BLV_ProcessPartyActions().

+ Граф вызовов:
+ Граф вызова функции:

◆ sub_407A1C()

bool sub_407A1C ( int  x,
int  z,
int  y,
struct Vec3_int_  v 
)

См. определение в файле Indoor.cpp строка 3199

3199  {
3200  unsigned int v4; // esi@1
3201  int dist_y; // edi@2
3202  int dist_z; // ebx@2
3203  int dist_x; // esi@2
3204  int v9; // ecx@2
3205  int v10; // eax@2
3206  int v12; // eax@4
3207  int v17; // ST34_4@25
3208  int v18; // ST38_4@25
3209  int v19; // eax@25
3210  char v20; // zf@25
3211  int v21; // ebx@25
3212  int v23; // edi@26
3213  int v24; // ST34_4@30
3214  int v32; // ecx@37
3215  int v33; // eax@37
3216  int v35; // eax@39
3217  int v40; // ebx@60
3218  int v42; // edi@61
3219  int v49; // ecx@73
3220  int v50; // eax@73
3221  int v51; // edx@75
3222  int v52; // ecx@75
3223  int v53; // eax@75
3224  int v59; // eax@90
3225  BLVFace *face; // esi@91
3226  int v63; // ST34_4@98
3227  int v64; // ST30_4@98
3228  int v65; // eax@98
3229  int v66; // ebx@98
3230  int v68; // edi@99
3231  int v69; // ST2C_4@103
3232  int v77; // ecx@111
3233  int v78; // eax@111
3234  int v79; // edx@113
3235  int v80; // ecx@113
3236  int v81; // eax@113
3237  int v87; // ecx@128
3238  int v91; // ebx@136
3239  int v93; // edi@137
3240  Vec3_int_ v97; // [sp-18h] [bp-94h]@1
3241  int v107; // [sp+10h] [bp-6Ch]@98
3242  int v108; // [sp+10h] [bp-6Ch]@104
3243  int v109; // [sp+18h] [bp-64h]@25
3244  int v110; // [sp+18h] [bp-64h]@31
3245  int v113; // [sp+20h] [bp-5Ch]@1
3246  int v114; // [sp+24h] [bp-58h]@1
3247  int v119; // [sp+34h] [bp-48h]@75
3248  int v120; // [sp+34h] [bp-48h]@113
3249  int v121; // [sp+38h] [bp-44h]@4
3250  int v122; // [sp+38h] [bp-44h]@39
3251  int v123; // [sp+38h] [bp-44h]@76
3252  int v124; // [sp+38h] [bp-44h]@114
3253  int v125; // [sp+3Ch] [bp-40h]@4
3254  int v126; // [sp+3Ch] [bp-40h]@39
3255  int v127; // [sp+3Ch] [bp-40h]@77
3256  int v128; // [sp+3Ch] [bp-40h]@115
3257  int v129; // [sp+40h] [bp-3Ch]@11
3258  int v130; // [sp+40h] [bp-3Ch]@46
3259  int v131; // [sp+40h] [bp-3Ch]@78
3260  int v132; // [sp+40h] [bp-3Ch]@116
3261  int v133; // [sp+44h] [bp-38h]@10
3262  int v134; // [sp+44h] [bp-38h]@45
3263  int v135; // [sp+44h] [bp-38h]@81
3264  int v136; // [sp+44h] [bp-38h]@119
3265  int v137; // [sp+48h] [bp-34h]@7
3266  int v138; // [sp+48h] [bp-34h]@42
3267  int v139; // [sp+48h] [bp-34h]@82
3268  int v140; // [sp+48h] [bp-34h]@120
3269  int v141; // [sp+4Ch] [bp-30h]@6
3270  int v142; // [sp+4Ch] [bp-30h]@41
3271  int v143; // [sp+4Ch] [bp-30h]@75
3272  int v144; // [sp+4Ch] [bp-30h]@113
3273  int v145; // [sp+50h] [bp-2Ch]@5
3274  int v146; // [sp+50h] [bp-2Ch]@40
3275  int v149; // [sp+54h] [bp-28h]@4
3276  int v150; // [sp+54h] [bp-28h]@39
3277  int sDepthb; // [sp+58h] [bp-24h]@90
3278  int a5b; // [sp+5Ch] [bp-20h]@83
3279  int a5c; // [sp+5Ch] [bp-20h]@121
3280  int v162; // [sp+60h] [bp-1Ch]@128
3281  int outz; // [sp+64h] [bp-18h]@2
3282  int outx; // [sp+68h] [bp-14h]@2
3283  int outy; // [sp+6Ch] [bp-10h]@2
3284  int sZ; // [sp+70h] [bp-Ch]@2
3285  int sX; // [sp+74h] [bp-8h]@2
3286  int sY; // [sp+78h] [bp-4h]@2
3287  // 8bytes unused
3288  int ya; // [sp+84h] [bp+8h]@60
3289  int yb; // [sp+84h] [bp+8h]@136
3290  int ve; // [sp+88h] [bp+Ch]@60
3291  int va; // [sp+88h] [bp+Ch]@60
3292  int vb; // [sp+88h] [bp+Ch]@66
3293  int vf; // [sp+88h] [bp+Ch]@136
3294  int vc; // [sp+88h] [bp+Ch]@136
3295  int vd; // [sp+88h] [bp+Ch]@142
3296  int v_4; // [sp+8Ch] [bp+10h]@60
3297  int v_4a; // [sp+8Ch] [bp+10h]@65
3298  int v_4b; // [sp+8Ch] [bp+10h]@136
3299  int v_4c; // [sp+8Ch] [bp+10h]@141
3300 
3301  // __debugbreak();срабатывает при стрельбе огненным шаром
3302  // triggered by fireball
3303 
3304  v4 = stru_5C6E00->Atan2(v.x - x, v.y - y);
3305 
3306  v113 = 0;
3307  v114 = 0;
3308 
3309  v97.z = z;
3310  v97.x = x;
3311  v97.y = y;
3312 
3313  if (uCurrentlyLoadedLevelType == LEVEL_Indoor) {
3314  Vec3_int_::Rotate(32, stru_5C6E00->uIntegerHalfPi + v4, 0, v97, &sX,
3315  &sY, &sZ);
3316  Vec3_int_::Rotate(32, stru_5C6E00->uIntegerHalfPi + v4, 0, v, &outx,
3317  &outy, &outz);
3318  dist_y = outy - sY;
3319  dist_z = outz - sZ;
3320  dist_x = outx - sX;
3321  v49 = integer_sqrt(dist_x * dist_x + dist_y * dist_y + dist_z * dist_z);
3322  v50 = 65536;
3323  if (v49) v50 = 65536 / v49;
3324  v51 = outx;
3325  v143 = dist_x * v50;
3326  v52 = dist_y * v50;
3327  v53 = dist_z * v50;
3328 
3329  v123 = std::max(outx, sX);
3330  v119 = std::min(outx, sX);
3331 
3332  v131 = std::max(outy, sY);
3333  v127 = std::min(outy, sY);
3334 
3335  v139 = std::max(outz, sZ);
3336  v135 = std::min(outz, sZ);
3337 
3338  for (a5b = 0; a5b < 2; a5b++) {
3339  if (a5b)
3340  v59 = pIndoor->GetSector(sX, sY, sZ);
3341  else
3342  v59 = pIndoor->GetSector(outx, outy, outz);
3343  // v60 = pIndoor->pSectors;
3344  // v61 = 116 * v59;
3345  // i = 116 * v59;
3346  // for (sDepthb = 0; *(__int16 *)((char
3347  // *)&pIndoor->pSectors->uNumWalls + v61)
3348  // + 2 * *(__int16 *)((char *)&pIndoor->pSectors->uNumFloors + v61);
3349  // ++sDepthb)
3350  for (sDepthb = 0; sDepthb < pIndoor->pSectors[v59].uNumFaces;
3351  ++sDepthb) {
3352  face =
3353  &pIndoor
3354  ->pFaces[pIndoor->pSectors[v59]
3355  .pFaceIDs[sDepthb]]; // face =
3356  // &pIndoor->pFaces[*(__int16
3357  // *)((char
3358  // *)&pIndoor->pSectors->pWalls
3359  // + v61)[sDepthb]]
3360  v63 = fixpoint_mul(v143, face->pFacePlane_old.vNormal.x);
3361  v64 = fixpoint_mul(v53, face->pFacePlane_old.vNormal.z);
3362  v65 = fixpoint_mul(v52, face->pFacePlane_old.vNormal.y);
3363  v20 = v63 + v64 + v65 == 0;
3364  v66 = v63 + v64 + v65;
3365  v107 = v63 + v64 + v65;
3366  if (face->Portal() || v119 > face->pBounding.x2 ||
3367  v123 < face->pBounding.x1 || v127 > face->pBounding.y2 ||
3368  v131 < face->pBounding.y1 || v135 > face->pBounding.z2 ||
3369  v139 < face->pBounding.z1 || v20)
3370  continue;
3371  v68 = -(face->pFacePlane_old.dist +
3372  sX * face->pFacePlane_old.vNormal.x +
3373  sY * face->pFacePlane_old.vNormal.y +
3374  sZ * face->pFacePlane_old.vNormal.z);
3375  if (v66 <= 0) {
3376  if (face->pFacePlane_old.dist +
3377  sX * face->pFacePlane_old.vNormal.x +
3378  sY * face->pFacePlane_old.vNormal.y +
3379  sZ * face->pFacePlane_old.vNormal.z <
3380  0)
3381  continue;
3382  } else {
3383  if (face->pFacePlane_old.dist +
3384  sX * face->pFacePlane_old.vNormal.x +
3385  sY * face->pFacePlane_old.vNormal.y +
3386  sZ * face->pFacePlane_old.vNormal.z >
3387  0)
3388  continue;
3389  }
3390  v69 = abs(-(face->pFacePlane_old.dist +
3391  sX * face->pFacePlane_old.vNormal.x +
3392  sY * face->pFacePlane_old.vNormal.y +
3393  sZ * face->pFacePlane_old.vNormal.z)) >>
3394  14;
3395  if (v69 <= abs(v66)) {
3396  // LODWORD(v70) = v68 << 16;
3397  // HIDWORD(v70) = v68 >> 16;
3398  // v71 = v70 / v107;
3399  // v108 = v70 / v107;
3400  v108 = fixpoint_div(v68, v107);
3401  if (v108 >= 0) {
3402  if (sub_4075DB(
3403  sX + ((signed int)(fixpoint_mul(v108, v143) +
3404  0x8000) >>
3405  16),
3406  sY + ((signed int)(fixpoint_mul(v108, v52) +
3407  0x8000) >>
3408  16),
3409  sZ + ((signed int)(fixpoint_mul(v108, v53) +
3410  0x8000) >>
3411  16),
3412  face)) {
3413  v114 = 1;
3414  break;
3415  }
3416  }
3417  }
3418  }
3419  }
3420 
3421  Vec3_int_::Rotate(32, v4 - stru_5C6E00->uIntegerHalfPi, 0, v97, &sX,
3422  &sY, &sZ);
3423  Vec3_int_::Rotate(32, v4 - stru_5C6E00->uIntegerHalfPi, 0, v, &outx,
3424  &outy, &outz);
3425  dist_y = outy - sY;
3426  dist_z = outz - sZ;
3427  dist_x = outx - sX;
3428  v77 = integer_sqrt(dist_x * dist_x + dist_y * dist_y + dist_z * dist_z);
3429  v78 = 65536;
3430  if (v77) v78 = 65536 / v77;
3431  v79 = outx;
3432  v144 = dist_x * v78;
3433  v80 = dist_y * v78;
3434  v81 = dist_z * v78;
3435 
3436  v120 = std::max(outx, sX);
3437  v124 = std::min(outx, sX);
3438 
3439  v132 = std::max(outy, sY);
3440  v128 = std::min(outy, sY);
3441 
3442  v140 = std::max(outz, sZ);
3443  v136 = std::min(outz, sZ);
3444 
3445  for (a5c = 0; a5c < 2; a5c++) {
3446  if (v113) return !v114 || !v113;
3447  if (a5c) {
3448  v87 = pIndoor->GetSector(sX, sY, sZ);
3449  } else {
3450  v87 = pIndoor->GetSector(outx, outy, outz);
3451  }
3452  for (v162 = 0; v162 < pIndoor->pSectors[v87].uNumFaces; v162++) {
3453  face = &pIndoor->pFaces[pIndoor->pSectors[v87].pFaceIDs[v162]];
3454  yb = fixpoint_mul(v144, face->pFacePlane_old.vNormal.x);
3455  v_4b = fixpoint_mul(v80, face->pFacePlane_old.vNormal.y);
3456  vf = fixpoint_mul(v81, face->pFacePlane_old.vNormal.z);
3457  v20 = yb + vf + v_4b == 0;
3458  v91 = yb + vf + v_4b;
3459  vc = yb + vf + v_4b;
3460  if (face->Portal() || v120 > face->pBounding.x2 ||
3461  v124 < face->pBounding.x1 || v128 > face->pBounding.y2 ||
3462  v132 < face->pBounding.y1 || v136 > face->pBounding.z2 ||
3463  v140 < face->pBounding.z1 || v20)
3464  continue;
3465  v93 = -(face->pFacePlane_old.dist +
3466  sX * face->pFacePlane_old.vNormal.x +
3467  sY * face->pFacePlane_old.vNormal.y +
3468  sZ * face->pFacePlane_old.vNormal.z);
3469  if (v91 <= 0) {
3470  if (face->pFacePlane_old.dist +
3471  sX * face->pFacePlane_old.vNormal.x +
3472  sY * face->pFacePlane_old.vNormal.y +
3473  sZ * face->pFacePlane_old.vNormal.z <
3474  0)
3475  continue;
3476  } else {
3477  if (face->pFacePlane_old.dist +
3478  sX * face->pFacePlane_old.vNormal.x +
3479  sY * face->pFacePlane_old.vNormal.y +
3480  sZ * face->pFacePlane_old.vNormal.z >
3481  0)
3482  continue;
3483  }
3484  v_4c = abs(-(face->pFacePlane_old.dist +
3485  sX * face->pFacePlane_old.vNormal.x +
3486  sY * face->pFacePlane_old.vNormal.y +
3487  sZ * face->pFacePlane_old.vNormal.z)) >>
3488  14;
3489  if (v_4c <= abs(v91)) {
3490  vd = fixpoint_div(v93, vc);
3491  if (vd >= 0) {
3492  if (sub_4075DB(
3493  sX + ((signed int)(fixpoint_mul(vd, v144) +
3494  0x8000) >>
3495  16),
3496  sY + ((signed int)(fixpoint_mul(vd, v80) +
3497  0x8000) >>
3498  16),
3499  sZ + ((signed int)(fixpoint_mul(vd, v81) +
3500  0x8000) >>
3501  16),
3502  face)) {
3503  v113 = 1;
3504  break;
3505  }
3506  }
3507  }
3508  }
3509  }
3510  } else if (uCurrentlyLoadedLevelType == LEVEL_Outdoor) {
3511  Vec3_int_::Rotate(32, stru_5C6E00->uIntegerHalfPi + v4, 0, v97, &sX,
3512  &sY, &sZ);
3513  Vec3_int_::Rotate(32, stru_5C6E00->uIntegerHalfPi + v4, 0, v, &outx,
3514  &outy, &outz);
3515  dist_y = outy - sY;
3516  dist_z = outz - sZ;
3517  dist_x = outx - sX;
3518  v9 = integer_sqrt(dist_x * dist_x + dist_y * dist_y + dist_z * dist_z);
3519  v10 = 65536;
3520  if (v9) v10 = 65536 / v9;
3521  v125 = dist_x * v10;
3522  v12 = dist_z * v10;
3523  v121 = dist_y * v10;
3524 
3525  v145 = std::max(outx, sX);
3526  v149 = std::min(outx, sX);
3527 
3528  v137 = std::max(outy, sY);
3529  v141 = std::min(outy, sY);
3530 
3531  v129 = std::max(outz, sZ);
3532  v133 = std::min(outz, sZ);
3533 
3534  for (BSPModel &model : pOutdoor->pBModels) {
3535  if (sub_4088E9(sX, sY, outx, outy, model.vPosition.x,
3536  model.vPosition.y) <= model.sBoundingRadius + 128) {
3537  for (ODMFace &face : model.pFaces) {
3538  v17 = fixpoint_mul(v125, face.pFacePlane.vNormal.x);
3539  v18 = fixpoint_mul(v121, face.pFacePlane.vNormal.y);
3540  v19 = fixpoint_mul(v12, face.pFacePlane.vNormal.z);
3541  v20 = v17 + v18 + v19 == 0;
3542  v21 = v17 + v18 + v19;
3543  v109 = v17 + v18 + v19;
3544  if (v149 > face.pBoundingBox.x2 ||
3545  v145 < face.pBoundingBox.x1 ||
3546  v141 > face.pBoundingBox.y2 ||
3547  v137 < face.pBoundingBox.y1 ||
3548  v133 > face.pBoundingBox.z2 ||
3549  v129 < face.pBoundingBox.z1 || v20)
3550  continue;
3551  v23 = -(face.pFacePlane.dist +
3552  sX * face.pFacePlane.vNormal.x +
3553  sY * face.pFacePlane.vNormal.y +
3554  sZ * face.pFacePlane.vNormal.z);
3555  if (v21 <= 0) {
3556  if (face.pFacePlane.dist +
3557  sX * face.pFacePlane.vNormal.x +
3558  sY * face.pFacePlane.vNormal.y +
3559  sZ * face.pFacePlane.vNormal.z <
3560  0)
3561  continue;
3562  } else {
3563  if (face.pFacePlane.dist +
3564  sX * face.pFacePlane.vNormal.x +
3565  sY * face.pFacePlane.vNormal.y +
3566  sZ * face.pFacePlane.vNormal.z >
3567  0)
3568  continue;
3569  }
3570  v24 = abs(-(face.pFacePlane.dist +
3571  sX * face.pFacePlane.vNormal.x +
3572  sY * face.pFacePlane.vNormal.y +
3573  sZ * face.pFacePlane.vNormal.z)) >>
3574  14;
3575  if (v24 <= abs(v21)) {
3576  v110 = fixpoint_div(v23, v109);
3577  if (v110 >= 0) {
3578  if (sub_4077F1(
3579  sX +
3580  ((signed int)(fixpoint_mul(v110, v125) +
3581  0x8000) >>
3582  16),
3583  sY +
3584  ((signed int)(fixpoint_mul(v110, v121) +
3585  0x8000) >>
3586  16),
3587  sZ + ((signed int)(fixpoint_mul(v110, v12) +
3588  0x8000) >>
3589  16),
3590  &face, &model.pVertices)) {
3591  v114 = 1;
3592  break;
3593  }
3594  }
3595  }
3596  }
3597  }
3598  }
3599 
3600  Vec3_int_::Rotate(32, v4 - stru_5C6E00->uIntegerHalfPi, 0, v97, &sX,
3601  &sY, &sZ);
3602  Vec3_int_::Rotate(32, v4 - stru_5C6E00->uIntegerHalfPi, 0, v, &outx,
3603  &outy, &outz);
3604  dist_y = outy - sY;
3605  dist_z = outz - sZ;
3606  dist_x = outx - sX;
3607  v32 = integer_sqrt(dist_x * dist_x + dist_y * dist_y + dist_z * dist_z);
3608  v33 = 65536;
3609  if (v32) v33 = 65536 / v32;
3610  v126 = dist_x * v33;
3611  v35 = dist_z * v33;
3612  v122 = dist_y * v33;
3613 
3614  v146 = std::max(outx, sX);
3615  v150 = std::min(outx, sX);
3616 
3617  v138 = std::max(outy, sY);
3618  v142 = std::min(outy, sY);
3619 
3620  v130 = std::max(outz, sZ);
3621  v134 = std::min(outz, sZ);
3622 
3623  for (BSPModel &model : pOutdoor->pBModels) {
3624  if (sub_4088E9(sX, sY, outx, outy, model.vPosition.x,
3625  model.vPosition.y) <= model.sBoundingRadius + 128) {
3626  for (ODMFace &face : model.pFaces) {
3627  ya = fixpoint_mul(v126, face.pFacePlane.vNormal.x);
3628  ve = fixpoint_mul(v122, face.pFacePlane.vNormal.y);
3629  v_4 = fixpoint_mul(v35, face.pFacePlane.vNormal.z);
3630  v20 = ya + ve + v_4 == 0;
3631  v40 = ya + ve + v_4;
3632  va = ya + ve + v_4;
3633  if (v150 > face.pBoundingBox.x2 ||
3634  v146 < face.pBoundingBox.x1 ||
3635  v142 > face.pBoundingBox.y2 ||
3636  v138 < face.pBoundingBox.y1 ||
3637  v134 > face.pBoundingBox.z2 ||
3638  v130 < face.pBoundingBox.z1 || v20)
3639  continue;
3640  v42 = -(face.pFacePlane.dist +
3641  sX * face.pFacePlane.vNormal.x +
3642  sY * face.pFacePlane.vNormal.y +
3643  sZ * face.pFacePlane.vNormal.z);
3644  if (v40 <= 0) {
3645  if (face.pFacePlane.dist +
3646  sX * face.pFacePlane.vNormal.x +
3647  sY * face.pFacePlane.vNormal.y +
3648  sZ * face.pFacePlane.vNormal.z <
3649  0)
3650  continue;
3651  } else {
3652  if (face.pFacePlane.dist +
3653  sX * face.pFacePlane.vNormal.x +
3654  sY * face.pFacePlane.vNormal.y +
3655  sZ * face.pFacePlane.vNormal.z >
3656  0)
3657  continue;
3658  }
3659  v_4a = abs(-(face.pFacePlane.dist +
3660  sX * face.pFacePlane.vNormal.x +
3661  sY * face.pFacePlane.vNormal.y +
3662  sZ * face.pFacePlane.vNormal.z)) >>
3663  14;
3664  if (v_4a <= abs(v40)) {
3665  // LODWORD(v43) = v42 << 16;
3666  // HIDWORD(v43) = v42 >> 16;
3667  // vb = v43 / va;
3668  vb = fixpoint_div(v42, va);
3669  if (vb >= 0) {
3670  if (sub_4077F1(sX + ((int)(fixpoint_mul(vb, v126) +
3671  0x8000) >>
3672  16),
3673  sY + ((int)(fixpoint_mul(vb, v122) +
3674  0x8000) >>
3675  16),
3676  sZ + ((int)(fixpoint_mul(vb, v35) +
3677  0x8000) >>
3678  16),
3679  &face, &model.pVertices)) {
3680  v113 = 1;
3681  break;
3682  }
3683  }
3684  }
3685  }
3686  }
3687  }
3688  }
3689  return !v114 || !v113;
3690 }

Перекрестные ссылки stru193_math::Atan2(), fixpoint_div(), fixpoint_mul(), IndoorLocation::GetSector(), integer_sqrt(), LEVEL_Indoor, LEVEL_Outdoor, OutdoorLocation::pBModels, BLVSector::pFaceIDs, BSPModel::pFaces, IndoorLocation::pFaces, pIndoor, pOutdoor, IndoorLocation::pSectors, BSPModel::pVertices, BSPModel::sBoundingRadius, stru_5C6E00, sub_4075DB(), sub_4077F1(), sub_4088E9(), uCurrentlyLoadedLevelType, stru193_math::uIntegerHalfPi, BLVSector::uNumFaces и BSPModel::vPosition.

Используется в Actor::AI_MeleeAttack(), Actor::AI_MissileAttack1(), Actor::AI_MissileAttack2(), Actor::AI_SpellAttack1(), Actor::AI_SpellAttack2() и area_of_effect__damage_evaluate().

+ Граф вызовов:
+ Граф вызова функции:

Переменные

◆ Lights

LightsData Lights

См. определение в файле Indoor.cpp строка 54

Используется в LightmapBuilder::ApplyLight_BLV(), LightmapBuilder::ApplyLight_ODM(), LightmapBuilder::ApplyLights_IndoorFace(), LightmapBuilder::ApplyLights_OutdoorFace(), Render::DrawBuildingsD3D(), IndoorLocation::ExecDraw_d3d(), FaceFlowTextureOffset(), Render::RenderTerrainD3D(), LightmapBuilder::StackLight_TerrainFace() и LightmapBuilder::StackLights_TerrainFace().

◆ stru_721530

stru141_actor_collision_object stru_721530

См. определение в файле Indoor.cpp строка 58

Используется в Actor::_46DF1A_collide_against_actor(), _46E0B2_collide_against_decorations(), _46E26D_collide_against_sprites(), _46E44E_collide_against_faces_and_portals(), _46E889_collide_against_bmodels(), _46ED8A_collide_against_sprite_objects(), _46EF01_collision_chech_player(), _46F04E_collide_against_portals(), BLV_ProcessPartyActions(), ODM_ProcessPartyActions(), UpdateActors_BLV(), UpdateActors_ODM(), SpriteObject::UpdateObject_fn0_BLV() и SpriteObject::UpdateObject_fn0_ODM().

◆ stru_F81018

stru337 stru_F81018

См. определение в файле Indoor.cpp строка 55

◆ uCurrentlyLoadedLevelType

LEVEL_TYPE uCurrentlyLoadedLevelType

См. определение в файле Indoor.cpp строка 52

Используется в CastSpellInfoHelpers::_427E01_cast_spell(), _43F55F_get_billboard_light_level(), _43F5C8_get_point_light_level_with_respect_to_lights(), ViewingParams::_443365(), Engine::_44EEA7(), _45063B_spawn_some_monster(), LightmapBuilder::_45BE86_build_light_polygon(), _494035_timed_effects__water_walking_damage__etc(), DecalBuilder::_49B790_build_decal_geometry(), Render::_4A4CC9_AddSomeBillboard(), Player::AddVariable(), Actor::AI_Pursue2(), Actor::AI_Pursue3(), Actor::AI_SpellAttack(), Actor::ApplyFineForKillingPeasant(), Actor::Arena_summon_actor(), ArenaFight(), Render::BeginSceneD3D(), ViewingParams::CenterOnPartyZoomIn(), CheckActors_proximity(), Player::CompareVariable(), Vis::DetermineFacetIntersection(), Vis::DoesRayIntersectBillboard(), DoInteractionWithTopmostZObject(), Engine::Draw(), DrawBook_Map_sub(), Render::DrawDecal(), Engine::DrawGUI(), Render::DrawLightmap(), Render::DrawProjectile(), EventCastSpell(), Application::Game::EventLoop(), FindBillboardsLightLevels_BLV(), GameUI_DrawMinimap(), GameUI_GetMinimapHintText(), GameUI_WritePointedObjectStatusString(), GetActorTintColor(), GetAlertStatus(), Actor::GetDirectionInfo(), IndoorCameraD3D::GetFarClip(), GetMapBookHintText(), IndoorCameraD3D::GetNearClip(), Party::GetPartyReputation(), IndoorCameraD3D::GetPickDepth(), GUIWindow_Transition::GUIWindow_Transition(), Vis::is_part_of_selection(), Render::MakeScreenshot(), MM7Initialization(), Engine::OnGameViewportClick(), OnMapLoad(), Chest::Open(), Engine::OutlineSelection(), Vis::PickKeyboard(), Vis::PickMouse(), AudioPlayer::PlaySound(), PrepareToLoadBLV(), PrepareToLoadODM(), PrepareToLoadRestUI(), Keyboard::ProcessInputActions(), IndoorCameraD3D::Project(), Engine::ResetCursor_Palettes_LODs_Level_Audio_SFT_Windows(), SaveGame(), Player::SetVariable(), SpawnEncounter(), Actor::StealFrom(), sub_4070EF_prolly_detect_player(), sub_407A1C(), sub_44861E_set_texture(), sub_44892E_set_faces_bit(), sub_44FA4C_spawn_light_elemental(), sub_4B1447_party_fine(), Player::SubtractVariable(), Actor::SummonMinion(), TempleDialog(), IndoorLocation::ToggleLight(), TrainingDialog(), UnprojectX(), UnprojectY(), Actor::UpdateActorAI(), UpdateObjects(), UpdateUserInput_and_MapSpecificStuff(), UseNPCSkill() и ParticleEngine::ViewProject_TrueIfStillVisible_BLV().

◆ pIndoor

IndoorLocation* pIndoor

См. определение в файле Indoor.cpp строка 49

Используется в CastSpellInfoHelpers::_427E01_cast_spell(), Player::_42FA66_do_explosive_impact(), _43F55F_get_billboard_light_level(), _43F5C8_get_point_light_level_with_respect_to_lights(), ViewingParams::_443365(), _45063B_spawn_some_monster(), _46E0B2_collide_against_decorations(), _46E44E_collide_against_faces_and_portals(), _46F04E_collide_against_portals(), AddBspNodeToRenderList(), BspRenderer::AddFaceToRenderList_d3d(), Player::AddVariable(), Actor::AI_RangedAttack(), Actor::AI_SpellAttack(), DecalBuilder::ApplyBloodsplatDecals_IndoorFace(), Actor::ApplyFineForKillingPeasant(), LightmapBuilder::ApplyLights_IndoorFace(), Actor::Arena_summon_actor(), ArenaFight(), Vis::BLV_CreateIntersectFacesVertexCoordList(), BLV_GetFloorLevel(), BLV_ProcessPartyActions(), BLV_UpdateDoors(), stru10::CalcPolygonLimits(), collide_against_floor(), collide_against_floor_approximate(), Player::CompareVariable(), SpriteObject::Create_Splash_Object(), IndoorCameraD3D::DebugDrawPortal(), Vis::DetermineFacetIntersection(), DoInteractionWithTopmostZObject(), Door_switch_animation(), Engine::Draw(), DrawBook_Map_sub(), Engine::DrawGUI(), RenderOpenGL::DrawIndoorPolygon(), Render::DrawIndoorSky(), Engine::DropHeldItem(), EventCastSpell(), Application::Game::EventLoop(), EventProcessor(), IndoorLocation::ExecDraw_d3d(), Actor::Explode(), FaceFlowTextureOffset(), GameUI_DrawMinimap(), GameUI_WritePointedObjectStatusString(), GetAlertStatus(), Actor::GetDirectionInfo(), Party::GetPartyReputation(), GetPortalScreenCoord(), Vis::is_part_of_selection(), IndoorCameraD3D::IsCulled(), Actor::MakeActorAIList_BLV(), Render::MakeScreenshot(), Engine::OnGameViewportClick(), OnMapLoad(), Chest::Open(), Vis::PickIndoorFaces_Keyboard(), Vis::PickIndoorFaces_Mouse(), AudioPlayer::PlaySound(), IndoorCameraD3D::PrepareAndDrawDebugOutline(), PrepareDrawLists_BLV(), PrepareToLoadBLV(), BLVRenderParams::Reset(), Engine::ResetCursor_Palettes_LODs_Level_Audio_SFT_Windows(), SaveGame(), Player::SetVariable(), SpawnEncounter(), MapInfo::SpawnRandomTreasure(), Actor::StealFrom(), sub_4070EF_prolly_detect_player(), sub_4075DB(), sub_407A1C(), Party::sub_421B2C_PlaceInInventory_or_DropPickedItem(), SpriteObject::sub_42F7EB_DropItemAt(), sub_4406BC(), sub_44861E_set_texture_indoor(), sub_44892E_set_faces_bit(), sub_44FA4C_spawn_light_elemental(), sub_450521_ProllyDropItemAt(), sub_475665(), sub_4B1447_party_fine(), Player::SubtractVariable(), Actor::SummonMinion(), TempleDialog(), IndoorLocation::ToggleLight(), UpdateActors_BLV() и SpriteObject::UpdateObject_fn0_BLV().

◆ pBLVRenderParams

BLVRenderParams* pBLVRenderParams

См. определение в файле Indoor.cpp строка 50

Используется в BspRenderer::AddFaceToRenderList_d3d(), IndoorLocation::Draw(), RenderOpenGL::DrawBillboardList_BLV(), Render::DrawBillboardList_BLV(), Render::DrawIndoorSky(), IndoorLocation::ExecDraw_d3d(), GetPortalScreenCoord(), IndoorLocation::PrepareActorRenderList_BLV(), PrepareBspRenderList_BLV(), IndoorLocation::PrepareDecorationsRenderList_BLV(), PrepareDrawLists_BLV() и BLVRenderParams::Reset().

◆ stru_F8A590

BspRenderer_PortalViewportData stru_F8A590

См. определение в файле Indoor.cpp строка 56

◆ pBspRenderer

struct BspRenderer* pBspRenderer

См. определение в файле Indoor.cpp строка 57

Используется в AddBspNodeToRenderList(), IndoorLocation::ExecDraw(), Vis::PickIndoorFaces_Keyboard(), Vis::PickIndoorFaces_Mouse(), IndoorLocation::PrepareActorRenderList_BLV(), PrepareBspRenderList_BLV(), PrepareDrawLists_BLV() и sub_4406BC().

BLVFace::uPolygonType
PolygonType uPolygonType
Definition: Indoor.h:487
PARTY_FLAGS_1_FALLING
@ PARTY_FLAGS_1_FALLING
Definition: Party.h:58
LightsData::pDeltaUV
int pDeltaUV[2]
Definition: Indoor.h:25
BspRenderer_stru0::uViewportY
uint16_t uViewportY
Definition: Indoor.h:778
TE_MOVEMENT
@ TE_MOVEMENT
Definition: TurnEngine.h:22
DecorationDesc_mm6::DontDraw
bool DontDraw()
Definition: DecorationList.h:29
LightsStack_StationaryLight_::uNumLightsActive
unsigned int uNumLightsActive
Definition: Lights.h:65
stru367::_screen_space_y
std::array< int, 60 > _screen_space_y
Definition: stru367.h:14
fWalkSpeedMultiplier
float fWalkSpeedMultiplier
Definition: mm7_data.cpp:706
TE_ATTACK
@ TE_ATTACK
Definition: TurnEngine.h:21
BLVFace::Portal
bool Portal() const
Definition: Indoor.h:448
uNumActors
size_t uNumActors
Definition: Actor.cpp:39
DMGT_PHISYCAL
@ DMGT_PHISYCAL
Definition: Items.h:15
Party::vPosition
Vec3_int_ vPosition
Definition: Party.h:250
BLVDoor::Closed
@ Closed
Definition: Indoor.h:380
BSPModel::pVertices
struct BSPVertexBuffer pVertices
Definition: BSPModel.h:189
face
GLenum GLuint GLint GLenum face
Definition: SDL_opengl_glext.h:3022
int_get_vector_length
uint32_t int_get_vector_length(int32_t x, int32_t y, int32_t z)
Definition: VectorTypes.cpp:8
pLevelDecorations
std::array< LevelDecoration, 3000 > pLevelDecorations
Definition: Decoration.cpp:8
stru193_math::uIntegerDoublePi
static const unsigned int uIntegerDoublePi
Definition: OurMath.h:90
BLV_UpdateDoors
void BLV_UpdateDoors()
Definition: Indoor.cpp:1506
Party::uFallSpeed
int uFallSpeed
Definition: Party.h:259
uSpeakingCharacter
int uSpeakingCharacter
Definition: mm7_data.cpp:764
BspRenderer::uNumVisibleNotEmptySectors
unsigned int uNumVisibleNotEmptySectors
Definition: Indoor.h:818
BLVDoor::pZOffsets
uint16_t * pZOffsets
Definition: Indoor.h:400
Dying
@ Dying
Definition: Actor.h:79
int16_t
signed __int16 int16_t
Definition: SDL_config.h:36
BLVFace::uNumVertices
uint8_t uNumVertices
Definition: Indoor.h:488
Timer::uTimeElapsed
unsigned int uTimeElapsed
Definition: Time.h:133
Party::field_24
int field_24
Definition: Party.h:245
v
const GLdouble * v
Definition: SDL_opengl.h:2064
BLVFaceExtra
Definition: Indoor.h:496
MapStats::pInfos
MapInfo pInfos[77]
Definition: MapInfo.h:79
stru141_actor_collision_object::field_6C
int field_6C
Definition: Indoor.h:168
BLVDoor::pDeltaVs
int16_t * pDeltaVs
Definition: Indoor.h:397
DecorationList::GetDecoration
DecorationDesc * GetDecoration(unsigned int index)
Definition: DecorationList.h:65
Party::GetPlayingTime
GameTime & GetPlayingTime()
Definition: Party.h:230
stru193_math::uDoublePiMask
static const unsigned int uDoublePiMask
Definition: OurMath.h:91
fixed::Raw
static fixed Raw(int value)
Definition: OurMath.h:31
Actor::AI_StandOrBored
static void AI_StandOrBored(unsigned int uActorID, signed int uObjID, int uActionLength, struct AIDirection *a4)
Definition: Actor.cpp:1100
GameTime::GetDays
int GetDays() const
Definition: Time.h:32
BLVFace::pFacePlane_old
struct Plane_int_ pFacePlane_old
Definition: Indoor.h:471
PARTY_StrafeLeft
@ PARTY_StrafeLeft
Definition: Party.h:98
Lights
LightsData Lights
Definition: Indoor.cpp:54
Vec2::x
T x
Definition: VectorTypes.h:12
TeleportToStartingPoint
void TeleportToStartingPoint(MapStartPoint point)
Definition: MapInfo.cpp:308
fTurnSpeedMultiplier
float fTurnSpeedMultiplier
Definition: mm7_data.cpp:708
BspRenderer::num_faces
unsigned int num_faces
Definition: Indoor.h:812
SPEECH_63
@ SPEECH_63
Definition: Player.h:109
BSPModel::vPosition
Vec3_int_ vPosition
Definition: BSPModel.h:173
BspRenderer_PortalViewportData::viewport_right_side
int16_t viewport_right_side[480]
Definition: Indoor.h:760
IndoorLocation::pSectors
struct BLVSector * pSectors
Definition: Indoor.h:634
CHARACTER_EXPRESSION_SCARED
@ CHARACTER_EXPRESSION_SCARED
Definition: Player.h:385
OutdoorLocation::pBModels
BSPModelList pBModels
Definition: Outdoor.h:119
pSpriteObjects
std::array< SpriteObject, MAX_SPRITE_OBJECTS > pSpriteObjects
Definition: SpriteObject.cpp:34
BspRenderer_stru0::PortalScreenData
BspRenderer_PortalViewportData PortalScreenData
Definition: Indoor.h:782
stru141_actor_collision_object::speed
int speed
Definition: Indoor.h:166
PARTY_LookDown
@ PARTY_LookDown
Definition: Party.h:103
BLVFace::pVertexIDs
uint16_t * pVertexIDs
Definition: Indoor.h:476
BLVDoor::pFaceIDs
uint16_t * pFaceIDs
Definition: Indoor.h:394
PARTY_FLAGS_1_BURNING
@ PARTY_FLAGS_1_BURNING
Definition: Party.h:63
DecorationDesc::uColoredLightRed
uint8_t uColoredLightRed
Definition: DecorationList.h:50
BSPNode::uCoplanarOffset
int16_t uCoplanarOffset
Definition: BSPModel.h:45
OBJECT_Item
@ OBJECT_Item
Definition: Actor.h:66
ai_arrays_size
int ai_arrays_size
Definition: mm7_data.cpp:503
uNumBillboardsToDraw
unsigned int uNumBillboardsToDraw
Definition: RenderOpenGL.cpp:55
ItemsTable::SetSpecialBonus
void SetSpecialBonus(ItemGen *pItem)
Definition: Items.cpp:472
stru141_actor_collision_object::uSectorID
unsigned int uSectorID
Definition: Indoor.h:170
Party::sRotationX
int sRotationX
Definition: Party.h:252
IndoorLocation::pSpawnPoints
struct SpawnPointMM7 * pSpawnPoints
Definition: Indoor.h:647
collide_against_floor_approximate
int collide_against_floor_approximate(int x, int y, int z, unsigned int *pSectorID, unsigned int *pFaceID)
Definition: Indoor.cpp:5667
BspRenderer::AddFaceToRenderList_d3d
void AddFaceToRenderList_d3d(unsigned int node_id, unsigned int uFaceID)
Definition: Indoor.cpp:584
POLYGON_Invalid
@ POLYGON_Invalid
Definition: Indoor.h:217
z
GLdouble GLdouble z
Definition: SDL_opengl_glext.h:407
BLVRenderParams::Reset
void Reset()
Definition: Indoor.cpp:163
FindBillboardsLightLevels_BLV
void FindBillboardsLightLevels_BLV()
Definition: Indoor.cpp:5654
pBLVRenderParams
BLVRenderParams * pBLVRenderParams
Definition: Indoor.cpp:50
Party::FeatherFallActive
bool FeatherFallActive()
Definition: Party.h:214
PlayerSpeechID
enum PlayerSpeech PlayerSpeechID
Definition: Player.cpp:48
fixpoint_div
__int64 fixpoint_div(int a1, int a2)
Definition: OurMath.cpp:147
MapStats::GetMapInfo
MAP_TYPE GetMapInfo(const String &Str2)
Definition: MapInfo.cpp:225
GameUI_StatusBar_NothingHere
void GameUI_StatusBar_NothingHere()
Definition: UIStatusBar.cpp:57
Actor
Definition: Actor.h:151
Party::TorchLightLastIntensity
float TorchLightLastIntensity
Definition: Party.h:328
AudioPlayer::PlaySound
void PlaySound(SoundID eSoundID, int pid, unsigned int uNumRepeats, int x, int y, int a7)
Definition: AudioPlayer.cpp:195
POLYGON_InBetweenFloorAndWall
@ POLYGON_InBetweenFloorAndWall
Definition: Indoor.h:221
BBox_short_::x1
int16_t x1
Definition: VectorTypes.h:114
MonsterInfo::Hostility_Friendly
@ Hostility_Friendly
Definition: Monsters.h:111
BLVFace::pXInterceptDisplacements
int16_t * pXInterceptDisplacements
Definition: Indoor.h:477
engine
std::shared_ptr< Engine > engine
Definition: Engine.cpp:130
IndoorLocation::pFaceExtras
struct BLVFaceExtra * pFaceExtras
Definition: Indoor.h:632
DecorationInteraction
void DecorationInteraction(unsigned int id, unsigned int pid)
Definition: Viewport.cpp:271
Texture
Definition: Texture.h:4
stru193_math::uIntegerHalfPi
static const unsigned int uIntegerHalfPi
Definition: OurMath.h:89
RenderBillboard::dimming_level
uint16_t dimming_level
Definition: IRender.h:43
BLVFaceExtra::uEventID
uint16_t uEventID
Definition: Indoor.h:512
BSPModel::sBoundingRadius
int32_t sBoundingRadius
Definition: BSPModel.h:187
Actor::AI_FaceObject
static void AI_FaceObject(unsigned int uActorID, unsigned int uObjID, int UNUSED, struct AIDirection *Dir_In)
Definition: Actor.cpp:1072
bNoNPCHiring
char bNoNPCHiring
Definition: mm7_data.cpp:720
BLVDoor::uMoveLength
int uMoveLength
Definition: Indoor.h:390
BLVDoor::Opening
@ Opening
Definition: Indoor.h:381
Party::FlyActive
bool FlyActive()
Definition: Party.h:202
BspRenderer_stru0::uSectorID
uint16_t uSectorID
Definition: Indoor.h:776
LEVEL_null
@ LEVEL_null
Definition: Indoor.h:285
SPEECH_46
@ SPEECH_46
Definition: Player.h:92
PARTY_WalkForward
@ PARTY_WalkForward
Definition: Party.h:100
BBox_short_::y1
int16_t y1
Definition: VectorTypes.h:116
UpdateObjects
void UpdateObjects()
Definition: Render.cpp:4955
Party::flt_TorchlightColorR
float flt_TorchlightColorR
Definition: Party.h:325
BLVSector::uNumNonBSPFaces
uint16_t uNumNonBSPFaces
Definition: Indoor.h:540
stru141_actor_collision_object::normal
Vec3_int_ normal
Definition: Indoor.h:159
BLVDoor::uOpenSpeed
int uOpenSpeed
Definition: Indoor.h:391
Party::pPlayers
std::array< Player, 4 > pPlayers
Definition: Party.h:310
BSPNode::uBack
int16_t uBack
Definition: BSPModel.h:44
SpawnPointMM7
Definition: Indoor.h:304
ACTOR_BUFF_SLOWED
@ ACTOR_BUFF_SLOWED
Definition: Actor.h:45
stru367::direction
bool direction
Definition: stru367.h:9
BLVDoor::uNumFaces
uint16_t uNumFaces
Definition: Indoor.h:402
POLYGON_Floor
@ POLYGON_Floor
Definition: Indoor.h:220
sub_4077F1
bool sub_4077F1(int a1, int a2, int a3, ODMFace *face, BSPVertexBuffer *a5)
Definition: Indoor.cpp:5486
OBJECT_Decoration
@ OBJECT_Decoration
Definition: Actor.h:69
BSPNode
Definition: BSPModel.h:42
SOUND_RunWaterIndoor
@ SOUND_RunWaterIndoor
Definition: AudioPlayer.h:32
POLYGON_unk
@ POLYGON_unk
Definition: Indoor.h:219
pPlayers
NZIArray< struct Player *, 5 > pPlayers
Definition: Player.cpp:46
x1
GLuint GLfloat GLfloat GLfloat x1
Definition: SDL_opengl_glext.h:8586
BLVRenderParams::bsp_fov_rad
int bsp_fov_rad
Definition: Indoor.h:692
pIndoor
IndoorLocation * pIndoor
Definition: Indoor.cpp:49
Actor::_46DF1A_collide_against_actor
static bool _46DF1A_collide_against_actor(int a1, int a2)
Definition: Actor.cpp:2699
stru367::_screen_space_x
std::array< int, 60 > _screen_space_x
Definition: stru367.h:15
current_screen_type
enum CURRENT_SCREEN current_screen_type
Definition: GUIWindow.cpp:83
collide_against_floor
int collide_against_floor(int x, int y, int z, unsigned int *pSectorID, unsigned int *pFaceID)
Definition: Render.cpp:4711
PARTY_BUFF_TORCHLIGHT
@ PARTY_BUFF_TORCHLIGHT
Definition: Party.h:87
UpdateActors_BLV
void UpdateActors_BLV()
Definition: Indoor.cpp:1718
Plane_int_::vNormal
Vec3_int_ vNormal
Definition: VectorTypes.h:107
pTurnEngine
struct stru262_TurnBased * pTurnEngine
Definition: TurnEngine.cpp:21
Dead
@ Dead
Definition: Actor.h:80
SOUND_WalkWaterIndoor
@ SOUND_WalkWaterIndoor
Definition: AudioPlayer.h:54
result
GLuint64EXT * result
Definition: SDL_opengl_glext.h:9435
pMapStats
struct MapStats * pMapStats
Definition: mm7_data.cpp:20
AIDirection
Definition: Actor.h:126
Party::pPartyBuffs
std::array< SpellBuff, 20 > pPartyBuffs
Definition: Party.h:309
AudioPlayer::StopAll
void StopAll(int sample_id)
Definition: AudioPlayer.cpp:189
OBJECT_Actor
@ OBJECT_Actor
Definition: Actor.h:67
BLVSector::uNumFloors
uint16_t uNumFloors
Definition: Indoor.h:524
Party::uFallStartY
int uFallStartY
Definition: Party.h:265
BLVRenderParams::uViewportZ
unsigned int uViewportZ
Definition: Indoor.h:698
fixed::FromInt
static fixed FromInt(int value)
Definition: OurMath.h:29
Party::uPartyHeight
unsigned int uPartyHeight
Definition: Party.h:237
IndoorLocation::uNumDoors
int uNumDoors
Definition: Indoor.h:637
_4E94D0_light_type
char _4E94D0_light_type
Definition: mm7_data.cpp:305
pItemsTable
struct ItemsTable * pItemsTable
Definition: Items.cpp:37
PARTY_FLAGS_1_LANDING
@ PARTY_FLAGS_1_LANDING
Definition: Party.h:62
GetAlertStatus
int GetAlertStatus()
Definition: Indoor.cpp:5287
MapInfo::SpawnRandomTreasure
int SpawnRandomTreasure(struct SpawnPointMM7 *a2)
Definition: MapInfo.cpp:240
OtherOverlayList::pOverlays
OtherOverlay pOverlays[50]
Definition: Overlays.h:36
y
EGLSurface EGLint EGLint y
Definition: SDL_egl.h:1596
IndoorLocation::Load
bool Load(const String &filename, int num_days_played, int respawn_interval_days, char *pDest)
Definition: Indoor.cpp:858
PARTY_LookUp
@ PARTY_LookUp
Definition: Party.h:102
BspRenderer_stru0::uViewportW
uint16_t uViewportW
Definition: Indoor.h:780
IndoorCameraD3D::vPartyPos
Vec3< int > vPartyPos
Definition: IndoorCameraD3D.h:253
BLVFace::Ethereal
bool Ethereal() const
Definition: Indoor.h:459
CURRENT_SCREEN::SCREEN_BRANCHLESS_NPC_DIALOG
@ SCREEN_BRANCHLESS_NPC_DIALOG
AddBspNodeToRenderList
void AddBspNodeToRenderList(unsigned int node_id)
Definition: Indoor.cpp:2970
Vec2::y
T y
Definition: VectorTypes.h:13
BLVSector::pFaceIDs
uint16_t * pFaceIDs
Definition: Indoor.h:541
BLVDoor::pDeltaUs
int16_t * pDeltaUs
Definition: Indoor.h:396
BspRenderer_PortalViewportData::_viewport_space_y
int _viewport_space_y
Definition: Indoor.h:753
stru141_actor_collision_object::field_0
int field_0
Definition: Indoor.h:151
DDM_DLV_Header::field_C_alert
int field_C_alert
Definition: Indoor.h:97
pParty
Party * pParty
Definition: Party.cpp:30
flt_6BE3AC_debug_recmod1_x_1_6
float flt_6BE3AC_debug_recmod1_x_1_6
Definition: mm7_data.cpp:718
_46ED8A_collide_against_sprite_objects
void _46ED8A_collide_against_sprite_objects(unsigned int _this)
Definition: Render.cpp:4732
BLVDoor::pXOffsets
uint16_t * pXOffsets
Definition: Indoor.h:398
IndoorLocation::pNodes
struct BSPNode * pNodes
Definition: Indoor.h:640
BspRenderer_stru0::uFaceID
uint16_t uFaceID
Definition: Indoor.h:783
IndoorLocation::uNumSpawnPoints
unsigned int uNumSpawnPoints
Definition: Indoor.h:646
stru141_actor_collision_object::field_8_radius
int field_8_radius
Definition: Indoor.h:153
BLVFace::zCalc3
int zCalc3
Definition: Indoor.h:474
BLVRenderParams::uViewportW
unsigned int uViewportW
Definition: Indoor.h:699
LEVEL_DECORATION_INVISIBLE
@ LEVEL_DECORATION_INVISIBLE
Definition: Decoration.h:14
BspRenderer::nodes
BspRenderer_stru0 nodes[150]
Definition: Indoor.h:817
Party::bFlying
unsigned int bFlying
Definition: Party.h:266
Party::flt_TorchlightColorB
float flt_TorchlightColorB
Definition: Party.h:327
GetGravityStrength
unsigned int GetGravityStrength()
Definition: Engine.cpp:1500
stru141_actor_collision_object::normal2
Vec3_int_ normal2
Definition: Indoor.h:161
ITEM_ARTIFACT_LADYS_ESCORT
@ ITEM_ARTIFACT_LADYS_ESCORT
Definition: Items.h:189
ITEM_ARTIFACT_HERMES_SANDALS
@ ITEM_ARTIFACT_HERMES_SANDALS
Definition: Items.h:182
OBJECT_BModel
@ OBJECT_BModel
Definition: Actor.h:70
BLVSector::pPortals
uint16_t * pPortals
Definition: Indoor.h:538
x
EGLSurface EGLint x
Definition: SDL_egl.h:1596
BspRenderer_stru0::uViewportX
uint16_t uViewportX
Definition: Indoor.h:777
DecorationDesc_mm6::uLightRadius
int16_t uLightRadius
Definition: DecorationList.h:42
_43F55F_get_billboard_light_level
int _43F55F_get_billboard_light_level(RenderBillboard *a1, int uBaseLightLevel)
Definition: Render.cpp:4211
stru367::_view_transformed_x
std::array< int, 60 > _view_transformed_x
Definition: stru367.h:11
stru141_actor_collision_object::field_7C
int field_7C
Definition: Indoor.h:172
pGameLoadingUI_ProgressBar
GUIProgressBar * pGameLoadingUI_ProgressBar
Definition: GUIProgressBar.cpp:14
viewparams
struct ViewingParams * viewparams
Definition: mm7_data.cpp:22
OS_GetTime
unsigned int OS_GetTime()
Definition: Lin.cpp:12
Disabled
@ Disabled
Definition: Actor.h:94
PARTY_FastTurnRight
@ PARTY_FastTurnRight
Definition: Party.h:114
PlayLevelMusic
void PlayLevelMusic()
Definition: AudioPlayer.cpp:377
MonsterInfo::uID
uint16_t uID
Definition: Monsters.h:169
BLVFaceExtra::sTextureDeltaV
int16_t sTextureDeltaV
Definition: Indoor.h:510
stru367::_view_transformed_y
std::array< int, 60 > _view_transformed_y
Definition: stru367.h:12
BLVDoor
Definition: Indoor.h:378
PARTY_TurnRight
@ PARTY_TurnRight
Definition: Party.h:97
check_event_triggers
void check_event_triggers()
Definition: Events.cpp:1215
BLVFace::uSectorID
uint16_t uSectorID
Definition: Indoor.h:484
BLVFace
Definition: Indoor.h:424
PARTY_CenterView
@ PARTY_CenterView
Definition: Party.h:104
BLVSector::uFirstBSPNode
int16_t uFirstBSPNode
Definition: Indoor.h:561
PARTY_RunBackward
@ PARTY_RunBackward
Definition: Party.h:112
stru123::_decor_events
std::array< unsigned char, 125 > _decor_events
Definition: stru123.h:8
Timer::dt_in_some_format
int dt_in_some_format
Definition: Time.h:134
v1
GLfloat GLfloat v1
Definition: SDL_opengl_glext.h:694
IndoorLocation::dlv
struct DDM_DLV_Header dlv
Definition: Indoor.h:648
Log::Warning
void Warning(const wchar_t *pFormat,...)
Definition: Log.cpp:28
stru141_actor_collision_object::field_70
int field_70
Definition: Indoor.h:169
BLV_ProcessPartyActions
void BLV_ProcessPartyActions()
Definition: Indoor.cpp:4655
fixpoint_mul
__int64 fixpoint_mul(int a1, int a2)
Definition: OurMath.cpp:138
stru141_actor_collision_object::height
int height
Definition: Indoor.h:154
pActors
std::array< Actor, 500 > pActors
Definition: Actor.cpp:38
BLVDoor::uState
State uState
Definition: Indoor.h:405
IndoorLocation::PrepareItemsRenderList_BLV
void PrepareItemsRenderList_BLV()
Definition: Indoor.cpp:2871
GUIProgressBar::Reset
void Reset(uint8_t uMaxProgress)
Definition: GUIProgressBar.cpp:78
SPEECH_64
@ SPEECH_64
Definition: Player.h:110
BLVRenderParams::uViewportCenterY
int uViewportCenterY
Definition: Indoor.h:705
uNumLevelDecorations
size_t uNumLevelDecorations
Definition: Decoration.cpp:9
BLVRenderParams::uViewportX
unsigned int uViewportX
Definition: Indoor.h:696
ActionQueue::Next
PartyAction Next()
Definition: Party.cpp:1204
Party::uFlags
unsigned int uFlags
Definition: Party.h:313
f
GLfloat f
Definition: SDL_opengl_glext.h:1873
_46EF01_collision_chech_player
int _46EF01_collision_chech_player(int a1)
Definition: Render.cpp:4790
BspRenderer::pVisibleSectorIDs_toDrawDecorsActorsEtcFrom
uint16_t pVisibleSectorIDs_toDrawDecorsActorsEtcFrom[6]
Definition: Indoor.h:819
EQUIP_POTION
@ EQUIP_POTION
Definition: Items.h:241
BLVFace::zCalc2
int zCalc2
Definition: Indoor.h:473
Party::uWalkSpeed
unsigned int uWalkSpeed
Definition: Party.h:243
BLVSector::uNumPortals
int16_t uNumPortals
Definition: Indoor.h:536
LEVEL_Outdoor
@ LEVEL_Outdoor
Definition: Indoor.h:287
BspRenderer::num_nodes
unsigned int num_nodes
Definition: Indoor.h:816
BspRenderer_stru0
Definition: Indoor.h:767
pPartyActionQueue
struct ActionQueue * pPartyActionQueue
Definition: Party.cpp:32
BLVSector::pFloors
uint16_t * pFloors
Definition: Indoor.h:526
MapInfo
Definition: MapInfo.h:35
TE_WAIT
@ TE_WAIT
Definition: TurnEngine.h:20
pCurrentMapName
String pCurrentMapName
Definition: mm7_data.cpp:712
Removed
@ Removed
Definition: Actor.h:86
PortalFace
stru367 PortalFace
Definition: mm7_data.cpp:564
pPaletteManager
PaletteManager * pPaletteManager
Definition: PaletteManager.cpp:7
BLVDoor::uNumVertices
uint16_t uNumVertices
Definition: Indoor.h:401
BSPNode::uCoplanarSize
int16_t uCoplanarSize
Definition: BSPModel.h:46
ViewingParams::_443365
void _443365()
Definition: Viewport.cpp:177
SpriteObject::InitializeSpriteObjects
static void InitializeSpriteObjects()
Definition: SpriteObject.cpp:898
BLVFace::pBounding
struct BBox_short_ pBounding
Definition: Indoor.h:486
t
GLdouble GLdouble t
Definition: SDL_opengl.h:2071
BspRenderer_PortalViewportData::viewport_left_side
int16_t viewport_left_side[480]
Definition: Indoor.h:759
OutdoorLocation::ddm
struct DDM_DLV_Header ddm
Definition: Outdoor.h:131
blv_prev_party_y
int blv_prev_party_y
Definition: mm7_data.cpp:739
BLVDoor::pVertexIDs
uint16_t * pVertexIDs
Definition: Indoor.h:393
LEVEL_Indoor
@ LEVEL_Indoor
Definition: Indoor.h:286
IndoorCameraD3D::ApplyViewTransform_TrueIfStillVisible_BLV
bool ApplyViewTransform_TrueIfStillVisible_BLV(int x, int y, int z, fixed *pOutX, fixed *pOutZ, fixed *pOutY, bool clip_plane_test)
Definition: IndoorCameraD3D.cpp:88
Plane_int_::dist
int dist
Definition: VectorTypes.h:108
_46E44E_collide_against_faces_and_portals
int _46E44E_collide_against_faces_and_portals(unsigned int b1)
Definition: Render.cpp:4350
_6807E0_num_decorations_with_sounds_6807B8
int _6807E0_num_decorations_with_sounds_6807B8
Definition: mm7_data.cpp:686
PARTY_TurnLeft
@ PARTY_TurnLeft
Definition: Party.h:96
SOUND_RunCarpet
@ SOUND_RunCarpet
Definition: AudioPlayer.h:23
OBJECT_Player
@ OBJECT_Player
Definition: Actor.h:68
Party::bTurnBasedModeOn
bool bTurnBasedModeOn
Definition: Party.h:305
Summoned
@ Summoned
Definition: Actor.h:92
BLVRenderParams::uPartySectorID
int uPartySectorID
Definition: Indoor.h:681
PaletteManager::RecalculateAll
void RecalculateAll()
Definition: PaletteManager.cpp:784
BspRenderer_PortalViewportData::GetViewportData
void GetViewportData(int16_t x, int y, int16_t z, int w)
Definition: Indoor.cpp:3181
uNumDecorationsDrawnThisFrame
int uNumDecorationsDrawnThisFrame
Definition: RenderOpenGL.cpp:53
PARTY_BUFF_INVISIBILITY
@ PARTY_BUFF_INVISIBILITY
Definition: Party.h:82
_4D864C_force_sw_render_rules
char _4D864C_force_sw_render_rules
Definition: mm7_data.cpp:208
uint8_t
unsigned __int8 uint8_t
Definition: SDL_config.h:35
BLVDoor::vDirection
Vec3_int_ vDirection
Definition: Indoor.h:389
LightsStack_MobileLight_::uNumLightsActive
unsigned int uNumLightsActive
Definition: Lights.h:88
OtherOverlay::field_E
int16_t field_E
Definition: Overlays.h:18
BspRenderer_stru0::viewing_portal_id
unsigned int viewing_portal_id
Definition: Indoor.h:785
dword_4F8580
std::array< int, 182 > dword_4F8580
Definition: mm7_data.cpp:506
BLVFace::pYInterceptDisplacements
int16_t * pYInterceptDisplacements
Definition: Indoor.h:478
uNumSpriteObjects
size_t uNumSpriteObjects
Definition: SpriteObject.cpp:33
BLVFace::resource
void * resource
Definition: Indoor.h:483
SOUND_WalkCarpet
@ SOUND_WalkCarpet
Definition: AudioPlayer.h:45
BLVFace::Pressure_Plate
bool Pressure_Plate() const
Definition: Indoor.h:456
stru367::_view_transformed_z
std::array< int, 48 > _view_transformed_z
Definition: stru367.h:13
ActionQueue::uNumActions
unsigned int uNumActions
Definition: Party.h:128
b
GLboolean GLboolean GLboolean b
Definition: SDL_opengl_glext.h:1112
stru193_math::Atan2
unsigned int Atan2(int x, int y)
Definition: OurMath.cpp:46
pOtherOverlayList
struct OtherOverlayList * pOtherOverlayList
Definition: Overlays.cpp:19
BLVFaceExtra::sTextureDeltaU
int16_t sTextureDeltaU
Definition: Indoor.h:509
sub_4088E9
int sub_4088E9(int x1, int y1, int x2, int y2, int x3, int y3)
Definition: Indoor.cpp:5277
sub_4406BC
void sub_4406BC(unsigned int node_id, unsigned int uFirstNode)
Definition: Indoor.cpp:2987
stru141_actor_collision_object::field_84
int field_84
Definition: Indoor.h:174
r
GLdouble GLdouble GLdouble r
Definition: SDL_opengl.h:2079
Party::field_14_radius
int field_14_radius
Definition: Party.h:241
x2
GLfixed GLfixed x2
Definition: SDL_opengl_glext.h:4586
stru141_actor_collision_object::prolly_normal_d
int prolly_normal_d
Definition: Indoor.h:152
blv_prev_party_x
int blv_prev_party_x
Definition: mm7_data.cpp:737
BLVSector::pDecorationIDs
uint16_t * pDecorationIDs
Definition: Indoor.h:550
BLVSector::uNumFaces
uint16_t uNumFaces
Definition: Indoor.h:539
flt_6BE150_look_up_down_dangle
float flt_6BE150_look_up_down_dangle
Definition: mm7_data.cpp:709
BLVDoor::pYOffsets
uint16_t * pYOffsets
Definition: Indoor.h:399
DecorationDesc_mm6::uSoundID
int16_t uSoundID
Definition: DecorationList.h:45
v2
GLfloat GLfloat GLfloat v2
Definition: SDL_opengl_glext.h:695
flt_6BE3A4_debug_recmod1
float flt_6BE3A4_debug_recmod1
Definition: mm7_data.cpp:716
ANIM_Walking
@ ANIM_Walking
Definition: Actor.h:100
integer_sqrt
int integer_sqrt(int val)
Definition: OurMath.cpp:164
SOUND_RunWood
@ SOUND_RunWood
Definition: AudioPlayer.h:33
uint
unsigned int uint
Definition: MM7.h:4
BLVDoor::Closing
@ Closing
Definition: Indoor.h:383
sub_4075DB
bool sub_4075DB(int x, int y, int z, BLVFace *face)
Definition: Indoor.cpp:5424
uActiveCharacter
unsigned int uActiveCharacter
Definition: mm7_data.cpp:555
v3
GLfloat GLfloat GLfloat GLfloat v3
Definition: SDL_opengl_glext.h:696
pStationaryLightsStack
LightsStack_StationaryLight_ * pStationaryLightsStack
Definition: LightmapBuilder.cpp:11
__debugbreak
void __cdecl __debugbreak(void)
Fleeing
@ Fleeing
Definition: Actor.h:82
BLVFace::Fluid
bool Fluid() const
Definition: Indoor.h:449
Actor::AI_Flee
static void AI_Flee(unsigned int uActorID, signed int edx0, int uActionLength, struct AIDirection *a4)
Definition: Actor.cpp:2070
DecorationDesc_mm6::uDecorationHeight
uint16_t uDecorationHeight
Definition: DecorationList.h:40
y1
GLfixed y1
Definition: SDL_opengl_glext.h:4586
BLVRenderParams::uViewportCenterX
int uViewportCenterX
Definition: Indoor.h:704
BSPModel::pFaces
std::vector< ODMFace > pFaces
Definition: BSPModel.h:190
ODMFace
Definition: BSPModel.h:93
stru141_actor_collision_object::direction
Vec3_int_ direction
Definition: Indoor.h:165
BSPModel::vBoundingCenter
Vec3_int_ vBoundingCenter
Definition: BSPModel.h:186
PARTY_BUFF_FLY
@ PARTY_BUFF_FLY
Definition: Party.h:78
OBJECT_BLVDoor
@ OBJECT_BLVDoor
Definition: Actor.h:65
BLVDoor::uAttributes
unsigned int uAttributes
Definition: Indoor.h:386
y2
GLfixed GLfixed GLfixed y2
Definition: SDL_opengl_glext.h:4586
DecorationList::InitializeDecorationSprite
void InitializeDecorationSprite(unsigned int uDecID)
Definition: DecorationList.cpp:45
uNumSpritesDrawnThisFrame
int uNumSpritesDrawnThisFrame
Definition: RenderOpenGL.cpp:56
SpawnPointMM7::vPosition
Vec3_int_ vPosition
Definition: Indoor.h:314
stru193_math::Cos
int Cos(int angle)
Definition: OurMath.cpp:28
Party::TorchlightActive
bool TorchlightActive()
Definition: Party.h:199
stru_5C6E00
struct stru193_math * stru_5C6E00
Definition: mm7_data.cpp:19
ODM_GetFloorLevel
int ODM_GetFloorLevel(int X, signed int Y, int Z, int __unused, bool *pIsOnWater, int *bmodel_pid, int bWaterWalk)
Definition: Outdoor.cpp:1877
Party::walk_sound_timer
int walk_sound_timer
Definition: Party.h:263
angle
GLfloat angle
Definition: SDL_opengl_glext.h:6100
ViewingParams::bRedrawGameUI
int bRedrawGameUI
Definition: Viewport.h:74
ActorInteraction
bool ActorInteraction(unsigned int id)
Definition: Viewport.cpp:250
BSPVertexBuffer::pVertices
Vec3_int_ * pVertices
Definition: BSPModel.h:53
dword_6BE364_game_settings_1
int dword_6BE364_game_settings_1
Definition: mm7_data.cpp:714
IndoorLocation::pVertices
struct Vec3_short_ * pVertices
Definition: Indoor.h:628
DecorationDesc
Definition: DecorationList.h:49
stru367
Definition: stru367.h:8
SoundID
SoundID
Definition: AudioPlayer.h:10
pBillboardRenderList
RenderBillboard pBillboardRenderList[500]
Definition: RenderOpenGL.cpp:54
EventProcessor
void EventProcessor(int uEventID, int targetObj, int canShowMessages, int entry_line)
Definition: Events.cpp:260
PARTY_Jump
@ PARTY_Jump
Definition: Party.h:107
uCurrentlyLoadedLevelType
LEVEL_TYPE uCurrentlyLoadedLevelType
Definition: Indoor.cpp:52
POLYGON_InBetweenCeilingAndWall
@ POLYGON_InBetweenCeilingAndWall
Definition: Indoor.h:223
stru_721530
stru141_actor_collision_object stru_721530
Definition: Indoor.cpp:58
Is_out15odm_underwater
char Is_out15odm_underwater()
Definition: Outdoor.cpp:3377
blv_prev_party_z
int blv_prev_party_z
Definition: mm7_data.cpp:738
IndoorLocation::GetSector
int GetSector(int sX, int sY, int sZ)
Definition: Indoor.cpp:1279
IndoorLocation::pFaces
struct BLVFace * pFaces
Definition: Indoor.h:630
uLevel_StartingPointType
MapStartPoint uLevel_StartingPointType
Definition: Outdoor.cpp:46
stru193_math::Sin
int Sin(int angle)
Definition: OurMath.cpp:133
LightsStack_StationaryLight_::AddLight
bool AddLight(int16_t x, int16_t y, int16_t z, int16_t a5, unsigned char r, unsigned char g, unsigned char b, char uLightType)
Definition: LightsStack.cpp:30
pAudioPlayer
AudioPlayer * pAudioPlayer
Definition: AudioPlayer.cpp:20
BSPNode::uFront
int16_t uFront
Definition: BSPModel.h:43
SpawnEncounter
void SpawnEncounter(MapInfo *pMapInfo, SpawnPointMM7 *spawn, int a3, int a4, int a5)
Definition: Actor.cpp:5063
stru141_actor_collision_object::CalcMovementExtents
int CalcMovementExtents(int a2)
Definition: Indoor.cpp:5697
BSPModel
Definition: BSPModel.h:163
fixed
Definition: OurMath.h:21
BLVSector
Definition: Indoor.h:522
Party::floor_face_pid
int floor_face_pid
Definition: Party.h:262
offset
GLintptr offset
Definition: SDL_opengl_glext.h:541
logger
Log * logger
Definition: IocContainer.cpp:47
PlayerSpeech
PlayerSpeech
Definition: Player.h:46
pMobileLightsStack
LightsStack_MobileLight_ * pMobileLightsStack
Definition: LightmapBuilder.cpp:14
Actor::PrepareSprites
void PrepareSprites(char load_sounds_if_bit1_set)
Definition: Actor.cpp:2481
stru_5E4C90_MapPersistVars
stru123 stru_5E4C90_MapPersistVars
Definition: mm7_data.cpp:23
BspRenderer::MakeVisibleSectorList
void MakeVisibleSectorList()
Definition: Indoor.cpp:3692
BLVDoor::uDoorID
unsigned int uDoorID
Definition: Indoor.h:387
res
GLuint res
Definition: SDL_opengl_glext.h:7940
RespawnGlobalDecorations
void RespawnGlobalDecorations()
Definition: DecorationList.cpp:70
DecorationDesc::uColoredLightBlue
uint8_t uColoredLightBlue
Definition: DecorationList.h:52
pOutdoor
OutdoorLocation * pOutdoor
Definition: Outdoor.cpp:48
SOUND_WalkWood
@ SOUND_WalkWood
Definition: AudioPlayer.h:55
BspRenderer_PortalViewportData::_viewport_space_w
int _viewport_space_w
Definition: Indoor.h:754
GUIProgressBar::Progress
void Progress()
Definition: GUIProgressBar.cpp:83
BLVSector::field_0
int32_t field_0
Definition: Indoor.h:523
PaletteManager::pPalette_tintColor
unsigned char pPalette_tintColor[3]
Definition: PaletteManager.h:36
MapInfo::uRespawnIntervalDays
unsigned int uRespawnIntervalDays
Definition: MapInfo.h:45
SpawnPointMM7::uIndex
uint16_t uIndex
Definition: Indoor.h:317
pDoorSoundIDsByLocationID
unsigned __int16 pDoorSoundIDsByLocationID[78]
Definition: Indoor.cpp:61
_A750D8_player_speech_timer
int64_t _A750D8_player_speech_timer
Definition: mm7_data.cpp:763
IndoorLocation::PrepareDecorationsRenderList_BLV
void PrepareDecorationsRenderList_BLV(unsigned int uDecorationID, unsigned int uSectorID)
Definition: Indoor.cpp:3042
BLVSector::uNumDecorations
uint16_t uNumDecorations
Definition: Indoor.h:548
pIndoorCameraD3D
IndoorCameraD3D * pIndoorCameraD3D
Definition: IndoorCameraD3D.cpp:21
_46E0B2_collide_against_decorations
void _46E0B2_collide_against_decorations()
Definition: Render.cpp:4855
Actor::pMonsterInfo
struct MonsterInfo pMonsterInfo
Definition: Actor.h:292
ai_near_actors_ids
std::array< unsigned int, 500 > ai_near_actors_ids
Definition: mm7_data.cpp:505
g
GLboolean GLboolean g
Definition: SDL_opengl_glext.h:1112
stru141_actor_collision_object::position
Vec3_int_ position
Definition: Indoor.h:160
_6807B8_level_decorations_ids
std::array< int, 777 > _6807B8_level_decorations_ids
Definition: mm7_data.cpp:685
_46F04E_collide_against_portals
int _46F04E_collide_against_portals()
Definition: Render.cpp:4895
PARTY_WalkBackward
@ PARTY_WalkBackward
Definition: Party.h:101
uint32_t
unsigned __int32 uint32_t
Definition: SDL_config.h:39
BLVRenderParams::uViewportY
unsigned int uViewportY
Definition: Indoor.h:697
PARTY_FastTurnLeft
@ PARTY_FastTurnLeft
Definition: Party.h:113
stru141_actor_collision_object::velocity
Vec3_int_ velocity
Definition: Indoor.h:158
BspRenderer_stru0::uViewportZ
uint16_t uViewportZ
Definition: Indoor.h:779
IndoorLocation::PrepareActorRenderList_BLV
void PrepareActorRenderList_BLV()
Definition: Indoor.cpp:2739
ItemInteraction
void ItemInteraction(unsigned int item_id)
Definition: Viewport.cpp:224
BLV_GetFloorLevel
int BLV_GetFloorLevel(int x, int y, int z, unsigned int uSectorID, unsigned int *pFaceID)
Definition: Indoor.cpp:2530
Party::sRotationY
int sRotationY
Definition: Party.h:251
BLVDoor::Open
@ Open
Definition: Indoor.h:382
stru262_TurnBased::turn_stage
int turn_stage
Definition: TurnEngine.h:75
EQUIP_BOOTS
@ EQUIP_BOOTS
Definition: Items.h:236
IndoorLocation::pDoors
struct BLVDoor * pDoors
Definition: Indoor.h:638
PrepareBspRenderList_BLV
void PrepareBspRenderList_BLV()
Definition: Indoor.cpp:3159
LightsStack_MobileLight_::AddLight
bool AddLight(int16_t x, int16_t y, int16_t z, int16_t uSectorID, int uRadius, uint8_t r, uint8_t g, uint8_t b, char a10)
Definition: LightsStack.cpp:6
POLYGON_Ceiling
@ POLYGON_Ceiling
Definition: Indoor.h:222
pEventTimer
Timer * pEventTimer
Definition: Time.cpp:8
PARTY_RunForward
@ PARTY_RunForward
Definition: Party.h:111
Pursuing
@ Pursuing
Definition: Actor.h:81
BLVFace::uAttributes
unsigned int uAttributes
Definition: Indoor.h:475
DecorationDesc::uColoredLightGreen
uint8_t uColoredLightGreen
Definition: DecorationList.h:51
Actor::InitializeActors
static void InitializeActors()
Definition: Actor.cpp:3334
dword_6BE13C_uCurrentlyLoadedLocationID
int dword_6BE13C_uCurrentlyLoadedLocationID
Definition: mm7_data.cpp:705
Vec3::z
T z
Definition: VectorTypes.h:27
ItemsTable::pItems
NZIArray< ItemDesc, 800 > pItems
Definition: Items.h:460
BLVDoor::uTimeSinceTriggered
unsigned int uTimeSinceTriggered
Definition: Indoor.h:388
Party::flt_TorchlightColorG
float flt_TorchlightColorG
Definition: Party.h:326
PARTY_StrafeRight
@ PARTY_StrafeRight
Definition: Party.h:99
pDecorationList
struct DecorationList * pDecorationList
Definition: DecorationList.cpp:11
fBackwardWalkSpeedMultiplier
float fBackwardWalkSpeedMultiplier
Definition: mm7_data.cpp:707
BLVDoor::uCloseSpeed
int uCloseSpeed
Definition: Indoor.h:392
stru141_actor_collision_object::pid
unsigned int pid
Definition: Indoor.h:171
BLVFace::uFaceExtraID
uint16_t uFaceExtraID
Definition: Indoor.h:482
POLYGON_VerticalWall
@ POLYGON_VerticalWall
Definition: Indoor.h:218
BLVFace::zCalc1
int zCalc1
Definition: Indoor.h:472
pBspRenderer
BspRenderer * pBspRenderer
Definition: Indoor.cpp:57
render
std::shared_ptr< IRender > render
Definition: RenderOpenGL.cpp:52