2015-05-19 21:54:34 +00:00
|
|
|
//-------------------------------------------------------------------------
|
|
|
|
/*
|
|
|
|
Copyright (C) 1997, 2005 - 3D Realms Entertainment
|
|
|
|
|
|
|
|
This file is part of Shadow Warrior version 1.2
|
|
|
|
|
|
|
|
Shadow Warrior is free software; you can redistribute it and/or
|
|
|
|
modify it under the terms of the GNU General Public License
|
|
|
|
as published by the Free Software Foundation; either version 2
|
|
|
|
of the License, or (at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
|
|
|
|
Original Source: 1997 - Frank Maddin and Jim Norwood
|
|
|
|
Prepared for public release: 03/28/2005 - Charlie Wiederhold, 3D Realms
|
|
|
|
*/
|
|
|
|
//-------------------------------------------------------------------------
|
2019-10-09 16:09:05 +00:00
|
|
|
#include "ns.h"
|
|
|
|
|
2015-05-19 21:54:34 +00:00
|
|
|
#include "build.h"
|
|
|
|
|
|
|
|
#include "names2.h"
|
|
|
|
#include "panel.h"
|
|
|
|
#include "tags.h"
|
|
|
|
#include "sector.h"
|
|
|
|
#include "ai.h"
|
|
|
|
#include "player.h"
|
|
|
|
#include "game.h"
|
|
|
|
|
2019-10-09 16:09:05 +00:00
|
|
|
BEGIN_SW_NS
|
|
|
|
|
2021-12-31 14:50:44 +00:00
|
|
|
void ScaleSectorObject(SECTOR_OBJECT*);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2021-12-11 02:49:58 +00:00
|
|
|
short DoSectorObjectSetScale(short match)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2021-12-31 14:50:44 +00:00
|
|
|
SECTOR_OBJECT* sop;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
for (sop = SectorObject; sop < &SectorObject[MAX_SECTOR_OBJECTS]; sop++)
|
|
|
|
{
|
2020-05-22 12:11:03 +00:00
|
|
|
if (SO_EMPTY(sop))
|
2015-05-19 21:54:34 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (sop->match_event == match)
|
|
|
|
{
|
2021-12-27 16:22:41 +00:00
|
|
|
sop->flags |= (SOBJ_DYNAMIC);
|
2015-05-19 21:54:34 +00:00
|
|
|
sop->PreMoveAnimator = ScaleSectorObject;
|
|
|
|
|
|
|
|
switch (sop->scale_active_type)
|
|
|
|
{
|
|
|
|
case SO_SCALE_RANDOM_POINT:
|
|
|
|
if (sop->scale_type == SO_SCALE_HOLD || sop->scale_type == SO_SCALE_NONE)
|
|
|
|
{
|
|
|
|
// if holding start it up
|
|
|
|
sop->scale_type = sop->scale_active_type;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// if moving set to hold
|
|
|
|
sop->scale_type = SO_SCALE_HOLD;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SO_SCALE_DEST:
|
|
|
|
|
|
|
|
sop->scale_type = sop->scale_active_type;
|
|
|
|
|
|
|
|
if (sop->scale_dist == sop->scale_dist_max)
|
|
|
|
{
|
|
|
|
// make it negative
|
|
|
|
if (sop->scale_speed > 0)
|
|
|
|
sop->scale_speed = -sop->scale_speed;
|
|
|
|
}
|
|
|
|
else if (sop->scale_dist == sop->scale_dist_min)
|
|
|
|
{
|
|
|
|
// make it positive
|
|
|
|
if (sop->scale_speed < 0)
|
|
|
|
sop->scale_speed = -sop->scale_speed;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// make it positive
|
|
|
|
if (sop->scale_speed < 0)
|
|
|
|
sop->scale_speed = -sop->scale_speed;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SO_SCALE_RANDOM:
|
|
|
|
case SO_SCALE_CYCLE:
|
|
|
|
if (sop->scale_type == SO_SCALE_HOLD)
|
|
|
|
{
|
|
|
|
// if holding start it up
|
|
|
|
sop->scale_type = sop->scale_active_type;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// if moving set to hold
|
|
|
|
sop->scale_type = SO_SCALE_HOLD;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-12-11 02:49:58 +00:00
|
|
|
short DoSOevent(short match, short state)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2021-12-31 14:50:44 +00:00
|
|
|
SECTOR_OBJECT* sop;
|
2015-05-19 21:54:34 +00:00
|
|
|
short vel_adj=0, spin_adj=0;
|
|
|
|
|
|
|
|
for (sop = SectorObject; sop < &SectorObject[MAX_SECTOR_OBJECTS]; sop++)
|
|
|
|
{
|
2020-05-22 12:11:03 +00:00
|
|
|
if (SO_EMPTY(sop))
|
2015-05-19 21:54:34 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (sop->match_event == match)
|
|
|
|
{
|
2021-12-29 05:53:36 +00:00
|
|
|
if ((sop->flags & SOBJ_WAIT_FOR_EVENT))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
if (sop->save_vel > 0 || sop->save_spin_speed > 0)
|
|
|
|
{
|
2021-12-27 17:58:15 +00:00
|
|
|
sop->flags &= ~(SOBJ_WAIT_FOR_EVENT);
|
2015-05-19 21:54:34 +00:00
|
|
|
sop->vel = sop->save_vel;
|
|
|
|
sop->spin_speed = sop->save_spin_speed;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-24 14:21:44 +00:00
|
|
|
auto me_act = sop->match_event_actor;
|
|
|
|
if (me_act == nullptr)
|
2015-05-19 21:54:34 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
// toggle
|
|
|
|
if (state == -1)
|
|
|
|
{
|
2021-12-24 23:03:43 +00:00
|
|
|
if (TEST_BOOL3(me_act))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2021-12-24 23:03:43 +00:00
|
|
|
RESET_BOOL3(me_act);
|
2021-12-29 05:40:52 +00:00
|
|
|
state = 0;
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2021-12-24 23:03:43 +00:00
|
|
|
SET_BOOL3(me_act);
|
2021-12-29 08:27:13 +00:00
|
|
|
state = 1;
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-29 08:27:13 +00:00
|
|
|
if (state == 1)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2021-12-24 14:21:44 +00:00
|
|
|
spin_adj = (int)SP_TAG3(me_act);
|
2021-12-24 23:03:43 +00:00
|
|
|
vel_adj = SP_TAG7(me_act);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
2021-12-29 05:40:52 +00:00
|
|
|
else if (state == 0)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2021-12-24 14:21:44 +00:00
|
|
|
spin_adj = -(int)SP_TAG3(me_act);
|
2021-12-24 23:03:43 +00:00
|
|
|
vel_adj = -SP_TAG7(me_act);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
sop->spin_speed += spin_adj;
|
|
|
|
|
2021-12-24 23:03:43 +00:00
|
|
|
if (TEST_BOOL1(me_act))
|
2015-05-19 21:54:34 +00:00
|
|
|
sop->vel_tgt += vel_adj;
|
|
|
|
else
|
|
|
|
sop->vel += vel_adj;
|
|
|
|
|
2021-12-24 23:03:43 +00:00
|
|
|
if (TEST_BOOL2(me_act))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
sop->dir *= -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// SCALING - PreAnimator
|
|
|
|
//
|
|
|
|
|
2021-12-31 14:50:44 +00:00
|
|
|
void ScaleSectorObject(SECTOR_OBJECT* sop)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
switch (sop->scale_type)
|
|
|
|
{
|
|
|
|
case SO_SCALE_NONE:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SO_SCALE_HOLD:
|
|
|
|
break;
|
|
|
|
|
|
|
|
// to dest
|
|
|
|
case SO_SCALE_DEST:
|
|
|
|
sop->scale_dist += sop->scale_speed;
|
|
|
|
|
|
|
|
if (sop->scale_dist > sop->scale_dist_max)
|
|
|
|
{
|
|
|
|
sop->scale_dist = sop->scale_dist_max;
|
|
|
|
sop->scale_type = SO_SCALE_HOLD;
|
|
|
|
}
|
|
|
|
else if (sop->scale_dist < sop->scale_dist_min)
|
|
|
|
{
|
|
|
|
sop->scale_dist = sop->scale_dist_min;
|
|
|
|
sop->scale_type = SO_SCALE_HOLD;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
// random direction change
|
|
|
|
case SO_SCALE_RANDOM:
|
|
|
|
|
|
|
|
sop->scale_dist += sop->scale_speed;
|
|
|
|
if (sop->scale_dist > sop->scale_dist_max)
|
|
|
|
{
|
|
|
|
sop->scale_speed *= -1;
|
|
|
|
sop->scale_dist = sop->scale_dist_max;
|
|
|
|
}
|
|
|
|
else if (sop->scale_dist < sop->scale_dist_min)
|
|
|
|
{
|
|
|
|
sop->scale_speed *= -1;
|
|
|
|
sop->scale_dist = sop->scale_dist_min;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (RANDOM_P2(1024) < sop->scale_rand_freq<<3)
|
|
|
|
{
|
|
|
|
sop->scale_speed *= -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
// cycle through max and min
|
|
|
|
case SO_SCALE_CYCLE:
|
|
|
|
sop->scale_dist += sop->scale_speed;
|
|
|
|
|
|
|
|
if (sop->scale_dist > sop->scale_dist_max)
|
|
|
|
{
|
|
|
|
sop->scale_speed *= -1;
|
|
|
|
sop->scale_dist = sop->scale_dist_max;
|
|
|
|
}
|
|
|
|
else if (sop->scale_dist < sop->scale_dist_min)
|
|
|
|
{
|
|
|
|
sop->scale_speed *= -1;
|
|
|
|
sop->scale_dist = sop->scale_dist_min;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-31 14:50:44 +00:00
|
|
|
void ScaleRandomPoint(SECTOR_OBJECT* sop, short k, short ang, int x, int y, int *dx, int *dy)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int xmul,ymul;
|
|
|
|
|
|
|
|
sop->scale_point_dist[k] += sop->scale_point_speed[k];
|
|
|
|
if (sop->scale_point_dist[k] > sop->scale_point_dist_max)
|
|
|
|
{
|
|
|
|
sop->scale_point_speed[k] *= -1;
|
|
|
|
sop->scale_point_dist[k] = sop->scale_point_dist_max;
|
|
|
|
}
|
|
|
|
else if (sop->scale_point_dist[k] < sop->scale_point_dist_min)
|
|
|
|
{
|
|
|
|
sop->scale_point_speed[k] *= -1;
|
|
|
|
sop->scale_point_dist[k] = sop->scale_point_dist_min;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (RANDOM_P2(1024) < sop->scale_point_rand_freq)
|
|
|
|
{
|
|
|
|
sop->scale_point_speed[k] *= -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// change up speed at random
|
|
|
|
if (RANDOM_P2(1024) < (sop->scale_point_rand_freq/2))
|
|
|
|
{
|
|
|
|
//sop->scale_point_speed[k] = SCALE_POINT_SPEED;
|
|
|
|
short half = sop->scale_point_base_speed/2;
|
|
|
|
short quart = sop->scale_point_base_speed/4;
|
2021-09-20 06:59:54 +00:00
|
|
|
sop->scale_point_speed[k] = sop->scale_point_base_speed + (RandomRange(half) - quart);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
xmul = (sop->scale_point_dist[k] * sop->scale_x_mult)>>8;
|
|
|
|
ymul = (sop->scale_point_dist[k] * sop->scale_y_mult)>>8;
|
|
|
|
|
2021-01-04 11:36:54 +00:00
|
|
|
*dx = x + MulScale(xmul, bcos(ang), 14);
|
|
|
|
*dy = y + MulScale(ymul, bsin(ang), 14);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Morph point - move point around
|
|
|
|
//
|
|
|
|
|
2021-12-31 14:50:44 +00:00
|
|
|
void MorphTornado(SECTOR_OBJECT* sop)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int mx, my;
|
2022-02-02 23:59:12 +00:00
|
|
|
int ceilz;
|
|
|
|
int florz;
|
2021-12-31 14:43:47 +00:00
|
|
|
sectortype* *sectp;
|
2015-05-19 21:54:34 +00:00
|
|
|
int j;
|
|
|
|
int x,y,sx,sy;
|
|
|
|
|
|
|
|
// z direction
|
2021-11-24 22:07:02 +00:00
|
|
|
ASSERT(sop->op_main_sector != nullptr);
|
2015-05-19 21:54:34 +00:00
|
|
|
sop->morph_z += Z(sop->morph_z_speed);
|
|
|
|
|
|
|
|
// move vector
|
2021-11-25 17:16:56 +00:00
|
|
|
if (sop->morph_wall_point == nullptr)
|
2015-05-19 21:54:34 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
// place at correct x,y offset from center
|
2022-08-18 16:27:31 +00:00
|
|
|
x = sop->int_pmid().X - sop->morph_xoff;
|
|
|
|
y = sop->int_pmid().Y - sop->morph_yoff;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
sx = x;
|
|
|
|
sy = y;
|
|
|
|
|
|
|
|
// move it from last x,y
|
2021-01-04 11:36:54 +00:00
|
|
|
mx = x + MulScale(sop->morph_speed, bcos(sop->morph_ang), 14);
|
|
|
|
my = y + MulScale(sop->morph_speed, bsin(sop->morph_ang), 14);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// bound check radius
|
2022-08-18 16:27:31 +00:00
|
|
|
if (ksqrt(SQ(sop->int_pmid().X - mx) + SQ(sop->int_pmid().Y - my)) > sop->morph_dist_max + sop->scale_dist)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
// find angle
|
2022-08-18 16:27:31 +00:00
|
|
|
sop->morph_ang = NORM_ANGLE(getangle(mx - sop->int_pmid().X, my - sop->int_pmid().Y));
|
2015-05-19 21:54:34 +00:00
|
|
|
// reverse angle
|
|
|
|
sop->morph_ang = NORM_ANGLE(sop->morph_ang + 1024);
|
|
|
|
|
|
|
|
// move back some from last point
|
2021-01-04 11:36:54 +00:00
|
|
|
mx = sx + MulScale(sop->morph_speed << 1, bcos(sop->morph_ang), 14);
|
|
|
|
my = sy + MulScale(sop->morph_speed << 1, bsin(sop->morph_ang), 14);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2022-08-18 16:27:31 +00:00
|
|
|
sop->morph_xoff = sop->int_pmid().X - mx;
|
|
|
|
sop->morph_yoff = sop->int_pmid().Y - my;
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// save x,y back as offset info
|
2022-08-18 16:27:31 +00:00
|
|
|
sop->morph_xoff = sop->int_pmid().X - mx;
|
|
|
|
sop->morph_yoff = sop->int_pmid().Y - my;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if ((RANDOM_P2(1024<<4)>>4) < sop->morph_rand_freq)
|
|
|
|
sop->morph_ang = RANDOM_P2(2048);
|
|
|
|
|
|
|
|
// move it x,y
|
2021-11-18 00:15:18 +00:00
|
|
|
dragpoint(sop->morph_wall_point, mx, my);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// bound the Z
|
2022-02-02 23:59:12 +00:00
|
|
|
ceilz = sop->op_main_sector->int_ceilingz();
|
|
|
|
florz = sop->op_main_sector->int_floorz();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
for (sectp = sop->sectp, j = 0; *sectp; sectp++, j++)
|
|
|
|
{
|
2021-11-19 21:35:08 +00:00
|
|
|
if ((*sectp)->hasU() &&
|
2021-12-29 05:53:36 +00:00
|
|
|
((*sectp)->flags & SECTFU_SO_SLOPE_CEILING_TO_POINT))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2022-02-02 23:59:12 +00:00
|
|
|
#define TOR_LOW (florz)
|
2015-05-19 21:54:34 +00:00
|
|
|
if (sop->morph_z > TOR_LOW)
|
|
|
|
{
|
|
|
|
sop->morph_z_speed *= -1;
|
|
|
|
sop->morph_z = TOR_LOW;
|
|
|
|
}
|
2022-02-02 23:59:12 +00:00
|
|
|
else if (sop->morph_z < ceilz)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
sop->morph_z_speed *= -1;
|
2022-02-02 23:59:12 +00:00
|
|
|
sop->morph_z = ceilz;
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
|
2021-11-24 21:43:32 +00:00
|
|
|
alignceilslope(*sectp, mx, my, sop->morph_z);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// moves center point around and aligns slope
|
2021-12-31 14:50:44 +00:00
|
|
|
void MorphFloor(SECTOR_OBJECT* sop)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int mx, my;
|
2022-02-02 23:59:12 +00:00
|
|
|
int florz;
|
2021-12-31 14:43:47 +00:00
|
|
|
sectortype* *sectp;
|
2015-05-19 21:54:34 +00:00
|
|
|
int j;
|
|
|
|
int x,y;
|
|
|
|
|
|
|
|
// z direction
|
2021-11-24 22:07:02 +00:00
|
|
|
ASSERT(sop->op_main_sector != nullptr);
|
2015-05-19 21:54:34 +00:00
|
|
|
sop->morph_z -= Z(sop->morph_z_speed);
|
|
|
|
|
|
|
|
// move vector
|
2021-11-25 17:16:56 +00:00
|
|
|
if (sop->morph_wall_point == nullptr)
|
2015-05-19 21:54:34 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
// place at correct x,y offset from center
|
2022-08-18 16:27:31 +00:00
|
|
|
x = sop->int_pmid().X - sop->morph_xoff;
|
|
|
|
y = sop->int_pmid().Y - sop->morph_yoff;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// move it from last x,y
|
2021-01-04 11:36:54 +00:00
|
|
|
mx = x + MulScale(sop->morph_speed, bcos(sop->morph_ang), 14);
|
|
|
|
my = y + MulScale(sop->morph_speed, bsin(sop->morph_ang), 14);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// save x,y back as offset info
|
2022-08-18 16:27:31 +00:00
|
|
|
sop->morph_xoff = sop->int_pmid().X - mx;
|
|
|
|
sop->morph_yoff = sop->int_pmid().Y - my;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// bound check radius
|
2022-08-18 16:27:31 +00:00
|
|
|
if (Distance(sop->int_pmid().X, sop->int_pmid().Y, mx, my) > sop->morph_dist_max)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
// go in the other direction
|
|
|
|
//sop->morph_speed *= -1;
|
|
|
|
sop->morph_ang = NORM_ANGLE(sop->morph_ang + 1024);
|
|
|
|
|
|
|
|
// back it up and save it off
|
2021-01-04 11:36:54 +00:00
|
|
|
mx = x + MulScale(sop->morph_speed, bcos(sop->morph_ang), 14);
|
|
|
|
my = y + MulScale(sop->morph_speed, bsin(sop->morph_ang), 14);
|
2022-08-18 16:27:31 +00:00
|
|
|
sop->morph_xoff = sop->int_pmid().X - mx;
|
|
|
|
sop->morph_yoff = sop->int_pmid().Y - my;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// turn it all the way around and then do a random -512 to 512 from there
|
|
|
|
//sop->morph_ang = NORM_ANGLE(sop->morph_ang + 1024 + (RANDOM_P2(1024) - 512));
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((RANDOM_P2(1024<<4)>>4) < sop->morph_rand_freq)
|
|
|
|
sop->morph_ang = RANDOM_P2(2048);
|
|
|
|
|
|
|
|
// move x,y point "just like in build"
|
2021-11-18 00:15:18 +00:00
|
|
|
dragpoint(sop->morph_wall_point, mx, my);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// bound the Z
|
2022-02-02 23:59:12 +00:00
|
|
|
florz = sop->op_main_sector->int_floorz();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
#define MORPH_FLOOR_ZRANGE Z(300)
|
|
|
|
|
|
|
|
if (sop->morph_z > MORPH_FLOOR_ZRANGE)
|
|
|
|
{
|
|
|
|
sop->morph_z = MORPH_FLOOR_ZRANGE;
|
|
|
|
//sop->morph_ang = NORM_ANGLE(sop->morph_ang + 1024);
|
|
|
|
sop->morph_z_speed *= -1;
|
|
|
|
}
|
|
|
|
else if (sop->morph_z < -MORPH_FLOOR_ZRANGE)
|
|
|
|
{
|
|
|
|
sop->morph_z = -MORPH_FLOOR_ZRANGE;
|
|
|
|
//sop->morph_ang = NORM_ANGLE(sop->morph_ang + 1024);
|
|
|
|
sop->morph_z_speed *= -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (sectp = sop->sectp, j = 0; *sectp; sectp++, j++)
|
|
|
|
{
|
2021-11-19 21:35:08 +00:00
|
|
|
if ((*sectp)->hasU() &&
|
2021-12-29 05:53:36 +00:00
|
|
|
((*sectp)->flags & SECTFU_SO_SLOPE_CEILING_TO_POINT))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2022-02-02 23:59:12 +00:00
|
|
|
alignflorslope(*sectp, mx, my, florz + sop->morph_z);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-31 14:50:44 +00:00
|
|
|
void SOBJ_AlignFloorToPoint(SECTOR_OBJECT* sop, int x, int y, int z)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2021-12-31 14:43:47 +00:00
|
|
|
sectortype* *sectp;
|
2015-05-19 21:54:34 +00:00
|
|
|
int j;
|
|
|
|
|
|
|
|
for (sectp = sop->sectp, j = 0; *sectp; sectp++, j++)
|
|
|
|
{
|
2021-11-19 21:35:08 +00:00
|
|
|
if ((*sectp)->hasU() &&
|
2021-12-29 05:53:36 +00:00
|
|
|
((*sectp)->flags & SECTFU_SO_SLOPE_CEILING_TO_POINT))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2021-11-24 21:43:32 +00:00
|
|
|
alignflorslope(*sectp, x, y, z);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-31 14:50:44 +00:00
|
|
|
void SOBJ_AlignCeilingToPoint(SECTOR_OBJECT* sop, int x, int y, int z)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2021-12-31 14:43:47 +00:00
|
|
|
sectortype* *sectp;
|
2015-05-19 21:54:34 +00:00
|
|
|
int j;
|
|
|
|
|
|
|
|
for (sectp = sop->sectp, j = 0; *sectp; sectp++, j++)
|
|
|
|
{
|
2021-11-19 21:35:08 +00:00
|
|
|
if ((*sectp)->hasU() &&
|
2021-12-29 05:53:36 +00:00
|
|
|
((*sectp)->flags & SECTFU_SO_SLOPE_CEILING_TO_POINT))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2021-11-24 21:43:32 +00:00
|
|
|
alignceilslope(*sectp, x, y, z);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-31 14:50:44 +00:00
|
|
|
void SOBJ_AlignFloorCeilingToPoint(SECTOR_OBJECT* sop, int x, int y, int z)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2021-12-31 14:43:47 +00:00
|
|
|
sectortype* *sectp;
|
2015-05-19 21:54:34 +00:00
|
|
|
int j;
|
|
|
|
|
|
|
|
for (sectp = sop->sectp, j = 0; *sectp; sectp++, j++)
|
|
|
|
{
|
2021-11-19 21:35:08 +00:00
|
|
|
if ((*sectp)->hasU() &&
|
2021-12-29 05:53:36 +00:00
|
|
|
((*sectp)->flags & SECTFU_SO_SLOPE_CEILING_TO_POINT))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2021-11-24 21:43:32 +00:00
|
|
|
alignflorslope(*sectp, x, y, z);
|
|
|
|
alignceilslope(*sectp, x, y, z);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// moves center point around and aligns slope
|
2021-12-31 14:50:44 +00:00
|
|
|
void SpikeFloor(SECTOR_OBJECT* sop)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int mx, my;
|
2022-02-02 23:59:12 +00:00
|
|
|
int florz;
|
2015-05-19 21:54:34 +00:00
|
|
|
int x,y;
|
|
|
|
|
|
|
|
// z direction
|
2021-11-24 22:07:02 +00:00
|
|
|
ASSERT(sop->op_main_sector != nullptr);
|
2015-05-19 21:54:34 +00:00
|
|
|
sop->morph_z -= Z(sop->morph_z_speed);
|
|
|
|
|
|
|
|
// move vector
|
2021-11-25 17:16:56 +00:00
|
|
|
if (sop->morph_wall_point == nullptr)
|
2015-05-19 21:54:34 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
// place at correct x,y offset from center
|
2022-08-18 16:27:31 +00:00
|
|
|
x = sop->int_pmid().X - sop->morph_xoff;
|
|
|
|
y = sop->int_pmid().Y - sop->morph_yoff;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// move it from last x,y
|
|
|
|
mx = x;
|
|
|
|
my = y;
|
|
|
|
|
|
|
|
// bound the Z
|
2022-02-02 23:59:12 +00:00
|
|
|
florz = sop->op_main_sector->int_floorz();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
#define MORPH_FLOOR_ZRANGE Z(300)
|
|
|
|
|
|
|
|
if (sop->morph_z > MORPH_FLOOR_ZRANGE)
|
|
|
|
{
|
|
|
|
sop->morph_z = MORPH_FLOOR_ZRANGE;
|
|
|
|
sop->morph_z_speed *= -1;
|
|
|
|
}
|
|
|
|
else if (sop->morph_z < -MORPH_FLOOR_ZRANGE)
|
|
|
|
{
|
|
|
|
sop->morph_z = -MORPH_FLOOR_ZRANGE;
|
|
|
|
sop->morph_z_speed *= -1;
|
|
|
|
}
|
|
|
|
|
2022-02-02 23:59:12 +00:00
|
|
|
SOBJ_AlignFloorToPoint(sop, mx, my, florz + sop->morph_z);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#include "saveable.h"
|
|
|
|
|
|
|
|
static saveable_code saveable_morph_code[] =
|
|
|
|
{
|
|
|
|
SAVE_CODE(ScaleSectorObject),
|
|
|
|
SAVE_CODE(MorphTornado),
|
|
|
|
SAVE_CODE(MorphFloor),
|
|
|
|
SAVE_CODE(SpikeFloor),
|
|
|
|
};
|
|
|
|
|
|
|
|
saveable_module saveable_morph =
|
|
|
|
{
|
|
|
|
// code
|
|
|
|
saveable_morph_code,
|
|
|
|
SIZ(saveable_morph_code),
|
|
|
|
|
|
|
|
// data
|
2021-07-10 12:25:18 +00:00
|
|
|
nullptr,0
|
2015-05-19 21:54:34 +00:00
|
|
|
};
|
2019-10-09 16:09:05 +00:00
|
|
|
END_SW_NS
|