mm7: Outdoor.cpp comparison

comparison Outdoor.cpp @ 1295:86a83e12d795

moving files

author	Ritor1
date	Mon, 17 Jun 2013 17:34:01 +0600
parents	1803172dffd9
children	5450af4f57ef

comparison

equal deleted inserted replaced

-:6bbd50bda571
+:86a83e12d795
 if ( (end_evt->_e_type != EVENT_Exit) || (start_evt->_e_type!= EVENT_MouseOver) )
 return false;
 else
 return true;
 }
+//----- (0046D49E) --------------------------------------------------------
+int __fastcall ODM_GetFloorLevel(int X, signed int Y, int Z, int __unused, int *pIsOnWater, int *a6, int bWaterWalk)
+{
+BSPModel *pBModel; // esi@4
+ODMFace *pFace; // ecx@11
+int v14; // edx@20
+signed int v18; // edx@26
+int v19; // eax@28
+int v20; // edx@30
+int v21; // ST1C_4@30
+signed int v22; // edx@30
+signed __int64 v23; // qtt@30
+int v24; // eax@36
+signed int v25; // ecx@38
+int result; // eax@42
+signed int v27; // ecx@43
+int v28; // edi@44
+signed int v29; // edx@44
+int v30; // esi@45
+int v31; // eax@45
+ODMFace *v32; // eax@57
+int v33; // ecx@59
+int v36; // [sp+14h] [bp-2Ch]@24
+int v38; // [sp+1Ch] [bp-24h]@2
+int v39; // [sp+20h] [bp-20h]@9
+signed int pBModelNum; // [sp+28h] [bp-18h]@1
+int pFaceNum; // [sp+2Ch] [bp-14h]@8
+bool v43; // [sp+30h] [bp-10h]@22
+bool v44; // [sp+34h] [bp-Ch]@24
+signed int v46; // [sp+3Ch] [bp-4h]@1
+signed int v48; // [sp+58h] [bp+18h]@22
+signed int v49; // [sp+58h] [bp+18h]@43
+v46 = 1;
+dword_721160[0] = -1;
+dword_721110[0] = -1;
+odm_floor_level[0] = GetTerrainHeightsAroundParty2(X, Y, pIsOnWater, bWaterWalk);
+for ( pBModelNum = 0; pBModelNum < pOutdoor->uNumBModels; ++pBModelNum )
+{
+pBModel = &pOutdoor->pBModels[pBModelNum];
+if ( X <= pBModel->sMaxX && X >= pBModel->sMinX &&
+Y <= pBModel->sMaxY && Y >= pBModel->sMinY )
+{
+if ( pBModel->uNumFaces > 0 )
+{
+v39 = 0;
+for ( pFaceNum = 0; pFaceNum < pBModel->uNumFaces; ++pFaceNum )
+{
+pFace = &pBModel->pFaces[pFaceNum];
+if ( (pFace->uPolygonType == POLYGON_Floor || pFace->uPolygonType == POLYGON_InBetweenFloorAndWall)
+&& !(pFace->uAttributes & 0x20000000)
+&& X <= pFace->pBoundingBox.x2 && X >= pFace->pBoundingBox.x1
+&& Y <= pFace->pBoundingBox.y2 && Y >= pFace->pBoundingBox.y1 )
+{
+for ( uint i = 0; i < pFace->uNumVertices; ++i)
+{
+word_721040[2 * i] = pFace->pXInterceptDisplacements[i] + pBModel->pVertices.pVertices[pFace->pVertexIDs[i]].x;
+word_720F70[2 * i] = pFace->pXInterceptDisplacements[i + 1] + pBModel->pVertices.pVertices[pFace->pVertexIDs[i]].y;
+word_721040[2 * i + 1] = pFace->pXInterceptDisplacements[i] + pBModel->pVertices.pVertices[pFace->pVertexIDs[i + 1]].x;
+word_720F70[2 * i + 1] = pFace->pXInterceptDisplacements[i + 1] + pBModel->pVertices.pVertices[pFace->pVertexIDs[i + 1]].y;
+}
+word_721040[2 * pFace->uNumVertices] = word_721040[0];
+word_720F70[2 * pFace->uNumVertices] = word_720F70[0];
+v43 = word_720F70[0] >= Y;
+v48 = 0;
+if ( 2 * pFace->uNumVertices > 0 )
+{
+for ( int i = 0; i < 2 * pFace->uNumVertices; ++i )
+{
+if ( v48 >= 2 )
+break;
+v36 = word_720F70[i + 1];
+v44 = word_720F70[i + 1] >= Y;
+if ( v43 != v44 )
+{
+v18 = word_721040[i + 1] >= X ? 0 : 2;
+v19 = v18 | (word_721040[i] < X);
+if ( v19 != 3 )
+{
+if ( !v19 )
+++v48;
+else
+{
+LODWORD(v23) = (Y - word_720F70[i]) << 16;
+HIDWORD(v23) = (Y - word_720F70[i]) >> 16;
+v22 = ((((word_721040[i + 1] - word_721040[i]) * v23 / (v36 - word_720F70[i])) >> 16) + word_721040[i]);
+if ( v22 >= X)
+++v48;
+}
+}
+}
+v43 = v44;
+}
+if ( v48 == 1 )
+{
+if ( v46 >= 20 )
+break;
+if ( pFace->uPolygonType == POLYGON_Floor )
+v24 = pBModel->pVertices.pVertices[pFace->pVertexIDs[0]].z;
+else
+v24 = ((unsigned __int64)(pFace->zCalc1 * (signed __int64)X) >> 16) + ((unsigned __int64)(pFace->zCalc2 * (signed __int64)Y) >> 16)
++ HIWORD(pFace->zCalc3);
+v25 = v46++;
+odm_floor_level[v25] = v24;
+dword_721160[v25] = pBModelNum;
+dword_721110[v25] = pFaceNum;
+}
+}
+}
+}
+}
+}
+}
+if ( v46 == 1 )
+{
+*a6 = 0;
+return odm_floor_level[0];
+}
+v27 = 0;
+if ( v46 <= 1 )
+*a6 = 0;
+else
+{
+//v29 = 1;
+for ( v49 = 1; v49 < v46; ++v49 )
+{
+if ( odm_floor_level[v49] == odm_floor_level[0] )
+{
+v27 = v49;
+//++v29;
+break;
+}
+if ( odm_floor_level[0] > Z + 5 )
+{
+if ( odm_floor_level[v49] >= odm_floor_level[0] )
+{
+//++v29;
+break;
+}
+v27 = v49;
+//++v29;
+break;
+}
+if ( odm_floor_level[v49] > odm_floor_level[0] && odm_floor_level[v49] <= Z + 5 )
+{
+v27 = v49;
+//++v29;
+}
+}
+if ( !v27 )
+*a6 = 0;
+else
+*a6 = dword_721110[v27] | (dword_721160[v27] << 6);
+}
+if ( v27 )
+{
+v32 = &pOutdoor->pBModels[dword_721160[v27]].pFaces[dword_721110[v27]];
+*pIsOnWater = false;
+if ( v32->Fluid())
+*pIsOnWater = true;
+}
+if ( odm_floor_level[v27] >= odm_floor_level[0] )
+odm_floor_level[0] = odm_floor_level[v27];
+return odm_floor_level[0];
+}
+//not sure if right- or left-handed coordinate space assumed, so this could be normal of inverse normal
+// for a right-handed system, that would be an inverse normal
+//----- (0046DCC8) --------------------------------------------------------
+void ODM_GetTerrainNormalAt(int pos_x, int pos_z, Vec3_int_ *out)
+{
+auto grid_x = WorldPosToGridCellX(pos_x);
+auto grid_z = WorldPosToGridCellZ(pos_z) - 1;
+auto grid_pos_x1 = GridCellToWorldPosX(grid_x);
+auto grid_pos_x2 = GridCellToWorldPosX(grid_x + 1);
+auto grid_pos_z1 = GridCellToWorldPosZ(grid_z);
+auto grid_pos_z2 = GridCellToWorldPosZ(grid_z + 1);
+auto x1z1_y = pOutdoor->DoGetHeightOnTerrain(grid_x, grid_z);
+auto x2z1_y = pOutdoor->DoGetHeightOnTerrain(grid_x + 1, grid_z);
+auto x2z2_y = pOutdoor->DoGetHeightOnTerrain(grid_x + 1, grid_z + 1);
+auto x1z2_y = pOutdoor->DoGetHeightOnTerrain(grid_x, grid_z + 1);
+float side1_dx, side1_dy, side1_dz,
+side2_dx, side2_dy, side2_dz;
+auto dx = abs(pos_x - grid_pos_x1),
+dz = abs(grid_pos_z1 - pos_z);
+if (dz >= dx)
+{
+side1_dy = (double)(x1z1_y - x1z2_y);
+side2_dy = (double)(x2z2_y - x1z2_y);
+side2_dx = (double)(grid_pos_x2 - grid_pos_x1);
+side1_dx = (double)(grid_pos_x1 - grid_pos_x2);
+side2_dz = 0.0;//(double)(grid_pos_z2 - grid_pos_z2);  // bug?  z2 - z2
+side1_dz = (double)(grid_pos_z1 - grid_pos_z2);  //       z1 - z2 yes
+//Log::Warning(L"%S %S %u\n", __FILE__, __FUNCTION__, __LINE__);
+/*       |\
+side1 |  \
+|____\
+side 2      */
+}
+else
+{
+side1_dy = (double)(x2z2_y - x2z1_y);
+side2_dy = (double)(x1z1_y - x2z1_y);
+side2_dx = (double)(grid_pos_x1 - grid_pos_x2);
+side1_dx = (double)(grid_pos_x2 - grid_pos_x1);
+side2_dz = 0.0;//(double)(grid_pos_z1 - grid_pos_z1);
+side1_dz = (double)(grid_pos_z2 - grid_pos_z1);
+/*   side 2
+_____
+\    |
+\  | side 1
+\|       */
+}
+float nx = side1_dy * side2_dz - side1_dz * side2_dy;
+float ny = side1_dx * side2_dy - side1_dy * side2_dx;
+float nz = side1_dz * side2_dx - side1_dx * side2_dz;
+float mag = sqrt(nx * nx + ny * ny + nz * nz);
+if (fabsf(mag) < 1e-6f)
+{
+out->y = 0;
+out->x = 0;
+out->z = 65536;
+}
+else
+{
+float invmag = 1.0 / mag;
+out->x = invmag * nx * 65536.0;
+out->y = invmag * ny * 65536.0;
+out->z = invmag * nz * 65536.0;
+}
+}
+//----- (004014E6) --------------------------------------------------------
+void MakeActorAIList_ODM()
+{
+int v1; // eax@4
+int v2; // ebx@4
+unsigned int v3; // ecx@4
+int v4; // edx@5
+int v5; // edx@7
+unsigned int v6; // edx@9
+unsigned int v7; // ST20_4@10
+int v9; // edi@10
+int v10; // ebx@14
+int v21; // [sp+Ch] [bp-14h]@4
+int v22; // [sp+10h] [bp-10h]@4
+pParty->uFlags &= 0xFFFFFFCFu;
+ai_arrays_size = 0;
+for (uint i = 0; i < uNumActors; ++i)
+{
+auto actor = &pActors[i];
+actor->uAttributes &= 0xFFFFFBFF;
+if (!actor->CanAct())
+{
+actor->uAttributes &= 0xFFFFBFFF;
+continue;
+}
+v22 = abs(pParty->vPosition.z - actor->vPosition.z);
+v21 = abs(pParty->vPosition.y - actor->vPosition.y);
+v1 = abs(pParty->vPosition.x - actor->vPosition.x);
+v2 = v21;
+v3 = v22;
+if ( v1 < v21 )
+{
+v4 = v1;
+v1 = v21;
+v2 = v4;
+}
+if ( v1 < v22 )
+{
+v5 = v1;
+v1 = v22;
+v3 = v5;
+}
+if ( v2 < (signed int)v3 )
+{
+v6 = v3;
+v3 = v2;
+v2 = v6;
+}
+v7 = ((unsigned int)(11 * v2) >> 5) + (v3 >> 2) + v1;
+	  //v8 = actor->uActorRadius;
+v9 = v7 - actor->uActorRadius;
+//v23 = v7 - v8;
+if ( v9 < 0 )
+{
+v9 = 0;
+//v23 = 0;
+}
+if (v9 < 5632)
+{
+v10 = actor->uAttributes & 0xFEFFFFFF;
+actor->uAttributes = v10;
+if ( v10 & 0x80000 || actor->GetActorsRelation(0) )
+{
+//v11 = (pParty->uFlags & 0x10) == 0;
+actor->uAttributes = v10 | 0x1000000;
+if (v9 < 5120 )
+pParty->SetYellowAlert();
+if (v9 < 307)
+pParty->SetRedAlert();
+}
+		actor->uAttributes |= 0x00004000;
+ai_near_actors_distances[ai_arrays_size] = v9;
+ai_near_actors_ids[ai_arrays_size++] = i;
+}
+else
+		  actor->uAttributes &= 0xFFFFBFFF;
+}
+/*
+result = v27;
+if ( v27 > 0 )
+{
+v14 = 0;
+v15 = 1;
+v26 = 1;
+do
+{
+while ( 1 )
+{
+v24 = v15;
+if ( v15 >= result )
+break;
+v16 = ai_near_actors_distances[v14];
+if ( v16 > ai_near_actors_distances[v15] )
+{
+v17 = &ai_near_actors_ids[v15];
+v18 = ai_near_actors_ids[v14];
+ai_near_actors_ids[v14] = *v17;
+*v17 = v18;
+v15 = v24;
+ai_near_actors_distances[v14] = ai_near_actors_distances[v24];
+ai_near_actors_distances[v24] = v16;
+}
+result = v27;
+++v15;
+}
+++v14;
+v15 = v26 + 1;
+v26 = v15;
+}
+while ( v15 - 1 < result );
+}*/
+for (uint i = 0; i < ai_arrays_size; ++i)
+for (uint j = 0; j < i; ++j)
+if (ai_near_actors_distances[j] > ai_near_actors_distances[i])
+{
+int tmp = ai_near_actors_distances[j];
+ai_near_actors_distances[j] = ai_near_actors_distances[i];
+ai_near_actors_distances[i] = tmp;
+tmp = ai_near_actors_ids[j];
+ai_near_actors_ids[j] = ai_near_actors_ids[i];
+ai_near_actors_ids[i] = tmp;
+}
+if (ai_arrays_size > 30)
+ai_arrays_size = 30;
+for (uint i = 0; i < ai_arrays_size; ++i)
+pActors[ai_near_actors_ids[i]].uAttributes |= 0x0400;
+}

Mercurial > mm7

comparison Outdoor.cpp @ 1295:86a83e12d795