Rev 8685 | Details | Compare with Previous | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 5196 | hendricks2 | 1 | //------------------------------------------------------------------------- |
| 2 | /* |
||
| 3 | Copyright (C) 1997, 2005 - 3D Realms Entertainment |
||
| 4 | |||
| 5 | This file is part of Shadow Warrior version 1.2 |
||
| 6 | |||
| 7 | Shadow Warrior is free software; you can redistribute it and/or |
||
| 8 | modify it under the terms of the GNU General Public License |
||
| 9 | as published by the Free Software Foundation; either version 2 |
||
| 10 | of the License, or (at your option) any later version. |
||
| 11 | |||
| 12 | This program is distributed in the hope that it will be useful, |
||
| 13 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
| 14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
||
| 15 | |||
| 16 | See the GNU General Public License for more details. |
||
| 17 | |||
| 18 | You should have received a copy of the GNU General Public License |
||
| 19 | along with this program; if not, write to the Free Software |
||
| 20 | Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
||
| 21 | |||
| 22 | Original Source: 1997 - Frank Maddin and Jim Norwood |
||
| 23 | Prepared for public release: 03/28/2005 - Charlie Wiederhold, 3D Realms |
||
| 24 | */ |
||
| 25 | //------------------------------------------------------------------------- |
||
| 26 | #include "build.h" |
||
| 27 | |||
| 28 | #include "keys.h" |
||
| 29 | #include "names2.h" |
||
| 30 | #include "panel.h" |
||
| 31 | #include "game.h" |
||
| 32 | #include "tags.h" |
||
| 33 | #include "ai.h" |
||
| 34 | #include "pal.h" |
||
| 35 | #include "actor.h" |
||
| 36 | #include "sprite.h" |
||
| 37 | #include "track.h" |
||
| 38 | |||
| 39 | ANIMATOR InitRipperHang; |
||
| 40 | ANIMATOR DoActorMoveJump; |
||
| 41 | ANIMATOR DoRipperMoveJump; |
||
| 42 | ANIMATOR DoRipperHangJF; |
||
| 43 | ANIMATOR DoRipperQuickJump; |
||
| 44 | |||
| 45 | DECISION RipperBattle[] = |
||
| 46 | { |
||
| 47 | {748, InitActorMoveCloser}, |
||
| 48 | {750, InitActorAlertNoise}, |
||
| 49 | // {900, InitRipperHang}, |
||
| 50 | {755, InitActorAttackNoise}, |
||
| 51 | {1024, InitActorAttack} |
||
| 52 | }; |
||
| 53 | |||
| 54 | DECISION RipperOffense[] = |
||
| 55 | { |
||
| 56 | {700, InitActorMoveCloser}, |
||
| 57 | {710, InitActorAlertNoise}, |
||
| 58 | {1024, InitActorAttack} |
||
| 59 | }; |
||
| 60 | |||
| 61 | DECISION RipperBroadcast[] = |
||
| 62 | { |
||
| 63 | {3, InitActorAlertNoise}, |
||
| 64 | {6, InitActorAmbientNoise}, |
||
| 65 | {1024, InitActorDecide} |
||
| 66 | }; |
||
| 67 | |||
| 68 | DECISION RipperSurprised[] = |
||
| 69 | { |
||
| 70 | {30, InitRipperHang}, |
||
| 71 | {701, InitActorMoveCloser}, |
||
| 72 | {1024, InitActorDecide} |
||
| 73 | }; |
||
| 74 | |||
| 75 | DECISION RipperEvasive[] = |
||
| 76 | { |
||
| 77 | {6, InitRipperHang}, |
||
| 78 | {1024, NULL} |
||
| 79 | }; |
||
| 80 | |||
| 81 | DECISION RipperLostTarget[] = |
||
| 82 | { |
||
| 83 | {980, InitActorFindPlayer}, |
||
| 84 | {1024, InitActorWanderAround} |
||
| 85 | }; |
||
| 86 | |||
| 87 | DECISION RipperCloseRange[] = |
||
| 88 | { |
||
| 89 | {900, InitActorAttack }, |
||
| 90 | {1024, InitActorReposition } |
||
| 91 | }; |
||
| 92 | |||
| 93 | PERSONALITY RipperPersonality = |
||
| 94 | { |
||
| 95 | RipperBattle, |
||
| 96 | RipperOffense, |
||
| 97 | RipperBroadcast, |
||
| 98 | RipperSurprised, |
||
| 99 | RipperEvasive, |
||
| 100 | RipperLostTarget, |
||
| 101 | RipperCloseRange, |
||
| 102 | RipperCloseRange |
||
| 103 | }; |
||
| 104 | |||
| 105 | ATTRIBUTE RipperAttrib = |
||
| 106 | { |
||
| 107 | {200, 220, 240, 280}, // Speeds |
||
| 108 | {5, 0, -2, -4}, // Tic Adjusts |
||
| 109 | 3, // MaxWeapons; |
||
| 110 | { |
||
| 111 | DIGI_RIPPERAMBIENT, DIGI_RIPPERALERT, DIGI_RIPPERATTACK, |
||
| 112 | DIGI_RIPPERPAIN, DIGI_RIPPERSCREAM, DIGI_RIPPERHEARTOUT, |
||
| 113 | 0,0,0,0 |
||
| 114 | } |
||
| 115 | }; |
||
| 116 | |||
| 117 | ////////////////////// |
||
| 118 | // |
||
| 119 | // RIPPER RUN |
||
| 120 | // |
||
| 121 | ////////////////////// |
||
| 122 | |||
| 123 | #define RIPPER_RUN_RATE 16 |
||
| 124 | |||
| 125 | ANIMATOR DoRipperMove, NullRipper, DoActorDebris; |
||
| 126 | |||
| 127 | STATE s_RipperRun[5][4] = |
||
| 128 | { |
||
| 129 | { |
||
| 130 | {RIPPER_RUN_R0 + 0, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[0][1]}, |
||
| 131 | {RIPPER_RUN_R0 + 1, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[0][2]}, |
||
| 132 | {RIPPER_RUN_R0 + 2, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[0][3]}, |
||
| 133 | {RIPPER_RUN_R0 + 3, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[0][0]}, |
||
| 134 | }, |
||
| 135 | { |
||
| 136 | {RIPPER_RUN_R1 + 0, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[1][1]}, |
||
| 137 | {RIPPER_RUN_R1 + 1, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[1][2]}, |
||
| 138 | {RIPPER_RUN_R1 + 2, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[1][3]}, |
||
| 139 | {RIPPER_RUN_R1 + 3, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[1][0]}, |
||
| 140 | }, |
||
| 141 | { |
||
| 142 | {RIPPER_RUN_R2 + 0, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[2][1]}, |
||
| 143 | {RIPPER_RUN_R2 + 1, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[2][2]}, |
||
| 144 | {RIPPER_RUN_R2 + 2, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[2][3]}, |
||
| 145 | {RIPPER_RUN_R2 + 3, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[2][0]}, |
||
| 146 | }, |
||
| 147 | { |
||
| 148 | {RIPPER_RUN_R3 + 0, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[3][1]}, |
||
| 149 | {RIPPER_RUN_R3 + 1, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[3][2]}, |
||
| 150 | {RIPPER_RUN_R3 + 2, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[3][3]}, |
||
| 151 | {RIPPER_RUN_R3 + 3, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[3][0]}, |
||
| 152 | }, |
||
| 153 | { |
||
| 154 | {RIPPER_RUN_R4 + 0, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[4][1]}, |
||
| 155 | {RIPPER_RUN_R4 + 1, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[4][2]}, |
||
| 156 | {RIPPER_RUN_R4 + 2, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[4][3]}, |
||
| 157 | {RIPPER_RUN_R4 + 3, RIPPER_RUN_RATE | SF_TIC_ADJUST, DoRipperMove, &s_RipperRun[4][0]}, |
||
| 158 | } |
||
| 159 | }; |
||
| 160 | |||
| 161 | |||
| 162 | STATEp sg_RipperRun[] = |
||
| 163 | { |
||
| 164 | &s_RipperRun[0][0], |
||
| 165 | &s_RipperRun[1][0], |
||
| 166 | &s_RipperRun[2][0], |
||
| 167 | &s_RipperRun[3][0], |
||
| 168 | &s_RipperRun[4][0] |
||
| 169 | }; |
||
| 170 | |||
| 171 | ////////////////////// |
||
| 172 | // |
||
| 173 | // RIPPER STAND |
||
| 174 | // |
||
| 175 | ////////////////////// |
||
| 176 | |||
| 177 | #define RIPPER_STAND_RATE 12 |
||
| 178 | |||
| 179 | STATE s_RipperStand[5][1] = |
||
| 180 | { |
||
| 181 | { |
||
| 182 | {RIPPER_STAND_R0 + 0, RIPPER_STAND_RATE, DoRipperMove, &s_RipperStand[0][0]}, |
||
| 183 | }, |
||
| 184 | { |
||
| 185 | {RIPPER_STAND_R1 + 0, RIPPER_STAND_RATE, DoRipperMove, &s_RipperStand[1][0]}, |
||
| 186 | }, |
||
| 187 | { |
||
| 188 | {RIPPER_STAND_R2 + 0, RIPPER_STAND_RATE, DoRipperMove, &s_RipperStand[2][0]}, |
||
| 189 | }, |
||
| 190 | { |
||
| 191 | {RIPPER_STAND_R3 + 0, RIPPER_STAND_RATE, DoRipperMove, &s_RipperStand[3][0]}, |
||
| 192 | }, |
||
| 193 | { |
||
| 194 | {RIPPER_STAND_R4 + 0, RIPPER_STAND_RATE, DoRipperMove, &s_RipperStand[4][0]}, |
||
| 195 | }, |
||
| 196 | }; |
||
| 197 | |||
| 198 | |||
| 199 | STATEp sg_RipperStand[] = |
||
| 200 | { |
||
| 201 | s_RipperStand[0], |
||
| 202 | s_RipperStand[1], |
||
| 203 | s_RipperStand[2], |
||
| 204 | s_RipperStand[3], |
||
| 205 | s_RipperStand[4] |
||
| 206 | }; |
||
| 207 | |||
| 208 | ////////////////////// |
||
| 209 | // |
||
| 210 | // RIPPER SWIPE |
||
| 211 | // |
||
| 212 | ////////////////////// |
||
| 213 | |||
| 214 | #define RIPPER_SWIPE_RATE 8 |
||
| 215 | ANIMATOR InitActorDecide; |
||
| 216 | ANIMATOR InitRipperSlash; |
||
| 217 | |||
| 218 | STATE s_RipperSwipe[5][8] = |
||
| 219 | { |
||
| 220 | { |
||
| 221 | {RIPPER_SWIPE_R0 + 0, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[0][1]}, |
||
| 222 | {RIPPER_SWIPE_R0 + 1, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[0][2]}, |
||
| 223 | {RIPPER_SWIPE_R0 + 1, 0 | SF_QUICK_CALL, InitRipperSlash, &s_RipperSwipe[0][3]}, |
||
| 224 | {RIPPER_SWIPE_R0 + 2, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[0][4]}, |
||
| 225 | {RIPPER_SWIPE_R0 + 3, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[0][5]}, |
||
| 226 | {RIPPER_SWIPE_R0 + 3, 0 | SF_QUICK_CALL, InitRipperSlash, &s_RipperSwipe[0][6]}, |
||
| 227 | {RIPPER_SWIPE_R0 + 3, 0 | SF_QUICK_CALL, InitActorDecide, &s_RipperSwipe[0][7]}, |
||
| 228 | {RIPPER_SWIPE_R0 + 3, RIPPER_SWIPE_RATE, DoRipperMove, &s_RipperSwipe[0][7]}, |
||
| 229 | }, |
||
| 230 | { |
||
| 231 | {RIPPER_SWIPE_R1 + 0, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[1][1]}, |
||
| 232 | {RIPPER_SWIPE_R1 + 1, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[1][2]}, |
||
| 233 | {RIPPER_SWIPE_R1 + 1, 0 | SF_QUICK_CALL, InitRipperSlash, &s_RipperSwipe[1][3]}, |
||
| 234 | {RIPPER_SWIPE_R1 + 2, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[1][4]}, |
||
| 235 | {RIPPER_SWIPE_R1 + 3, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[1][5]}, |
||
| 236 | {RIPPER_SWIPE_R1 + 3, 0 | SF_QUICK_CALL, InitRipperSlash, &s_RipperSwipe[1][6]}, |
||
| 237 | {RIPPER_SWIPE_R1 + 3, 0 | SF_QUICK_CALL, InitActorDecide, &s_RipperSwipe[1][7]}, |
||
| 238 | {RIPPER_SWIPE_R1 + 3, RIPPER_SWIPE_RATE, DoRipperMove, &s_RipperSwipe[1][7]}, |
||
| 239 | }, |
||
| 240 | { |
||
| 241 | {RIPPER_SWIPE_R2 + 0, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[2][1]}, |
||
| 242 | {RIPPER_SWIPE_R2 + 1, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[2][2]}, |
||
| 243 | {RIPPER_SWIPE_R2 + 1, 0 | SF_QUICK_CALL, InitRipperSlash, &s_RipperSwipe[2][3]}, |
||
| 244 | {RIPPER_SWIPE_R2 + 2, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[2][4]}, |
||
| 245 | {RIPPER_SWIPE_R2 + 3, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[2][5]}, |
||
| 246 | {RIPPER_SWIPE_R2 + 3, 0 | SF_QUICK_CALL, InitRipperSlash, &s_RipperSwipe[2][6]}, |
||
| 247 | {RIPPER_SWIPE_R2 + 3, 0 | SF_QUICK_CALL, InitActorDecide, &s_RipperSwipe[2][7]}, |
||
| 248 | {RIPPER_SWIPE_R2 + 3, RIPPER_SWIPE_RATE, DoRipperMove, &s_RipperSwipe[2][7]}, |
||
| 249 | }, |
||
| 250 | { |
||
| 251 | {RIPPER_SWIPE_R3 + 0, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[3][1]}, |
||
| 252 | {RIPPER_SWIPE_R3 + 1, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[3][2]}, |
||
| 253 | {RIPPER_SWIPE_R3 + 1, 0 | SF_QUICK_CALL, InitRipperSlash, &s_RipperSwipe[3][3]}, |
||
| 254 | {RIPPER_SWIPE_R3 + 2, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[3][4]}, |
||
| 255 | {RIPPER_SWIPE_R3 + 3, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[3][5]}, |
||
| 256 | {RIPPER_SWIPE_R3 + 3, 0 | SF_QUICK_CALL, InitRipperSlash, &s_RipperSwipe[3][6]}, |
||
| 257 | {RIPPER_SWIPE_R3 + 3, 0 | SF_QUICK_CALL, InitActorDecide, &s_RipperSwipe[3][7]}, |
||
| 258 | {RIPPER_SWIPE_R3 + 3, RIPPER_SWIPE_RATE, DoRipperMove, &s_RipperSwipe[3][7]}, |
||
| 259 | }, |
||
| 260 | { |
||
| 261 | {RIPPER_SWIPE_R4 + 0, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[4][1]}, |
||
| 262 | {RIPPER_SWIPE_R4 + 1, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[4][2]}, |
||
| 263 | {RIPPER_SWIPE_R4 + 1, 0 | SF_QUICK_CALL, InitRipperSlash, &s_RipperSwipe[4][3]}, |
||
| 264 | {RIPPER_SWIPE_R4 + 2, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[4][4]}, |
||
| 265 | {RIPPER_SWIPE_R4 + 3, RIPPER_SWIPE_RATE, NullRipper, &s_RipperSwipe[4][5]}, |
||
| 266 | {RIPPER_SWIPE_R4 + 3, 0 | SF_QUICK_CALL, InitRipperSlash, &s_RipperSwipe[4][6]}, |
||
| 267 | {RIPPER_SWIPE_R4 + 3, 0 | SF_QUICK_CALL, InitActorDecide, &s_RipperSwipe[4][7]}, |
||
| 268 | {RIPPER_SWIPE_R4 + 3, RIPPER_SWIPE_RATE, DoRipperMove, &s_RipperSwipe[4][7]}, |
||
| 269 | } |
||
| 270 | }; |
||
| 271 | |||
| 272 | |||
| 273 | STATEp sg_RipperSwipe[] = |
||
| 274 | { |
||
| 275 | &s_RipperSwipe[0][0], |
||
| 276 | &s_RipperSwipe[1][0], |
||
| 277 | &s_RipperSwipe[2][0], |
||
| 278 | &s_RipperSwipe[3][0], |
||
| 279 | &s_RipperSwipe[4][0] |
||
| 280 | }; |
||
| 281 | |||
| 282 | |||
| 283 | ////////////////////// |
||
| 284 | // |
||
| 285 | // RIPPER SPEW |
||
| 286 | // |
||
| 287 | ////////////////////// |
||
| 288 | |||
| 289 | #define RIPPER_SPEW_RATE 8 |
||
| 290 | ANIMATOR InitActorDecide; |
||
| 291 | ANIMATOR InitCoolgFire; |
||
| 292 | |||
| 293 | STATE s_RipperSpew[5][7] = |
||
| 294 | { |
||
| 295 | { |
||
| 296 | {RIPPER_SWIPE_R0 + 0, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[0][1]}, |
||
| 297 | {RIPPER_SWIPE_R0 + 1, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[0][2]}, |
||
| 298 | {RIPPER_SWIPE_R0 + 1, 0 | SF_QUICK_CALL, InitCoolgFire, &s_RipperSpew[0][3]}, |
||
| 299 | {RIPPER_SWIPE_R0 + 2, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[0][4]}, |
||
| 300 | {RIPPER_SWIPE_R0 + 3, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[0][5]}, |
||
| 301 | {RIPPER_SWIPE_R0 + 3, 0 | SF_QUICK_CALL, InitActorDecide, &s_RipperSpew[0][6]}, |
||
| 302 | {RIPPER_SWIPE_R0 + 3, RIPPER_SPEW_RATE, DoRipperMove, &s_RipperSpew[0][6]}, |
||
| 303 | }, |
||
| 304 | { |
||
| 305 | {RIPPER_SWIPE_R1 + 0, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[1][1]}, |
||
| 306 | {RIPPER_SWIPE_R1 + 1, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[1][2]}, |
||
| 307 | {RIPPER_SWIPE_R1 + 1, 0 | SF_QUICK_CALL, InitCoolgFire, &s_RipperSpew[1][3]}, |
||
| 308 | {RIPPER_SWIPE_R1 + 2, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[1][4]}, |
||
| 309 | {RIPPER_SWIPE_R1 + 3, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[1][5]}, |
||
| 310 | {RIPPER_SWIPE_R1 + 3, 0 | SF_QUICK_CALL, InitActorDecide, &s_RipperSpew[1][6]}, |
||
| 311 | {RIPPER_SWIPE_R1 + 3, RIPPER_SPEW_RATE, DoRipperMove, &s_RipperSpew[1][6]}, |
||
| 312 | }, |
||
| 313 | { |
||
| 314 | {RIPPER_SWIPE_R2 + 0, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[2][1]}, |
||
| 315 | {RIPPER_SWIPE_R2 + 1, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[2][2]}, |
||
| 316 | {RIPPER_SWIPE_R2 + 1, 0 | SF_QUICK_CALL, InitCoolgFire, &s_RipperSpew[2][3]}, |
||
| 317 | {RIPPER_SWIPE_R2 + 2, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[2][4]}, |
||
| 318 | {RIPPER_SWIPE_R2 + 3, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[2][5]}, |
||
| 319 | {RIPPER_SWIPE_R2 + 3, 0 | SF_QUICK_CALL, InitActorDecide, &s_RipperSpew[2][6]}, |
||
| 320 | {RIPPER_SWIPE_R2 + 3, RIPPER_SPEW_RATE, DoRipperMove, &s_RipperSpew[2][6]}, |
||
| 321 | }, |
||
| 322 | { |
||
| 323 | {RIPPER_SWIPE_R3 + 0, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[3][1]}, |
||
| 324 | {RIPPER_SWIPE_R3 + 1, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[3][2]}, |
||
| 325 | {RIPPER_SWIPE_R3 + 1, 0 | SF_QUICK_CALL, InitCoolgFire, &s_RipperSpew[3][3]}, |
||
| 326 | {RIPPER_SWIPE_R3 + 2, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[3][4]}, |
||
| 327 | {RIPPER_SWIPE_R3 + 3, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[3][5]}, |
||
| 328 | {RIPPER_SWIPE_R3 + 3, 0 | SF_QUICK_CALL, InitActorDecide, &s_RipperSpew[3][6]}, |
||
| 329 | {RIPPER_SWIPE_R3 + 3, RIPPER_SPEW_RATE, DoRipperMove, &s_RipperSpew[3][6]}, |
||
| 330 | }, |
||
| 331 | { |
||
| 332 | {RIPPER_SWIPE_R4 + 0, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[4][1]}, |
||
| 333 | {RIPPER_SWIPE_R4 + 1, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[4][2]}, |
||
| 334 | {RIPPER_SWIPE_R4 + 1, 0 | SF_QUICK_CALL, InitCoolgFire, &s_RipperSpew[4][3]}, |
||
| 335 | {RIPPER_SWIPE_R4 + 2, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[4][4]}, |
||
| 336 | {RIPPER_SWIPE_R4 + 3, RIPPER_SPEW_RATE, NullRipper, &s_RipperSpew[4][5]}, |
||
| 337 | {RIPPER_SWIPE_R4 + 3, 0 | SF_QUICK_CALL, InitActorDecide, &s_RipperSpew[4][6]}, |
||
| 338 | {RIPPER_SWIPE_R4 + 3, RIPPER_SPEW_RATE, DoRipperMove, &s_RipperSpew[4][6]}, |
||
| 339 | } |
||
| 340 | }; |
||
| 341 | |||
| 342 | |||
| 343 | STATEp sg_RipperSpew[] = |
||
| 344 | { |
||
| 345 | &s_RipperSpew[0][0], |
||
| 346 | &s_RipperSpew[1][0], |
||
| 347 | &s_RipperSpew[2][0], |
||
| 348 | &s_RipperSpew[3][0], |
||
| 349 | &s_RipperSpew[4][0] |
||
| 350 | }; |
||
| 351 | |||
| 352 | |||
| 353 | ////////////////////// |
||
| 354 | // |
||
| 355 | // RIPPER HEART - show players heart |
||
| 356 | // |
||
| 357 | ////////////////////// |
||
| 358 | |||
| 359 | #define RIPPER_HEART_RATE 14 |
||
| 360 | ANIMATOR DoRipperStandHeart; |
||
| 361 | |||
| 362 | STATE s_RipperHeart[5][4] = |
||
| 363 | { |
||
| 364 | { |
||
| 365 | {RIPPER_HEART_R0 + 0, RIPPER_HEART_RATE, DoRipperStandHeart, &s_RipperHeart[0][0]}, |
||
| 366 | }, |
||
| 367 | { |
||
| 368 | {RIPPER_HEART_R1 + 0, RIPPER_HEART_RATE, DoRipperStandHeart, &s_RipperHeart[1][0]}, |
||
| 369 | }, |
||
| 370 | { |
||
| 371 | {RIPPER_HEART_R2 + 0, RIPPER_HEART_RATE, DoRipperStandHeart, &s_RipperHeart[2][0]}, |
||
| 372 | }, |
||
| 373 | { |
||
| 374 | {RIPPER_HEART_R3 + 0, RIPPER_HEART_RATE, DoRipperStandHeart, &s_RipperHeart[3][0]}, |
||
| 375 | }, |
||
| 376 | { |
||
| 377 | {RIPPER_HEART_R4 + 0, RIPPER_HEART_RATE, DoRipperStandHeart, &s_RipperHeart[4][0]}, |
||
| 378 | } |
||
| 379 | }; |
||
| 380 | |||
| 381 | STATEp sg_RipperHeart[] = |
||
| 382 | { |
||
| 383 | &s_RipperHeart[0][0], |
||
| 384 | &s_RipperHeart[1][0], |
||
| 385 | &s_RipperHeart[2][0], |
||
| 386 | &s_RipperHeart[3][0], |
||
| 387 | &s_RipperHeart[4][0] |
||
| 388 | }; |
||
| 389 | |||
| 390 | ////////////////////// |
||
| 391 | // |
||
| 392 | // RIPPER HANG |
||
| 393 | // |
||
| 394 | ////////////////////// |
||
| 395 | |||
| 396 | #define RIPPER_HANG_RATE 14 |
||
| 397 | ANIMATOR DoRipperHang; |
||
| 398 | |||
| 399 | STATE s_RipperHang[5][4] = |
||
| 400 | { |
||
| 401 | { |
||
| 402 | {RIPPER_HANG_R0 + 0, RIPPER_HANG_RATE, DoRipperHang, &s_RipperHang[0][0]}, |
||
| 403 | }, |
||
| 404 | { |
||
| 405 | {RIPPER_HANG_R1 + 0, RIPPER_HANG_RATE, DoRipperHang, &s_RipperHang[1][0]}, |
||
| 406 | }, |
||
| 407 | { |
||
| 408 | {RIPPER_HANG_R2 + 0, RIPPER_HANG_RATE, DoRipperHang, &s_RipperHang[2][0]}, |
||
| 409 | }, |
||
| 410 | { |
||
| 411 | {RIPPER_HANG_R3 + 0, RIPPER_HANG_RATE, DoRipperHang, &s_RipperHang[3][0]}, |
||
| 412 | }, |
||
| 413 | { |
||
| 414 | {RIPPER_HANG_R4 + 0, RIPPER_HANG_RATE, DoRipperHang, &s_RipperHang[4][0]}, |
||
| 415 | } |
||
| 416 | }; |
||
| 417 | |||
| 418 | |||
| 419 | STATEp sg_RipperHang[] = |
||
| 420 | { |
||
| 421 | &s_RipperHang[0][0], |
||
| 422 | &s_RipperHang[1][0], |
||
| 423 | &s_RipperHang[2][0], |
||
| 424 | &s_RipperHang[3][0], |
||
| 425 | &s_RipperHang[4][0] |
||
| 426 | }; |
||
| 427 | |||
| 428 | |||
| 429 | ////////////////////// |
||
| 430 | // |
||
| 431 | // RIPPER PAIN |
||
| 432 | // |
||
| 433 | ////////////////////// |
||
| 434 | |||
| 435 | #define RIPPER_PAIN_RATE 38 |
||
| 436 | ANIMATOR DoRipperPain; |
||
| 437 | |||
| 438 | STATE s_RipperPain[5][1] = |
||
| 439 | { |
||
| 440 | { |
||
| 441 | {RIPPER_JUMP_R0 + 0, RIPPER_PAIN_RATE, DoRipperPain, &s_RipperPain[0][0]}, |
||
| 442 | }, |
||
| 443 | { |
||
| 444 | {RIPPER_JUMP_R0 + 0, RIPPER_PAIN_RATE, DoRipperPain, &s_RipperPain[1][0]}, |
||
| 445 | }, |
||
| 446 | { |
||
| 447 | {RIPPER_JUMP_R0 + 0, RIPPER_PAIN_RATE, DoRipperPain, &s_RipperPain[2][0]}, |
||
| 448 | }, |
||
| 449 | { |
||
| 450 | {RIPPER_JUMP_R0 + 0, RIPPER_PAIN_RATE, DoRipperPain, &s_RipperPain[3][0]}, |
||
| 451 | }, |
||
| 452 | { |
||
| 453 | {RIPPER_JUMP_R0 + 0, RIPPER_PAIN_RATE, DoRipperPain, &s_RipperPain[4][0]}, |
||
| 454 | } |
||
| 455 | }; |
||
| 456 | |||
| 457 | STATEp sg_RipperPain[] = |
||
| 458 | { |
||
| 459 | &s_RipperPain[0][0], |
||
| 460 | &s_RipperPain[1][0], |
||
| 461 | &s_RipperPain[2][0], |
||
| 462 | &s_RipperPain[3][0], |
||
| 463 | &s_RipperPain[4][0] |
||
| 464 | }; |
||
| 465 | |||
| 466 | ////////////////////// |
||
| 467 | // |
||
| 468 | // RIPPER JUMP |
||
| 469 | // |
||
| 470 | ////////////////////// |
||
| 471 | |||
| 472 | #define RIPPER_JUMP_RATE 25 |
||
| 473 | |||
| 474 | STATE s_RipperJump[5][6] = |
||
| 475 | { |
||
| 476 | { |
||
| 477 | {RIPPER_JUMP_R0 + 0, RIPPER_JUMP_RATE, NullRipper, &s_RipperJump[0][1]}, |
||
| 478 | {RIPPER_JUMP_R0 + 1, RIPPER_JUMP_RATE, DoRipperMoveJump, &s_RipperJump[0][1]}, |
||
| 479 | }, |
||
| 480 | { |
||
| 481 | {RIPPER_JUMP_R1 + 0, RIPPER_JUMP_RATE, NullRipper, &s_RipperJump[1][1]}, |
||
| 482 | {RIPPER_JUMP_R1 + 1, RIPPER_JUMP_RATE, DoRipperMoveJump, &s_RipperJump[1][1]}, |
||
| 483 | }, |
||
| 484 | { |
||
| 485 | {RIPPER_JUMP_R2 + 0, RIPPER_JUMP_RATE, NullRipper, &s_RipperJump[2][1]}, |
||
| 486 | {RIPPER_JUMP_R2 + 1, RIPPER_JUMP_RATE, DoRipperMoveJump, &s_RipperJump[2][1]}, |
||
| 487 | }, |
||
| 488 | { |
||
| 489 | {RIPPER_JUMP_R3 + 0, RIPPER_JUMP_RATE, NullRipper, &s_RipperJump[3][1]}, |
||
| 490 | {RIPPER_JUMP_R3 + 1, RIPPER_JUMP_RATE, DoRipperMoveJump, &s_RipperJump[3][1]}, |
||
| 491 | }, |
||
| 492 | { |
||
| 493 | {RIPPER_JUMP_R4 + 0, RIPPER_JUMP_RATE, NullRipper, &s_RipperJump[4][1]}, |
||
| 494 | {RIPPER_JUMP_R4 + 1, RIPPER_JUMP_RATE, DoRipperMoveJump, &s_RipperJump[4][1]}, |
||
| 495 | } |
||
| 496 | }; |
||
| 497 | |||
| 498 | |||
| 499 | STATEp sg_RipperJump[] = |
||
| 500 | { |
||
| 501 | &s_RipperJump[0][0], |
||
| 502 | &s_RipperJump[1][0], |
||
| 503 | &s_RipperJump[2][0], |
||
| 504 | &s_RipperJump[3][0], |
||
| 505 | &s_RipperJump[4][0] |
||
| 506 | }; |
||
| 507 | |||
| 508 | |||
| 509 | ////////////////////// |
||
| 510 | // |
||
| 511 | // RIPPER FALL |
||
| 512 | // |
||
| 513 | ////////////////////// |
||
| 514 | |||
| 515 | #define RIPPER_FALL_RATE 25 |
||
| 516 | |||
| 517 | STATE s_RipperFall[5][6] = |
||
| 518 | { |
||
| 519 | { |
||
| 520 | {RIPPER_FALL_R0 + 0, RIPPER_FALL_RATE, DoRipperMoveJump, &s_RipperFall[0][0]}, |
||
| 521 | }, |
||
| 522 | { |
||
| 523 | {RIPPER_FALL_R1 + 0, RIPPER_FALL_RATE, DoRipperMoveJump, &s_RipperFall[1][0]}, |
||
| 524 | }, |
||
| 525 | { |
||
| 526 | {RIPPER_FALL_R2 + 0, RIPPER_FALL_RATE, DoRipperMoveJump, &s_RipperFall[2][0]}, |
||
| 527 | }, |
||
| 528 | { |
||
| 529 | {RIPPER_FALL_R3 + 0, RIPPER_FALL_RATE, DoRipperMoveJump, &s_RipperFall[3][0]}, |
||
| 530 | }, |
||
| 531 | { |
||
| 532 | {RIPPER_FALL_R4 + 0, RIPPER_FALL_RATE, DoRipperMoveJump, &s_RipperFall[4][0]}, |
||
| 533 | } |
||
| 534 | }; |
||
| 535 | |||
| 536 | |||
| 537 | STATEp sg_RipperFall[] = |
||
| 538 | { |
||
| 539 | &s_RipperFall[0][0], |
||
| 540 | &s_RipperFall[1][0], |
||
| 541 | &s_RipperFall[2][0], |
||
| 542 | &s_RipperFall[3][0], |
||
| 543 | &s_RipperFall[4][0] |
||
| 544 | }; |
||
| 545 | |||
| 546 | |||
| 547 | ////////////////////// |
||
| 548 | // |
||
| 549 | // RIPPER JUMP ATTACK |
||
| 550 | // |
||
| 551 | ////////////////////// |
||
| 552 | |||
| 553 | #define RIPPER_JUMP_ATTACK_RATE 35 |
||
| 554 | int DoRipperBeginJumpAttack(short SpriteNum); |
||
| 555 | |||
| 556 | STATE s_RipperJumpAttack[5][6] = |
||
| 557 | { |
||
| 558 | { |
||
| 559 | {RIPPER_JUMP_R0 + 0, RIPPER_JUMP_ATTACK_RATE, NullRipper, &s_RipperJumpAttack[0][1]}, |
||
| 560 | {RIPPER_JUMP_R0 + 0, 0 | SF_QUICK_CALL, DoRipperBeginJumpAttack, &s_RipperJumpAttack[0][2]}, |
||
| 561 | {RIPPER_JUMP_R0 + 1, RIPPER_JUMP_ATTACK_RATE, DoRipperMoveJump, &s_RipperJumpAttack[0][2]}, |
||
| 562 | }, |
||
| 563 | { |
||
| 564 | {RIPPER_JUMP_R1 + 0, RIPPER_JUMP_ATTACK_RATE, NullRipper, &s_RipperJumpAttack[1][1]}, |
||
| 565 | {RIPPER_JUMP_R1 + 0, 0 | SF_QUICK_CALL, DoRipperBeginJumpAttack, &s_RipperJumpAttack[1][2]}, |
||
| 566 | {RIPPER_JUMP_R1 + 1, RIPPER_JUMP_ATTACK_RATE, DoRipperMoveJump, &s_RipperJumpAttack[1][2]}, |
||
| 567 | }, |
||
| 568 | { |
||
| 569 | {RIPPER_JUMP_R2 + 0, RIPPER_JUMP_ATTACK_RATE, NullRipper, &s_RipperJumpAttack[2][1]}, |
||
| 570 | {RIPPER_JUMP_R2 + 0, 0 | SF_QUICK_CALL, DoRipperBeginJumpAttack, &s_RipperJumpAttack[2][2]}, |
||
| 571 | {RIPPER_JUMP_R2 + 1, RIPPER_JUMP_ATTACK_RATE, DoRipperMoveJump, &s_RipperJumpAttack[2][2]}, |
||
| 572 | }, |
||
| 573 | { |
||
| 574 | {RIPPER_JUMP_R3 + 0, RIPPER_JUMP_ATTACK_RATE, NullRipper, &s_RipperJumpAttack[3][1]}, |
||
| 575 | {RIPPER_JUMP_R3 + 0, 0 | SF_QUICK_CALL, DoRipperBeginJumpAttack, &s_RipperJumpAttack[3][2]}, |
||
| 576 | {RIPPER_JUMP_R3 + 1, RIPPER_JUMP_ATTACK_RATE, DoRipperMoveJump, &s_RipperJumpAttack[3][2]}, |
||
| 577 | }, |
||
| 578 | { |
||
| 579 | {RIPPER_JUMP_R4 + 0, RIPPER_JUMP_ATTACK_RATE, NullRipper, &s_RipperJumpAttack[4][1]}, |
||
| 580 | {RIPPER_JUMP_R4 + 0, 0 | SF_QUICK_CALL, DoRipperBeginJumpAttack, &s_RipperJumpAttack[4][2]}, |
||
| 581 | {RIPPER_JUMP_R4 + 1, RIPPER_JUMP_ATTACK_RATE, DoRipperMoveJump, &s_RipperJumpAttack[4][2]}, |
||
| 582 | } |
||
| 583 | }; |
||
| 584 | |||
| 585 | |||
| 586 | STATEp sg_RipperJumpAttack[] = |
||
| 587 | { |
||
| 588 | &s_RipperJumpAttack[0][0], |
||
| 589 | &s_RipperJumpAttack[1][0], |
||
| 590 | &s_RipperJumpAttack[2][0], |
||
| 591 | &s_RipperJumpAttack[3][0], |
||
| 592 | &s_RipperJumpAttack[4][0] |
||
| 593 | }; |
||
| 594 | |||
| 595 | |||
| 596 | ////////////////////// |
||
| 597 | // |
||
| 598 | // RIPPER HANG_JUMP |
||
| 599 | // |
||
| 600 | ////////////////////// |
||
| 601 | |||
| 602 | #define RIPPER_HANG_JUMP_RATE 20 |
||
| 603 | |||
| 604 | STATE s_RipperHangJump[5][6] = |
||
| 605 | { |
||
| 606 | { |
||
| 607 | {RIPPER_JUMP_R0 + 0, RIPPER_HANG_JUMP_RATE, NullRipper, &s_RipperHangJump[0][1]}, |
||
| 608 | {RIPPER_JUMP_R0 + 1, RIPPER_HANG_JUMP_RATE, DoRipperHangJF, &s_RipperHangJump[0][1]}, |
||
| 609 | }, |
||
| 610 | { |
||
| 611 | {RIPPER_JUMP_R1 + 0, RIPPER_HANG_JUMP_RATE, NullRipper, &s_RipperHangJump[1][1]}, |
||
| 612 | {RIPPER_JUMP_R1 + 1, RIPPER_HANG_JUMP_RATE, DoRipperHangJF, &s_RipperHangJump[1][1]}, |
||
| 613 | }, |
||
| 614 | { |
||
| 615 | {RIPPER_JUMP_R2 + 0, RIPPER_HANG_JUMP_RATE, NullRipper, &s_RipperHangJump[2][1]}, |
||
| 616 | {RIPPER_JUMP_R2 + 1, RIPPER_HANG_JUMP_RATE, DoRipperHangJF, &s_RipperHangJump[2][1]}, |
||
| 617 | }, |
||
| 618 | { |
||
| 619 | {RIPPER_JUMP_R3 + 0, RIPPER_HANG_JUMP_RATE, NullRipper, &s_RipperHangJump[3][1]}, |
||
| 620 | {RIPPER_JUMP_R3 + 1, RIPPER_HANG_JUMP_RATE, DoRipperHangJF, &s_RipperHangJump[3][1]}, |
||
| 621 | }, |
||
| 622 | { |
||
| 623 | {RIPPER_JUMP_R4 + 0, RIPPER_HANG_JUMP_RATE, NullRipper, &s_RipperHangJump[4][1]}, |
||
| 624 | {RIPPER_JUMP_R4 + 1, RIPPER_HANG_JUMP_RATE, DoRipperHangJF, &s_RipperHangJump[4][1]}, |
||
| 625 | } |
||
| 626 | }; |
||
| 627 | |||
| 628 | |||
| 629 | STATEp sg_RipperHangJump[] = |
||
| 630 | { |
||
| 631 | &s_RipperHangJump[0][0], |
||
| 632 | &s_RipperHangJump[1][0], |
||
| 633 | &s_RipperHangJump[2][0], |
||
| 634 | &s_RipperHangJump[3][0], |
||
| 635 | &s_RipperHangJump[4][0] |
||
| 636 | }; |
||
| 637 | |||
| 638 | ////////////////////// |
||
| 639 | // |
||
| 640 | // RIPPER HANG_FALL |
||
| 641 | // |
||
| 642 | ////////////////////// |
||
| 643 | |||
| 644 | #define RIPPER_FALL_RATE 25 |
||
| 645 | |||
| 646 | STATE s_RipperHangFall[5][6] = |
||
| 647 | { |
||
| 648 | { |
||
| 649 | {RIPPER_FALL_R0 + 0, RIPPER_FALL_RATE, DoRipperHangJF, &s_RipperHangFall[0][0]}, |
||
| 650 | }, |
||
| 651 | { |
||
| 652 | {RIPPER_FALL_R1 + 0, RIPPER_FALL_RATE, DoRipperHangJF, &s_RipperHangFall[1][0]}, |
||
| 653 | }, |
||
| 654 | { |
||
| 655 | {RIPPER_FALL_R2 + 0, RIPPER_FALL_RATE, DoRipperHangJF, &s_RipperHangFall[2][0]}, |
||
| 656 | }, |
||
| 657 | { |
||
| 658 | {RIPPER_FALL_R3 + 0, RIPPER_FALL_RATE, DoRipperHangJF, &s_RipperHangFall[3][0]}, |
||
| 659 | }, |
||
| 660 | { |
||
| 661 | {RIPPER_FALL_R4 + 0, RIPPER_FALL_RATE, DoRipperHangJF, &s_RipperHangFall[4][0]}, |
||
| 662 | } |
||
| 663 | }; |
||
| 664 | |||
| 665 | |||
| 666 | STATEp sg_RipperHangFall[] = |
||
| 667 | { |
||
| 668 | &s_RipperHangFall[0][0], |
||
| 669 | &s_RipperHangFall[1][0], |
||
| 670 | &s_RipperHangFall[2][0], |
||
| 671 | &s_RipperHangFall[3][0], |
||
| 672 | &s_RipperHangFall[4][0] |
||
| 673 | }; |
||
| 674 | |||
| 675 | |||
| 676 | |||
| 677 | ////////////////////// |
||
| 678 | // |
||
| 679 | // RIPPER DIE |
||
| 680 | // |
||
| 681 | ////////////////////// |
||
| 682 | |||
| 683 | #define RIPPER_DIE_RATE 16 |
||
| 684 | |||
| 685 | STATE s_RipperDie[] = |
||
| 686 | { |
||
| 687 | {RIPPER_DIE + 0, RIPPER_DIE_RATE, NullRipper, &s_RipperDie[1]}, |
||
| 688 | {RIPPER_DIE + 1, RIPPER_DIE_RATE, NullRipper, &s_RipperDie[2]}, |
||
| 689 | {RIPPER_DIE + 2, RIPPER_DIE_RATE, NullRipper, &s_RipperDie[3]}, |
||
| 690 | {RIPPER_DIE + 3, RIPPER_DIE_RATE, NullRipper, &s_RipperDie[4]}, |
||
| 691 | {RIPPER_DEAD, RIPPER_DIE_RATE, DoActorDebris, &s_RipperDie[4]}, |
||
| 692 | }; |
||
| 693 | |||
| 694 | #define RIPPER_DEAD_RATE 8 |
||
| 695 | |||
| 696 | STATE s_RipperDead[] = |
||
| 697 | { |
||
| 698 | {RIPPER_DIE + 2, RIPPER_DEAD_RATE, NullAnimator, &s_RipperDead[1]}, |
||
| 699 | {RIPPER_DIE + 3, RIPPER_DEAD_RATE, NullAnimator, &s_RipperDead[2]}, |
||
| 700 | {RIPPER_DEAD, SF_QUICK_CALL, QueueFloorBlood, &s_RipperDead[3]}, |
||
| 701 | {RIPPER_DEAD, RIPPER_DEAD_RATE, DoActorDebris, &s_RipperDead[3]}, |
||
| 702 | }; |
||
| 703 | |||
| 704 | STATEp sg_RipperDie[] = |
||
| 705 | { |
||
| 706 | s_RipperDie |
||
| 707 | }; |
||
| 708 | |||
| 709 | STATEp sg_RipperDead[] = |
||
| 710 | { |
||
| 711 | s_RipperDead |
||
| 712 | }; |
||
| 713 | |||
| 714 | STATE s_RipperDeathJump[] = |
||
| 715 | { |
||
| 716 | {RIPPER_DIE + 0, RIPPER_DIE_RATE, DoActorDeathMove, &s_RipperDeathJump[0]} |
||
| 717 | }; |
||
| 718 | |||
| 719 | STATE s_RipperDeathFall[] = |
||
| 720 | { |
||
| 721 | {RIPPER_DIE + 1, RIPPER_DIE_RATE, DoActorDeathMove, &s_RipperDeathFall[0]} |
||
| 722 | }; |
||
| 723 | |||
| 724 | |||
| 725 | STATEp sg_RipperDeathJump[] = |
||
| 726 | { |
||
| 727 | s_RipperDeathJump |
||
| 728 | }; |
||
| 729 | |||
| 730 | STATEp sg_RipperDeathFall[] = |
||
| 731 | { |
||
| 732 | s_RipperDeathFall |
||
| 733 | }; |
||
| 734 | |||
| 735 | |||
| 736 | /* |
||
| 737 | STATEp *Stand[MAX_WEAPONS]; |
||
| 738 | STATEp *Run; |
||
| 739 | STATEp *Jump; |
||
| 740 | STATEp *Fall; |
||
| 741 | STATEp *Crawl; |
||
| 742 | STATEp *Swim; |
||
| 743 | STATEp *Fly; |
||
| 744 | STATEp *Rise; |
||
| 745 | STATEp *Sit; |
||
| 746 | STATEp *Look; |
||
| 747 | STATEp *Climb; |
||
| 748 | STATEp *Pain; |
||
| 749 | STATEp *Death1; |
||
| 750 | STATEp *Death2; |
||
| 751 | STATEp *Dead; |
||
| 752 | STATEp *DeathJump; |
||
| 753 | STATEp *DeathFall; |
||
| 754 | STATEp *CloseAttack[2]; |
||
| 755 | STATEp *Attack[6]; |
||
| 756 | STATEp *Special[2]; |
||
| 757 | */ |
||
| 758 | |||
| 759 | |||
| 760 | ACTOR_ACTION_SET RipperActionSet = |
||
| 761 | { |
||
| 762 | sg_RipperStand, |
||
| 763 | sg_RipperRun, |
||
| 764 | sg_RipperJump, |
||
| 765 | sg_RipperFall, |
||
| 766 | NULL, // sg_RipperCrawl, |
||
| 767 | NULL, // sg_RipperSwim, |
||
| 768 | NULL, // sg_RipperFly, |
||
| 769 | NULL, // sg_RipperRise, |
||
| 770 | NULL, // sg_RipperSit, |
||
| 771 | NULL, // sg_RipperLook, |
||
| 772 | NULL, // climb |
||
| 773 | sg_RipperPain, |
||
| 774 | sg_RipperDie, |
||
| 775 | NULL, // sg_RipperHariKari, |
||
| 776 | sg_RipperDead, |
||
| 777 | sg_RipperDeathJump, |
||
| 778 | sg_RipperDeathFall, |
||
| 779 | {sg_RipperSwipe,sg_RipperSpew}, |
||
| 780 | {800,1024}, |
||
| 781 | {sg_RipperJumpAttack, sg_RipperSpew}, |
||
| 782 | {400, 1024}, |
||
| 783 | {sg_RipperHeart, sg_RipperHang}, |
||
| 784 | NULL, |
||
| 785 | NULL |
||
| 786 | }; |
||
| 787 | |||
| 788 | ACTOR_ACTION_SET RipperBrownActionSet = |
||
| 789 | { |
||
| 790 | sg_RipperStand, |
||
| 791 | sg_RipperRun, |
||
| 792 | sg_RipperJump, |
||
| 793 | sg_RipperFall, |
||
| 794 | NULL, // sg_RipperCrawl, |
||
| 795 | NULL, // sg_RipperSwim, |
||
| 796 | NULL, // sg_RipperFly, |
||
| 797 | NULL, // sg_RipperRise, |
||
| 798 | NULL, // sg_RipperSit, |
||
| 799 | NULL, // sg_RipperLook, |
||
| 800 | NULL, // climb |
||
| 801 | sg_RipperPain, // pain |
||
| 802 | sg_RipperDie, |
||
| 803 | NULL, // sg_RipperHariKari, |
||
| 804 | sg_RipperDead, |
||
| 805 | sg_RipperDeathJump, |
||
| 806 | sg_RipperDeathFall, |
||
| 807 | {sg_RipperSwipe}, |
||
| 808 | {1024}, |
||
| 809 | {sg_RipperJumpAttack, sg_RipperSwipe}, |
||
| 810 | {800, 1024}, |
||
| 811 | {sg_RipperHeart, sg_RipperHang}, |
||
| 812 | NULL, |
||
| 813 | NULL |
||
| 814 | }; |
||
| 815 | |||
| 816 | int |
||
| 817 | SetupRipper(short SpriteNum) |
||
| 818 | { |
||
| 819 | SPRITEp sp = &sprite[SpriteNum]; |
||
| 820 | USERp u; |
||
| 821 | ANIMATOR DoActorDecide; |
||
| 822 | |||
| 823 | if (TEST(sp->cstat, CSTAT_SPRITE_RESTORE)) |
||
| 824 | { |
||
| 825 | u = User[SpriteNum]; |
||
| 826 | ASSERT(u); |
||
| 827 | } |
||
| 828 | else |
||
| 829 | { |
||
| 830 | User[SpriteNum] = u = SpawnUser(SpriteNum, RIPPER_RUN_R0, s_RipperRun[0]); |
||
| 831 | u->Health = HEALTH_RIPPER/2; // Baby rippers are weaker |
||
| 832 | } |
||
| 833 | |||
| 834 | ChangeState(SpriteNum, s_RipperRun[0]); |
||
| 835 | u->Attrib = &RipperAttrib; |
||
| 836 | DoActorSetSpeed(SpriteNum, FAST_SPEED); |
||
| 837 | u->StateEnd = s_RipperDie; |
||
| 838 | u->Rot = sg_RipperRun; |
||
| 839 | sp->xrepeat = 64; |
||
| 840 | sp->yrepeat = 64; |
||
| 841 | |||
| 842 | if (sp->pal == PALETTE_BROWN_RIPPER) |
||
| 843 | { |
||
| 844 | EnemyDefaults(SpriteNum, &RipperBrownActionSet, &RipperPersonality); |
||
| 845 | sp->xrepeat = 106; |
||
| 846 | sp->yrepeat = 90; |
||
| 847 | |||
| 848 | if (!TEST(sp->cstat, CSTAT_SPRITE_RESTORE)) |
||
| 849 | u->Health = HEALTH_MOMMA_RIPPER; |
||
| 850 | |||
| 851 | sp->clipdist += 128 >> 2; |
||
| 852 | } |
||
| 853 | else |
||
| 854 | { |
||
| 855 | EnemyDefaults(SpriteNum, &RipperActionSet, &RipperPersonality); |
||
| 856 | } |
||
| 857 | |||
| 858 | SET(u->Flags, SPR_XFLIP_TOGGLE); |
||
| 859 | |||
| 860 | return 0; |
||
| 861 | } |
||
| 862 | |||
| 863 | int |
||
| 864 | GetJumpHeight(short jump_speed, short jump_grav) |
||
| 865 | { |
||
| 866 | int jump_iterations; |
||
| 867 | int height; |
||
| 868 | |||
| 869 | jump_speed = labs(jump_speed); |
||
| 870 | |||
| 871 | jump_iterations = jump_speed / (jump_grav * ACTORMOVETICS); |
||
| 872 | |||
| 873 | height = jump_speed * jump_iterations * ACTORMOVETICS; |
||
| 874 | |||
| 875 | height = DIV256(height); |
||
| 876 | |||
| 877 | return DIV2(height); |
||
| 878 | } |
||
| 879 | |||
| 880 | int |
||
| 881 | PickJumpSpeed(short SpriteNum, int pix_height) |
||
| 882 | { |
||
| 883 | USERp u = User[SpriteNum]; |
||
| 884 | |||
| 885 | //ASSERT(pix_height < 128); |
||
| 886 | |||
| 887 | u->jump_speed = -600; |
||
| 888 | u->jump_grav = 8; |
||
| 889 | |||
| 890 | while (TRUE) |
||
| 891 | { |
||
| 892 | if (GetJumpHeight(u->jump_speed, u->jump_grav) > pix_height + 20) |
||
| 893 | break; |
||
| 894 | |||
| 895 | u->jump_speed -= 100; |
||
| 896 | |||
| 897 | ASSERT(u->jump_speed > -3000); |
||
| 898 | } |
||
| 899 | |||
| 900 | return u->jump_speed; |
||
| 901 | } |
||
| 902 | |||
| 903 | |||
| 904 | int |
||
| 905 | PickJumpMaxSpeed(short SpriteNum, short max_speed) |
||
| 906 | { |
||
| 907 | SPRITEp sp = &sprite[SpriteNum]; |
||
| 908 | USERp u = User[SpriteNum]; |
||
| 909 | int zh; |
||
| 910 | |||
| 911 | ASSERT(max_speed < 0); |
||
| 912 | |||
| 913 | u->jump_speed = max_speed; |
||
| 914 | u->jump_grav = 8; |
||
| 915 | |||
| 916 | zh = SPRITEp_TOS(sp); |
||
| 917 | |||
| 918 | while (TRUE) |
||
| 919 | { |
||
| 920 | if (zh - Z(GetJumpHeight(u->jump_speed, u->jump_grav)) - Z(16) > u->hiz) |
||
| 921 | break; |
||
| 922 | |||
| 923 | u->jump_speed += 100; |
||
| 924 | |||
| 925 | if (u->jump_speed > -200) |
||
| 926 | break; |
||
| 927 | } |
||
| 928 | |||
| 929 | return u->jump_speed; |
||
| 930 | } |
||
| 931 | |||
| 932 | |||
| 933 | // |
||
| 934 | // HANGING - Jumping/Falling/Stationary |
||
| 935 | // |
||
| 936 | |||
| 937 | int |
||
| 938 | InitRipperHang(short SpriteNum) |
||
| 939 | { |
||
| 940 | SPRITEp sp = &sprite[SpriteNum]; |
||
| 941 | USERp u = User[SpriteNum]; |
||
| 942 | int dist; |
||
| 943 | |||
| 5202 | hendricks2 | 944 | hitdata_t hitinfo = { { 0, 0, 0 }, -2, 0, -2 }; |
| 5196 | hendricks2 | 945 | |
| 5198 | hendricks2 | 946 | SWBOOL Found = FALSE; |
| 5196 | hendricks2 | 947 | short dang, tang; |
| 948 | |||
| 949 | for (dang = 0; dang < 2048; dang += 128) |
||
| 950 | { |
||
| 951 | tang = NORM_ANGLE(sp->ang + dang); |
||
| 952 | |||
| 953 | FAFhitscan(sp->x, sp->y, sp->z - SPRITEp_SIZE_Z(sp), sp->sectnum, // Start position |
||
| 954 | sintable[NORM_ANGLE(tang + 512)], // X vector of 3D ang |
||
| 955 | sintable[tang], // Y vector of 3D ang |
||
| 956 | 0, // Z vector of 3D ang |
||
| 5202 | hendricks2 | 957 | &hitinfo, CLIPMASK_MISSILE); |
| 5196 | hendricks2 | 958 | |
| 5202 | hendricks2 | 959 | //ASSERT(hitinfo.sect >= 0); |
| 960 | if (hitinfo.sect < 0) |
||
| 5196 | hendricks2 | 961 | continue; |
| 962 | |||
| 5202 | hendricks2 | 963 | dist = Distance(sp->x, sp->y, hitinfo.pos.x, hitinfo.pos.y); |
| 5196 | hendricks2 | 964 | |
| 5202 | hendricks2 | 965 | if (hitinfo.wall < 0 || dist < 2000 || dist > 7000) |
| 5196 | hendricks2 | 966 | { |
| 967 | continue; |
||
| 968 | } |
||
| 969 | |||
| 970 | Found = TRUE; |
||
| 971 | sp->ang = tang; |
||
| 972 | break; |
||
| 973 | } |
||
| 974 | |||
| 975 | if (!Found) |
||
| 976 | { |
||
| 977 | InitActorDecide(SpriteNum); |
||
| 978 | return 0; |
||
| 979 | } |
||
| 980 | |||
| 981 | NewStateGroup(SpriteNum, sg_RipperHangJump); |
||
| 982 | u->StateFallOverride = sg_RipperHangFall; |
||
| 983 | DoActorSetSpeed(SpriteNum, FAST_SPEED); |
||
| 984 | |||
| 985 | //u->jump_speed = -800; |
||
| 986 | PickJumpMaxSpeed(SpriteNum, -800); |
||
| 987 | |||
| 988 | SET(u->Flags, SPR_JUMPING); |
||
| 989 | RESET(u->Flags, SPR_FALLING); |
||
| 990 | |||
| 991 | // set up individual actor jump gravity |
||
| 992 | u->jump_grav = 8; |
||
| 993 | |||
| 994 | DoJump(SpriteNum); |
||
| 995 | |||
| 996 | return 0; |
||
| 997 | } |
||
| 998 | |||
| 999 | int |
||
| 1000 | DoRipperHang(short SpriteNum) |
||
| 1001 | { |
||
| 1002 | USERp u = User[SpriteNum]; |
||
| 1003 | |||
| 1004 | if ((u->WaitTics -= ACTORMOVETICS) > 0) |
||
| 1005 | return 0; |
||
| 1006 | |||
| 1007 | NewStateGroup(SpriteNum, sg_RipperJumpAttack); |
||
| 1008 | // move to the 2nd frame - past the pause frame |
||
| 1009 | u->Tics += u->State->Tics; |
||
| 1010 | return 0; |
||
| 1011 | } |
||
| 1012 | |||
| 1013 | int |
||
| 1014 | DoRipperMoveHang(short SpriteNum) |
||
| 1015 | { |
||
| 1016 | SPRITEp sp = &sprite[SpriteNum]; |
||
| 1017 | USERp u = User[SpriteNum]; |
||
| 1018 | int nx, ny; |
||
| 1019 | |||
| 1020 | // Move while jumping |
||
| 1021 | nx = sp->xvel * (int) sintable[NORM_ANGLE(sp->ang + 512)] >> 14; |
||
| 1022 | ny = sp->xvel * (int) sintable[sp->ang] >> 14; |
||
| 1023 | |||
| 1024 | // if cannot move the sprite |
||
| 1025 | if (!move_actor(SpriteNum, nx, ny, 0L)) |
||
| 1026 | { |
||
| 1027 | switch (TEST(u->ret, HIT_MASK)) |
||
| 1028 | { |
||
| 1029 | case HIT_WALL: |
||
| 1030 | { |
||
| 5202 | hendricks2 | 1031 | short hit_wall; |
| 5196 | hendricks2 | 1032 | short w, nw; |
| 1033 | |||
| 5202 | hendricks2 | 1034 | hit_wall = NORM_WALL(u->ret); |
| 5196 | hendricks2 | 1035 | |
| 1036 | NewStateGroup(SpriteNum, u->ActorActionSet->Special[1]); |
||
| 1037 | u->WaitTics = 2 + ((RANDOM_P2(4 << 8) >> 8) * 120); |
||
| 1038 | |||
| 1039 | // hang flush with the wall |
||
| 5202 | hendricks2 | 1040 | w = hit_wall; |
| 5196 | hendricks2 | 1041 | nw = wall[w].point2; |
| 1042 | sp->ang = NORM_ANGLE(getangle(wall[nw].x - wall[w].x, wall[nw].y - wall[w].y) - 512); |
||
| 1043 | |||
| 1044 | return 0; |
||
| 1045 | } |
||
| 1046 | } |
||
| 1047 | } |
||
| 1048 | |||
| 1049 | return 0; |
||
| 1050 | } |
||
| 1051 | |||
| 1052 | |||
| 1053 | int |
||
| 1054 | DoRipperHangJF(short SpriteNum) |
||
| 1055 | { |
||
| 1056 | USERp u = User[SpriteNum]; |
||
| 1057 | |||
| 1058 | if (TEST(u->Flags, SPR_JUMPING | SPR_FALLING)) |
||
| 1059 | { |
||
| 1060 | if (TEST(u->Flags, SPR_JUMPING)) |
||
| 1061 | DoJump(SpriteNum); |
||
| 1062 | else |
||
| 1063 | DoFall(SpriteNum); |
||
| 1064 | } |
||
| 1065 | |||
| 1066 | if (!TEST(u->Flags, SPR_JUMPING | SPR_FALLING)) |
||
| 1067 | { |
||
| 1068 | if (DoRipperQuickJump(SpriteNum)) |
||
| 1069 | return 0; |
||
| 1070 | |||
| 1071 | InitActorDecide(SpriteNum); |
||
| 1072 | } |
||
| 1073 | |||
| 1074 | DoRipperMoveHang(SpriteNum); |
||
| 1075 | |||
| 1076 | return 0; |
||
| 1077 | |||
| 1078 | } |
||
| 1079 | |||
| 1080 | // |
||
| 1081 | // JUMP ATTACK |
||
| 1082 | // |
||
| 1083 | |||
| 1084 | int |
||
| 1085 | DoRipperBeginJumpAttack(short SpriteNum) |
||
| 1086 | { |
||
| 1087 | SPRITEp sp = &sprite[SpriteNum]; |
||
| 1088 | USERp u = User[SpriteNum]; |
||
| 1089 | SPRITEp psp = User[SpriteNum]->tgt_sp; |
||
| 1090 | int CanSeePlayer(short SpriteNum); |
||
| 1091 | short tang; |
||
| 1092 | |||
| 1093 | tang = getangle(psp->x - sp->x, psp->y - sp->y); |
||
| 1094 | |||
| 1095 | if (move_sprite(SpriteNum, sintable[NORM_ANGLE(tang+512)] >> 7, sintable[tang] >> 7, |
||
| 1096 | 0L, u->ceiling_dist, u->floor_dist, CLIPMASK_ACTOR, ACTORMOVETICS)) |
||
| 8798 | ny00123 | 1097 | sp->ang = NORM_ANGLE((sp->ang + 1024) + (RANDOM_NEG(256, 6) >> 6)); |
| 5196 | hendricks2 | 1098 | else |
| 8798 | ny00123 | 1099 | sp->ang = NORM_ANGLE(tang + (RANDOM_NEG(256, 6) >> 6)); |
| 5196 | hendricks2 | 1100 | |
| 1101 | DoActorSetSpeed(SpriteNum, FAST_SPEED); |
||
| 1102 | |||
| 1103 | //u->jump_speed = -800; |
||
| 1104 | PickJumpMaxSpeed(SpriteNum, -400); // was -800 |
||
| 1105 | |||
| 1106 | SET(u->Flags, SPR_JUMPING); |
||
| 1107 | RESET(u->Flags, SPR_FALLING); |
||
| 1108 | |||
| 1109 | // set up individual actor jump gravity |
||
| 1110 | u->jump_grav = 17; // was 8 |
||
| 1111 | |||
| 1112 | // if I didn't do this here they get stuck in the air sometimes |
||
| 1113 | DoActorZrange(SpriteNum); |
||
| 1114 | |||
| 1115 | DoJump(SpriteNum); |
||
| 1116 | |||
| 1117 | return 0; |
||
| 1118 | } |
||
| 1119 | |||
| 1120 | int |
||
| 1121 | DoRipperMoveJump(short SpriteNum) |
||
| 1122 | { |
||
| 1123 | USERp u = User[SpriteNum]; |
||
| 1124 | |||
| 1125 | if (TEST(u->Flags, SPR_JUMPING | SPR_FALLING)) |
||
| 1126 | { |
||
| 1127 | if (TEST(u->Flags, SPR_JUMPING)) |
||
| 1128 | DoJump(SpriteNum); |
||
| 1129 | else |
||
| 1130 | DoFall(SpriteNum); |
||
| 1131 | } |
||
| 1132 | |||
| 1133 | if (!TEST(u->Flags, SPR_JUMPING | SPR_FALLING)) |
||
| 1134 | { |
||
| 1135 | if (DoRipperQuickJump(SpriteNum)) |
||
| 1136 | return 0; |
||
| 1137 | |||
| 1138 | InitActorDecide(SpriteNum); |
||
| 1139 | } |
||
| 1140 | |||
| 1141 | DoRipperMoveHang(SpriteNum); |
||
| 1142 | return 0; |
||
| 1143 | } |
||
| 1144 | |||
| 1145 | // |
||
| 1146 | // STD MOVEMENT |
||
| 1147 | // |
||
| 1148 | |||
| 1149 | int |
||
| 1150 | DoRipperQuickJump(short SpriteNum) |
||
| 1151 | { |
||
| 1152 | USERp u = User[SpriteNum]; |
||
| 1153 | |||
| 1154 | // Tests to see if ripper is on top of a player/enemy and then immediatly |
||
| 1155 | // does another jump |
||
| 1156 | |||
| 1157 | if (u->lo_sp) |
||
| 1158 | { |
||
| 1159 | SPRITEp tsp = u->lo_sp; |
||
| 1160 | |||
| 1161 | if (TEST(tsp->extra, SPRX_PLAYER_OR_ENEMY)) |
||
| 1162 | { |
||
| 1163 | NewStateGroup(SpriteNum, sg_RipperJumpAttack); |
||
| 1164 | // move past the first state |
||
| 1165 | u->Tics = 30; |
||
| 1166 | return TRUE; |
||
| 1167 | } |
||
| 1168 | } |
||
| 1169 | |||
| 1170 | return FALSE; |
||
| 1171 | } |
||
| 1172 | |||
| 1173 | |||
| 1174 | int |
||
| 1175 | NullRipper(short SpriteNum) |
||
| 1176 | { |
||
| 1177 | USERp u = User[SpriteNum]; |
||
| 1178 | |||
| 1179 | if (TEST(u->Flags,SPR_SLIDING)) |
||
| 1180 | DoActorSlide(SpriteNum); |
||
| 1181 | |||
| 1182 | DoActorSectorDamage(SpriteNum); |
||
| 1183 | |||
| 1184 | return 0; |
||
| 1185 | } |
||
| 1186 | |||
| 1187 | |||
| 1188 | int DoRipperPain(short SpriteNum) |
||
| 1189 | { |
||
| 1190 | USERp u = User[SpriteNum]; |
||
| 1191 | |||
| 1192 | NullRipper(SpriteNum); |
||
| 1193 | |||
| 1194 | if ((u->WaitTics -= ACTORMOVETICS) <= 0) |
||
| 1195 | InitActorDecide(SpriteNum); |
||
| 1196 | return 0; |
||
| 1197 | } |
||
| 1198 | |||
| 1199 | |||
| 1200 | // CTW MODIFICATION |
||
| 1201 | //int DoRipperRipHeart(SpriteNum) |
||
| 1202 | int DoRipperRipHeart(short SpriteNum) |
||
| 1203 | // CTW MODIFICATION END |
||
| 1204 | { |
||
| 1205 | SPRITEp sp = &sprite[SpriteNum]; |
||
| 1206 | USERp u = User[SpriteNum]; |
||
| 1207 | |||
| 1208 | SPRITEp tsp = u->tgt_sp; |
||
| 1209 | |||
| 1210 | NewStateGroup(SpriteNum, sg_RipperHeart); |
||
| 1211 | u->WaitTics = 6 * 120; |
||
| 1212 | |||
| 1213 | // player face ripper |
||
| 1214 | tsp->ang = getangle(sp->x - tsp->x, sp->y - tsp->y); |
||
| 1215 | return 0; |
||
| 1216 | } |
||
| 1217 | |||
| 1218 | // CTW MODIFICATION |
||
| 1219 | //int DoRipperStandHeart(SpriteNum) |
||
| 1220 | int DoRipperStandHeart(short SpriteNum) |
||
| 1221 | // CTW MODIFICATION END |
||
| 1222 | { |
||
| 1223 | USERp u = User[SpriteNum]; |
||
| 1224 | |||
| 1225 | NullRipper(SpriteNum); |
||
| 1226 | |||
| 1227 | if ((u->WaitTics -= ACTORMOVETICS) <= 0) |
||
| 1228 | NewStateGroup(SpriteNum, sg_RipperRun); |
||
| 1229 | return 0; |
||
| 1230 | } |
||
| 1231 | |||
| 1232 | void RipperHatch(short Weapon) |
||
| 1233 | { |
||
| 1234 | SPRITEp wp = &sprite[Weapon]; |
||
| 1235 | |||
| 6048 | hendricks2 | 1236 | short New,i; |
| 5196 | hendricks2 | 1237 | SPRITEp np; |
| 1238 | USERp nu; |
||
| 1239 | #define MAX_RIPPERS 1 |
||
| 1240 | short rip_ang[MAX_RIPPERS]; |
||
| 1241 | |||
| 1242 | rip_ang[0] = RANDOM_P2(2048); |
||
| 5228 | hendricks2 | 1243 | // rip_ang[1] = NORM_ANGLE(rip_ang[0] + 1024 + (RANDOM_P2(512) - 256)); |
| 5196 | hendricks2 | 1244 | |
| 1245 | for (i = 0; i < MAX_RIPPERS; i++) |
||
| 1246 | { |
||
| 6048 | hendricks2 | 1247 | New = COVERinsertsprite(wp->sectnum, STAT_DEFAULT); |
| 1248 | np = &sprite[New]; |
||
| 5196 | hendricks2 | 1249 | memset(np,0,sizeof(SPRITE)); |
| 1250 | np->sectnum = wp->sectnum; |
||
| 1251 | np->statnum = STAT_DEFAULT; |
||
| 1252 | np->x = wp->x; |
||
| 1253 | np->y = wp->y; |
||
| 1254 | np->z = wp->z; |
||
| 1255 | np->owner = -1; |
||
| 1256 | //np->xrepeat = np->yrepeat = 36; |
||
| 1257 | np->xrepeat = np->yrepeat = 64; |
||
| 1258 | np->ang = rip_ang[i]; |
||
| 1259 | np->pal = 0; |
||
| 6048 | hendricks2 | 1260 | SetupRipper(New); |
| 1261 | nu = User[New]; |
||
| 5196 | hendricks2 | 1262 | |
| 1263 | // make immediately active |
||
| 1264 | SET(nu->Flags, SPR_ACTIVE); |
||
| 1265 | |||
| 6048 | hendricks2 | 1266 | NewStateGroup(New, nu->ActorActionSet->Jump); |
| 5196 | hendricks2 | 1267 | nu->ActorActionFunc = DoActorMoveJump; |
| 6048 | hendricks2 | 1268 | DoActorSetSpeed(New, FAST_SPEED); |
| 1269 | PickJumpMaxSpeed(New, -600); |
||
| 5196 | hendricks2 | 1270 | |
| 1271 | SET(nu->Flags, SPR_JUMPING); |
||
| 1272 | RESET(nu->Flags, SPR_FALLING); |
||
| 1273 | |||
| 1274 | nu->jump_grav = 8; |
||
| 1275 | |||
| 1276 | // if I didn't do this here they get stuck in the air sometimes |
||
| 6048 | hendricks2 | 1277 | DoActorZrange(New); |
| 5196 | hendricks2 | 1278 | |
| 6048 | hendricks2 | 1279 | DoJump(New); |
| 5196 | hendricks2 | 1280 | } |
| 1281 | } |
||
| 1282 | |||
| 1283 | int |
||
| 1284 | DoRipperMove(short SpriteNum) |
||
| 1285 | { |
||
| 1286 | USERp u = User[SpriteNum]; |
||
| 1287 | |||
| 1288 | if (u->scale_speed) |
||
| 1289 | { |
||
| 1290 | DoScaleSprite(SpriteNum); |
||
| 1291 | } |
||
| 1292 | |||
| 1293 | if (TEST(u->Flags, SPR_JUMPING | SPR_FALLING)) |
||
| 1294 | { |
||
| 1295 | if (TEST(u->Flags, SPR_JUMPING)) |
||
| 1296 | DoJump(SpriteNum); |
||
| 1297 | else |
||
| 1298 | DoFall(SpriteNum); |
||
| 1299 | } |
||
| 1300 | |||
| 1301 | // if on a player/enemy sprite jump quickly |
||
| 1302 | if (!TEST(u->Flags, SPR_JUMPING | SPR_FALLING)) |
||
| 1303 | { |
||
| 1304 | if (DoRipperQuickJump(SpriteNum)) |
||
| 1305 | return 0; |
||
| 1306 | |||
| 1307 | KeepActorOnFloor(SpriteNum); |
||
| 1308 | } |
||
| 1309 | |||
| 1310 | if (TEST(u->Flags, SPR_SLIDING)) |
||
| 1311 | DoActorSlide(SpriteNum); |
||
| 1312 | |||
| 1313 | if (u->track >= 0) |
||
| 1314 | ActorFollowTrack(SpriteNum, ACTORMOVETICS); |
||
| 1315 | else |
||
| 1316 | (*u->ActorActionFunc)(SpriteNum); |
||
| 1317 | |||
| 1318 | DoActorSectorDamage(SpriteNum); |
||
| 1319 | return 0; |
||
| 1320 | } |
||
| 1321 | |||
| 1322 | |||
| 1323 | #include "saveable.h" |
||
| 1324 | |||
| 1325 | static saveable_code saveable_ripper_code[] = |
||
| 1326 | { |
||
| 1327 | SAVE_CODE(SetupRipper), |
||
| 1328 | SAVE_CODE(GetJumpHeight), |
||
| 1329 | SAVE_CODE(PickJumpSpeed), |
||
| 1330 | SAVE_CODE(PickJumpMaxSpeed), |
||
| 1331 | |||
| 1332 | SAVE_CODE(InitRipperHang), |
||
| 1333 | SAVE_CODE(DoRipperHang), |
||
| 1334 | SAVE_CODE(DoRipperMoveHang), |
||
| 1335 | SAVE_CODE(DoRipperHangJF), |
||
| 1336 | |||
| 1337 | SAVE_CODE(DoRipperBeginJumpAttack), |
||
| 1338 | SAVE_CODE(DoRipperMoveJump), |
||
| 1339 | |||
| 1340 | SAVE_CODE(DoRipperQuickJump), |
||
| 1341 | SAVE_CODE(NullRipper), |
||
| 1342 | SAVE_CODE(DoRipperPain), |
||
| 1343 | SAVE_CODE(DoRipperRipHeart), |
||
| 1344 | SAVE_CODE(DoRipperStandHeart), |
||
| 1345 | SAVE_CODE(RipperHatch), |
||
| 1346 | SAVE_CODE(DoRipperMove), |
||
| 1347 | }; |
||
| 1348 | |||
| 1349 | static saveable_data saveable_ripper_data[] = |
||
| 1350 | { |
||
| 1351 | SAVE_DATA(RipperBattle), |
||
| 1352 | SAVE_DATA(RipperOffense), |
||
| 1353 | SAVE_DATA(RipperBroadcast), |
||
| 1354 | SAVE_DATA(RipperSurprised), |
||
| 1355 | SAVE_DATA(RipperEvasive), |
||
| 1356 | SAVE_DATA(RipperLostTarget), |
||
| 1357 | SAVE_DATA(RipperCloseRange), |
||
| 1358 | |||
| 1359 | SAVE_DATA(RipperPersonality), |
||
| 1360 | |||
| 1361 | SAVE_DATA(RipperAttrib), |
||
| 1362 | |||
| 1363 | SAVE_DATA(s_RipperRun), |
||
| 1364 | SAVE_DATA(sg_RipperRun), |
||
| 1365 | SAVE_DATA(s_RipperStand), |
||
| 1366 | SAVE_DATA(sg_RipperStand), |
||
| 1367 | SAVE_DATA(s_RipperSwipe), |
||
| 1368 | SAVE_DATA(sg_RipperSwipe), |
||
| 1369 | SAVE_DATA(s_RipperSpew), |
||
| 1370 | SAVE_DATA(sg_RipperSpew), |
||
| 1371 | SAVE_DATA(s_RipperHeart), |
||
| 1372 | SAVE_DATA(sg_RipperHeart), |
||
| 1373 | SAVE_DATA(s_RipperHang), |
||
| 1374 | SAVE_DATA(sg_RipperHang), |
||
| 1375 | SAVE_DATA(s_RipperPain), |
||
| 1376 | SAVE_DATA(sg_RipperPain), |
||
| 1377 | SAVE_DATA(s_RipperJump), |
||
| 1378 | SAVE_DATA(sg_RipperJump), |
||
| 1379 | SAVE_DATA(s_RipperFall), |
||
| 1380 | SAVE_DATA(sg_RipperFall), |
||
| 1381 | SAVE_DATA(s_RipperJumpAttack), |
||
| 1382 | SAVE_DATA(sg_RipperJumpAttack), |
||
| 1383 | SAVE_DATA(s_RipperHangJump), |
||
| 1384 | SAVE_DATA(sg_RipperHangJump), |
||
| 1385 | SAVE_DATA(s_RipperHangFall), |
||
| 1386 | SAVE_DATA(sg_RipperHangFall), |
||
| 1387 | SAVE_DATA(s_RipperDie), |
||
| 1388 | SAVE_DATA(s_RipperDead), |
||
| 1389 | SAVE_DATA(sg_RipperDie), |
||
| 1390 | SAVE_DATA(sg_RipperDead), |
||
| 1391 | SAVE_DATA(s_RipperDeathJump), |
||
| 1392 | SAVE_DATA(s_RipperDeathFall), |
||
| 1393 | SAVE_DATA(sg_RipperDeathJump), |
||
| 1394 | SAVE_DATA(sg_RipperDeathFall), |
||
| 1395 | |||
| 1396 | SAVE_DATA(RipperActionSet), |
||
| 1397 | SAVE_DATA(RipperBrownActionSet), |
||
| 1398 | }; |
||
| 1399 | |||
| 1400 | saveable_module saveable_ripper = |
||
| 1401 | { |
||
| 1402 | // code |
||
| 1403 | saveable_ripper_code, |
||
| 1404 | SIZ(saveable_ripper_code), |
||
| 1405 | |||
| 1406 | // data |
||
| 1407 | saveable_ripper_data, |
||
| 1408 | SIZ(saveable_ripper_data) |
||
| 1409 | }; |