void CTrueTalkManager::load(SimpleFile *file) {
loadStatics(file);
// Iterate through loading characters
int charId = file->readNumber();
while (charId) {
loadNPC(file, charId);
int ident1 = file->readNumber();
int ident2 = file->readNumber();
if (ident1 != MKTAG_BE('U', 'R', 'A', 'H')) {
while (ident2 != MKTAG_BE('A', 'K', 'E', 'R')) {
ident1 = ident2;
ident2 = file->readNumber();
if (!ident1)
break;
}
}
// Get start of next character
charId = file->readNumber();
}
}
void CTrueTalkManager::saveNPC(SimpleFile *file, int charId) const {
TTnpcScript *script = _scripts.getNpcScript(charId);
if (script) {
script->save(file);
file->writeNumber(MKTAG_BE('U', 'R', 'A', 'H'));
file->writeNumber(MKTAG_BE('A', 'K', 'E', 'R'));
}
}
void CStarCloseup::draw(const FPose &pose, const FVector &vector, const FVector &vector2,
CSurfaceArea *surfaceArea, CStarCamera *camera) {
const int VALUES[] = { 0, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4 };
float val1 = camera->getThreshold();
StarColor starColor = camera->getStarColor();
if (!_flag)
return;
int f1, f3, size2, size1;
float f2, f4, f5, f6, f7, f8, f9;
float f10, incr, f12, f13, f14, f15, f16, f17, f18, f19;
float f20, f21, f22;
FVector tempV;
if (vector2._z < 6.0e9) {
int count, start;
if (vector._x != 0.0 && (vector._y != 0.0 || vector._z != 0.0)) {
// WORKAROUND: Ignoring non-sensical randSeed((int)vector._x);
count = VALUES[g_vm->getRandomNumber(15)];
start = 5 * g_vm->getRandomNumber(255);
} else {
count = 9;
start = 0;
}
Entry *entryP = &_entries[start];
for (; count > 0; --count, ++entryP) {
f1 = _multiplier * entryP->_field8;
f2 = entryP->_field14;
f3 = (f1 + entryP->_fieldC) & 0x1FF;
f4 = _sineTable[f1 & 0x1FF] * entryP->_field10;
f5 = _sineTable[f3];
f6 = cos(f4);
f7 = sin(f4);
f8 = _sineTable[f3 + 128];
f9 = f7;
f10 = f6 * f8;
incr = f6;
f12 = f6 * f5;
f13 = f2 * f10;
f14 = f8 * f2;
f15 = f9 * f2;
f16 = f2 * f12;
f17 = -(f7 * f8 * f2);
f18 = incr * f2;
f19 = -(f9 * f5 * f2);
f20 = -(f5 * f2);
f21 = f14;
_sub1._row1._x = f13;
_sub1._row1._y = f15;
_sub1._row1._z = f16;
_sub1._row2._x = f17;
_sub1._row2._y = f18;
_sub1._row2._z = f19;
_sub1._row3._x = f20;
_sub1._row3._z = f14;
f22 = (float)entryP->_field0;
_sub1._vector._x = f22 * f10 + vector._x;
_sub1._vector._y = f9 * f22 + vector._y;
_sub1._vector._z = f22 * f12 + vector._z;
_sub2._row1._x = pose._row1._x * f13 + f16 * pose._row3._x + f15 * pose._row2._x;
_sub2._row1._y = f15 * pose._row2._y + f16 * pose._row3._y + f13 * pose._row1._y;
_sub2._row1._z = f16 * pose._row3._z + f13 * pose._row1._z + f15 * pose._row2._z;
_sub2._row2._x = pose._row1._x * f17 + f19 * pose._row3._x + f18 * pose._row2._x;
_sub2._row2._y = f18 * pose._row2._y + f17 * pose._row1._y + f19 * pose._row3._y;
_sub2._row2._z = f18 * pose._row2._z + f19 * pose._row3._z + f17 * pose._row1._z;
_sub2._row3._x = pose._row1._x * f20 + f21 * pose._row3._x;
_sub2._row3._y = f20 * pose._row1._y + f21 * pose._row3._y;
_sub2._row3._z = f20 * pose._row1._z + f21 * pose._row3._z;
_sub2._vector._x = pose._row1._x * _sub1._vector._x
+ pose._row3._x * _sub1._vector._z
+ pose._row2._x * _sub1._vector._y + pose._vector._x;
_sub2._vector._y = pose._row2._y * _sub1._vector._y
+ pose._row3._y * _sub1._vector._z
+ pose._row1._y * _sub1._vector._x + pose._vector._y;
_sub2._vector._z = pose._row3._z * _sub1._vector._z
+ pose._row1._z * _sub1._vector._x
+ pose._row2._z * _sub1._vector._y + pose._vector._z;
size2 = (int)_array[1]._data2.size();
size1 = (int)_array[1]._data1.size();
if (size2 > 0) {
for (int ctr2 = 0; ctr2 < size2; ++ctr2) {
FVector &currVector = _array[1]._data2[ctr2];
GridEntry &gridEntry = _grid[ctr2];
gridEntry._x = currVector._z * _sub2._row3._x
+ currVector._y * _sub2._row2._x
+ currVector._x * _sub2._row1._x + _sub2._vector._x;
gridEntry._y = currVector._z * _sub2._row3._y
+ currVector._y * _sub2._row2._y
+ currVector._x * _sub2._row1._y + _sub2._vector._y;
gridEntry._z = currVector._z * _sub2._row3._z
+ currVector._y * _sub2._row2._z
+ currVector._x * _sub2._row1._z + _sub2._vector._z;
}
}
switch (starColor) {
case WHITE:
surfaceArea->setMode(SA_SOLID);
surfaceArea->_pixel = MKTAG_BE(entryP->_pixel1, entryP->_pixel2,
entryP->_pixel3, 0);
surfaceArea->setColorFromPixel();
for (int ctr2 = 0; ctr2 < size2; ++ctr2) {
GridEntry &gridEntry = _grid[ctr2];
tempV = camera->getRelativePos(2, gridEntry);
gridEntry._position._x = tempV._x;
gridEntry._position._y = tempV._y + vector2._y;
}
for (int ctr2 = 0; ctr2 < size1; ++ctr2) {
Data1 &d1 = _array[1]._data1[ctr2];
GridEntry &grid1 = _grid[d1._index1];
GridEntry &grid2 = _grid[d1._index2];
if (grid1._z > val1 && grid2._z > val1) {
surfaceArea->drawLine(FRect(grid1._position._x, grid1._position._y,
grid2._position._x, grid2._position._y));
}
}
break;
case PINK:
surfaceArea->setMode(SA_SOLID);
surfaceArea->_pixel = entryP->_pixel1;
surfaceArea->setColorFromPixel();
for (int ctr2 = 0; ctr2 < size2; ++ctr2) {
GridEntry &gridEntry = _grid[ctr2];
tempV = camera->getRelativePos(0, gridEntry);
gridEntry._position._x = tempV._x + vector2._x;
gridEntry._position._y = tempV._y + vector2._y;
}
for (int ctr2 = 0; ctr2 < size1; ++ctr2) {
Data1 &d1 = _array[1]._data1[ctr2];
GridEntry &grid1 = _grid[d1._index1];
GridEntry &grid2 = _grid[d1._index2];
if (grid1._z > val1 && grid2._z > val1) {
surfaceArea->drawLine(FRect(grid1._position._x, grid1._position._y,
grid2._position._x, grid2._position._y));
}
}
surfaceArea->_pixel = entryP->_pixel3;
surfaceArea->setColorFromPixel();
surfaceArea->setMode(SA_MODE2);
for (int ctr2 = 0; ctr2 < size2; ++ctr2) {
GridEntry &gridEntry = _grid[ctr2];
tempV = camera->getRelativePos(1, gridEntry);
gridEntry._position._x = tempV._x + vector2._x;
gridEntry._position._y = tempV._y + vector2._y;
}
for (int ctr2 = 0; ctr2 < size1; ++ctr2) {
Data1 &d1 = _array[1]._data1[ctr2];
GridEntry &grid1 = _grid[d1._index1];
GridEntry &grid2 = _grid[d1._index2];
if (grid1._z > val1 && grid2._z > val1) {
surfaceArea->drawLine(FRect(grid1._position._x, grid1._position._y,
grid2._position._x, grid2._position._y));
}
}
break;
default:
assert(0);
}
}
}
uint pixel1 = 0x81EEF5, pixel2 = 0xF5, pixel3 = 0x810000;
int arrIndex = 0;
if (vector2._z >= 200000000.0) {
if (vector2._z >= 900000000.0) {
if (vector2._z >= 6000000000.0) {
arrIndex = 3;
if (vector2._z >= 1.0e10)
arrIndex = 4;
} else {
arrIndex = 2;
}
} else {
arrIndex = 1;
}
} else {
arrIndex = 0;
}
SubEntry &entry = _array[arrIndex];
for (uint ctr = 0; ctr < entry._data2.size(); ++ctr) {
GridEntry &gridEntry = _grid[ctr];
const FVector &d2v = entry._data2[ctr];
FVector newV = d2v + vector;
gridEntry._x = pose._row1._x * newV._x + pose._row3._x * newV._z
+ pose._row2._x * newV._y + pose._vector._x;
gridEntry._y = newV._y * pose._row2._y + newV._z * pose._row3._y
+ newV._x * pose._row1._y + pose._vector._y;
gridEntry._z = newV._z * pose._row3._z + newV._y * pose._row2._z
+ newV._x * pose._row1._z + pose._vector._z;
}
switch(starColor) {
case WHITE:
surfaceArea->setMode(SA_SOLID);
surfaceArea->_pixel = pixel1;
surfaceArea->setColorFromPixel();
for (uint ctr = 0; ctr < entry._data2.size(); ++ctr) {
GridEntry &gridEntry = _grid[ctr];
tempV = camera->getRelativePos(2, gridEntry);
gridEntry._position._x = tempV._x + vector2._x;
gridEntry._position._y = tempV._y + vector2._y;
}
for (uint ctr = 0; ctr < entry._data1.size(); ++ctr) {
Data1 &d1 = entry._data1[ctr];
GridEntry &grid1 = _grid[d1._index1];
GridEntry &grid2 = _grid[d1._index2];
if (grid2._z > val1 && grid1._z > val1) {
surfaceArea->drawLine(FRect(grid1._position._x, grid1._position._y,
grid2._position._x, grid2._position._y));
}
}
break;
case PINK:
surfaceArea->setMode(SA_SOLID);
surfaceArea->_pixel = pixel2;
surfaceArea->setColorFromPixel();
for (uint ctr = 0; ctr < entry._data2.size(); ++ctr) {
GridEntry &gridEntry = _grid[ctr];
tempV = camera->getRelativePos(2, gridEntry);
gridEntry._position._x = tempV._x + vector2._x;
gridEntry._position._y = tempV._y + vector2._y;
}
for (uint ctr = 0; ctr < entry._data1.size(); ++ctr) {
Data1 &d1 = entry._data1[ctr];
GridEntry &grid1 = _grid[d1._index1];
GridEntry &grid2 = _grid[d1._index2];
if (grid2._z > val1 && grid1._z > val1) {
surfaceArea->drawLine(FRect(grid1._position._x, grid1._position._y,
grid2._position._x, grid2._position._y));
}
}
surfaceArea->_pixel = pixel3;
surfaceArea->setColorFromPixel();
surfaceArea->setMode(SA_MODE2);
for (uint ctr = 0; ctr < entry._data2.size(); ++ctr) {
GridEntry &gridEntry = _grid[ctr];
tempV = camera->getRelativePos(2, gridEntry);
gridEntry._position._x = tempV._x + vector2._x;
gridEntry._position._y = tempV._y + vector2._y;
}
for (uint ctr = 0; ctr < entry._data1.size(); ++ctr) {
Data1 &d1 = entry._data1[ctr];
GridEntry &grid1 = _grid[d1._index1];
GridEntry &grid2 = _grid[d1._index2];
if (grid2._z > val1 && grid1._z > val1) {
surfaceArea->drawLine(FRect(grid1._position._x, grid1._position._y,
grid2._position._x, grid2._position._y));
}
}
break;
default:
assert(0);
}
}
