├── FoundedStrings.txt ├── README.md ├── animscripts ├── debug.gsc ├── traverse │ ├── zombie_jump_down_127.gsc │ ├── zombie_jump_down_184.gsc │ ├── zombie_jump_down_190.gsc │ ├── zombie_jump_down_222.gsc │ ├── zombie_jump_down_240.gsc │ ├── zombie_jump_down_40.gsc │ ├── zombie_jump_down_72.gsc │ ├── zombie_jump_up_222.gsc │ ├── zombie_shared.gsc │ └── zombie_wall_crawl_drop.gsc ├── zombie_combat.gsc ├── zombie_death.gsc ├── zombie_dog_death.gsc ├── zombie_init.gsc ├── zombie_melee.gsc ├── zombie_move.gsc ├── zombie_pain.gsc ├── zombie_run.gsc └── zombie_shared.gsc ├── animtrees └── generic_human.atr ├── clientscripts ├── _audio.csc ├── _callbacks.csc ├── _clientfaceanim.csc ├── _face_utility.csc ├── _filter.csc ├── _footsteps.csc ├── _fx.csc ├── _load.csc ├── _utility.csc ├── _zombiemode.csc ├── _zombiemode_equipment.csc ├── _zombiemode_ffotd.csc ├── _zombiemode_weap_freezegun.csc ├── _zombiemode_weap_tesla.csc ├── _zombiemode_weap_thundergun.csc └── _zombiemode_weapons.csc ├── get_string.bat ├── maps ├── _ballistic_knife.gsc ├── _callbackglobal.gsc ├── _gameskill.gsc ├── _hud_message.gsc ├── _laststand.gsc ├── _loadout.gsc ├── _utility.gsc ├── _weaponobjects.gsc ├── _weapons.gsc ├── _zombiemode.gsc ├── _zombiemode_ai_ape.gsc ├── _zombiemode_ai_dogs.gsc ├── _zombiemode_audio.gsc ├── _zombiemode_auto_turret.gsc ├── _zombiemode_blockers.gsc ├── _zombiemode_bowie.gsc ├── _zombiemode_claymore.gsc ├── _zombiemode_devgui.gsc ├── _zombiemode_equipment.gsc ├── _zombiemode_ffotd.gsc ├── _zombiemode_load.gsc ├── _zombiemode_perks.gsc ├── _zombiemode_powerups.gsc ├── _zombiemode_score.gsc ├── _zombiemode_server_throttle.gsc ├── _zombiemode_sidequests.gsc ├── _zombiemode_spawner.gsc ├── _zombiemode_traps.gsc ├── _zombiemode_utility.gsc ├── _zombiemode_weap_crossbow.gsc ├── _zombiemode_weap_cymbal_monkey.gsc ├── _zombiemode_weap_freezegun.gsc ├── _zombiemode_weap_tesla.gsc ├── _zombiemode_weap_thundergun.gsc ├── _zombiemode_weapons.gsc ├── _zombiemode_zone_manager.gsc └── mod_cabcon │ ├── _load.gsc │ ├── _load_functions.gsc │ ├── _load_gamemodes.gsc │ ├── _load_menubase.gsc │ ├── _load_settings.gsc │ └── _load_utilies.gsc ├── mod.csv ├── mod.ff ├── radiant └── keys.txt ├── release ├── version 0.83 │ ├── Readme.txt │ ├── [cabconmodding.com] EnCoReV8 Zombie Edition - 0.83.rar │ └── common_zombie_patch.ff ├── version 0.85 │ ├── Readme.txt │ ├── [cabconmodding.com] EnCoReV8 Zombie Edition - 0.85.rar │ └── common_zombie_patch.ff └── version 0.9 │ ├── Readme.txt │ ├── [cabconmodding.com] EnCoReV8 Zombie Edition - 0.9.rar │ └── common_zombie_patch.ff └── zm_zombie_modus.files /FoundedStrings.txt: -------------------------------------------------------------------------------- 1 | maps\mod_cabcon\_load_functions.gsc: ai = spawn_zombie( spawn_point ); 2 | maps\_zombiemode.gsc: flag_init( "spawn_zombies", true ); 3 | maps\_zombiemode.gsc: if ( !flag("spawn_zombies" ) ) 4 | maps\_zombiemode.gsc: flag_wait( "spawn_zombies" ); 5 | maps\_zombiemode.gsc: ai = spawn_zombie( spawn_point ); 6 | maps\_zombiemode.gsc: ai = spawn_zombie( spawn_point ); 7 | maps\_zombiemode_ai_dogs.gsc: ai = spawn_zombie( level.enemy_dog_spawns[0] ); 8 | maps\_zombiemode_ai_dogs.gsc: ai = spawn_zombie( spawn_point ); 9 | maps\_zombiemode_ai_dogs.gsc: ai = spawn_zombie( spawn_point ); 10 | maps\_zombiemode_ai_dogs.gsc: ai = spawn_zombie( level.enemy_dog_spawns[0] ); 11 | maps\_zombiemode_ai_dogs.gsc: ai = spawn_zombie( spawn_point ); 12 | maps\_zombiemode_utility.gsc:spawn_zombie( spawner, target_name ) 13 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # EnCoReV8 - Zombie Edition GSC Mod 2 | Hello, 3 | this is the official github source for the Black Ops 1 EnCoReV8 Remake to Zombie. It is my first Menu for Black Ops 1 Zombie but the 13 part of our EnCoRe-series. So I hope you will enjoy it. 4 | 5 | [Download, Install Mod Menu & Credits](https://cabconmodding.com/threads/black-ops-1-zombie-encorev8-zombie-edition-gsc-mod-by-cabcon.48/) 6 | 7 | ![Mod Menu Preview](https://i.imgur.com/y4f2DGH.jpg) 8 | 9 | ## Features 10 | * Dynamic Build System (Play on each map with their weapons, entities, effects. DLC included) 11 | * Menu with the most options ever for Black Ops 1. (More than 1300+ Options) 12 | * Slider Editor (Change any Dvar to your value) 13 | * Customizable Menu Base (Change Position, Shader, Animations, Color, Alpha of each Menu element) 14 | * Controller Remembrance (Remembrance the Controller Position for a simple control) 15 | * Unlimited Scroll Menu Base (Unlimited Space for Options) 16 | * Every Option is toggleable (You can turn off and on every option) 17 | 18 | -------------------------------------------------------------------------------- /animscripts/debug.gsc: -------------------------------------------------------------------------------- 1 | /# 2 | 3 | isDebugOn() 4 | { 5 | return ( (getdebugdvarint("animDebug") == 1) || ( IsDefined (anim.debugEnt) && anim.debugEnt == self ) ); 6 | } 7 | 8 | drawDebugLineInternal(fromPoint, toPoint, color, durationFrames) 9 | { 10 | //println ("Drawing line, color "+color[0]+","+color[1]+","+color[2]); 11 | //player = getent("player", "classname" ); 12 | //println ( "Point1 : "+fromPoint+", Point2: "+toPoint+", player: "+player.origin ); 13 | for (i=0;i 0; 60 | debugClearState(); 61 | 62 | while(1) 63 | { 64 | waittillframeend; 65 | 66 | UpdateDebugInfoInternal(); 67 | 68 | wait(0.05); 69 | } 70 | } 71 | 72 | UpdateDebugInfoInternal() 73 | { 74 | if( IsDefined(anim.debugEnt) && (anim.debugEnt==self) ) 75 | { 76 | doInfo = true; 77 | } 78 | else 79 | { 80 | doInfo = GetDvarInt( #"ai_debugAnimscript") > 0; 81 | 82 | // check if there's a selected ent 83 | if( doInfo ) 84 | { 85 | ai_entNum = GetDvarInt( #"ai_debugEntIndex"); 86 | if( ai_entNum > -1 && ai_entNum != self getEntityNumber() ) 87 | { 88 | doInfo = false; 89 | } 90 | } 91 | 92 | // clear everything out if it was just switched on to make sure we start clean 93 | if( !self.debugInfo.enabled && doInfo ) 94 | { 95 | self.debugInfo.shouldClearOnAnimscriptChange = true; 96 | } 97 | 98 | self.debugInfo.enabled = doInfo; 99 | } 100 | 101 | if( doInfo ) 102 | { 103 | drawDebugInfo(doInfo); 104 | } 105 | } 106 | 107 | drawDebugInfo(debugLevel) 108 | { 109 | allowedStancesStr = ""; 110 | 111 | if( self IsStanceAllowed("stand") ) 112 | allowedStancesStr += "s"; 113 | if( self IsStanceAllowed("crouch") ) 114 | allowedStancesStr += "c"; 115 | if( self IsStanceAllowed("prone") ) 116 | allowedStancesStr += "p"; 117 | 118 | // general info: entnum - pose - movement type - goal radius 119 | drawDebugEntText( "(" + self getEntityNumber() + ") : " + self.a.pose + " (" + allowedStancesStr + ") : " + self.a.movement + " : " + self.goalradius + " : " + self.pathEnemyFightDist, self, level.color_debug["cyan"], "Brain" ); 120 | 121 | // extra info 122 | extraInfoStr = ""; 123 | 124 | if( self.ignoreall ) 125 | { 126 | extraInfoStr += "ignoreAll "; 127 | } 128 | 129 | if( self.ignoreme ) 130 | { 131 | extraInfoStr += "ignoreMe "; 132 | } 133 | 134 | if( self.ignoresuppression ) 135 | { 136 | extraInfoStr += "ignoreSuppression "; 137 | } 138 | 139 | if( !self.a.allow_shooting ) 140 | { 141 | extraInfoStr += "!allow_shooting "; 142 | } 143 | 144 | if( animscripts\utility::isCQBWalking() ) 145 | { 146 | extraInfoStr += "cqb "; 147 | } 148 | 149 | if( self.walk ) 150 | { 151 | extraInfoStr += "walk "; 152 | } 153 | 154 | if( self.sprint ) 155 | { 156 | extraInfoStr += "sprint "; 157 | } 158 | 159 | if( IsDefined(self.disableArrivals) && self.disableArrivals ) 160 | { 161 | extraInfoStr += "!arrivals "; 162 | } 163 | 164 | if( IsDefined(self.disableExits) && self.disableExits ) 165 | { 166 | extraInfoStr += "!exits "; 167 | } 168 | 169 | if( self.grenadeAwareness == 0 ) 170 | { 171 | extraInfoStr += "!grenadeAwareness "; 172 | } 173 | 174 | if( !self.takedamage ) 175 | { 176 | extraInfoStr += "!takedamage "; 177 | } 178 | 179 | if( !self.allowPain ) 180 | { 181 | extraInfoStr += "!allowPain "; 182 | } 183 | 184 | // if( !self.allowDeath ) 185 | // { 186 | // extraInfoStr += "!allowDeath "; 187 | // } 188 | 189 | if( self.delayedDeath ) 190 | { 191 | extraInfoStr += "delayedDeath "; 192 | } 193 | 194 | if( IsDefined(self.disableTurns) && self.disableTurns ) 195 | { 196 | extraInfoStr += "disableTurns "; 197 | } 198 | 199 | if( extraInfoStr != "" ) 200 | { 201 | drawDebugEntText( extraInfoStr, self, level.color_debug["grey"], "Brain" ); 202 | } 203 | 204 | // weapon info 205 | 206 | if ( IsDefined(self.primaryweapon) && IsDefined(self.secondaryweapon) && IsDefined(self.sidearm) && IsDefined(self.weapon) ) 207 | { 208 | drawDebugEntText( self.primaryweapon + " : " + self.secondaryweapon + " : " + self.sidearm + " (" + self.weapon + ")", self, level.color_debug["grey"], "Brain" ); 209 | } 210 | 211 | // state info 212 | for( i=0; i < self.debugInfo.states.size; i++ ) 213 | { 214 | stateString = self.debugInfo.states[i].stateName; 215 | 216 | if( debugLevel > 1 ) 217 | { 218 | stateString += " (" + (GetTime() - self.debugInfo.states[i].stateTime)/1000 + ")"; 219 | } 220 | 221 | if( IsDefined(self.debugInfo.states[i].extraInfo) ) 222 | { 223 | stateString += ": " + self.debugInfo.states[i].extraInfo; 224 | } 225 | 226 | lineColor = level.color_debug["white"]; 227 | 228 | // state was popped this frame 229 | if( !self.debugInfo.states[i].stateValid ) 230 | { 231 | stateString += " [end"; 232 | lineColor = (1,0.75,0.75); 233 | 234 | if( IsDefined(self.debugInfo.states[i].exitReason) ) 235 | { 236 | stateString += ": " + self.debugInfo.states[i].exitReason; 237 | } 238 | 239 | stateString += "]"; 240 | } 241 | else if( self.debugInfo.states[i].stateTime == GetTime() - 50 ) // new state 242 | { 243 | lineColor = (0.75,1,0.75); 244 | } 245 | 246 | drawDebugEntText( indent(self.debugInfo.states[i].stateLevel) + "-" + stateString, self, lineColor, "Brain" ); 247 | } 248 | 249 | // insert empty line 250 | drawDebugEntText( " ", self, level.color_debug["grey"], "Brain" ); 251 | 252 | // remove popped states 253 | debugCleanStateStack(); 254 | } 255 | 256 | drawDebugEntText( text, ent, color, channel ) 257 | { 258 | assert( IsDefined(ent) ); 259 | 260 | if( !GetDvarInt( #"recorder_enableRec") ) 261 | { 262 | if( !IsDefined(ent.debugAnimScriptTime) || GetTime() > ent.debugAnimScriptTime ) 263 | { 264 | ent.debugAnimScriptLevel = 0; 265 | ent.debugAnimScriptTime = GetTime(); 266 | } 267 | 268 | indentLevel = common_scripts\utility::vector_scale( (0,0,-10), ent.debugAnimScriptLevel ); 269 | print3d( self.origin + (0,0,70) + indentLevel, text, color ); 270 | ent.debugAnimScriptLevel++; 271 | } 272 | else 273 | { 274 | recordEntText( text, ent, color, channel ); 275 | } 276 | } 277 | 278 | debugPushState(stateName, extraInfo) 279 | { 280 | if( !GetDvarInt( #"ai_debugAnimscript") ) 281 | { 282 | return; 283 | } 284 | 285 | // don't do anything if it's not the selected ent 286 | ai_entNum = GetDvarInt( #"ai_debugEntIndex"); 287 | if( ai_entNum > -1 && ai_entNum != self getEntityNumber() ) 288 | { 289 | return; 290 | } 291 | 292 | assert( IsDefined(self.debugInfo.states) ); 293 | assert( IsDefined(stateName) ); 294 | 295 | //recordEntText( "push: " + stateName, self, level.color_debug["green"], "Brain" ); 296 | 297 | state = SpawnStruct(); 298 | state.stateName = stateName; 299 | state.stateLevel = self.debugInfo.stateLevel; 300 | state.stateTime = GetTime(); 301 | state.stateValid = true; 302 | 303 | self.debugInfo.stateLevel++; 304 | 305 | if( IsDefined(extraInfo) ) 306 | { 307 | state.extraInfo = extraInfo + " "; 308 | } 309 | 310 | self.debugInfo.states[ self.debugInfo.states.size ] = state; 311 | } 312 | 313 | debugAddStateInfo(stateName, extraInfo) 314 | { 315 | if( !GetDvarInt( #"ai_debugAnimscript") ) 316 | { 317 | return; 318 | } 319 | 320 | // don't do anything if it's not the selected ent 321 | ai_entNum = GetDvarInt( #"ai_debugEntIndex"); 322 | if( ai_entNum > -1 && ai_entNum != self getEntityNumber() ) 323 | { 324 | return; 325 | } 326 | 327 | assert( IsDefined(self.debugInfo.states) ); 328 | 329 | // find the first matching state from bottom 330 | if( IsDefined(stateName) ) 331 | { 332 | for( i = self.debugInfo.states.size - 1; i >= 0; i-- ) 333 | { 334 | assert( IsDefined( self.debugInfo.states[i] ) ); 335 | 336 | if( self.debugInfo.states[i].stateName == stateName ) 337 | { 338 | if( !IsDefined(self.debugInfo.states[i].extraInfo) ) 339 | { 340 | self.debugInfo.states[i].extraInfo = ""; 341 | } 342 | 343 | self.debugInfo.states[i].extraInfo += extraInfo + " "; 344 | break; 345 | } 346 | } 347 | } 348 | else if( self.debugInfo.states.size > 0 ) 349 | { 350 | // add to the last one 351 | lastIndex = self.debugInfo.states.size - 1; 352 | 353 | assert( IsDefined(self.debugInfo.states[lastIndex]) ); 354 | 355 | if( !IsDefined(self.debugInfo.states[lastIndex].extraInfo) ) 356 | { 357 | self.debugInfo.states[lastIndex].extraInfo = ""; 358 | } 359 | 360 | self.debugInfo.states[lastIndex].extraInfo += extraInfo + " "; 361 | } 362 | } 363 | 364 | debugPopState(stateName, exitReason) 365 | { 366 | if( !GetDvarInt( #"ai_debugAnimscript") || self.debugInfo.states.size <= 0 ) 367 | { 368 | return; 369 | } 370 | 371 | // don't do anything if it's not the selected ent 372 | ai_entNum = GetDvarInt( #"ai_debugEntIndex"); 373 | if( ai_entNum > -1 && ai_entNum != self getEntityNumber() ) 374 | { 375 | return; 376 | } 377 | 378 | assert( IsDefined(self.debugInfo.states) ); 379 | 380 | if( IsDefined(stateName) ) 381 | { 382 | //recordEntText( "pop: " + stateName, self, level.color_debug["red"], "Brain" ); 383 | 384 | // remove elements at and after stateName 385 | for( i=0; i < self.debugInfo.states.size; i++ ) 386 | { 387 | if( self.debugInfo.states[i].stateName == stateName && self.debugInfo.states[i].stateValid ) 388 | { 389 | self.debugInfo.states[i].stateValid = false; 390 | self.debugInfo.states[i].exitReason = exitReason; 391 | self.debugInfo.stateLevel = self.debugInfo.states[i].stateLevel; 392 | 393 | // invalidate all states below this one 394 | for( j=i+1; j < self.debugInfo.states.size && self.debugInfo.states[j].stateLevel > self.debugInfo.states[i].stateLevel; j++ ) 395 | { 396 | self.debugInfo.states[j].stateValid = false; 397 | } 398 | 399 | break; 400 | } 401 | } 402 | } 403 | else 404 | { 405 | //recordEntText( "pop", self, level.color_debug["red"], "Brain" ); 406 | 407 | // remove the last element 408 | if( self.debugInfo.states[ self.debugInfo.states.size - 1 ].stateValid ) 409 | { 410 | self.debugInfo.states[ self.debugInfo.states.size - 1 ].stateValid = false; 411 | self.debugInfo.states[ self.debugInfo.states.size - 1 ].exitReason = exitReason; 412 | self.debugInfo.stateLevel--; 413 | } 414 | } 415 | } 416 | 417 | debugClearState() 418 | { 419 | self.debugInfo.states = []; 420 | self.debugInfo.stateLevel = 0; 421 | self.debugInfo.shouldClearOnAnimscriptChange = false; 422 | } 423 | 424 | debugShouldClearState() 425 | { 426 | if( IsDefined(self.debugInfo) && IsDefined(self.debugInfo.shouldClearOnAnimscriptChange) && self.debugInfo.shouldClearOnAnimscriptChange ) 427 | { 428 | return true; 429 | } 430 | 431 | return false; 432 | } 433 | 434 | debugCleanStateStack() 435 | { 436 | newArray = []; 437 | for( i=0; i < self.debugInfo.states.size; i++ ) 438 | { 439 | if( self.debugInfo.states[i].stateValid ) 440 | { 441 | newArray[ newArray.size ] = self.debugInfo.states[i]; 442 | } 443 | } 444 | 445 | self.debugInfo.states = newArray; 446 | } 447 | 448 | indent(depth) 449 | { 450 | indent = ""; 451 | 452 | for( i=0; i < depth; i++ ) 453 | { 454 | indent += " "; 455 | } 456 | 457 | return indent; 458 | } 459 | 460 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////// 461 | ////////////////////////////////////// END ANIMSCRIPT STATE DEBUGGING ////////////////////////////////////////// 462 | //////////////////////////////////////////////////////////////////////////////////////////////////////////////// 463 | 464 | /* COD4 version 465 | drawDebugInfo() 466 | { 467 | // What do we want to print? 468 | line[0] = self getEntityNumber()+" "+self.a.script; 469 | line[1] = self.a.pose+" "+self.a.movement; 470 | line[2] = self.a.alertness+" "+self.a.special; 471 | 472 | if (self DebugIsInCombat()) 473 | { 474 | line[3] = "in combat for "+(self.a.combatEndTime - GetTime())+" ms."; 475 | } 476 | else 477 | { 478 | line[3] = "not in combat"; 479 | } 480 | 481 | line[4] = self.a.lastDebugPrint1; 482 | 483 | belowFeet = self.origin + (0,0,-8); 484 | //aboveHead = self GetShootAtPos() + (0,0,8); 485 | offset = (0,0,-10); 486 | 487 | for (i=0 ; i 1 ) 203 | { 204 | vertWeight = 1; 205 | } 206 | horzWeight = 1 - vertWeight; 207 | 208 | self setAnimLimited( vertAnim, vertWeight, 0 ); 209 | self setAnimLimited( horzAnim, horzWeight, 0 ); 210 | self setFlaggedAnimKnob( "falling_death", %wall_death, 1 ); 211 | self animscripts\zombie_shared::DoNotetracks( "falling_death" ); 212 | } 213 | 214 | wait_on_vertical_death() 215 | { 216 | self endon( "death" ); 217 | self endon( "traverse_death" ); 218 | 219 | self waittill( "zombie_vertical" ); 220 | self.vertical_fall = true; 221 | } -------------------------------------------------------------------------------- /animscripts/zombie_combat.gsc: -------------------------------------------------------------------------------- 1 | #include animscripts\zombie_utility; 2 | #include animscripts\Debug; 3 | #include animscripts\zombie_SetPoseMovement; 4 | #include animscripts\Combat_utility; 5 | #include animscripts\zombie_shared; 6 | #include common_scripts\utility; 7 | 8 | #using_animtree("generic_human"); 9 | 10 | main() 11 | { 12 | self endon("killanimscript"); 13 | 14 | [[ self.exception[ "exposed" ] ]](); 15 | 16 | animscripts\zombie_utility::initialize("zombie_combat"); 17 | self.a.arrivalType = undefined; 18 | 19 | self setup(); 20 | 21 | self exposedCombatMainLoop(); 22 | } 23 | 24 | idleThread() 25 | { 26 | self endon("killanimscript"); 27 | self endon("kill_idle_thread"); 28 | for(;;) 29 | { 30 | idleAnim = animArrayPickRandom( "exposed_idle" ); 31 | self setflaggedanimlimited("idle", idleAnim ); 32 | self waittillmatch( "idle", "end" ); 33 | self ClearAnim( idleAnim, .2 ); 34 | } 35 | } 36 | 37 | setup() 38 | { 39 | if(self.a.pose == "stand") 40 | { 41 | self set_animarray_standing(); 42 | } 43 | else if( self.a.pose == "crouch" ) 44 | { 45 | self set_animarray_crouching(); 46 | } 47 | else 48 | { 49 | assertMsg( "Unsupported self.a.pose: " + self.a.pose ); 50 | } 51 | 52 | self thread stopShortly(); 53 | self.previousPitchDelta = 0.0; 54 | 55 | self ClearAnim( %root, .2 ); 56 | self SetAnim( animarray("straight_level") ); 57 | self SetAnim( %add_idle ); 58 | 59 | if ( !isDefined(self.no_idle) ) 60 | { 61 | self thread idleThread(); 62 | } 63 | } 64 | 65 | stopShortly() 66 | { 67 | self endon("killanimscript"); 68 | self endon("melee"); 69 | // we want to stop at about the time we blend out of whatever we were just doing. 70 | wait .2; 71 | self.a.movement = "stop"; 72 | } 73 | 74 | // CCheng (8/22/2008): This was getting ridiculously convoluted with lots of redundant assignments, 75 | // so I broke down and reorganized it in a more straightforward manner: now the first part sets the 76 | // default anims, while the second part overrides only as necessary. This way, if you want to know 77 | // what are all the possible anim slots that need to be filled if you add a new pose, just look at 78 | // the default assignment section. 79 | 80 | set_animarray_standing() 81 | { 82 | self.a.array = []; 83 | 84 | // START OF DEFAULTS: First, set the defaults, then override with weapon-specific animations. 85 | 86 | self.a.array["exposed_idle"] = array( %exposed_idle_alert_v1, %exposed_idle_alert_v2, %exposed_idle_alert_v3 ); 87 | 88 | self.a.array["crouch_2_stand"] = %exposed_crouch_2_stand; 89 | self.a.array["stand_2_crouch"] = %exposed_stand_2_crouch; 90 | 91 | // END OF DEFAULTS - OVERRIDE STUFF BELOW BASED ON WEAPONS OR WHATEVER ELSE // 92 | 93 | if ( self.animname == "quad_zombie" ) 94 | { 95 | self.a.array["exposed_idle"] = array( %ai_zombie_quad_idle, %ai_zombie_quad_idle_2 ); 96 | self.a.array["straight_level"] = %ai_zombie_quad_idle; 97 | self.a.array["stand_2_crouch"] = %ai_zombie_shot_leg_right_2_crawl; 98 | } 99 | else 100 | if ( self.animname == "boss_zombie" ) 101 | { 102 | self.a.array["exposed_idle"] = array( %ai_zombie_boss_idle_a, %ai_zombie_boss_idle_b ); 103 | self.a.array["straight_level"] = %ai_zombie_boss_idle_a; 104 | self.a.array["stand_2_crouch"] = %ai_zombie_boss_idle_a; 105 | } 106 | else 107 | { 108 | self.a.array["exposed_idle"] = array( %ai_zombie_idle_v1 ); 109 | self.a.array["straight_level"] = %ai_zombie_idle_base; 110 | self.a.array["stand_2_crouch"] = %ai_zombie_shot_leg_right_2_crawl; 111 | } 112 | if (isDefined(self.set_animarray_standing_override) ) 113 | { 114 | self [[self.set_animarray_standing_override]](); 115 | } 116 | } 117 | 118 | // CCheng (8/22/2008): This was not as Byzantine as set_animarray_standing(), but it was still 119 | // becoming increasingly difficult to tell which anims were and were not getting set in any 120 | // particular case, so I reorganized it to match the new set_animarray_standing(). 121 | 122 | set_animarray_crouching() 123 | { 124 | self.a.array = []; 125 | 126 | // START OF DEFAULTS: First, set the defaults, then override with weapon-specific animations. 127 | 128 | /# 129 | //SUMEET_TODO - take this block out once the issues are resolved. 130 | if( GetDvar( #"debug_script_issues") == "on" ) 131 | { 132 | if( self.a.script != "combat" ) 133 | { 134 | Print( "AI is in combat script but its script is " + self.a.script ); 135 | anything = undefined; 136 | if( anything ) 137 | { 138 | // do nothing, this is just to halt the script debugger, as on AssetEx, it does not halt sometimes. 139 | } 140 | } 141 | //AssertEx(self.a.script == "combat", "AI is in combat script but its script is " + self.a.script ); 142 | } 143 | #/ 144 | self.a.array["exposed_idle"] = array( %exposed_crouch_idle_alert_v1, %exposed_crouch_idle_alert_v2, %exposed_crouch_idle_alert_v3 ); 145 | 146 | self.a.array["crouch_2_stand"] = %exposed_crouch_2_stand; 147 | self.a.array["stand_2_crouch"] = %exposed_stand_2_crouch; 148 | 149 | self.a.array["exposed_idle"] = array( %ai_zombie_idle_crawl ); 150 | self.a.array["straight_level"] = %ai_zombie_idle_crawl_base; 151 | self.a.array["stand_2_crouch"] = %ai_zombie_shot_leg_left_2_crawl; 152 | 153 | // END OF DEFAULTS 154 | // START OF WEAPON-SPECIFICS: To keep things organized, only override stuff you need to change. 155 | } 156 | 157 | exposedCombatMainLoop() 158 | { 159 | self endon ("killanimscript"); 160 | self endon ("melee"); 161 | self endon ("special_attack"); 162 | 163 | self thread ReacquireWhenNecessary(); 164 | 165 | self AnimMode("zonly_physics", false); 166 | 167 | // before, we oriented to enemy briefly and then changed to face current. 168 | // now we just face current immediately and rely on turning. 169 | self OrientMode( "face angle", self.angles[1] ); 170 | 171 | self resetGiveUpOnEnemyTime(); 172 | 173 | // hesitate to crouch. 174 | // crouching too early can look stupid because we'll tend to stand right back up in a lot of cases. 175 | self.a.dontCrouchTime = GetTime() + randomintrange( 500, 1500 ); 176 | 177 | justWaited = false; 178 | 179 | for(;;) 180 | { 181 | 182 | self IsInCombat(); // reset our in-combat state 183 | 184 | if ( !justWaited ) 185 | { 186 | if ( self.a.pose == "stand" ) 187 | { 188 | self set_animarray_standing(); 189 | } 190 | else 191 | { 192 | self set_animarray_crouching(); 193 | } 194 | } 195 | 196 | justWaited = false; 197 | 198 | if ( TrySpecialAttack() ) 199 | { 200 | return; 201 | } 202 | 203 | if ( TryMelee() ) 204 | { 205 | return; 206 | } 207 | 208 | exposedWait(); 209 | justWaited = true; 210 | } 211 | } 212 | 213 | exposedWait() 214 | { 215 | if ( !isDefined(self.can_always_see) && (!IsDefined( self.enemy ) || !self cansee( self.enemy )) ) 216 | { 217 | self endon("enemy"); 218 | 219 | wait 0.2 + RandomFloat( 0.1 ); 220 | self waittill("do_slow_things"); 221 | } 222 | else 223 | if ( !IsDefined( self.enemy ) ) 224 | { 225 | self endon("enemy"); 226 | 227 | wait 0.2 + RandomFloat( 0.1 ); 228 | self waittill("do_slow_things"); 229 | } 230 | else 231 | { 232 | wait 0.05; 233 | } 234 | } 235 | 236 | resetGiveUpOnEnemyTime() 237 | { 238 | self.a.nextGiveUpOnEnemyTime = GetTime() + randomintrange( 2000, 4000 ); 239 | } 240 | 241 | // does turntable movement to face the enemy; 242 | // should be used sparingly because turn animations look better. 243 | faceEnemyImmediately() 244 | { 245 | self endon("killanimscript"); 246 | self notify("facing_enemy_immediately"); 247 | self endon("facing_enemy_immediately"); 248 | 249 | maxYawChange = 5; // degrees per frame 250 | 251 | while(1) 252 | { 253 | yawChange = 0 - GetYawToEnemy(); 254 | 255 | if ( abs( yawChange ) < 2 ) 256 | { 257 | break; 258 | } 259 | 260 | if ( abs( yawChange ) > maxYawChange ) 261 | { 262 | yawChange = maxYawChange * sign( yawChange ); 263 | } 264 | 265 | self OrientMode( "face angle", self.angles[1] + yawChange ); 266 | 267 | wait .05; 268 | } 269 | 270 | self OrientMode( "face current" ); 271 | } 272 | 273 | TryMelee() 274 | { 275 | if ( is_true( self.cant_melee ) ) 276 | { 277 | return false; 278 | } 279 | if ( !IsDefined( self.enemy ) ) 280 | { 281 | return false; 282 | } 283 | if ( isDefined(self.in_special_attack) ) 284 | { 285 | return false; 286 | } 287 | // early out 288 | if ( DistanceSquared( self.origin, self.enemy.origin ) > 512*512 ) 289 | { 290 | animscripts\zombie_melee::debug_melee( "Not doing melee - Distance to enemy is more than 512 units." ); 291 | return false; 292 | } 293 | 294 | canMelee = animscripts\zombie_melee::CanMeleeDesperate(); 295 | 296 | if ( !canMelee ) 297 | { 298 | return false; 299 | } 300 | 301 | self thread animscripts\zombie_melee::MeleeCombat(); 302 | self melee_notify_wrapper(); 303 | 304 | return true; 305 | } 306 | 307 | // If I am a banzai guy, and either I'm attacking an AI or else I randomly choose to, do a banzai attack. 308 | can_banzai_melee() 309 | { 310 | if ( !IsDefined( self.banzai ) || !self.banzai ) 311 | { 312 | return false; 313 | } 314 | 315 | if ( !self maps\_bayonet::has_bayonet() ) 316 | { 317 | return false; 318 | } 319 | 320 | return 0; 321 | } 322 | 323 | drop_turret() 324 | { 325 | maps\_mgturret::dropTurret(); 326 | 327 | self animscripts\weaponList::RefillClip(); 328 | self.a.needsToRechamber = 0; 329 | self notify ("dropped_gun"); 330 | maps\_mgturret::restoreDefaults(); 331 | } 332 | 333 | exception_exposed_mg42_portable() 334 | { 335 | drop_turret(); 336 | } 337 | 338 | ReacquireWhenNecessary() 339 | { 340 | self endon("killanimscript"); 341 | self endon("melee"); 342 | 343 | // don't look for a cover node right away. stand and fight. 344 | self.a.lookForNewCoverTime = GetTime() + randomintrange( 800, 1500 ); 345 | 346 | if ( self.fixedNode ) 347 | { 348 | return; 349 | } 350 | 351 | while(1) 352 | { 353 | wait .05; 354 | 355 | if ( self.fixedNode ) 356 | { 357 | return; 358 | } 359 | 360 | TryExposedReacquire(); 361 | } 362 | } 363 | 364 | // this function is meant to be called many times in succession. 365 | // each time it tries another option, until eventually it finds something it can do. 366 | TryExposedReacquire() 367 | { 368 | //prof_begin( "TryExposedReacquire" ); 369 | if ( !isValidEnemy(self.enemy) ) 370 | { 371 | self.reacquire_state = 0; 372 | return; 373 | } 374 | 375 | if ( isdefined(self.isAttacking) && self.isAttacking ) 376 | { 377 | self.reacquire_state = 0; 378 | return; 379 | } 380 | 381 | if ( self canSee( self.enemy ) ) 382 | { 383 | self.reacquire_state = 0; 384 | return; 385 | } 386 | 387 | switch (self.reacquire_state) 388 | { 389 | case 0: 390 | if (self ReacquireStep(32)) 391 | { 392 | assert(self.reacquire_state == 0); 393 | return; 394 | } 395 | break; 396 | 397 | case 1: 398 | if (self ReacquireStep(64)) 399 | { 400 | self.reacquire_state = 0; 401 | return; 402 | } 403 | break; 404 | 405 | case 2: 406 | if (self ReacquireStep(96)) 407 | { 408 | self.reacquire_state = 0; 409 | return; 410 | } 411 | break; 412 | 413 | case 3: 414 | if ( self.a.script != "combat" ) 415 | { 416 | self.reacquire_state = 0; 417 | return; 418 | } 419 | 420 | self FindReacquireNode(); 421 | self.reacquire_state++; 422 | // fall through 423 | 424 | case 4: 425 | node = self GetReacquireNode(); 426 | if (IsDefined(node)) 427 | { 428 | oldKeepNodeInGoal = self.keepClaimedNodeInGoal; 429 | oldKeepNode = self.keepClaimedNode; 430 | self.keepClaimedNodeInGoal = false; 431 | self.keepClaimedNode = false; 432 | 433 | if (self UseReacquireNode(node)) 434 | { 435 | self.reacquire_state = 0; 436 | } 437 | else 438 | { 439 | self.keepClaimedNodeInGoal = oldKeepNodeInGoal; 440 | self.keepClaimedNode = oldKeepNode; 441 | } 442 | 443 | return; 444 | } 445 | break; 446 | 447 | case 5: 448 | if ( tryRunningToEnemy( false ) ) 449 | { 450 | self.reacquire_state = 0; 451 | return; 452 | } 453 | 454 | break; 455 | 456 | default: 457 | assert(self.reacquire_state == 6); 458 | self.reacquire_state = 0; 459 | if ( !(self canSee( self.enemy )) ) 460 | self FlagEnemyUnattackable(); 461 | return; 462 | } 463 | 464 | self.reacquire_state++; 465 | } 466 | 467 | TrySpecialAttack() 468 | { 469 | if ( !isdefined( self.specialAttack ) ) 470 | { 471 | return false; 472 | } 473 | 474 | return self [[ self.specialAttack ]](); 475 | } -------------------------------------------------------------------------------- /animscripts/zombie_dog_death.gsc: -------------------------------------------------------------------------------- 1 | #include common_scripts\utility; 2 | 3 | #using_animtree ("zombie_dog"); 4 | 5 | main() 6 | { 7 | self endon("killanimscript"); 8 | if ( IsDefined( self.a.nodeath ) ) 9 | { 10 | assertex( self.a.nodeath, "Nodeath needs to be set to true or undefined." ); 11 | 12 | // allow death script to run for a bit so it doesn't turn to corpse and get deleted too soon during melee sequence 13 | wait 3; 14 | return; 15 | } 16 | 17 | self Unlink(); 18 | 19 | if ( IsDefined( self.enemy ) && IsDefined( self.enemy.syncedMeleeTarget ) && self.enemy.syncedMeleeTarget == self ) 20 | { 21 | self.enemy.syncedMeleeTarget = undefined; 22 | } 23 | 24 | if ( is_true( self.tesla_death ) || is_true( self.microwavegun_death ) || is_true( self.microwavegun_dw_death ) ) 25 | { 26 | death_anims = []; 27 | death_anims[death_anims.size] = %zombie_dog_tesla_death_a; 28 | death_anims[death_anims.size] = %zombie_dog_tesla_death_b; 29 | death_anims[death_anims.size] = %zombie_dog_tesla_death_c; 30 | death_anims[death_anims.size] = %zombie_dog_tesla_death_d; 31 | death_anims[death_anims.size] = %zombie_dog_tesla_death_e; 32 | 33 | self animMode( "gravity" ); 34 | self clearanim(%root, 0.2); 35 | self setflaggedanimrestart("dog_anim", death_anims[ randomint( death_anims.size ) ], 1, 0.2, 1); 36 | self animscripts\zombie_shared::DoNoteTracks( "dog_anim" ); 37 | } 38 | else 39 | { 40 | death_direction = animscripts\zombie_dog_pain::getAnimDirection( self.damageyaw ); 41 | 42 | self animMode( "gravity" ); 43 | self clearanim(%root, 0.2); 44 | self setflaggedanimrestart("dog_anim", anim.dogAnims[self.animSet].death[death_direction], 1, 0.2, 1); 45 | self animscripts\zombie_shared::DoNoteTracks( "dog_anim" ); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /clientscripts/_clientfaceanim.csc: -------------------------------------------------------------------------------- 1 | // Initial clientside script for doing face animations. 2 | #include clientscripts\_face_utility; 3 | #include clientscripts\_utility; 4 | 5 | actor_flag_change_handler( localClientNum, flag, set, newEnt ) 6 | { 7 | if( flag == 1 ) 8 | { 9 | if ( set ) 10 | { 11 | //println("*** SET flag " + flag + " - for ent " + self getentitynumber() + "["+self.type+"]"); 12 | self.face_disable = true; 13 | self notify( "face", "face_advance" ); 14 | } 15 | else 16 | { 17 | //println("*** CLEARED flag " + flag + " - for ent " + self getentitynumber() + "["+self.type+"]"); 18 | self.face_disable = false; 19 | self notify( "face", "face_advance" ); 20 | } 21 | } 22 | } 23 | 24 | init_clientfaceanim() 25 | { 26 | // Attached in entity spawned 27 | level._faceAnimCBFunc = clientscripts\_clientfaceanim::doFace; 28 | } 29 | 30 | doFace( localClientNum ) 31 | { 32 | //PrintLn( "New DoFace Call" ); 33 | while( true ) 34 | { 35 | if ( self IsPlayer() ) 36 | { 37 | //PrintLn( "DoFace!" ); 38 | doFace_player( localClientNum ); 39 | self waittill( "respawn" ); 40 | while( !IsDefined( self ) ) 41 | { 42 | wait( 0.05 ); 43 | } 44 | self.face_death = false; 45 | self.face_disable = false; 46 | } 47 | else 48 | { 49 | return; 50 | } 51 | } 52 | } 53 | 54 | #using_animtree ( "multiplayer" ); 55 | doFace_player( localClientNum ) 56 | { 57 | level.face_anim_tree = "multiplayer"; 58 | 59 | self setFaceRoot( %head ); 60 | self buildFaceState( "face_casual", true, -1, 0, "basestate", %pf_casual_idle ); 61 | self buildFaceState( "face_alert", true, -1, 0, "basestate", %pf_alert_idle ); 62 | self buildFaceState( "face_shoot", true, 1, 1, "eventstate", %pf_firing ); 63 | self buildFaceState( "face_shoot_single", true, 1, 1, "eventstate", %pf_firing ); 64 | self buildFaceState( "face_melee", true, 2, 1, "eventstate", %pf_melee ); 65 | self buildFaceState( "face_pain", false, -1, 2, "eventstate", %pf_pain ); 66 | self buildFaceState( "face_death", false, -1, 2, "exitstate", %pf_death ); 67 | self buildFaceState( "face_advance", false, -1, 3, "nullstate", undefined ); 68 | 69 | PrintLn( "Starting Client Face Anims" ); 70 | 71 | self thread processFaceEvents( localClientNum ); 72 | } 73 | 74 | do_corpse_face_hack(localClientNum) 75 | { 76 | if( IsDefined( self ) && IsDefined( level.face_anim_tree ) && IsDefined( level.faceStates ) ) 77 | { 78 | numAnims = level.faceStates["face_death"]["animation"].size; 79 | if ( !isdefined ( self ) ) 80 | return; 81 | self SetAnimKnob( level.faceStates["face_death"]["animation"][RandomInt(numAnims)], 1.0, 0.1, 1.0 ); 82 | } 83 | } 84 | -------------------------------------------------------------------------------- /clientscripts/_face_utility.csc: -------------------------------------------------------------------------------- 1 | #include clientscripts\_utility; 2 | 3 | setFaceRoot( root ) 4 | { 5 | if( !IsDefined( level.faceStates ) ) 6 | { 7 | level.faceStates = []; 8 | } 9 | 10 | if( !IsDefined( level.faceStates ) ) 11 | { 12 | level.faceStates = []; 13 | } 14 | 15 | level.faceStates["face_root"] = root; 16 | } 17 | 18 | buildFaceState( face_state, looping, timer, priority, statetype, animation ) 19 | { 20 | if( !IsDefined( level.faceStates ) ) 21 | { 22 | level.faceStates = []; 23 | } 24 | 25 | if( !IsDefined( level.faceStates ) ) 26 | { 27 | level.faceStates = []; 28 | } 29 | 30 | level.faceStates[face_state][ "looping" ] = looping; 31 | level.faceStates[face_state][ "timer" ] = timer; 32 | level.faceStates[face_state][ "priority" ] = priority; 33 | level.faceStates[face_state][ "statetype" ] = statetype; 34 | level.faceStates[face_state][ "animation" ] = []; 35 | level.faceStates[face_state][ "animation" ][0] = animation; 36 | } 37 | 38 | addAnimToFaceState( face_state, animation ) 39 | { 40 | Assert( IsDefined( level.faceStates[face_state] ) ); 41 | Assert( IsDefined( level.faceStates[face_state]["animation"] ) ); 42 | 43 | curr_size = level.faceStates[face_state][ "animation" ].size; 44 | level.faceStates[face_state][ "animation" ][curr_size] = animation; 45 | } 46 | 47 | isHigherPriority( new_state, old_state ) 48 | { 49 | if ( GetDvarInt( #"cg_debugFace" ) != 0 ) 50 | { 51 | PrintLn( "newstate "+new_state+" oldstate "+old_state ); 52 | if ( !isdefined( new_state ) ) 53 | PrintLn( "new_state undefined\n" ); 54 | if ( !isdefined( level.faceStates ) ) 55 | PrintLn( "level.faceStates undefined\n" ); 56 | if ( !isdefined( level.faceStates ) ) 57 | PrintLn( "level.faceStates undefined\n" ); 58 | if ( !isdefined( level.faceStates[new_state] ) ) 59 | PrintLn( "level.faceStates[new_state] undefined\n" ); 60 | 61 | if ( !isdefined( level.faceStates[new_state] ) ) 62 | { 63 | 64 | faceStatesArray = getArrayKeys( level.faceStates ); 65 | PrintLn( new_state + " undefined\n" ); 66 | 67 | for( i = 0; i < faceStatesArray.size; i++ ) 68 | { 69 | println( i + ":" ); 70 | PrintLn( faceStatesArray[i] + "\n" ); 71 | } 72 | } 73 | } 74 | if( level.faceStates[new_state]["priority"] >= level.faceStates[old_state]["priority"] ) 75 | { 76 | if ( GetDvarInt( #"cg_debugFace" ) != 0 ) 77 | { 78 | PrintLn( "FaceState "+new_state+" is higher priority than "+old_state ); 79 | } 80 | return true; 81 | } 82 | if ( GetDvarInt( #"cg_debugFace" ) != 0 ) 83 | { 84 | PrintLn( "FaceState "+new_state+" is not higher priority than "+old_state ); 85 | } 86 | return false; 87 | } 88 | 89 | waitForAnyPriorityReturn( prevState ) 90 | { 91 | level endon( "demo_jump" ); 92 | self endon( "entityshutdown" ); 93 | self endon( "stop_facial_anims" ); 94 | self endon( "new_face_processor" ); 95 | 96 | if ( GetDvarInt( #"cg_debugFace" ) != 0 ) 97 | { 98 | PrintLn( "Waiting for priority return for "+prevState ); 99 | } 100 | 101 | while( true ) 102 | { 103 | self waittill( "face", newState ); 104 | if( isdefined( newState ) && newState != prevState && isHigherPriority( newState, prevState ) ) 105 | { 106 | break; 107 | } 108 | } 109 | 110 | return newState; 111 | } 112 | 113 | waitForFaceEventRepeat( base_time ) 114 | { 115 | level endon( "demo_jump" ); 116 | self endon( "entityshutdown" ); 117 | self endon( "stop_face_anims" ); 118 | self endon( "new_face_event" ); 119 | self endon( "face_timer_expired" ); 120 | 121 | state = self.face_curr_event; 122 | 123 | while( true ) 124 | { 125 | self waittill( "face", newState ); 126 | if( newState == state ) 127 | { 128 | self.face_timer = base_time; 129 | } 130 | } 131 | } 132 | 133 | waitForFaceEventComplete(localClientNum) 134 | { 135 | level endon( "demo_jump" ); 136 | self endon( "entityshutdown" ); 137 | self endon( "stop_face_anims" ); 138 | self endon( "new_face_event" ); 139 | 140 | if ( GetDvarInt( #"cg_debugFace" ) != 0 ) 141 | { 142 | PrintLn( "Trying to get animation for state "+self.face_curr_event+" # "+self.face_curr_event_idx ); 143 | } 144 | 145 | Assert( IsDefined( level.faceStates[self.face_curr_event]["animation"][self.face_curr_event_idx] ) ); 146 | 147 | self waittillmatch( self.face_curr_event, "end" ); 148 | 149 | self.face_curr_event = undefined; 150 | self.face_curr_event_idx = undefined; 151 | 152 | if ( GetDvarInt( #"cg_debugFace" ) != 0 ) 153 | { 154 | println("setAnimKnob Back To base"); 155 | } 156 | if ( !isdefined ( self ) ) 157 | return; 158 | self SetAnimKnob( level.faceStates[self.face_curr_base]["animation"][self.face_curr_base_idx], 1.0, 0.1, 1.0 ); 159 | self notify( "face", "face_advance" ); 160 | } 161 | 162 | processFaceEvents( localClientNum ) 163 | { 164 | self notify( "new_face_processor" ); 165 | level endon( "demo_jump" ); 166 | self endon( "entityshutdown" ); 167 | self endon( "new_face_processor" ); 168 | 169 | // Start the entity in face_alert 170 | state = "face_alert"; 171 | self.face_curr_base = "face_alert"; 172 | numAnims = level.faceStates[state]["animation"].size; 173 | self.face_curr_base_idx = RandomInt( numAnims ); 174 | 175 | if ( GetDvarInt( #"cg_debugFace" ) != 0 ) 176 | { 177 | println("setAnimKnobProcessFaceEvents"); 178 | } 179 | if ( !isdefined ( self ) ) 180 | return; 181 | self SetAnimKnob( level.faceStates[self.face_curr_base]["animation"][self.face_curr_base_idx], 1.0, 0.0, 1.0 ); 182 | 183 | // Unless we already have preset them as disabled or dead 184 | if ( isdefined( self.face_disable ) && self.face_disable ) 185 | state = "face_disable"; 186 | else if ( isdefined( self.face_death ) && self.face_death ) 187 | state = "face_death"; 188 | 189 | if ( !isdefined(self) ) 190 | return; 191 | 192 | self.face_state = state; 193 | self thread showState(); 194 | self thread watchfor_death(); 195 | 196 | while ( true ) 197 | { 198 | if ( GetDvarInt( #"cg_debugFace" ) != 0 ) 199 | { 200 | if ( !isdefined( state ) ) 201 | PrintLn( "state undefined\n" ); 202 | if ( !isdefined( level.faceStates ) ) 203 | PrintLn( "level.faceStates undefined\n" ); 204 | if ( !isdefined( level.faceStates ) ) 205 | PrintLn( "level.faceStates undefined\n" ); 206 | if ( !isdefined( level.faceStates[state] ) ) 207 | PrintLn( "level.faceStates[state] undefined\n" ); 208 | 209 | if ( !isdefined( level.faceStates[state] ) ) 210 | { 211 | 212 | faceStatesArray = getArrayKeys( level.faceStates ); 213 | PrintLn( state + " undefined\n" ); 214 | 215 | for( i = 0; i < faceStatesArray.size; i++ ) 216 | { 217 | println( i + ":" ); 218 | PrintLn( faceStatesArray[i] + "\n" ); 219 | } 220 | } 221 | } 222 | 223 | numAnims = level.faceStates[state]["animation"].size; 224 | 225 | if ( GetDvarInt( #"cg_debugFace" ) != 0 ) 226 | { 227 | PrintLn( "Found "+numAnims+" anims for state "+state ); 228 | } 229 | 230 | // If we have set face_disable on this entity, clear anims and wait for it to unset 231 | if( IsDefined( self.face_disable ) && self.face_disable == true ) 232 | { 233 | if ( GetDvarInt( #"cg_debugFace" ) != 0 ) 234 | { 235 | PrintLn( "Disabling face anims" ); 236 | } 237 | setFaceState( "face_disabled" ); 238 | self ClearAnim( level.faceStates[ "face_root" ], 0 ); 239 | self notify( "stop_face_anims" ); 240 | 241 | while( self.face_disable ) 242 | { 243 | wait( 0.05 ); 244 | } 245 | } 246 | 247 | if ( GetDvarInt( #"cg_debugFace" ) != 0 ) 248 | { 249 | if ( !isdefined( state ) ) 250 | PrintLn( "state undefined\n" ); 251 | if ( !isdefined( level.faceStates ) ) 252 | PrintLn( "level.faceStates undefined\n" ); 253 | if ( !isdefined( level.faceStates ) ) 254 | PrintLn( "level.faceStates undefined\n" ); 255 | if ( !isdefined( level.faceStates[state] ) ) 256 | PrintLn( "level.faceStates[state] undefined\n" ); 257 | 258 | if ( !isdefined( level.faceStates[state] ) ) 259 | { 260 | 261 | faceStatesArray = getArrayKeys( level.faceStates ); 262 | PrintLn( state + " undefined\n" ); 263 | 264 | for( i = 0; i < faceStatesArray.size; i++ ) 265 | { 266 | println( i + ":" ); 267 | PrintLn( faceStatesArray[i] + "\n" ); 268 | } 269 | } 270 | } 271 | 272 | setFaceState( state ); 273 | 274 | // If our current state is an exit state, nothing will supercede this animation so we should return 275 | if( level.faceStates[state]["statetype"] == "exitstate" ) 276 | { 277 | if ( GetDvarInt( #"cg_debugFace" ) != 0 ) 278 | { 279 | PrintLn( "Exitstate found, returning, anim tree:" + level.face_anim_tree ); 280 | } 281 | if ( !isdefined ( self ) ) 282 | return; 283 | if ( GetDvarInt( #"cg_debugFace" ) != 0 ) 284 | { 285 | println("setAnimKnob286"); 286 | } 287 | self SetAnimKnob( level.faceStates[state]["animation"][RandomInt(numAnims)], 1.0, 0.1, 1.0 ); 288 | self notify( "stop_face_anims" ); 289 | self.curr_face_base = undefined; 290 | self.curr_face_event = undefined; 291 | return; // All done! 292 | } 293 | else if( level.faceStates[state]["statetype"] == "basestate" ) 294 | { 295 | if( !IsDefined( self.face_curr_base ) || self.face_curr_base != state ) 296 | { 297 | self.face_curr_base = state; 298 | self.face_curr_base_idx = RandomInt( numAnims ); 299 | if ( GetDvarInt( #"cg_debugFace" ) != 0 ) 300 | { 301 | PrintLn( "New base face anim state "+self.face_curr_base+" anim # "+self.face_curr_base_idx ); 302 | } 303 | if( !IsDefined( self.face_curr_event ) ) 304 | { 305 | if ( GetDvarInt( #"cg_debugFace" ) != 0 ) 306 | { 307 | PrintLn( "trying to play animation for state "+self.face_curr_base+" w/ index "+self.face_curr_base_idx ); 308 | } 309 | if ( GetDvarInt( #"cg_debugFace" ) != 0 ) 310 | { 311 | println("setAnimKnob310"); 312 | } 313 | if ( !isdefined ( self ) ) 314 | return; 315 | self SetAnimKnob( level.faceStates[self.face_curr_base]["animation"][self.face_curr_base_idx], 1.0, 0.1, 1.0 ); 316 | } 317 | } 318 | } 319 | else if( level.faceStates[state]["statetype"] == "eventstate" ) 320 | { 321 | if( !IsDefined( self.face_curr_event ) || !level.faceStates[self.face_curr_event]["looping"] || self.face_curr_event != state ) 322 | { 323 | self.face_curr_event= state; 324 | self.face_curr_event_idx = RandomInt( numAnims ); 325 | if ( GetDvarInt( #"cg_debugFace" ) != 0 ) 326 | { 327 | PrintLn( "New face anim event "+self.face_curr_event+" anim # "+self.face_curr_event_idx ); 328 | } 329 | if ( !isdefined ( self ) ) 330 | return; 331 | self SetFlaggedAnimKnobRestart( self.face_curr_event, level.faceStates[self.face_curr_event]["animation"][self.face_curr_event_idx], 1.0, 0.1, 1.0 ); 332 | self thread waitForFaceEventComplete(localClientNum); 333 | } 334 | } 335 | 336 | if( IsDefined( self.face_curr_event ) ) 337 | { 338 | state = self waitForAnyPriorityReturn( self.face_curr_event ); 339 | } 340 | else 341 | { 342 | state = self waitForAnyPriorityReturn( self.face_curr_base ); 343 | } 344 | } 345 | } 346 | 347 | showState( state ) 348 | { 349 | /# 350 | level endon( "demo_jump" ); 351 | self endon( "entityshutdown" ); 352 | 353 | while ( true ) 354 | { 355 | if ( GetDvarInt( #"cg_debugFace" ) != 0 ) 356 | { 357 | if ( isdefined( self.face_state ) && isdefined( self.origin ) ) 358 | { 359 | entNum = self getentitynumber(); 360 | if ( !isdefined( entNum ) ) 361 | entNum = "?"; 362 | 363 | if ( isdefined( self.face_disable ) && self.face_disable ) 364 | disableChar = "-"; 365 | else 366 | disableChar = "+"; 367 | 368 | if ( isdefined( self.face_death ) && self.face_death ) 369 | deathChar = "D"; 370 | else 371 | deathChar = "A"; 372 | 373 | Print3d( self.origin + ( 0, 0, 72 ), disableChar + deathChar + "["+ entNum +"]" + self.face_state, (1,1,1), 1, 0.25 ); 374 | } 375 | } 376 | 377 | wait( 0.01667 ); 378 | } 379 | #/ 380 | } 381 | 382 | setFaceState( state ) 383 | { 384 | self.face_state = state; 385 | } 386 | 387 | watchfor_death() 388 | { 389 | level endon( "demo_jump" ); 390 | self endon( "entityshutdown" ); 391 | self endon( "new_face_processor" ); 392 | 393 | if ( !isdefined( self.face_death ) ) 394 | { 395 | self waittillmatch( "face", "face_death" ); 396 | self.face_death = true; 397 | } 398 | } 399 | 400 | -------------------------------------------------------------------------------- /clientscripts/_footsteps.csc: -------------------------------------------------------------------------------- 1 | init () 2 | { 3 | SetAIFootstepPrepend ("fly_step_run_npc_"); 4 | } 5 | 6 | playerFootstep(client_num, player, movementtype, ground_type, firstperson, quiet ) 7 | { 8 | // don't play footstep sounds while underwater 9 | if( player underwater() ) 10 | return; 11 | 12 | //Ayers - Added in specifically to override low footstep volume during tunnel sequence in Creek 13 | //Can be used to change the footstep type to run during any sequence 14 | if( IsDefined( level.footstep_vol_override ) ) 15 | { 16 | movementtype = "run"; 17 | } 18 | 19 | full_movement_type = "step_" + movementtype; 20 | sound_alias = buildMovementSoundAliasName(full_movement_type, ground_type, firstperson, quiet ); 21 | 22 | //set movement type for current footstep for use in _audio.csc 23 | player.movementtype = movementtype; 24 | //iprintlnbold (player.movementtype); 25 | 26 | player playsound( client_num, sound_alias ); 27 | 28 | if ( IsDefined( player.step_sound ) && (!quiet) && (player.step_sound) != "none" ) 29 | { 30 | volume = clientscripts\_audio::get_vol_from_speed (player); 31 | 32 | //iprintlnbold ("step sound " + player.step_sound + " Volume " + volume); 33 | player playsound (client_num, player.step_sound, player.origin, volume); 34 | } 35 | } 36 | 37 | playerJump(client_num, player, ground_type, firstperson, quiet) 38 | { 39 | // in cod4 and WAW the jump just played the run footstep sound 40 | sound_alias = buildMovementSoundAliasName("step_run", ground_type, firstperson, quiet ); 41 | 42 | player playsound( client_num, sound_alias ); 43 | } 44 | 45 | playerLand(client_num, player, ground_type, firstperson, quiet, damagePlayer) 46 | { 47 | sound_alias = buildMovementSoundAliasName("land", ground_type, firstperson, quiet ); 48 | 49 | player playsound( client_num, sound_alias ); 50 | // play step sound for landings if one exists 51 | if ( IsDefined( player.step_sound ) && (!quiet) && (player.step_sound) != "none" ) 52 | { 53 | volume = clientscripts\_audio::get_vol_from_speed (player); 54 | 55 | //iprintlnbold ("step sound " + player.step_sound + " Volume " + volume); 56 | player playsound (client_num, player.step_sound, player.origin, volume); 57 | } 58 | if ( damagePlayer ) 59 | { 60 | sound_alias = "fly_land_damage_npc"; 61 | if ( firstperson ) 62 | { 63 | sound_alias = "fly_land_damage_plr"; 64 | player playsound( client_num, sound_alias ); 65 | 66 | } 67 | } 68 | } 69 | 70 | playerFoliage(client_num, player, firstperson, quiet) 71 | { 72 | sound_alias = "fly_movement_foliage_npc"; 73 | if ( firstperson ) 74 | { 75 | sound_alias = "fly_movement_foliage_plr"; 76 | } 77 | 78 | player playsound( client_num, sound_alias ); 79 | } 80 | SetAIFootstepPrepend( prepend ) 81 | { 82 | level.footstepPrepend = prepend; 83 | } 84 | 85 | playAIFootstep(client_num, ent, pos, ground_type, on_fire, is_dog) 86 | { 87 | //iprintlnbold ("AI step called from _footsteps"); 88 | 89 | sound_alias = undefined; 90 | 91 | if ( !IsDefined( is_dog ) ) 92 | { 93 | is_dog = false; 94 | } 95 | 96 | if(IsDefined(ent.footstepPrepend)) 97 | { 98 | sound_alias = ent.footstepPrepend + ground_type; 99 | } 100 | else if( isdefined( level.footstepPrepend ) ) 101 | { 102 | sound_alias = level.footstepPrepend + ground_type; 103 | //sound_alias = "fly_step_run_npc_" + ground_type; 104 | } 105 | 106 | if ( is_dog ) 107 | { 108 | sound_alias = "fly_dog_step_run_default"; 109 | } 110 | 111 | if( isdefined( sound_alias ) ) 112 | playsound ( client_num, sound_alias, pos); 113 | 114 | if ( IsDefined( ent.step_sound ) && (ent.step_sound) != "null" ) 115 | { 116 | volume = clientscripts\_audio::get_vol_from_speed (ent); 117 | 118 | //iprintlnbold ("step sound " + ent.step_sound + " Volume " + volume); 119 | ent playsound (client_num, ent.step_sound, ent.origin, volume); 120 | } 121 | 122 | // we do not use this alias anymore 123 | // playSound( client_num, "fly_gear_run", pos ); 124 | 125 | ent do_foot_effect(client_num, ground_type, pos, on_fire); 126 | } 127 | 128 | buildMovementSoundAliasName( movementtype, ground_type, firstperson, quiet ) 129 | { 130 | if(firstperson && isdefined(level.snd_footstep_override_plr) && (level.snd_footstep_override_plr != "")) 131 | { 132 | return level.snd_footstep_override_plr; 133 | } 134 | 135 | if((!firstperson) && isdefined(level.snd_footstep_override_npc) && (level.snd_footstep_override_npc != "")) 136 | { 137 | return level.snd_footstep_override_npc; 138 | } 139 | 140 | sound_alias = "fly_"; 141 | if ( quiet ) 142 | { 143 | sound_alias = sound_alias + "q"; 144 | } 145 | 146 | sound_alias = sound_alias + movementtype; 147 | 148 | if ( firstperson ) 149 | { 150 | sound_alias = sound_alias + "_plr_"; 151 | } 152 | else 153 | { 154 | sound_alias = sound_alias + "_npc_"; 155 | } 156 | 157 | sound_alias = sound_alias + ground_type; 158 | 159 | return sound_alias; 160 | } 161 | 162 | do_foot_effect(client_num, ground_type, foot_pos, on_fire) 163 | { 164 | 165 | if(!isdefined(level._optionalStepEffects) && !isdefined(self._footstepOverrideEffect)) 166 | { 167 | return; 168 | } 169 | 170 | if( on_fire ) 171 | { 172 | ground_type = "fire"; 173 | } 174 | 175 | /# 176 | 177 | if(GetDvarInt(#"debug_surface_type")) 178 | { 179 | print3d(foot_pos, ground_type, (0.5, 0.5, 0.8), 1, 3, 30); 180 | } 181 | 182 | #/ 183 | 184 | if(isdefined(self._footstepOverrideEffect)) 185 | { 186 | fwd = anglestoforward(self.angles); 187 | playfx(client_num, level._effect[self._footstepOverrideEffect], foot_pos, fwd, (0,0,1) ); 188 | return; 189 | } 190 | 191 | for(i = 0; i < level._optionalStepEffects.size; i ++) 192 | { 193 | if(level._optionalStepEffects[i] == ground_type) 194 | { 195 | effect = "step_" + ground_type; 196 | 197 | if(isdefined(level._effect[effect])) 198 | { 199 | playfx(client_num, level._effect[effect], foot_pos, foot_pos + (0,0,100)); 200 | return; 201 | } 202 | } 203 | } 204 | 205 | } -------------------------------------------------------------------------------- /clientscripts/_load.csc: -------------------------------------------------------------------------------- 1 | // clientscripts/_load.csc 2 | 3 | #include clientscripts\_utility; 4 | #include clientscripts\_lights; 5 | #include clientscripts\_music; 6 | #include clientscripts\_busing; 7 | #include clientscripts\_clientfaceanim; 8 | 9 | 10 | levelNotifyHandler(clientNum, state, oldState) 11 | { 12 | if(state != "") 13 | { 14 | level notify(state, clientNum); 15 | } 16 | } 17 | 18 | end_last_stand(clientNum) 19 | { 20 | self waittill("lastStandEnd"); 21 | 22 | println("Last stand ending for client " + clientNum); 23 | 24 | if(getlocalplayers().size == 1) // No busing modifications in split screen. 25 | { 26 | setBusState("return_default"); 27 | } 28 | 29 | realwait(0.7); 30 | 31 | println("Gasp."); 32 | playsound(clientNum, "revive_gasp"); 33 | } 34 | 35 | last_stand_thread(clientNum) 36 | { 37 | self thread end_last_stand(clientNum); 38 | 39 | self endon("lastStandEnd"); 40 | 41 | println("*** Client : Last stand starts on client " + clientNum); 42 | 43 | if( IsDefined( level.zombie_intermission ) && level.zombie_intermission ) 44 | { 45 | setBusState("zombie_death"); 46 | } 47 | else if(getlocalplayers().size == 1) 48 | { 49 | setBusState("last_stand_start"); 50 | realWait(0.1); 51 | setBusState("last_stand_duration"); 52 | } 53 | 54 | startVol = 0.5; 55 | maxVol = 1.0; 56 | 57 | startPause = 0.5; 58 | maxPause = 2.0; 59 | 60 | pause = startPause; 61 | vol = startVol; 62 | 63 | while(1) 64 | { 65 | id = playsound(clientNum, "chr_heart_beat"); 66 | setSoundVolume(id, vol); 67 | //iprintlnbold( "LASTSTAND ON CLIENT " + clientNum ); 68 | 69 | realWait(pause); 70 | 71 | if(pause < maxPause) 72 | { 73 | pause *= 1.05; 74 | 75 | if(pause > maxPause) 76 | { 77 | pause = maxPause; 78 | } 79 | } 80 | 81 | if(vol < maxVol) 82 | { 83 | vol *= 1.05; 84 | 85 | if(vol > maxVol) 86 | { 87 | vol = maxVol; 88 | } 89 | } 90 | } 91 | } 92 | 93 | last_stand_monitor(clientNum, state, oldState) 94 | { 95 | player = getlocalplayers()[clientNum]; 96 | players = getlocalplayers(); 97 | 98 | if ( !isdefined( level._laststand ) ) 99 | { 100 | level._laststand = []; 101 | } 102 | 103 | if ( !isdefined( level._laststand[clientNum] ) ) 104 | { 105 | level._laststand[clientNum] = 0; 106 | } 107 | 108 | if(state == "1") 109 | { 110 | if(!level._laststand[clientNum]) 111 | { 112 | if(!isdefined(level.lslooper)) 113 | { 114 | level.lslooper = spawn(0, player.origin, "script.origin"); 115 | } 116 | player thread last_stand_thread(clientNum); 117 | 118 | //Check to make sure this sound doesn't play during a splitscreen game 119 | if( players.size <= 1 ) 120 | { 121 | level.lslooper playloopsound("evt_laststand_loop", 0.3); 122 | } 123 | 124 | level._laststand[clientNum] = true; 125 | } 126 | } 127 | else 128 | { 129 | if(level._laststand[clientNum]) 130 | { 131 | if(isdefined(level.lslooper)) 132 | { 133 | level.lslooper stoploopsound(0.7); 134 | } 135 | player notify("lastStandEnd"); 136 | level._laststand[clientNum] = false; 137 | } 138 | } 139 | } 140 | 141 | damage_visionset_think(local_client_num) 142 | { 143 | 144 | player = getlocalplayers()[local_client_num]; 145 | player endon("disconnect"); 146 | level endon("save_restore"); // Don't know if I need this. DSL 147 | 148 | wait(1.0); // Let player's health get set up. 149 | 150 | max_health = 100; // GetLocalClientMaxHealth(local_client_num); 151 | 152 | health_threshold = max_health * 0.75; 153 | 154 | health_threshold_off = max_health; 155 | 156 | visionset = false; 157 | 158 | PrintLn("*** HTH " + health_threshold); 159 | 160 | while(1) 161 | { 162 | health = GetLocalClientHealth(local_client_num); 163 | 164 | if(visionset == false) 165 | { 166 | if(health < health_threshold) 167 | { 168 | VisionSetDamage(local_client_num, 1, "low_health", 2); 169 | visionset = true; 170 | } 171 | } 172 | else 173 | { 174 | if(health >= max_health) 175 | { 176 | PrintLn("*** VS OFF"); 177 | VisionSetDamage(local_client_num, 0, "low_health", 2); 178 | visionset = false; 179 | } 180 | } 181 | realWait(0.01); 182 | } 183 | } 184 | 185 | effects_init_thread(client, notify_name) 186 | { 187 | // rsh061411 - client 1 doesn't get effects started on splitscreen map restart 188 | if ( level.zombiemode && IsSplitscreen() && client == 1 ) 189 | { 190 | level.effects_init = undefined; 191 | level thread effects_init_failsafe(); 192 | } 193 | level waittill(notify_name); 194 | println("*** Client : Starting effects system for client " + client); 195 | if ( level.zombiemode && IsSplitscreen() && client == 1 ) 196 | { 197 | level.effects_init = true; 198 | } 199 | clientscripts\_fx::fx_init(client); 200 | clientscripts\_ambient::init(client); 201 | 202 | // DSL - Removed visionset from damage overlay. 4/30/2010 6:52:14 PM 203 | 204 | /* if ( GetDvar( #"zombiemode" ) == "0" ) 205 | { 206 | level thread damage_visionset_think(client); 207 | } */ 208 | } 209 | 210 | effects_init_failsafe() 211 | { 212 | wait( 1 ); 213 | if ( !isdefined( level.effects_init ) ) 214 | { 215 | println( "**** Client : Effects never started for client 1" ); 216 | level notify( "effects_init_1" ); 217 | } 218 | } 219 | 220 | default_flag_change_handler(localClientNum, flag, set, newEnt) 221 | { 222 | /* 223 | action = "SET"; 224 | if(!set) 225 | { 226 | action = "CLEAR"; 227 | } 228 | 229 | println("*** DEFAULT client_flag_callback to " + action + " flag " + flag + " - for ent " + self getentitynumber() + "["+self.type+"]"); 230 | */ 231 | } 232 | 233 | init_client_flags() 234 | { 235 | level.CF_PLAYER_UNDERWATER = 15; 236 | } 237 | 238 | register_default_vehicle_callbacks() 239 | { 240 | // level._client_flag_callbacks["vehicle"] = clientscripts\_vehicle::vehicle_flag_change_handler; 241 | level._client_flag_callbacks["vehicle"] = []; 242 | register_clientflag_callback("vehicle", 0, clientscripts\_vehicle::vehicle_flag_0_handler); 243 | register_clientflag_callback("vehicle", 1, clientscripts\_vehicle::vehicle_flag_1_handler); 244 | register_clientflag_callback("vehicle", 2, clientscripts\_vehicle::vehicle_flag_toggle_sounds); 245 | register_clientflag_callback("vehicle", 3, clientscripts\_vehicle::vehicle_flag_3_handler); 246 | register_clientflag_callback("vehicle", 4, clientscripts\_vehicle::vehicle_flag_4_handler); 247 | register_clientflag_callback("vehicle", 6, clientscripts\_vehicle::vehicle_flag_turn_off_treadfx); 248 | register_clientflag_callback("vehicle", 7, clientscripts\_vehicle::vehicle_flag_change_treadfx_handler); 249 | register_clientflag_callback("vehicle", 8, clientscripts\_vehicle::vehicle_flag_toggle_exhaustfx_handler); 250 | register_clientflag_callback("vehicle", 9, clientscripts\_vehicle::vehicle_flag_change_exhaustfx_handler); 251 | register_clientflag_callback("vehicle", 10, clientscripts\_vehicle::vehicle_flag_toggle_lights_handler); 252 | register_clientflag_callback("vehicle", 11, clientscripts\_vehicle::vehicle_flag_toggle_siren_lights_handler); 253 | register_clientflag_callback("vehicle", 12, clientscripts\_vehicle::vehicle_flag_toggle_interior_lights_handler); 254 | } 255 | 256 | register_default_actor_callbacks() 257 | { 258 | // level._client_flag_callbacks["actor"] = ::default_flag_change_handler; 259 | level._client_flag_callbacks["actor"] = []; 260 | } 261 | 262 | register_default_player_callbacks() 263 | { 264 | level._client_flag_callbacks["player"] = []; 265 | register_clientflag_callback("player", level.CF_PLAYER_UNDERWATER, ::player_underwater_flag_handler); 266 | } 267 | 268 | register_default_NA_callbacks() 269 | { 270 | level._client_flag_callbacks["NA"] = []; 271 | } 272 | 273 | register_default_general_callbacks() 274 | { 275 | level._client_flag_callbacks["general"] = []; 276 | } 277 | 278 | register_default_missile_callbacks() 279 | { 280 | level._client_flag_callbacks["missile"] = []; 281 | } 282 | 283 | register_default_scriptmover_callbacks() 284 | { 285 | level._client_flag_callbacks["scriptmover"] = []; 286 | } 287 | 288 | register_default_mg42_callbacks() 289 | { 290 | level._client_flag_callbacks["mg42"] = []; 291 | } 292 | 293 | register_default_plane_callbacks() 294 | { 295 | level._client_flag_callbacks["plane"] = []; 296 | register_clientflag_callback("plane", 6, clientscripts\_vehicle::vehicle_flag_turn_off_treadfx); 297 | } 298 | 299 | setup_default_client_flag_callbacks() 300 | { 301 | init_client_flags(); 302 | 303 | level._client_flag_callbacks = []; 304 | 305 | register_default_vehicle_callbacks(); 306 | register_default_actor_callbacks(); 307 | register_default_player_callbacks(); 308 | register_default_NA_callbacks(); 309 | register_default_general_callbacks(); 310 | register_default_missile_callbacks(); 311 | register_default_scriptmover_callbacks(); 312 | register_default_mg42_callbacks(); 313 | register_default_plane_callbacks(); 314 | } 315 | 316 | player_underwater_flag_handler(localClientNum, set, newEnt) 317 | { 318 | action = "SET"; 319 | if(!set) 320 | { 321 | action = "CLEAR"; 322 | } 323 | 324 | if(action == "SET") 325 | { 326 | if(isDefined(level.swimming_underwater_func)) 327 | { 328 | self [[level.swimming_underwater_func]](); 329 | } 330 | else 331 | { 332 | self clientscripts\_swimming::underwater(); 333 | } 334 | } 335 | else 336 | { 337 | if(isDefined(level.swimming_surface_func)) 338 | { 339 | self [[level.swimming_surface_func]](); 340 | } 341 | else 342 | { 343 | self clientscripts\_swimming::surface(); 344 | } 345 | } 346 | } 347 | 348 | main() 349 | { 350 | clientscripts\_utility_code::struct_class_init(); 351 | 352 | clientscripts\_utility::registerSystem("levelNotify", ::levelNotifyHandler); 353 | clientscripts\_utility::registerSystem("lsm", ::last_stand_monitor); 354 | 355 | level.createFX_enabled = ( getdvar( #"createfx" ) != "" ); 356 | level.zombiemode = ( GetDvar( #"zombiemode" ) == "1" ); 357 | 358 | if( !isDefined( level.scr_anim ) ) 359 | level.scr_anim[ 0 ][ 0 ] = 0; 360 | 361 | setup_default_client_flag_callbacks(); 362 | 363 | clientscripts\_global_fx::main(); 364 | clientscripts\_busing::busInit(); 365 | clientscripts\_ambientpackage::init(); 366 | clientscripts\_music::music_init(); 367 | clientscripts\_vehicle::init_vehicles(); 368 | clientscripts\_contextual_melee::main(); 369 | clientscripts\_footsteps::init(); 370 | clientscripts\_helicopter_sounds::init(); 371 | 372 | /# 373 | clientscripts\_radiant_live_update::main(); 374 | #/ 375 | 376 | clientscripts\_face_generichuman::init(); 377 | clientscripts\_clientfaceanim::init_clientfaceanim(); 378 | 379 | // clientscripts\_russian_diary::init(); 380 | 381 | if(IsDefined(level._uses_crossbow) && level._uses_crossbow == true) 382 | { 383 | level thread clientscripts\_explosive_bolt::main(); 384 | } 385 | 386 | for(i = 0; i < 4; i ++) 387 | { 388 | level thread effects_init_thread(i, "effects_init_"+i); 389 | } 390 | 391 | //clientscripts\_utility::init_exploders(); 392 | 393 | // Setup global listen threads 394 | 395 | // rfo = red flashing overlay from _gameskill.gsc 396 | add_listen_thread( "rfo1", clientscripts\_utility::loop_sound_on_client, "chr_breathing_hurt", 0.3, 0.7, "rfo2" ); 397 | add_listen_thread( "rfo3", clientscripts\_utility::play_sound_on_client, "chr_breathing_better" ); 398 | add_listen_thread( "zi", ::zombie_intermission ); 399 | 400 | level.onlineGame = GetDvarInt( #"onlinegame" ); 401 | level._load_done = 1; 402 | } 403 | 404 | zombie_intermission() 405 | { 406 | level.zombie_intermission = true; 407 | } 408 | 409 | -------------------------------------------------------------------------------- /clientscripts/_zombiemode_equipment.csc: -------------------------------------------------------------------------------- 1 | #include clientscripts\_utility; 2 | 3 | is_equipment_included( equipment_name ) 4 | { 5 | if ( !IsDefined( level._included_equipment ) ) 6 | { 7 | return false; 8 | } 9 | 10 | for ( i = 0; i < level._included_equipment.size; i++ ) 11 | { 12 | if ( equipment_name == level._included_equipment[i] ) 13 | { 14 | return true; 15 | } 16 | } 17 | 18 | return false; 19 | } 20 | 21 | 22 | include_equipment( equipment ) 23 | { 24 | if ( !IsDefined( level._included_equipment ) ) 25 | { 26 | level._included_equipment = []; 27 | } 28 | 29 | level._included_equipment[level._included_equipment.size] = equipment; 30 | } 31 | -------------------------------------------------------------------------------- /clientscripts/_zombiemode_ffotd.csc: -------------------------------------------------------------------------------- 1 | #include clientscripts\_utility; 2 | 3 | 4 | main_start() 5 | { 6 | } 7 | 8 | 9 | main_end() 10 | { 11 | } 12 | 13 | -------------------------------------------------------------------------------- /clientscripts/_zombiemode_weap_tesla.csc: -------------------------------------------------------------------------------- 1 | #include clientscripts\_utility; 2 | #include clientscripts\_fx; 3 | #include clientscripts\_music; 4 | 5 | init() 6 | { 7 | if ( GetDvar( #"createfx" ) == "on" ) 8 | { 9 | return; 10 | } 11 | 12 | if ( !clientscripts\_zombiemode_weapons::is_weapon_included( "tesla_gun_zm" ) && !(isdefined( level.uses_tesla_powerup ) && level.uses_tesla_powerup) ) 13 | { 14 | return; 15 | } 16 | 17 | level._effect["tesla_viewmodel_rail"] = loadfx("maps/zombie/fx_zombie_tesla_rail_view"); 18 | level._effect["tesla_viewmodel_tube"] = loadfx("maps/zombie/fx_zombie_tesla_tube_view"); 19 | level._effect["tesla_viewmodel_tube2"] = loadfx("maps/zombie/fx_zombie_tesla_tube_view2"); 20 | level._effect["tesla_viewmodel_tube3"] = loadfx("maps/zombie/fx_zombie_tesla_tube_view3"); 21 | 22 | level._effect["tesla_viewmodel_rail_upgraded"] = loadfx( "maps/zombie/fx_zombie_tesla_rail_view_ug" ); 23 | level._effect["tesla_viewmodel_tube_upgraded"] = loadfx( "maps/zombie/fx_zombie_tesla_tube_view_ug" ); 24 | level._effect["tesla_viewmodel_tube2_upgraded"] = loadfx( "maps/zombie/fx_zombie_tesla_tube_view2_ug" ); 25 | level._effect["tesla_viewmodel_tube3_upgraded"] = loadfx( "maps/zombie/fx_zombie_tesla_tube_view3_ug" ); 26 | 27 | level thread player_init(); 28 | level thread tesla_notetrack_think(); 29 | } 30 | 31 | player_init() 32 | { 33 | waitforclient( 0 ); 34 | level.tesla_play_fx = []; 35 | level.tesla_play_rail = true; 36 | 37 | players = GetLocalPlayers(); 38 | for( i = 0; i < players.size; i++ ) 39 | { 40 | level.tesla_play_fx[i] = false; 41 | players[i] thread tesla_fx_rail( i ); 42 | players[i] thread tesla_fx_tube( i ); 43 | players[i] thread tesla_happy( i ); 44 | } 45 | } 46 | 47 | tesla_fx_rail( localclientnum ) 48 | { 49 | self endon( "disconnect" ); 50 | 51 | for( ;; ) 52 | { 53 | realwait( RandomFloatRange( 8, 12 ) ); 54 | 55 | if ( !level.tesla_play_fx[localclientnum] ) 56 | { 57 | continue; 58 | } 59 | if ( !level.tesla_play_rail ) 60 | { 61 | continue; 62 | } 63 | 64 | currentweapon = GetCurrentWeapon( localclientnum ); 65 | if ( currentweapon != "tesla_gun_zm" && currentweapon != "tesla_gun_upgraded_zm" ) 66 | { 67 | continue; 68 | } 69 | 70 | if ( IsADS( localclientnum ) || IsThrowingGrenade( localclientnum ) || IsMeleeing( localclientnum ) || IsOnTurret( localclientnum ) ) 71 | { 72 | continue; 73 | } 74 | 75 | if ( GetWeaponAmmoClip( localclientnum, currentweapon ) <= 0 ) 76 | { 77 | continue; 78 | } 79 | 80 | fx = level._effect["tesla_viewmodel_rail"]; 81 | 82 | if ( currentweapon == "tesla_gun_upgraded_zm" ) 83 | { 84 | fx = level._effect["tesla_viewmodel_rail_upgraded"]; 85 | } 86 | 87 | PlayViewmodelFx( localclientnum, fx, "tag_flash" ); 88 | playsound(localclientnum,"wpn_tesla_effects", (0,0,0)); 89 | } 90 | } 91 | 92 | tesla_fx_tube( localclientnum ) 93 | { 94 | self endon( "disconnect" ); 95 | 96 | for( ;; ) 97 | { 98 | realwait( 0.1 ); 99 | 100 | if ( !level.tesla_play_fx[localclientnum] ) 101 | { 102 | continue; 103 | } 104 | 105 | currentweapon = GetCurrentWeapon( localclientnum ); 106 | if ( currentweapon != "tesla_gun_zm" && currentweapon != "tesla_gun_upgraded_zm" ) 107 | { 108 | continue; 109 | } 110 | 111 | if ( IsThrowingGrenade( localclientnum ) || IsMeleeing( localclientnum ) || IsOnTurret( localclientnum ) ) 112 | { 113 | continue; 114 | } 115 | 116 | ammo = GetWeaponAmmoClip( localclientnum, currentweapon ); 117 | 118 | if ( ammo <= 0 ) 119 | { 120 | continue; 121 | } 122 | 123 | fx = level._effect["tesla_viewmodel_tube"]; 124 | 125 | if ( currentweapon == "tesla_gun_upgraded_zm" ) 126 | { 127 | if ( ammo == 3 || ammo == 4 ) 128 | { 129 | fx = level._effect["tesla_viewmodel_tube2_upgraded"]; 130 | } 131 | else if ( ammo == 1 || ammo == 2 ) 132 | { 133 | fx = level._effect["tesla_viewmodel_tube3_upgraded"]; 134 | } 135 | else 136 | { 137 | fx = level._effect["tesla_viewmodel_tube_upgraded"]; 138 | } 139 | } 140 | else // regular tesla gun 141 | { 142 | if ( ammo == 1 ) 143 | { 144 | fx = level._effect["tesla_viewmodel_tube3"]; 145 | } 146 | else if ( ammo == 2 ) 147 | { 148 | fx = level._effect["tesla_viewmodel_tube2"]; 149 | } 150 | else 151 | { 152 | fx = level._effect["tesla_viewmodel_tube"]; 153 | } 154 | } 155 | 156 | PlayViewmodelFx( localclientnum, fx, "tag_brass" ); 157 | } 158 | } 159 | tesla_notetrack_think() 160 | { 161 | for ( ;; ) 162 | { 163 | level waittill( "notetrack", localclientnum, note ); 164 | 165 | //println( "@@@ Got notetrack: " + note + " for client: " + localclientnum ); 166 | 167 | switch( note ) 168 | { 169 | case "sndnt#wpn_tesla_switch_flip_off": 170 | case "sndnt#wpn_tesla_first_raise_start": 171 | level.tesla_play_fx[localclientnum] = false; 172 | break; 173 | 174 | case "sndnt#wpn_tesla_switch_flip_on": 175 | case "sndnt#wpn_tesla_pullout_start": 176 | case "tesla_idle_start": 177 | level.tesla_play_fx[localclientnum] = true; 178 | break; 179 | 180 | } 181 | } 182 | } 183 | tesla_happy( localclientnum ) 184 | { 185 | for(;;) 186 | { 187 | level waittill ("TGH"); 188 | currentweapon = GetCurrentWeapon( localclientnum ); 189 | if ( currentweapon == "tesla_gun_zm" || currentweapon == "tesla_gun_upgraded_zm" ) 190 | { 191 | playsound(localclientnum,"wpn_tesla_happy", (0,0,0)); 192 | level.tesla_play_rail = false; 193 | realwait(2); 194 | level.tesla_play_rail = true; 195 | } 196 | 197 | } 198 | 199 | } 200 | 201 | 202 | 203 | -------------------------------------------------------------------------------- /clientscripts/_zombiemode_weap_thundergun.csc: -------------------------------------------------------------------------------- 1 | #include clientscripts\_utility; 2 | #include clientscripts\_fx; 3 | #include clientscripts\_music; 4 | 5 | init() 6 | { 7 | if ( GetDvar( #"createfx" ) == "on" ) 8 | { 9 | return; 10 | } 11 | 12 | if ( !clientscripts\_zombiemode_weapons::is_weapon_included( "thundergun_zm" ) ) 13 | { 14 | return; 15 | } 16 | 17 | 18 | level._effect["thundergun_viewmodel_power_cell1"] = loadfx("weapon/thunder_gun/fx_thundergun_power_cell_view1"); 19 | level._effect["thundergun_viewmodel_power_cell2"] = loadfx("weapon/thunder_gun/fx_thundergun_power_cell_view2"); 20 | level._effect["thundergun_viewmodel_power_cell3"] = loadfx("weapon/thunder_gun/fx_thundergun_power_cell_view3"); 21 | level._effect["thundergun_viewmodel_steam"] = loadfx("weapon/thunder_gun/fx_thundergun_steam_view"); 22 | 23 | level._effect["thundergun_viewmodel_power_cell_upgraded1"] = loadfx("weapon/thunder_gun/fx_thundergun_power_cell_view1"); 24 | level._effect["thundergun_viewmodel_power_cell_upgraded2"] = loadfx("weapon/thunder_gun/fx_thundergun_power_cell_view2"); 25 | level._effect["thundergun_viewmodel_power_cell_upgraded3"] = loadfx("weapon/thunder_gun/fx_thundergun_power_cell_view3"); 26 | level._effect["thundergun_viewmodel_steam"] = loadfx("weapon/thunder_gun/fx_thundergun_steam_view"); 27 | level._effect["thundergun_viewmodel_steam_upgraded"] = loadfx("weapon/thunder_gun/fx_thundergun_steam_view"); 28 | 29 | level.thundergun_steam_vents = 3; 30 | level.thundergun_power_cell_fx_handles = []; 31 | level.thundergun_power_cell_fx_handles[level.thundergun_power_cell_fx_handles.size] = -1; 32 | level.thundergun_power_cell_fx_handles[level.thundergun_power_cell_fx_handles.size] = -1; 33 | level.thundergun_power_cell_fx_handles[level.thundergun_power_cell_fx_handles.size] = -1; 34 | 35 | level thread player_init(); 36 | level thread thundergun_notetrack_think(); 37 | } 38 | 39 | player_init() 40 | { 41 | waitforclient( 0 ); 42 | level.thundergun_play_fx_power_cell = []; 43 | 44 | players = GetLocalPlayers(); 45 | for( i = 0; i < players.size; i++ ) 46 | { 47 | level.thundergun_play_fx_power_cell[i] = true; 48 | players[i] thread thundergun_fx_power_cell( i ); 49 | } 50 | } 51 | 52 | thundergun_fx_power_cell( localclientnum ) 53 | { 54 | self endon( "disconnect" ); 55 | 56 | oldAmmo = -1; 57 | oldCount = -1; 58 | 59 | self thread thundergun_fx_listener( localclientnum ); 60 | 61 | for( ;; ) 62 | { 63 | realwait( 0.1 ); 64 | 65 | // Fix for SP Campaign save game restore issue 66 | while ( !ClientHasSnapshot(0) ) 67 | { 68 | wait( 0.05 ); 69 | } 70 | 71 | weaponname = undefined; 72 | 73 | currentweapon = GetCurrentWeapon( localclientnum ); 74 | if ( !level.thundergun_play_fx_power_cell[localclientnum] || IsThrowingGrenade( localclientnum ) || IsMeleeing( localclientnum ) || IsOnTurret( localclientnum ) || (currentweapon != "thundergun_zm" && currentweapon != "thundergun_upgraded_zm") ) 75 | { 76 | if ( oldAmmo != -1 ) 77 | { 78 | thundergun_play_power_cell_fx( localclientnum, 0 ); 79 | } 80 | oldAmmo = -1; 81 | oldCount = -1; 82 | continue; 83 | } 84 | 85 | ammo = GetWeaponAmmoClip( localclientnum, currentweapon ); 86 | if ( oldAmmo > 0 && oldAmmo != ammo ) 87 | { 88 | thundergun_fx_fire( localclientnum ); 89 | 90 | } 91 | oldAmmo = ammo; 92 | 93 | if ( ammo > level.thundergun_power_cell_fx_handles.size ) 94 | { 95 | ammo = level.thundergun_power_cell_fx_handles.size; 96 | } 97 | 98 | if ( oldCount == -1 || oldCount != ammo ) 99 | { 100 | level thread thundergun_play_power_cell_fx( localclientnum, ammo ); 101 | } 102 | oldCount = ammo; 103 | } 104 | } 105 | 106 | thundergun_play_power_cell_fx( localclientnum, count ) 107 | { 108 | level notify( "kill_power_cell_fx" ); 109 | 110 | for ( i = 0; i < level.thundergun_power_cell_fx_handles.size; i++ ) 111 | { 112 | if ( IsDefined(level.thundergun_power_cell_fx_handles[i]) && level.thundergun_power_cell_fx_handles[i] != -1 ) 113 | { 114 | deletefx( localclientnum, level.thundergun_power_cell_fx_handles[i] ); 115 | level.thundergun_power_cell_fx_handles[i] = -1; 116 | } 117 | } 118 | 119 | if ( !count ) 120 | { 121 | return; 122 | } 123 | 124 | level endon( "kill_power_cell_fx" ); 125 | 126 | for ( ;; ) 127 | { 128 | currentweapon = GetCurrentWeapon( localclientnum ); 129 | if ( currentweapon != "thundergun_zm" && currentweapon != "thundergun_upgraded_zm" ) 130 | { 131 | wait( 0.05 ); 132 | continue; 133 | } 134 | 135 | for ( i = count; i > 0; i-- ) 136 | { 137 | fx = level._effect["thundergun_viewmodel_power_cell" + i]; 138 | if( currentweapon == "thundergun_upgraded_zm" ) 139 | { 140 | fx = level._effect["thundergun_viewmodel_power_cell_upgraded" + i]; 141 | } 142 | 143 | level.thundergun_power_cell_fx_handles[i - 1] = PlayViewmodelFx( localclientnum, fx, "tag_bulb" + i ); 144 | } 145 | realwait( 3 ); 146 | } 147 | } 148 | 149 | thundergun_fx_fire( localclientnum ) 150 | { 151 | currentweapon = GetCurrentWeapon( localclientnum ); 152 | 153 | fx = level._effect["thundergun_viewmodel_steam"]; 154 | if( currentweapon == "thundergun_upgraded_zm" ) 155 | { 156 | fx = level._effect["thundergun_viewmodel_steam_upgraded"]; 157 | } 158 | 159 | for ( i = level.thundergun_steam_vents; i > 0; i-- ) 160 | { 161 | PlayViewmodelFx( localclientnum, fx, "tag_steam" + i ); 162 | } 163 | playsound(localclientnum,"wpn_thunder_breath", (0,0,0)); 164 | } 165 | 166 | thundergun_notetrack_think() 167 | { 168 | for ( ;; ) 169 | { 170 | level waittill( "notetrack", localclientnum, note ); 171 | 172 | //println( "@@@ Got notetrack: " + note + " for client: " + localclientnum ); 173 | 174 | switch( note ) 175 | { 176 | case "thundergun_putaway_start": 177 | level.thundergun_play_fx_power_cell[localclientnum] = false; 178 | break; 179 | 180 | case "thundergun_pullout_start": 181 | level.thundergun_play_fx_power_cell[localclientnum] = true; 182 | break; 183 | 184 | case "thundergun_fire_start": 185 | thundergun_fx_fire( localclientnum ); 186 | break; 187 | } 188 | } 189 | } 190 | 191 | thundergun_death_effects( localclientnum, weaponname, userdata ) 192 | { 193 | } 194 | thread_zombie_vox() 195 | { 196 | ent = spawn (0, self.origin, "script_origin"); 197 | playsound(0, "wpn_thundergun_proj_impact_zombie", ent.origin); 198 | wait(5); 199 | ent delete(); 200 | 201 | } 202 | 203 | // listen for the fx to be enabled/disabled 204 | thundergun_fx_listener( localclientnum ) 205 | { 206 | self endon( "disconnect" ); 207 | 208 | while (1) 209 | { 210 | level waittill( "tgfx0" ); // Thundergun fx off 211 | 212 | level.thundergun_play_fx_power_cell[localclientnum] = false; 213 | 214 | level waittill( "tgfx1" ); 215 | 216 | level.thundergun_play_fx_power_cell[localclientnum] = true; 217 | } 218 | } 219 | -------------------------------------------------------------------------------- /clientscripts/_zombiemode_weapons.csc: -------------------------------------------------------------------------------- 1 | #include clientscripts\_utility; 2 | 3 | weapon_box_callback(localClientNum, set, newEnt) 4 | { 5 | if(localClientNum != 0) 6 | { 7 | return; 8 | } 9 | 10 | if(set) 11 | { 12 | self thread weapon_floats_up(); 13 | } 14 | else 15 | { 16 | self notify("end_float"); 17 | 18 | cleanup_weapon_models(); 19 | } 20 | } 21 | 22 | cleanup_weapon_models() 23 | { 24 | if(IsDefined(self.weapon_models)) 25 | { 26 | players = getlocalplayers(); 27 | for( index = 0; index < players.size; index++) 28 | { 29 | if(IsDefined(self.weapon_models[index])) 30 | { 31 | self.weapon_models[index].dw Delete(); 32 | self.weapon_models[index] Delete(); 33 | } 34 | } 35 | self.weapon_models = undefined; 36 | } 37 | } 38 | 39 | weapon_is_dual_wield(name) 40 | { 41 | switch(name) 42 | { 43 | case "cz75dw_zm": 44 | case "cz75dw_upgraded_zm": 45 | case "m1911_upgraded_zm": 46 | case "hs10_upgraded_zm": 47 | case "pm63_upgraded_zm": 48 | case "microwavegundw_zm": 49 | case "microwavegundw_upgraded_zm": 50 | return true; 51 | default: 52 | return false; 53 | } 54 | } 55 | 56 | get_left_hand_weapon_model_name( name ) 57 | { 58 | switch ( name ) 59 | { 60 | case "microwavegundw_zm": 61 | return GetWeaponModel( "microwavegunlh_zm" ); 62 | case "microwavegundw_upgraded_zm": 63 | return GetWeaponModel( "microwavegundwlh_upgraded_zm" ); 64 | default: 65 | return GetWeaponModel( name ); 66 | } 67 | } 68 | 69 | weapon_floats_up() 70 | { 71 | self endon("end_float"); 72 | 73 | cleanup_weapon_models(); 74 | 75 | self.weapon_models = []; 76 | 77 | number_cycles = 39; 78 | floatHeight = 64; 79 | 80 | rand = treasure_chest_ChooseRandomWeapon(); 81 | modelname = GetWeaponModel( rand ); 82 | 83 | players = getlocalplayers(); 84 | for( i = 0; i < players.size; i ++) 85 | { 86 | self.weapon_models[i] = spawn(i, self.origin, "script_model"); 87 | self.weapon_models[i].angles = self.angles+( 0, 180, 0 ); 88 | self.weapon_models[i].dw = spawn(i, self.weapon_models[i].origin - ( 3, 3, 3 ), "script_model"); 89 | self.weapon_models[i].dw.angles = self.weapon_models[i].angles; 90 | self.weapon_models[i].dw Hide(); 91 | 92 | self.weapon_models[i] SetModel( modelname ); 93 | self.weapon_models[i].dw SetModel(modelname); 94 | self.weapon_models[i] useweaponhidetags( rand ); 95 | 96 | //move it up 97 | self.weapon_models[i] moveto( self.origin +( 0, 0, floatHeight ), 3, 2, 0.9 ); 98 | self.weapon_models[i].dw MoveTo(self.origin + (0,0,floatHeight) - ( 3, 3, 3 ), 3, 2, 0.9); 99 | } 100 | 101 | for( i = 0; i < number_cycles; i++ ) 102 | { 103 | 104 | if( i < 20 ) 105 | { 106 | wait( 0.05 ); 107 | } 108 | else if( i < 30 ) 109 | { 110 | wait( 0.1 ); 111 | } 112 | else if( i < 35 ) 113 | { 114 | wait( 0.2 ); 115 | } 116 | else if( i < 38 ) 117 | { 118 | wait( 0.3 ); 119 | } 120 | 121 | //debugstar(self.weapon_models[0].origin, 20, (0,1,0)); 122 | 123 | rand = treasure_chest_ChooseRandomWeapon(); 124 | modelname = GetWeaponModel( rand ); 125 | 126 | players = getlocalplayers(); 127 | for( index = 0; index < players.size; index++) 128 | { 129 | if(IsDefined(self.weapon_models[index])) 130 | { 131 | self.weapon_models[index] SetModel( modelname ); 132 | self.weapon_models[index] useweaponhidetags( rand ); 133 | 134 | if(weapon_is_dual_wield(rand)) 135 | { 136 | self.weapon_models[index].dw SetModel( get_left_hand_weapon_model_name( rand ) ); 137 | self.weapon_models[index].dw useweaponhidetags(rand); 138 | self.weapon_models[index].dw show(); 139 | } 140 | else 141 | { 142 | self.weapon_models[index].dw Hide(); 143 | } 144 | } 145 | } 146 | } 147 | 148 | cleanup_weapon_models(); 149 | } 150 | 151 | is_weapon_included( weapon_name ) 152 | { 153 | if ( !IsDefined( level._included_weapons ) ) 154 | { 155 | return false; 156 | } 157 | 158 | for ( i = 0; i < level._included_weapons.size; i++ ) 159 | { 160 | if ( weapon_name == level._included_weapons[i] ) 161 | { 162 | return true; 163 | } 164 | } 165 | 166 | return false; 167 | } 168 | 169 | 170 | include_weapon( weapon, display_in_box, func ) 171 | { 172 | if ( !IsDefined( level._included_weapons ) ) 173 | { 174 | level._included_weapons = []; 175 | } 176 | 177 | level._included_weapons[level._included_weapons.size] = weapon; 178 | 179 | if ( !IsDefined( level._display_box_weapons ) ) 180 | { 181 | level._display_box_weapons = []; 182 | } 183 | 184 | if ( !IsDefined( display_in_box ) ) 185 | { 186 | display_in_box = true; 187 | } 188 | 189 | if ( !display_in_box ) 190 | { 191 | return; 192 | } 193 | 194 | level._display_box_weapons[level._display_box_weapons.size] = weapon; 195 | } 196 | 197 | treasure_chest_ChooseRandomWeapon() 198 | { 199 | if ( !IsDefined(level._display_box_weapons)) 200 | { 201 | level._display_box_weapons = array( "python_zm", "g11_lps_zm", "famas_zm" ); 202 | } 203 | 204 | return level._display_box_weapons[RandomInt( level._display_box_weapons.size )]; 205 | } -------------------------------------------------------------------------------- /get_string.bat: -------------------------------------------------------------------------------- 1 | @echo off 2 | title getString by CabCon 3 | COLOR 2F 4 | echo Welcome To CabCons String Finder. Created by CabCon Mods ! 5 | echo. 6 | set /p Input= Enter String: 7 | echo %id% 8 | findstr /s /i "%Input%" *.* >FoundedStrings.txt 9 | pause 10 | -------------------------------------------------------------------------------- /maps/_ballistic_knife.gsc: -------------------------------------------------------------------------------- 1 | #include maps\_utility; 2 | #include common_scripts\utility; 3 | 4 | init() 5 | { 6 | if ( IsDefined( level._uses_retrievable_ballisitic_knives ) && level._uses_retrievable_ballisitic_knives == true ) 7 | { 8 | PrecacheModel( "t5_weapon_ballistic_knife_blade" ); 9 | PrecacheModel( "t5_weapon_ballistic_knife_blade_retrieve" ); 10 | } 11 | } 12 | 13 | on_spawn( watcher, player ) 14 | { 15 | player endon( "death" ); 16 | player endon( "disconnect" ); 17 | player endon( "zmb_lost_knife" ); // occurs when the player gives up or changes the type of ballistic_knife they are carrying 18 | level endon( "game_ended" ); 19 | 20 | self waittill( "stationary", endpos, normal, angles, attacker, prey, bone ); 21 | 22 | isFriendly = false; 23 | 24 | if( isDefined(endpos) ) 25 | { 26 | // once the missile dies, spawn a model there to be retrieved 27 | retrievable_model = Spawn( "script_model", endpos ); 28 | retrievable_model SetModel( "t5_weapon_ballistic_knife_blade" ); 29 | retrievable_model SetOwner( player ); 30 | retrievable_model.owner = player; 31 | retrievable_model.angles = angles; 32 | retrievable_model.name = watcher.weapon; 33 | 34 | if( IsDefined( prey ) ) 35 | { 36 | //Don't stick to teammates and friendly dogs 37 | if( isPlayer(prey) && player.team == prey.team ) 38 | isFriendly = true; 39 | else if( isAI(prey) && player.team == prey.team) 40 | isFriendly = true; 41 | 42 | if( !isFriendly ) 43 | { 44 | retrievable_model LinkTo( prey, bone ); 45 | retrievable_model thread force_drop_knives_to_ground_on_death( player, prey ); 46 | } 47 | else if( isFriendly ) 48 | { 49 | //launchVec = normal * -1; 50 | retrievable_model physicslaunch( normal, (randomint(10),randomint(10),randomint(10)) ); 51 | 52 | //Since the impact normal is not what we want anymore, and the knife will fall to the ground, send the world up normal. 53 | normal = (0,0,1); 54 | } 55 | 56 | } 57 | 58 | watcher.objectArray[watcher.objectArray.size] = retrievable_model; 59 | 60 | //Wait until the model is stationary again 61 | if( isFriendly ) 62 | { 63 | retrievable_model waittill( "stationary"); 64 | } 65 | 66 | retrievable_model thread drop_knives_to_ground( player ); 67 | 68 | if ( isFriendly ) 69 | { 70 | player notify( "ballistic_knife_stationary", retrievable_model, normal ); 71 | } 72 | else 73 | { 74 | player notify( "ballistic_knife_stationary", retrievable_model, normal, prey ); 75 | } 76 | 77 | retrievable_model thread wait_to_show_glowing_model( prey ); 78 | } 79 | } 80 | 81 | wait_to_show_glowing_model( prey ) // self == retrievable_model 82 | { 83 | level endon( "game_ended" ); 84 | self endon( "death" ); 85 | 86 | glowing_retrievable_model = Spawn( "script_model", self.origin ); 87 | self.glowing_model = glowing_retrievable_model; 88 | glowing_retrievable_model.angles = self.angles; 89 | glowing_retrievable_model LinkTo( self ); 90 | 91 | // we don't want to show the glowing retrievable model until the ragdoll finishes, this will keep the glow out of the kill cam 92 | if( IsDefined( prey ) ) 93 | { 94 | wait( 2 ); 95 | } 96 | 97 | glowing_retrievable_model SetModel( "t5_weapon_ballistic_knife_blade_retrieve" ); 98 | } 99 | 100 | on_spawn_retrieve_trigger( watcher, player ) 101 | { 102 | player endon( "death" ); 103 | player endon( "disconnect" ); 104 | player endon( "zmb_lost_knife" ); // occurs when the player gives up or changes the type of ballistic_knife they are carrying 105 | level endon( "game_ended" ); 106 | 107 | player waittill( "ballistic_knife_stationary", retrievable_model, normal, prey ); 108 | 109 | if( !IsDefined( retrievable_model ) ) 110 | return; 111 | 112 | vec_scale = 10; 113 | trigger_pos = []; 114 | if ( IsDefined( prey ) && ( isPlayer( prey ) || isAI( prey ) ) ) 115 | { 116 | trigger_pos[0] = prey.origin[0]; 117 | trigger_pos[1] = prey.origin[1]; 118 | trigger_pos[2] = prey.origin[2] + vec_scale; 119 | } 120 | else 121 | { 122 | trigger_pos[0] = retrievable_model.origin[0] + (vec_scale * normal[0]); 123 | trigger_pos[1] = retrievable_model.origin[1] + (vec_scale * normal[1]); 124 | trigger_pos[2] = retrievable_model.origin[2] + (vec_scale * normal[2]); 125 | } 126 | pickup_trigger = Spawn( "trigger_radius_use", (trigger_pos[0], trigger_pos[1], trigger_pos[2]) ); 127 | pickup_trigger SetCursorHint( "HINT_NOICON" ); 128 | pickup_trigger.owner = player; 129 | retrievable_model.retrievableTrigger = pickup_trigger; 130 | 131 | 132 | //retrievable_model thread debug_print( endpos ); 133 | 134 | hint_string = &"WEAPON_BALLISTIC_KNIFE_PICKUP"; 135 | if( IsDefined( hint_string ) ) 136 | { 137 | pickup_trigger SetHintString( hint_string ); 138 | } 139 | else 140 | { 141 | pickup_trigger SetHintString( &"GENERIC_PICKUP" ); 142 | } 143 | 144 | 145 | pickup_trigger SetTeamForTrigger( player.team ); 146 | 147 | player ClientClaimTrigger( pickup_trigger ); 148 | 149 | // link the model and trigger, then link them to the ragdoll if needed 150 | pickup_trigger EnableLinkTo(); 151 | if ( IsDefined( prey ) ) 152 | { 153 | pickup_trigger LinkTo( prey ); 154 | } 155 | else 156 | { 157 | pickup_trigger LinkTo( retrievable_model ); 158 | } 159 | 160 | retrievable_model thread watch_use_trigger( pickup_trigger, retrievable_model, ::pick_up, watcher.weapon, watcher.pickUpSoundPlayer, watcher.pickUpSound ); 161 | player thread watch_shutdown( pickup_trigger, retrievable_model ); 162 | } 163 | 164 | debug_print( endpos ) 165 | { 166 | self endon( "death" ); 167 | while( true ) 168 | { 169 | Print3d( endpos, "pickup_trigger" ); 170 | wait(0.05); 171 | } 172 | } 173 | 174 | watch_use_trigger( trigger, model, callback, weapon, playerSoundOnUse, npcSoundOnUse ) // self == retrievable_model 175 | { 176 | self endon( "death" ); 177 | self endon( "delete" ); 178 | level endon ( "game_ended" ); 179 | 180 | while ( true ) 181 | { 182 | trigger waittill( "trigger", player ); 183 | 184 | if ( !IsAlive( player ) ) 185 | continue; 186 | 187 | if ( !player IsOnGround() ) 188 | continue; 189 | 190 | if ( IsDefined( trigger.triggerTeam ) && ( player.team != trigger.triggerTeam ) ) 191 | continue; 192 | 193 | if ( IsDefined( trigger.claimedBy ) && ( player != trigger.claimedBy ) ) 194 | continue; 195 | 196 | if ( player UseButtonPressed() && !player.throwingGrenade && !player meleeButtonPressed() ) 197 | { 198 | if ( isdefined( playerSoundOnUse ) ) 199 | player playLocalSound( playerSoundOnUse ); 200 | if ( isdefined( npcSoundOnUse ) ) 201 | player playSound( npcSoundOnUse ); 202 | player thread [[callback]]( weapon, model, trigger ); 203 | break; 204 | } 205 | } 206 | } 207 | 208 | pick_up( weapon, model, trigger ) // self == player 209 | { 210 | // if we're not currently on the ballistic knife and the clip is empty then put the ammo in the clip 211 | current_weapon = self GetCurrentWeapon(); 212 | if( current_weapon != weapon ) 213 | { 214 | // if the clip is empty, fill it 215 | clip_ammo = self GetWeaponAmmoClip( weapon ); 216 | if( !clip_ammo ) 217 | { 218 | self SetWeaponAmmoClip( weapon , 1 ); 219 | } 220 | else 221 | { 222 | new_ammo_stock = self GetWeaponAmmoStock( weapon ) + 1; 223 | self SetWeaponAmmoStock( weapon , new_ammo_stock ); 224 | } 225 | } 226 | else 227 | { 228 | new_ammo_stock = self GetWeaponAmmoStock( weapon ) + 1; 229 | self SetWeaponAmmoStock( weapon, new_ammo_stock ); 230 | } 231 | 232 | model destroy_ent(); 233 | trigger destroy_ent(); 234 | } 235 | 236 | destroy_ent() 237 | { 238 | if( IsDefined(self) ) 239 | { 240 | if( IsDefined( self.glowing_model ) ) 241 | { 242 | self.glowing_model delete(); 243 | } 244 | 245 | self delete(); 246 | } 247 | } 248 | 249 | watch_shutdown( trigger, model ) // self == player 250 | { 251 | self waittill_any( "death", "disconnect", "zmb_lost_knife" ); // "zmb_lost_knife", occurs when the player gives up or changes the type of ballistic_knife they are carrying 252 | 253 | trigger destroy_ent(); 254 | model destroy_ent(); 255 | } 256 | 257 | drop_knives_to_ground( player ) 258 | { 259 | player endon("death"); 260 | player endon( "zmb_lost_knife" ); // occurs when the player gives up or changes the type of ballistic_knife they are carrying 261 | 262 | for( ;; ) 263 | { 264 | level waittill( "drop_objects_to_ground", origin, radius ); 265 | if( DistanceSquared( origin, self.origin )< radius * radius ) 266 | { 267 | self physicslaunch( (0,0,1), (5,5,5)); 268 | self thread update_retrieve_trigger( player ); 269 | } 270 | } 271 | } 272 | 273 | force_drop_knives_to_ground_on_death( player, prey ) 274 | { 275 | self endon("death"); 276 | player endon( "zmb_lost_knife" ); // occurs when the player gives up or changes the type of ballistic_knife they are carrying 277 | 278 | prey waittill( "death" ); 279 | self Unlink(); 280 | self physicslaunch( (0,0,1), (5,5,5)); 281 | self thread update_retrieve_trigger( player ); 282 | } 283 | 284 | update_retrieve_trigger( player ) 285 | { 286 | self endon("death"); 287 | player endon( "zmb_lost_knife" ); // occurs when the player gives up or changes the type of ballistic_knife they are carrying 288 | 289 | self waittill( "stationary"); 290 | 291 | trigger = self.retrievableTrigger; 292 | 293 | trigger.origin = ( self.origin[0], self.origin[1], self.origin[2] + 10 ); 294 | trigger LinkTo( self ); 295 | } -------------------------------------------------------------------------------- /maps/_utility.gsc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mcabcon/encorev8/11e609a285bd72c0d3d7b75a9b240d2e65dbbd43/maps/_utility.gsc -------------------------------------------------------------------------------- /maps/_weapons.gsc: -------------------------------------------------------------------------------- 1 | // AE 2-16-10: added this to the workflow, it comes from the same file name in MP, this is a slimmed down version 2 | #include common_scripts\utility; 3 | #include maps\_utility; 4 | 5 | init() 6 | { 7 | level thread on_player_connect(); 8 | 9 | // TODO: put weapon init's here 10 | maps\_flashgrenades::main(); 11 | maps\_weaponobjects::init(); 12 | maps\_explosive_bolt::init(); 13 | maps\_flamethrower_plight::init(); 14 | maps\_ballistic_knife::init(); 15 | } 16 | 17 | on_player_connect() 18 | { 19 | while( true ) 20 | { 21 | level waittill("connecting", player); 22 | 23 | player.usedWeapons = false; 24 | player.hits = 0; 25 | 26 | player thread on_player_spawned(); 27 | } 28 | } 29 | 30 | on_player_spawned() 31 | { 32 | self endon("disconnect"); 33 | self endon("death"); 34 | 35 | self.usedWeapons = false; 36 | self.hits = 0; 37 | 38 | while( true ) 39 | { 40 | self waittill("spawned_player"); 41 | 42 | self thread watch_weapon_usage(); 43 | self thread watch_grenade_usage(); 44 | } 45 | } 46 | 47 | watch_weapon_usage() 48 | { 49 | self endon( "death" ); 50 | self endon( "disconnect" ); 51 | level endon ( "game_ended" ); 52 | 53 | while( true ) 54 | { 55 | self waittill ( "begin_firing" ); 56 | 57 | curWeapon = self GetCurrentWeapon(); 58 | 59 | switch ( WeaponClass( curWeapon ) ) 60 | { 61 | case "rifle": 62 | case "pistol": 63 | case "mg": 64 | case "smg": 65 | case "spread": 66 | break; 67 | case "rocketlauncher": 68 | case "grenade": 69 | if ( WeaponInventoryType( curWeapon ) != "item" ) 70 | { 71 | self thread maps\_shellshock::rocket_earthQuake(); 72 | } 73 | break; 74 | default: 75 | break; 76 | } 77 | self waittill ( "end_firing" ); 78 | } 79 | } 80 | 81 | watch_grenade_usage() 82 | { 83 | self endon( "death" ); 84 | self endon( "disconnect" ); 85 | 86 | self thread begin_other_grenade_tracking(); 87 | 88 | while( true ) 89 | { 90 | self waittill ( "grenade_pullback", weaponName ); 91 | 92 | if ( weaponName == "claymore_mp" ) 93 | { 94 | continue; 95 | } 96 | 97 | self begin_grenade_tracking(); 98 | } 99 | } 100 | 101 | begin_grenade_tracking() 102 | { 103 | self endon ( "death" ); 104 | self endon ( "disconnect" ); 105 | 106 | startTime = GetTime(); 107 | 108 | self waittill ( "grenade_fire", grenade, weaponName ); 109 | 110 | if ( (getTime() - startTime > 1000) ) 111 | { 112 | grenade.isCooked = true; 113 | } 114 | 115 | switch( weaponName ) 116 | { 117 | case "frag_grenade_sp": 118 | case "sticky_grenade_mp": 119 | grenade thread maps\_shellshock::grenade_earthQuake(); 120 | grenade.originalOwner = self; 121 | break; 122 | case "satchel_charge_mp": 123 | grenade thread maps\_shellshock::satchel_earthQuake(); 124 | break; 125 | case "c4_mp": 126 | grenade thread maps\_shellshock::c4_earthQuake(); 127 | break; 128 | } 129 | 130 | self.throwingGrenade = false; 131 | } 132 | 133 | begin_other_grenade_tracking() 134 | { 135 | self notify( "grenadeTrackingStart" ); 136 | self endon( "grenadeTrackingStart" ); 137 | self endon( "disconnect" ); 138 | 139 | while( true ) 140 | { 141 | self waittill ( "grenade_fire", grenade, weaponName, parent ); 142 | 143 | switch( weaponName ) 144 | { 145 | case "flash_grenade_sp": 146 | break; 147 | case "signal_flare_mp": 148 | break; 149 | case "tabun_gas_mp": 150 | break; 151 | case "vc_grenade_sp": 152 | break; 153 | case "willy_pete_sp": 154 | case "m8_orange_smoke_sp": 155 | grenade thread watchSmokeGrenadeDetonation(); 156 | break; 157 | case "sticky_grenade_mp": 158 | case "satchel_charge_mp": 159 | case "c4_mp": 160 | break; 161 | } 162 | } 163 | } 164 | 165 | 166 | // these functions are used with scripted weapons (like satchels, shoeboxs, artillery) 167 | // returns an array of objects representing damageable entities (including players) within a given sphere. 168 | // each object has the property damageCenter, which represents its center (the location from which it can be damaged). 169 | // each object also has the property entity, which contains the entity that it represents. 170 | // to damage it, call damageEnt() on it. 171 | getDamageableEnts(pos, radius, doLOS, startRadius) 172 | { 173 | ents = []; 174 | 175 | if (!isdefined(doLOS)) 176 | doLOS = false; 177 | 178 | if ( !isdefined( startRadius ) ) 179 | startRadius = 0; 180 | 181 | // players 182 | players = GetPlayers(); 183 | for (i = 0; i < players.size; i++) 184 | { 185 | if (!isalive(players[i]) || players[i].sessionstate != "playing") 186 | continue; 187 | 188 | playerpos = players[i].origin + (0,0,32); 189 | dist = distance(pos, playerpos); 190 | if (dist < radius && (!doLOS || weaponDamageTracePassed(pos, playerpos, startRadius, undefined))) 191 | { 192 | newent = spawnstruct(); 193 | newent.isPlayer = true; 194 | newent.isADestructable = false; 195 | newent.entity = players[i]; 196 | newent.damageCenter = playerpos; 197 | ents[ents.size] = newent; 198 | } 199 | } 200 | 201 | // AI 202 | guys = getAIarray("axis", "allies", "neutral"); 203 | for (i = 0; i < guys.size; i++) 204 | { 205 | entpos = guys[i].origin; 206 | dist = distance(pos, entpos); 207 | if (dist < radius && (!doLOS || weaponDamageTracePassed(pos, entpos, startRadius, guys[i]))) 208 | { 209 | newent = spawnstruct(); 210 | newent.isPlayer = false; 211 | newent.isADestructable = false; 212 | newent.entity = guys[i]; 213 | newent.damageCenter = entpos; 214 | ents[ents.size] = newent; 215 | } 216 | } 217 | 218 | 219 | // grenades 220 | grenades = getentarray("grenade", "classname"); 221 | for (i = 0; i < grenades.size; i++) 222 | { 223 | entpos = grenades[i].origin; 224 | dist = distance(pos, entpos); 225 | if (dist < radius && (!doLOS || weaponDamageTracePassed(pos, entpos, startRadius, grenades[i]))) 226 | { 227 | newent = spawnstruct(); 228 | newent.isPlayer = false; 229 | newent.isADestructable = false; 230 | newent.entity = grenades[i]; 231 | newent.damageCenter = entpos; 232 | ents[ents.size] = newent; 233 | } 234 | } 235 | 236 | destructibles = getentarray("destructible", "targetname"); 237 | for (i = 0; i < destructibles.size; i++) 238 | { 239 | entpos = destructibles[i].origin; 240 | dist = distance(pos, entpos); 241 | if (dist < radius && (!doLOS || weaponDamageTracePassed(pos, entpos, startRadius, destructibles[i]))) 242 | { 243 | newent = spawnstruct(); 244 | newent.isPlayer = false; 245 | newent.isADestructable = false; 246 | newent.entity = destructibles[i]; 247 | newent.damageCenter = entpos; 248 | ents[ents.size] = newent; 249 | } 250 | } 251 | 252 | destructables = getentarray("destructable", "targetname"); 253 | for (i = 0; i < destructables.size; i++) 254 | { 255 | entpos = destructables[i].origin; 256 | dist = distance(pos, entpos); 257 | if (dist < radius && (!doLOS || weaponDamageTracePassed(pos, entpos, startRadius, destructables[i]))) 258 | { 259 | newent = spawnstruct(); 260 | newent.isPlayer = false; 261 | newent.isADestructable = true; 262 | newent.entity = destructables[i]; 263 | newent.damageCenter = entpos; 264 | ents[ents.size] = newent; 265 | } 266 | } 267 | 268 | return ents; 269 | } 270 | 271 | weaponDamageTracePassed(from, to, startRadius, ignore) 272 | { 273 | midpos = undefined; 274 | 275 | diff = to - from; 276 | if ( lengthsquared( diff ) < startRadius*startRadius ) 277 | midpos = to; 278 | dir = vectornormalize( diff ); 279 | midpos = from + (dir[0]*startRadius, dir[1]*startRadius, dir[2]*startRadius); 280 | 281 | trace = bullettrace(midpos, to, false, ignore); 282 | 283 | // if ( GetDvarInt( #"scr_damage_debug") != 0 ) 284 | // { 285 | // if (trace["fraction"] == 1) 286 | // { 287 | // thread debugline(midpos, to, (1,1,1)); 288 | // } 289 | // else 290 | // { 291 | // thread debugline(midpos, trace["position"], (1,.9,.8)); 292 | // thread debugline(trace["position"], to, (1,.4,.3)); 293 | // } 294 | // } 295 | 296 | return (trace["fraction"] == 1); 297 | } 298 | 299 | // eInflictor = the entity that causes the damage (e.g. a shoebox) 300 | // eAttacker = the player that is attacking 301 | // iDamage = the amount of damage to do 302 | // sMeansOfDeath = string specifying the method of death (e.g. "MOD_PROJECTILE_SPLASH") 303 | // sWeapon = string specifying the weapon used (e.g. "mine_shoebox_mp") 304 | // damagepos = the position damage is coming from 305 | // damagedir = the direction damage is moving in 306 | damageEnt(eInflictor, eAttacker, iDamage, sMeansOfDeath, sWeapon, damagepos, damagedir) 307 | { 308 | if (self.isPlayer) 309 | { 310 | self.damageOrigin = damagepos; 311 | self.entity thread [[level.callbackPlayerDamage]]( 312 | eInflictor, // eInflictor The entity that causes the damage.(e.g. a turret) 313 | eAttacker, // eAttacker The entity that is attacking. 314 | iDamage, // iDamage Integer specifying the amount of damage done 315 | 0, // iDFlags Integer specifying flags that are to be applied to the damage 316 | sMeansOfDeath, // sMeansOfDeath Integer specifying the method of death 317 | sWeapon, // sWeapon The weapon number of the weapon used to inflict the damage 318 | damagepos, // vPoint The point the damage is from? 319 | damagedir, // vDir The direction of the damage 320 | "none", // sHitLoc The location of the hit 321 | 0, // modelIndex ??? 322 | 0 // psOffsetTime The time offset for the damage 323 | ); 324 | } 325 | else if ( IsAlive( self.entity ) ) 326 | { 327 | // AIs should go through DoDamage and not use the "damage" notify directly 328 | self.entity DoDamage( iDamage, damagepos, eAttacker, eInflictor, sMeansOfDeath, 0 ); 329 | } 330 | else 331 | { 332 | // destructable walls and such can only be damaged in certain ways. 333 | if (self.isADestructable && (sWeapon == "artillery_mp" || sWeapon == "mine_bouncing_betty_mp")) 334 | return; 335 | 336 | self.entity damage_notify_wrapper( iDamage, eAttacker, (0,0,0), (0,0,0), "mod_explosive", "", "" ); 337 | } 338 | } 339 | 340 | watchSmokeGrenadeDetonation() 341 | { 342 | self waittill( "explode", position, surface ); 343 | 344 | smokeSound = spawn ("script_origin",(0,0,1)); 345 | smokeSound.origin = position; 346 | 347 | //playsoundatposition( "wpn_smoke_grenade_explode", position ); 348 | smokeSound playsound( "wpn_smoke_hiss_start" ); 349 | smokeSound playLoopSound ( "wpn_smoke_hiss_lp" ); 350 | wait(6); 351 | playsoundatposition( "wpn_smoke_hiss_end", position ); 352 | smokeSound StopLoopSound( .5); 353 | wait(.5); 354 | smokeSound delete(); 355 | } 356 | 357 | -------------------------------------------------------------------------------- /maps/_zombiemode_auto_turret.gsc: -------------------------------------------------------------------------------- 1 | #include maps\_utility; 2 | #include common_scripts\utility; 3 | #include maps\_zombiemode_utility; 4 | 5 | init() 6 | { 7 | level.auto_turret_array = GetEntArray( "auto_turret_trigger", "script_noteworthy" ); 8 | 9 | if( !isDefined( level.auto_turret_array ) ) 10 | { 11 | return; 12 | } 13 | else if( level.mutators["mutator_noTraps"] ) 14 | { 15 | for( i = 0; i < level.auto_turret_array.size; i++ ) 16 | { 17 | level.auto_turret_array[i] disable_trigger(); 18 | } 19 | } 20 | 21 | level.curr_auto_turrets_active = 0; 22 | 23 | if( !isDefined( level.max_auto_turrets_active ) ) 24 | { 25 | level.max_auto_turrets_active = 2; 26 | } 27 | 28 | if( !isDefined( level.auto_turret_cost ) ) 29 | { 30 | level.auto_turret_cost = 1500; 31 | } 32 | 33 | if( !isDefined( level.auto_turret_timeout ) ) 34 | { 35 | level.auto_turret_timeout = 30; 36 | } 37 | 38 | for( i = 0; i < level.auto_turret_array.size; i++ ) 39 | { 40 | level.auto_turret_array[i] SetCursorHint( "HINT_NOICON" ); 41 | level.auto_turret_array[i] sethintstring( &"ZOMBIE_NEED_POWER" ); 42 | level.auto_turret_array[i] UseTriggerRequireLookAt(); 43 | level.auto_turret_array[i].curr_time = -1; 44 | level.auto_turret_array[i].turret_active = false; 45 | level.auto_turret_array[i] thread auto_turret_think(); 46 | } 47 | } 48 | 49 | auto_turret_think() 50 | { 51 | if( !isDefined( self.target ) ) 52 | { 53 | return; 54 | } 55 | 56 | turret_array = GetEntArray( self.target, "targetname" ); 57 | 58 | if(IsDefined(self.target)) 59 | { 60 | for(i=0;i 1 && level.team_pool[player.team_num].score < cost) ) 111 | if(player.score < cost) 112 | { 113 | //player iprintln( "Not enough points to buy Perk: " + perk ); 114 | self playsound("deny"); 115 | player thread play_no_money_turret_dialog(); 116 | continue; 117 | } 118 | 119 | // if ( players.size == 1 ) 120 | { 121 | player maps\_zombiemode_score::minus_to_player_score( cost ); 122 | } 123 | /* else 124 | { 125 | player maps\_zombiemode_score::minus_to_team_score( cost ); 126 | } */ 127 | 128 | bbPrint( "zombie_uses: playername %s playerscore %d teamscore %d round %d cost %d name %s x %f y %f z %f type autoturret", player.playername, player.score, level.team_pool[ player.team_num ].score, level.round_number, cost, self.target, self.origin ); 129 | 130 | if( IsDefined( player ) ) 131 | { 132 | player maps\_zombiemode_audio::create_and_play_dialog( "general", "turret_active" ); 133 | } 134 | 135 | self thread auto_turret_activate(); 136 | self PlaySound( "zmb_turret_startup" ); 137 | 138 | self disable_trigger(); 139 | 140 | self waittill( "turret_deactivated" ); 141 | 142 | if( IsDefined( player ) ) 143 | { 144 | //Play the turret inactive vox 145 | player maps\_zombiemode_audio::create_and_play_dialog( "general", "turret_inactive" ); 146 | } 147 | 148 | playsoundatposition( "zmb_turret_down", self.audio_origin ); 149 | 150 | self enable_trigger(); 151 | } 152 | } 153 | 154 | 155 | activate_move_handle() 156 | { 157 | if(IsDefined(self.handle)) 158 | { 159 | // Rotate switch model 160 | self.handle rotatepitch( 160, .5 ); 161 | //self.handle playsound( "amb_sparks_l_b" ); 162 | self.handle waittill( "rotatedone" ); 163 | 164 | self notify( "switch_activated" ); 165 | self waittill( "turret_deactivated" ); 166 | 167 | self.handle rotatepitch( -160, .5 ); 168 | } 169 | } 170 | 171 | play_no_money_turret_dialog() 172 | { 173 | 174 | } 175 | 176 | auto_turret_activate() 177 | { 178 | self endon( "turret_deactivated" ); 179 | 180 | self thread activate_move_handle(); 181 | self waittill( "switch_activated" ); 182 | 183 | if( level.max_auto_turrets_active <= 0 ) 184 | { 185 | return; 186 | } 187 | 188 | while( level.curr_auto_turrets_active >= level.max_auto_turrets_active ) 189 | { 190 | worst_turret = undefined; 191 | worst_turret_time = -1; 192 | for( i = 0; i < level.auto_turret_array.size; i++ ) 193 | { 194 | if( level.auto_turret_array[i] == self ) 195 | { 196 | continue; 197 | } 198 | 199 | if( !level.auto_turret_array[i].turret_active ) 200 | { 201 | continue; 202 | } 203 | 204 | if( worst_turret_time < 0 || level.auto_turret_array[i].curr_time < worst_turret_time ) 205 | { 206 | worst_turret = level.auto_turret_array[i]; 207 | worst_turret_time = level.auto_turret_array[i].curr_time; 208 | } 209 | } 210 | if( isDefined( worst_turret ) ) 211 | { 212 | worst_turret auto_turret_deactivate(); 213 | } 214 | else 215 | { 216 | assertex( false, "Couldn't free an auto turret to activate another, this should never be the case" ); 217 | } 218 | } 219 | 220 | self.turret SetMode( "auto_nonai" ); 221 | self.turret thread maps\_mgturret::burst_fire_unmanned(); 222 | self.turret_active = true; 223 | 224 | self.turret_fx = Spawn( "script_model", self.turret.origin ); 225 | self.turret_fx SetModel( "tag_origin" ); 226 | self.turret_fx.angles = self.turret.angles; 227 | PlayFxOnTag( level._effect["auto_turret_light"], self.turret_fx, "tag_origin" ); 228 | 229 | self.curr_time = level.auto_turret_timeout; 230 | 231 | self thread auto_turret_update_timeout(); 232 | 233 | wait( level.auto_turret_timeout ); 234 | 235 | self auto_turret_deactivate(); 236 | } 237 | 238 | auto_turret_deactivate() 239 | { 240 | self.turret_active = false; 241 | self.curr_time = -1; 242 | self.turret SetMode( "auto_ai" ); 243 | self.turret notify( "stop_burst_fire_unmanned" ); 244 | 245 | self.turret_fx delete(); 246 | 247 | self notify( "turret_deactivated" ); 248 | } 249 | 250 | auto_turret_update_timeout() 251 | { 252 | self endon( "turret_deactivated" ); 253 | 254 | while( self.curr_time > 0 ) 255 | { 256 | wait( 1 ); 257 | self.curr_time--; 258 | } 259 | } -------------------------------------------------------------------------------- /maps/_zombiemode_bowie.gsc: -------------------------------------------------------------------------------- 1 | #include maps\_utility; 2 | #include common_scripts\utility; 3 | #include maps\_zombiemode_utility; 4 | 5 | bowie_init() 6 | { 7 | PrecacheItem( "zombie_bowie_flourish" ); 8 | 9 | if( isDefined( level.bowie_cost ) ) 10 | { 11 | cost = level.bowie_cost; 12 | } 13 | else 14 | { 15 | cost = 3000; 16 | } 17 | 18 | bowie_triggers = GetEntArray( "bowie_upgrade", "targetname" ); 19 | for( i = 0; i < bowie_triggers.size; i++ ) 20 | { 21 | knife_model = GetEnt( bowie_triggers[i].target, "targetname" ); 22 | knife_model hide(); 23 | bowie_triggers[i] thread bowie_think(cost); 24 | bowie_triggers[i] SetHintString( &"ZOMBIE_WEAPON_BOWIE_BUY", cost ); 25 | bowie_triggers[i] setCursorHint( "HINT_NOICON" ); 26 | bowie_triggers[i] UseTriggerRequireLookAt(); 27 | } 28 | } 29 | 30 | bowie_think(cost) 31 | { 32 | 33 | self.first_time_triggered = false; 34 | 35 | for( ;; ) 36 | { 37 | self waittill( "trigger", player ); 38 | // if not first time and they have the weapon give ammo 39 | 40 | if( !is_player_valid( player ) ) 41 | { 42 | player thread ignore_triggers( 0.5 ); 43 | continue; 44 | } 45 | 46 | if( player in_revive_trigger() ) 47 | { 48 | wait( 0.1 ); 49 | continue; 50 | } 51 | 52 | if( player isThrowingGrenade() ) 53 | { 54 | wait( 0.1 ); 55 | continue; 56 | } 57 | 58 | if( player is_drinking() ) 59 | { 60 | wait( 0.1 ); 61 | continue; 62 | } 63 | 64 | if( player HasWeapon( "bowie_knife_zm" ) || player HasWeapon( "minigun_zm" ) ) 65 | { 66 | wait(0.1); 67 | continue; 68 | } 69 | 70 | if( player isSwitchingWeapons() ) 71 | { 72 | wait(0.1); 73 | continue; 74 | } 75 | 76 | current_weapon = player GetCurrentWeapon(); 77 | if( is_placeable_mine( current_weapon ) || is_equipment( current_weapon ) || current_weapon == "minigun_zm" ) 78 | { 79 | wait(0.1); 80 | continue; 81 | } 82 | 83 | if (player maps\_laststand::player_is_in_laststand() || is_true( player.intermission ) ) 84 | { 85 | wait(0.1); 86 | continue; 87 | } 88 | 89 | //Z2 HasPerk( "specialty_altmelee" ) is returning undefined 90 | // player_has_bowie = player HasPerk( "specialty_altmelee" ); 91 | player_has_bowie = false; 92 | 93 | if( !player_has_bowie ) 94 | { 95 | // else make the weapon show and give it 96 | if( player.score >= cost ) 97 | { 98 | if( self.first_time_triggered == false ) 99 | { 100 | model = getent( self.target, "targetname" ); 101 | // model show(); 102 | model thread bowie_show( player ); 103 | self.first_time_triggered = true; 104 | } 105 | 106 | player maps\_zombiemode_score::minus_to_player_score( cost ); 107 | 108 | bbPrint( "zombie_uses: playername %s playerscore %d teamscore %d round %d cost %d name %s x %f y %f z %f type weapon", 109 | player.playername, player.score, level.team_pool[ player.team_num ].score, level.round_number, cost, "bowie_knife", self.origin ); 110 | 111 | player maps\_zombiemode_weapons::check_collector_achievement( "bowie_knife_zm" ); 112 | 113 | player give_bowie(); 114 | 115 | if ( player maps\_laststand::player_is_in_laststand() || is_true( player.intermission ) ) 116 | { 117 | // if they're in laststand at this point then they won't have gotten the bowie, so don't hide the trigger 118 | continue; 119 | } 120 | 121 | self SetInvisibleToPlayer( player ); 122 | player._bowie_zm_equipped = 1; 123 | } 124 | else 125 | { 126 | play_sound_on_ent( "no_purchase" ); 127 | player maps\_zombiemode_audio::create_and_play_dialog( "general", "no_money", undefined, 1 ); 128 | } 129 | } 130 | } 131 | } 132 | 133 | give_bowie() 134 | { 135 | //self SetPerk( "specialty_altmelee" ); 136 | 137 | gun = self do_bowie_flourish_begin(); 138 | self maps\_zombiemode_audio::create_and_play_dialog( "weapon_pickup", "bowie" ); 139 | 140 | self waittill_any( "fake_death", "death", "player_downed", "weapon_change_complete" ); 141 | 142 | // restore player controls and movement 143 | self do_bowie_flourish_end( gun ); 144 | } 145 | 146 | do_bowie_flourish_begin() 147 | { 148 | self increment_is_drinking(); 149 | 150 | self AllowLean( false ); 151 | self AllowAds( false ); 152 | self AllowSprint( false ); 153 | self AllowCrouch( true ); 154 | self AllowProne( false ); 155 | self AllowMelee( false ); 156 | 157 | wait( 0.05 ); 158 | 159 | if ( self GetStance() == "prone" ) 160 | { 161 | self SetStance( "crouch" ); 162 | } 163 | 164 | gun = self GetCurrentWeapon(); 165 | weapon = "zombie_bowie_flourish"; 166 | 167 | self GiveWeapon( weapon ); 168 | self SwitchToWeapon( weapon ); 169 | 170 | return gun; 171 | } 172 | 173 | do_bowie_flourish_end( gun ) 174 | { 175 | assert( gun != "zombie_perk_bottle_doubletap" ); 176 | assert( gun != "zombie_perk_bottle_revive" ); 177 | assert( gun != "zombie_perk_bottle_jugg" ); 178 | assert( gun != "zombie_perk_bottle_sleight" ); 179 | assert( gun != "zombie_perk_bottle_marathon" ); 180 | assert( gun != "zombie_perk_bottle_nuke" ); 181 | assert( gun != "zombie_perk_bottle_deadshot" ); 182 | assert( gun != "zombie_perk_bottle_additionalprimaryweapon" ); 183 | assert( gun != "syrette_sp" ); 184 | 185 | self AllowLean( true ); 186 | self AllowAds( true ); 187 | self AllowSprint( true ); 188 | self AllowProne( true ); 189 | self AllowMelee( true ); 190 | weapon = "zombie_bowie_flourish"; 191 | 192 | // TODO: race condition? 193 | if ( self maps\_laststand::player_is_in_laststand() || is_true( self.intermission ) ) 194 | { 195 | self TakeWeapon(weapon); 196 | self.lastActiveWeapon = "none"; // this should be handled by laststand.gsc, but then we couldn't FFOTD the fix 197 | return; 198 | } 199 | 200 | if ( self HasWeapon( "knife_ballistic_zm" ) ) 201 | { 202 | self notify( "zmb_lost_knife" ); 203 | self TakeWeapon( "knife_ballistic_zm" ); 204 | self GiveWeapon( "knife_ballistic_bowie_zm" ); 205 | 206 | if ( gun == "knife_ballistic_zm" ) 207 | { 208 | gun = "knife_ballistic_bowie_zm"; 209 | } 210 | } 211 | else if ( self HasWeapon( "knife_ballistic_upgraded_zm" ) ) 212 | { 213 | self notify( "zmb_lost_knife" ); 214 | self TakeWeapon( "knife_ballistic_upgraded_zm" ); 215 | self GiveWeapon( "knife_ballistic_bowie_upgraded_zm", 0, self maps\_zombiemode_weapons::get_pack_a_punch_weapon_options( "knife_ballistic_bowie_upgraded_zm" ) ); 216 | 217 | if ( gun == "knife_ballistic_upgraded_zm" ) 218 | { 219 | gun = "knife_ballistic_bowie_upgraded_zm"; 220 | } 221 | } 222 | 223 | self TakeWeapon(weapon); 224 | 225 | self GiveWeapon( "bowie_knife_zm" ); 226 | self set_player_melee_weapon( "bowie_knife_zm" ); 227 | 228 | if( self HasWeapon("knife_zm") ) 229 | { 230 | self TakeWeapon( "knife_zm" ); 231 | } 232 | 233 | if( self is_multiple_drinking() ) 234 | { 235 | self decrement_is_drinking(); 236 | return; 237 | } 238 | else if ( gun == "knife_zm" ) // if all they had was the knife, we need to switch them to the bowie 239 | { 240 | self SwitchToWeapon( "bowie_knife_zm" ); 241 | 242 | // and since it has no raise anim, there'll be no "weapon_change_complete" notify 243 | self decrement_is_drinking(); 244 | return; 245 | } 246 | else if ( gun != "none" && !is_placeable_mine( gun ) && !is_equipment( gun ) ) 247 | { 248 | self SwitchToWeapon( gun ); 249 | } 250 | else 251 | { 252 | // try to switch to first primary weapon 253 | primaryWeapons = self GetWeaponsListPrimaries(); 254 | if( IsDefined( primaryWeapons ) && primaryWeapons.size > 0 ) 255 | { 256 | self SwitchToWeapon( primaryWeapons[0] ); 257 | } 258 | } 259 | 260 | self waittill( "weapon_change_complete" ); 261 | 262 | if ( !self maps\_laststand::player_is_in_laststand() && !is_true( self.intermission ) ) 263 | { 264 | self decrement_is_drinking(); 265 | } 266 | } 267 | 268 | bowie_show( player ) 269 | { 270 | player_angles = VectorToAngles( player.origin - self.origin ); 271 | 272 | player_yaw = player_angles[1]; 273 | weapon_yaw = self.angles[1]; 274 | 275 | yaw_diff = AngleClamp180( player_yaw - weapon_yaw ); 276 | 277 | if( yaw_diff > 0 ) 278 | { 279 | yaw = weapon_yaw - 90; 280 | } 281 | else 282 | { 283 | yaw = weapon_yaw + 90; 284 | } 285 | 286 | self.og_origin = self.origin; 287 | self.origin = self.origin +( AnglesToForward( ( 0, yaw, 0 ) ) * 8 ); 288 | 289 | wait( 0.05 ); 290 | self Show(); 291 | 292 | play_sound_at_pos( "weapon_show", self.origin, self ); 293 | 294 | time = 1; 295 | self MoveTo( self.og_origin, time ); 296 | } -------------------------------------------------------------------------------- /maps/_zombiemode_claymore.gsc: -------------------------------------------------------------------------------- 1 | #include common_scripts\utility; 2 | #include maps\_utility; 3 | #include maps\_zombiemode_utility; 4 | 5 | 6 | /*------------------------------------ 7 | CLAYMORE STUFFS - 8 | a rough prototype for now, needs a bit more polish 9 | 10 | ------------------------------------*/ 11 | init() 12 | { 13 | trigs = getentarray("claymore_purchase","targetname"); 14 | for(i=0; i= self.zombie_cost ) 57 | { 58 | if ( !who is_player_placeable_mine( "claymore_zm" ) ) 59 | { 60 | play_sound_at_pos( "purchase", self.origin ); 61 | 62 | //set the score 63 | who maps\_zombiemode_score::minus_to_player_score( self.zombie_cost ); 64 | who maps\_zombiemode_weapons::check_collector_achievement( "claymore_zm" ); 65 | who thread claymore_setup(); 66 | who thread show_claymore_hint("claymore_purchased"); 67 | who thread maps\_zombiemode_audio::create_and_play_dialog( "weapon_pickup", "grenade" ); 68 | 69 | // JMA - display the claymores 70 | if( self.claymores_triggered == false ) 71 | { 72 | model = getent( self.target, "targetname" ); 73 | model thread maps\_zombiemode_weapons::weapon_show( who ); 74 | self.claymores_triggered = true; 75 | } 76 | 77 | trigs = getentarray("claymore_purchase","targetname"); 78 | for(i = 0; i < trigs.size; i++) 79 | { 80 | trigs[i] SetInvisibleToPlayer(who); 81 | } 82 | } 83 | else 84 | { 85 | who thread show_claymore_hint("already_purchased"); 86 | } 87 | } 88 | } 89 | } 90 | } 91 | 92 | set_claymore_visible() 93 | { 94 | players = getplayers(); 95 | trigs = getentarray("claymore_purchase","targetname"); 96 | 97 | while(1) 98 | { 99 | for(j = 0; j < players.size; j++) 100 | { 101 | if( !players[j] is_player_placeable_mine( "claymore_zm" ) ) 102 | { 103 | for(i = 0; i < trigs.size; i++) 104 | { 105 | trigs[i] SetInvisibleToPlayer(players[j], false); 106 | } 107 | } 108 | } 109 | 110 | wait(1); 111 | players = getplayers(); 112 | } 113 | } 114 | 115 | claymore_watch() 116 | { 117 | self endon("death"); 118 | 119 | while(1) 120 | { 121 | self waittill("grenade_fire",claymore,weapname); 122 | if(weapname == "claymore_zm") 123 | { 124 | claymore.owner = self; 125 | claymore thread satchel_damage(); 126 | claymore thread claymore_detonation(); 127 | claymore thread play_claymore_effects(); 128 | 129 | self notify( "zmb_enable_claymore_prompt" ); 130 | } 131 | } 132 | } 133 | 134 | claymore_setup() 135 | { 136 | self thread claymore_watch(); 137 | 138 | self giveweapon("claymore_zm"); 139 | self set_player_placeable_mine("claymore_zm"); 140 | self setactionslot(4,"weapon","claymore_zm"); 141 | self setweaponammostock("claymore_zm",2); 142 | } 143 | 144 | pickup_claymores() 145 | { 146 | player = self.owner; 147 | 148 | if ( !player hasweapon( "claymore_zm" ) ) 149 | { 150 | player thread claymore_watch(); 151 | 152 | player giveweapon("claymore_zm"); 153 | player set_player_placeable_mine("claymore_zm"); 154 | player setactionslot(4,"weapon","claymore_zm"); 155 | player setweaponammoclip("claymore_zm",0); 156 | player notify( "zmb_enable_claymore_prompt" ); 157 | } 158 | else 159 | { 160 | clip_ammo = player GetWeaponAmmoClip( self.name ); 161 | clip_max_ammo = WeaponClipSize( self.name ); 162 | if ( clip_ammo >= clip_max_ammo ) 163 | { 164 | player notify( "zmb_disable_claymore_prompt" ); // just to be safe 165 | return; 166 | } 167 | } 168 | 169 | self maps\_weaponobjects::pick_up(); 170 | 171 | clip_ammo = player GetWeaponAmmoClip( self.name ); 172 | clip_max_ammo = WeaponClipSize( self.name ); 173 | if ( clip_ammo >= clip_max_ammo ) 174 | { 175 | player notify( "zmb_disable_claymore_prompt" ); 176 | } 177 | } 178 | 179 | pickup_claymores_trigger_listener( trigger, player ) 180 | { 181 | self thread pickup_claymores_trigger_listener_enable( trigger, player ); 182 | self thread pickup_claymores_trigger_listener_disable( trigger, player ); 183 | } 184 | 185 | pickup_claymores_trigger_listener_enable( trigger, player ) 186 | { 187 | self endon( "delete" ); 188 | 189 | while ( true ) 190 | { 191 | player waittill_any( "zmb_enable_claymore_prompt", "spawned_player" ); 192 | 193 | if ( !isDefined( trigger ) ) 194 | { 195 | return; 196 | } 197 | 198 | trigger trigger_on(); 199 | trigger linkto( self ); 200 | } 201 | } 202 | 203 | pickup_claymores_trigger_listener_disable( trigger, player ) 204 | { 205 | self endon( "delete" ); 206 | 207 | while ( true ) 208 | { 209 | player waittill( "zmb_disable_claymore_prompt" ); 210 | 211 | if ( !isDefined( trigger ) ) 212 | { 213 | return; 214 | } 215 | 216 | trigger unlink(); 217 | trigger trigger_off(); 218 | } 219 | } 220 | 221 | /* 222 | waittill_not_moving() 223 | { 224 | prevorigin = self.origin; 225 | while(1) 226 | { 227 | wait .1; 228 | if ( self.origin == prevorigin ) 229 | break; 230 | prevorigin = self.origin; 231 | } 232 | } 233 | */ 234 | 235 | shouldAffectWeaponObject( object ) 236 | { 237 | pos = self.origin + (0,0,32); 238 | 239 | dirToPos = pos - object.origin; 240 | objectForward = anglesToForward( object.angles ); 241 | 242 | dist = vectorDot( dirToPos, objectForward ); 243 | if ( dist < level.claymore_detectionMinDist ) 244 | return false; 245 | 246 | dirToPos = vectornormalize( dirToPos ); 247 | 248 | dot = vectorDot( dirToPos, objectForward ); 249 | return ( dot > level.claymore_detectionDot ); 250 | } 251 | 252 | claymore_detonation() 253 | { 254 | self endon("death"); 255 | 256 | // wait until we settle 257 | self waittill_not_moving(); 258 | 259 | detonateRadius = 96; 260 | 261 | spawnFlag = 1;// SF_TOUCH_AI_AXIS 262 | playerTeamToAllow = "axis"; 263 | if( isDefined( self.owner ) && isDefined( self.owner.pers["team"] ) && self.owner.pers["team"] == "axis" ) 264 | { 265 | spawnFlag = 2;// SF_TOUCH_AI_ALLIES 266 | playerTeamToAllow = "allies"; 267 | } 268 | 269 | damagearea = spawn("trigger_radius", self.origin + (0,0,0-detonateRadius), spawnFlag, detonateRadius, detonateRadius*2); 270 | 271 | damagearea enablelinkto(); 272 | damagearea linkto( self ); 273 | 274 | self thread delete_claymores_on_death( damagearea ); 275 | 276 | if(!isdefined(level.claymores)) 277 | level.claymores = []; 278 | level.claymores = array_add( level.claymores, self ); 279 | 280 | if( level.claymores.size > 15 && GetDvar( #"player_sustainAmmo") != "0" ) 281 | level.claymores[0] delete(); 282 | 283 | while(1) 284 | { 285 | damagearea waittill( "trigger", ent ); 286 | 287 | if ( isdefined( self.owner ) && ent == self.owner ) 288 | continue; 289 | 290 | if( isDefined( ent.pers ) && isDefined( ent.pers["team"] ) && ent.pers["team"] != playerTeamToAllow ) 291 | continue; 292 | 293 | if ( !ent shouldAffectWeaponObject( self ) ) 294 | continue; 295 | 296 | if ( ent damageConeTrace(self.origin, self) > 0 ) 297 | { 298 | self playsound ("claymore_activated_SP"); 299 | wait 0.4; 300 | if ( isdefined( self.owner ) ) 301 | self detonate( self.owner ); 302 | else 303 | self detonate( undefined ); 304 | 305 | return; 306 | } 307 | } 308 | } 309 | 310 | delete_claymores_on_death(ent) 311 | { 312 | self waittill("death"); 313 | // stupid getarraykeys in array_remove reversing the order - nate 314 | level.claymores = array_remove_nokeys( level.claymores, self ); 315 | wait .05; 316 | if ( isdefined( ent ) ) 317 | ent delete(); 318 | } 319 | 320 | satchel_damage() 321 | { 322 | // self endon( "death" ); 323 | 324 | self setcandamage(true); 325 | self.health = 100000; 326 | 327 | attacker = undefined; 328 | 329 | playerTeamToAllow = "axis"; 330 | if( isDefined( self.owner ) && isDefined( self.owner.pers["team"] ) && self.owner.pers["team"] == "axis" ) 331 | { 332 | playerTeamToAllow = "allies"; 333 | } 334 | 335 | while(1) 336 | { 337 | self waittill("damage", amount, attacker); 338 | 339 | if ( !isdefined( self ) ) // something else killed it 340 | { 341 | return; 342 | } 343 | 344 | self.health = self.maxhealth; 345 | if ( !isplayer(attacker) ) 346 | continue; 347 | 348 | if ( isdefined( self.owner ) && attacker == self.owner ) 349 | continue; 350 | 351 | if( isDefined( attacker.pers ) && isDefined( attacker.pers["team"] ) && attacker.pers["team"] != playerTeamToAllow ) 352 | continue; 353 | 354 | break; 355 | } 356 | 357 | if ( level.satchelexplodethisframe ) 358 | wait .1 + randomfloat(.4); 359 | else 360 | wait .05; 361 | 362 | if (!isdefined(self)) 363 | return; 364 | 365 | level.satchelexplodethisframe = true; 366 | 367 | thread reset_satchel_explode_this_frame(); 368 | 369 | self detonate( attacker ); 370 | // won't get here; got death notify. 371 | } 372 | 373 | reset_satchel_explode_this_frame() 374 | { 375 | wait .05; 376 | level.satchelexplodethisframe = false; 377 | } 378 | 379 | play_claymore_effects() 380 | { 381 | self endon("death"); 382 | 383 | self waittill_not_moving(); 384 | 385 | PlayFXOnTag( level._effect[ "claymore_laser" ], self, "tag_fx" ); 386 | } 387 | 388 | give_claymores_after_rounds() 389 | { 390 | while(1) 391 | { 392 | level waittill( "between_round_over" ); 393 | 394 | if ( !level flag_exists( "teleporter_used" ) || !flag( "teleporter_used" ) ) 395 | { 396 | players = get_players(); 397 | for(i=0;i 0 ) 207 | { 208 | self SwitchToWeapon( primaryWeapons[0] ); 209 | } 210 | } 211 | 212 | self set_player_equipment( equipment ); 213 | self GiveWeapon( equipment ); 214 | self thread show_equipment_hint( equipment ); 215 | self notify(equipment + "_given"); 216 | self set_equipment_invisibility_to_player( equipment, true ); 217 | self setactionslot( 1, "weapon", equipment ); 218 | 219 | if(IsDefined(level.zombie_equipment[equipment].watcher_thread)) 220 | { 221 | self thread [[level.zombie_equipment[equipment].watcher_thread]](); 222 | } 223 | 224 | self thread equipment_slot_watcher(equipment); 225 | 226 | self maps\_zombiemode_audio::create_and_play_dialog( "weapon_pickup", level.zombie_equipment[equipment].vox ); 227 | } 228 | 229 | equipment_slot_watcher(equipment) 230 | { 231 | self notify("kill_equipment_slot_watcher"); 232 | self endon("kill_equipment_slot_watcher"); 233 | self endon("disconnect"); 234 | 235 | while(1) 236 | { 237 | self waittill( "weapon_change", curr_weapon, prev_weapon ); 238 | 239 | self.prev_weapon_before_equipment_change = undefined; 240 | if ( isdefined( prev_weapon ) && "none" != prev_weapon ) 241 | { 242 | prev_weapon_type = WeaponInventoryType( prev_weapon ); 243 | if ( "primary" == prev_weapon_type || "altmode" == prev_weapon_type ) 244 | { 245 | self.prev_weapon_before_equipment_change = prev_weapon; 246 | } 247 | } 248 | 249 | if ( IsDefined( level.zombie_equipment[equipment].watcher_thread ) ) 250 | { 251 | if ( curr_weapon == equipment ) 252 | { 253 | if ( self.current_equipment_active[equipment] == true ) 254 | { 255 | self notify( equipment + "_deactivate" ); 256 | self.current_equipment_active[equipment] = false; 257 | } 258 | else if ( self.current_equipment_active[equipment] == false ) 259 | { 260 | self notify( equipment + "_activate" ); 261 | self.current_equipment_active[equipment] = true; 262 | } 263 | 264 | self waittill( "equipment_select_response_done" ); 265 | } 266 | } 267 | else 268 | { 269 | if ( curr_weapon == equipment && !self.current_equipment_active[equipment] ) 270 | { 271 | self notify( equipment + "_activate" ); 272 | self.current_equipment_active[equipment] = true; 273 | } 274 | else if ( curr_weapon != equipment && self.current_equipment_active[equipment] ) 275 | { 276 | self notify( equipment + "_deactivate" ); 277 | self.current_equipment_active[equipment] = false; 278 | } 279 | } 280 | } 281 | } 282 | 283 | is_limited_equipment(equipment) 284 | { 285 | if(isDefined(level._limited_equipment)) 286 | { 287 | 288 | for(i=0;i= 6 ) 303 | { 304 | if( is_player_valid( player_with_back_bolt ) && !player_who_fired IsNoTarget() ) 305 | { 306 | if( IsDefined( player_who_fired ) ) 307 | { 308 | player_who_fired giveachievement_wrapper( "SP_ZOM_SILVERBACK" ); 309 | } 310 | 311 | player_with_back_bolt giveachievement_wrapper( "SP_ZOM_SILVERBACK" ); 312 | } 313 | } 314 | } -------------------------------------------------------------------------------- /maps/_zombiemode_weap_cymbal_monkey.gsc: -------------------------------------------------------------------------------- 1 | // For the cymbal monkey weapon 2 | #include maps\_utility; 3 | #include common_scripts\utility; 4 | #include maps\_zombiemode_utility; 5 | 6 | init() 7 | { 8 | if( !cymbal_monkey_exists() ) 9 | { 10 | return; 11 | } 12 | 13 | level._effect["monkey_glow"] = loadfx( "maps/zombie/fx_zombie_monkey_light" ); 14 | } 15 | 16 | player_give_cymbal_monkey() 17 | { 18 | self giveweapon( "zombie_cymbal_monkey" ); 19 | self set_player_tactical_grenade( "zombie_cymbal_monkey" ); 20 | self thread player_handle_cymbal_monkey(); 21 | } 22 | 23 | #using_animtree( "zombie_cymbal_monkey" ); 24 | player_handle_cymbal_monkey() 25 | { 26 | self notify( "starting_monkey_watch" ); 27 | self endon( "disconnect" ); 28 | self endon( "starting_monkey_watch" ); 29 | 30 | // Min distance to attract positions 31 | attract_dist_diff = level.monkey_attract_dist_diff; 32 | if( !isDefined( attract_dist_diff ) ) 33 | { 34 | attract_dist_diff = 45; 35 | } 36 | 37 | num_attractors = level.num_monkey_attractors; 38 | if( !isDefined( num_attractors ) ) 39 | { 40 | num_attractors = 96; 41 | } 42 | 43 | max_attract_dist = level.monkey_attract_dist; 44 | if( !isDefined( max_attract_dist ) ) 45 | { 46 | max_attract_dist = 1536; 47 | } 48 | 49 | while( true ) 50 | { 51 | grenade = get_thrown_monkey(); 52 | if( IsDefined( grenade ) ) 53 | { 54 | if( self maps\_laststand::player_is_in_laststand() ) 55 | { 56 | grenade delete(); 57 | continue; 58 | } 59 | grenade hide(); 60 | model = spawn( "script_model", grenade.origin ); 61 | model SetModel( "weapon_zombie_monkey_bomb" ); 62 | model UseAnimTree( #animtree ); 63 | model linkTo( grenade ); 64 | model.angles = grenade.angles; 65 | 66 | info = spawnStruct(); 67 | info.sound_attractors = []; 68 | grenade thread monitor_zombie_groans( info ); 69 | velocitySq = 10000*10000; 70 | oldPos = grenade.origin; 71 | grenade create_zombie_point_of_interest( max_attract_dist, num_attractors, 10000 ); 72 | grenade.attract_to_origin = true; 73 | 74 | while( velocitySq != 0 ) 75 | { 76 | wait( 0.05 ); 77 | 78 | if( !isDefined( grenade ) ) 79 | { 80 | break; 81 | } 82 | 83 | velocitySq = distanceSquared( grenade.origin, oldPos ); 84 | oldPos = grenade.origin; 85 | } 86 | if( isDefined( grenade ) ) 87 | { 88 | model SetAnim( %o_monkey_bomb ); 89 | model thread monkey_cleanup( grenade ); 90 | 91 | model unlink(); 92 | model.origin = grenade.origin; 93 | model.angles = grenade.angles; 94 | 95 | grenade resetmissiledetonationtime(); 96 | PlayFxOnTag( level._effect["monkey_glow"], model, "origin_animate_jnt" ); 97 | 98 | valid_poi = check_point_in_active_zone( grenade.origin ); 99 | 100 | if( !valid_poi ) 101 | { 102 | valid_poi = check_point_in_playable_area( grenade.origin ); 103 | } 104 | 105 | if(valid_poi) 106 | { 107 | grenade thread create_zombie_point_of_interest_attractor_positions( 4, attract_dist_diff ); 108 | grenade thread wait_for_attractor_positions_complete(); 109 | } 110 | else 111 | { 112 | self.script_noteworthy = undefined; 113 | } 114 | 115 | grenade thread do_monkey_sound( model, info ); 116 | } 117 | } 118 | wait( 0.05 ); 119 | } 120 | } 121 | 122 | wait_for_attractor_positions_complete() 123 | { 124 | self waittill( "attractor_positions_generated" ); 125 | 126 | self.attract_to_origin = false; 127 | } 128 | 129 | monkey_cleanup( parent ) 130 | { 131 | while( true ) 132 | { 133 | if( !isDefined( parent ) ) 134 | { 135 | self_delete(); 136 | return; 137 | } 138 | wait( 0.05 ); 139 | } 140 | } 141 | 142 | do_monkey_sound( model, info ) 143 | { 144 | monk_scream_vox = false; 145 | 146 | if( isdefined(level.monk_scream_trig) && self IsTouching( level.monk_scream_trig)) 147 | { 148 | self playsound( "zmb_vox_monkey_scream" ); 149 | monk_scream_vox = true; 150 | } 151 | else if( level.music_override == false ) 152 | { 153 | monk_scream_vox = false; 154 | self playsound( "zmb_monkey_song" ); 155 | } 156 | 157 | self thread play_delayed_explode_vox(); 158 | 159 | self waittill( "explode", position ); 160 | if( isDefined( model ) ) 161 | { 162 | model ClearAnim( %o_monkey_bomb, 0.2 ); 163 | } 164 | 165 | for( i = 0; i < info.sound_attractors.size; i++ ) 166 | { 167 | if( isDefined( info.sound_attractors[i] ) ) 168 | { 169 | info.sound_attractors[i] notify( "monkey_blown_up" ); 170 | } 171 | } 172 | 173 | if( !monk_scream_vox ) 174 | { 175 | //play_sound_in_space( "zmb_vox_monkey_explode", position ); 176 | } 177 | else 178 | { 179 | thread play_sam_furnace(); 180 | } 181 | } 182 | 183 | play_delayed_explode_vox() 184 | { 185 | wait(6.5); 186 | if(isdefined( self ) ) 187 | { 188 | self playsound( "zmb_vox_monkey_explode" ); 189 | } 190 | } 191 | 192 | play_sam_furnace() 193 | { 194 | wait(2); 195 | play_sound_2d( "sam_furnace_1" ); 196 | wait(2.5); 197 | play_sound_2d( "sam_furnace_2" ); 198 | } 199 | 200 | get_thrown_monkey() 201 | { 202 | self endon( "disconnect" ); 203 | self endon( "starting_monkey_watch" ); 204 | 205 | while( true ) 206 | { 207 | self waittill( "grenade_fire", grenade, weapName ); 208 | if( weapName == "zombie_cymbal_monkey" ) 209 | { 210 | return grenade; 211 | } 212 | 213 | wait( 0.05 ); 214 | } 215 | } 216 | 217 | monitor_zombie_groans( info ) 218 | { 219 | self endon( "explode" ); 220 | 221 | while( true ) 222 | { 223 | if( !isDefined( self ) ) 224 | { 225 | return; 226 | } 227 | 228 | if( !isDefined( self.attractor_array ) ) 229 | { 230 | wait( 0.05 ); 231 | continue; 232 | } 233 | 234 | for( i = 0; i < self.attractor_array.size; i++ ) 235 | { 236 | if( array_check_for_dupes( info.sound_attractors, self.attractor_array[i] ) ) 237 | { 238 | if ( isDefined( self.origin ) && isDefined( self.attractor_array[i].origin ) ) 239 | { 240 | if( distanceSquared( self.origin, self.attractor_array[i].origin ) < 500 * 500 ) 241 | { 242 | info.sound_attractors = array_add( info.sound_attractors, self.attractor_array[i] ); 243 | self.attractor_array[i] thread play_zombie_groans(); 244 | } 245 | } 246 | } 247 | } 248 | wait( 0.05 ); 249 | } 250 | } 251 | 252 | play_zombie_groans() 253 | { 254 | self endon( "death" ); 255 | self endon( "monkey_blown_up" ); 256 | 257 | while(1) 258 | { 259 | if( isdefined ( self ) ) 260 | { 261 | self playsound( "zmb_vox_zombie_groan" ); 262 | wait randomfloatrange( 2, 3 ); 263 | } 264 | else 265 | { 266 | return; 267 | } 268 | } 269 | } 270 | 271 | cymbal_monkey_exists() 272 | { 273 | return IsDefined( level.zombie_weapons["zombie_cymbal_monkey"] ); 274 | } 275 | -------------------------------------------------------------------------------- /maps/_zombiemode_weap_thundergun.gsc: -------------------------------------------------------------------------------- 1 | #include maps\_utility; 2 | #include common_scripts\utility; 3 | #include maps\_zombiemode_utility; 4 | #include maps\_zombiemode_net; 5 | 6 | #using_animtree( "generic_human" ); 7 | 8 | init() 9 | { 10 | if( !maps\_zombiemode_weapons::is_weapon_included( "thundergun_zm" ) ) 11 | { 12 | return; 13 | } 14 | 15 | // precache the clientside effects 16 | level._effect["thundergun_viewmodel_power_cell1"] = loadfx("weapon/thunder_gun/fx_thundergun_power_cell_view1"); 17 | level._effect["thundergun_viewmodel_power_cell2"] = loadfx("weapon/thunder_gun/fx_thundergun_power_cell_view2"); 18 | level._effect["thundergun_viewmodel_power_cell3"] = loadfx("weapon/thunder_gun/fx_thundergun_power_cell_view3"); 19 | level._effect["thundergun_viewmodel_steam"] = loadfx("weapon/thunder_gun/fx_thundergun_steam_view"); 20 | 21 | level._effect["thundergun_viewmodel_power_cell1_upgraded"] = loadfx("weapon/thunder_gun/fx_thundergun_power_cell_view1"); 22 | level._effect["thundergun_viewmodel_power_cell2_upgraded"] = loadfx("weapon/thunder_gun/fx_thundergun_power_cell_view2"); 23 | level._effect["thundergun_viewmodel_power_cell3_upgraded"] = loadfx("weapon/thunder_gun/fx_thundergun_power_cell_view3"); 24 | level._effect["thundergun_viewmodel_steam_upgraded"] = loadfx("weapon/thunder_gun/fx_thundergun_steam_view"); 25 | 26 | 27 | level._effect["thundergun_knockdown_ground"] = loadfx( "weapon/thunder_gun/fx_thundergun_knockback_ground" ); 28 | level._effect["thundergun_smoke_cloud"] = loadfx( "weapon/thunder_gun/fx_thundergun_smoke_cloud" ); 29 | 30 | set_zombie_var( "thundergun_cylinder_radius", 180 ); 31 | set_zombie_var( "thundergun_fling_range", 480 ); // 40 feet 32 | set_zombie_var( "thundergun_gib_range", 900 ); // 75 feet 33 | set_zombie_var( "thundergun_gib_damage", 75 ); 34 | set_zombie_var( "thundergun_knockdown_range", 1200 ); // 100 feet 35 | set_zombie_var( "thundergun_knockdown_damage", 15 ); 36 | 37 | level.thundergun_gib_refs = []; 38 | level.thundergun_gib_refs[level.thundergun_gib_refs.size] = "guts"; 39 | level.thundergun_gib_refs[level.thundergun_gib_refs.size] = "right_arm"; 40 | level.thundergun_gib_refs[level.thundergun_gib_refs.size] = "left_arm"; 41 | 42 | level thread thundergun_on_player_connect(); 43 | } 44 | 45 | 46 | thundergun_on_player_connect() 47 | { 48 | for( ;; ) 49 | { 50 | level waittill( "connecting", player ); 51 | player thread wait_for_thundergun_fired(); 52 | } 53 | } 54 | 55 | 56 | wait_for_thundergun_fired() 57 | { 58 | self endon( "disconnect" ); 59 | self waittill( "spawned_player" ); 60 | 61 | for( ;; ) 62 | { 63 | self waittill( "weapon_fired" ); 64 | currentweapon = self GetCurrentWeapon(); 65 | if( ( currentweapon == "thundergun_zm" ) || ( currentweapon == "thundergun_upgraded_zm" ) ) 66 | { 67 | self thread thundergun_fired(); 68 | 69 | view_pos = self GetTagOrigin( "tag_flash" ) - self GetPlayerViewHeight(); 70 | view_angles = self GetTagAngles( "tag_flash" ); 71 | playfx( level._effect["thundergun_smoke_cloud"], view_pos, AnglesToForward( view_angles ), AnglesToUp( view_angles ) ); 72 | } 73 | } 74 | } 75 | 76 | 77 | thundergun_network_choke() 78 | { 79 | level.thundergun_network_choke_count++; 80 | 81 | if ( !(level.thundergun_network_choke_count % 10) ) 82 | { 83 | wait_network_frame(); 84 | wait_network_frame(); 85 | wait_network_frame(); 86 | } 87 | } 88 | 89 | 90 | thundergun_fired() 91 | { 92 | // ww: physics hit when firing 93 | PhysicsExplosionCylinder( self.origin, 600, 240, 1 ); 94 | 95 | if ( !IsDefined( level.thundergun_knockdown_enemies ) ) 96 | { 97 | level.thundergun_knockdown_enemies = []; 98 | level.thundergun_knockdown_gib = []; 99 | level.thundergun_fling_enemies = []; 100 | level.thundergun_fling_vecs = []; 101 | } 102 | 103 | self thundergun_get_enemies_in_range(); 104 | 105 | //iprintlnbold( "flg: " + level.thundergun_fling_enemies.size + " gib: " + level.thundergun_gib_enemies.size + " kno: " + level.thundergun_knockdown_enemies.size ); 106 | 107 | level.thundergun_network_choke_count = 0; 108 | for ( i = 0; i < level.thundergun_fling_enemies.size; i++ ) 109 | { 110 | thundergun_network_choke(); 111 | level.thundergun_fling_enemies[i] thread thundergun_fling_zombie( self, level.thundergun_fling_vecs[i], i ); 112 | } 113 | 114 | for ( i = 0; i < level.thundergun_knockdown_enemies.size; i++ ) 115 | { 116 | thundergun_network_choke(); 117 | level.thundergun_knockdown_enemies[i] thread thundergun_knockdown_zombie( self, level.thundergun_knockdown_gib[i] ); 118 | } 119 | 120 | level.thundergun_knockdown_enemies = []; 121 | level.thundergun_knockdown_gib = []; 122 | level.thundergun_fling_enemies = []; 123 | level.thundergun_fling_vecs = []; 124 | } 125 | 126 | 127 | thundergun_get_enemies_in_range() 128 | { 129 | view_pos = self GetWeaponMuzzlePoint(); 130 | zombies = get_array_of_closest( view_pos, GetAiSpeciesArray( "axis", "all" ), undefined, undefined, level.zombie_vars["thundergun_knockdown_range"] ); 131 | if ( !isDefined( zombies ) ) 132 | { 133 | return; 134 | } 135 | 136 | knockdown_range_squared = level.zombie_vars["thundergun_knockdown_range"] * level.zombie_vars["thundergun_knockdown_range"]; 137 | gib_range_squared = level.zombie_vars["thundergun_gib_range"] * level.zombie_vars["thundergun_gib_range"]; 138 | fling_range_squared = level.zombie_vars["thundergun_fling_range"] * level.zombie_vars["thundergun_fling_range"]; 139 | cylinder_radius_squared = level.zombie_vars["thundergun_cylinder_radius"] * level.zombie_vars["thundergun_cylinder_radius"]; 140 | 141 | forward_view_angles = self GetWeaponForwardDir(); 142 | end_pos = view_pos + vector_scale( forward_view_angles, level.zombie_vars["thundergun_knockdown_range"] ); 143 | 144 | /# 145 | if ( 2 == GetDvarInt( #"scr_thundergun_debug" ) ) 146 | { 147 | // push the near circle out a couple units to avoid an assert in Circle() due to it attempting to 148 | // derive the view direction from the circle's center point minus the viewpos 149 | // (which is what we're using as our center point, which results in a zeroed direction vector) 150 | near_circle_pos = view_pos + vector_scale( forward_view_angles, 2 ); 151 | 152 | Circle( near_circle_pos, level.zombie_vars["thundergun_cylinder_radius"], (1, 0, 0), false, false, 100 ); 153 | Line( near_circle_pos, end_pos, (0, 0, 1), 1, false, 100 ); 154 | Circle( end_pos, level.zombie_vars["thundergun_cylinder_radius"], (1, 0, 0), false, false, 100 ); 155 | } 156 | #/ 157 | 158 | for ( i = 0; i < zombies.size; i++ ) 159 | { 160 | if ( !IsDefined( zombies[i] ) || !IsAlive( zombies[i] ) ) 161 | { 162 | // guy died on us 163 | continue; 164 | } 165 | 166 | test_origin = zombies[i] getcentroid(); 167 | test_range_squared = DistanceSquared( view_pos, test_origin ); 168 | if ( test_range_squared > knockdown_range_squared ) 169 | { 170 | zombies[i] thundergun_debug_print( "range", (1, 0, 0) ); 171 | return; // everything else in the list will be out of range 172 | } 173 | 174 | normal = VectorNormalize( test_origin - view_pos ); 175 | dot = VectorDot( forward_view_angles, normal ); 176 | if ( 0 > dot ) 177 | { 178 | // guy's behind us 179 | zombies[i] thundergun_debug_print( "dot", (1, 0, 0) ); 180 | continue; 181 | } 182 | 183 | radial_origin = PointOnSegmentNearestToPoint( view_pos, end_pos, test_origin ); 184 | if ( DistanceSquared( test_origin, radial_origin ) > cylinder_radius_squared ) 185 | { 186 | // guy's outside the range of the cylinder of effect 187 | zombies[i] thundergun_debug_print( "cylinder", (1, 0, 0) ); 188 | continue; 189 | } 190 | 191 | if ( 0 == zombies[i] DamageConeTrace( view_pos, self ) ) 192 | { 193 | // guy can't actually be hit from where we are 194 | zombies[i] thundergun_debug_print( "cone", (1, 0, 0) ); 195 | continue; 196 | } 197 | 198 | if ( test_range_squared < fling_range_squared ) 199 | { 200 | level.thundergun_fling_enemies[level.thundergun_fling_enemies.size] = zombies[i]; 201 | 202 | // the closer they are, the harder they get flung 203 | dist_mult = (fling_range_squared - test_range_squared) / fling_range_squared; 204 | fling_vec = VectorNormalize( test_origin - view_pos ); 205 | 206 | // within 6 feet, just push them straight away from the player, ignoring radial motion 207 | if ( 5000 < test_range_squared ) 208 | { 209 | fling_vec = fling_vec + VectorNormalize( test_origin - radial_origin ); 210 | } 211 | fling_vec = (fling_vec[0], fling_vec[1], abs( fling_vec[2] )); 212 | fling_vec = vector_scale( fling_vec, 100 + 100 * dist_mult ); 213 | level.thundergun_fling_vecs[level.thundergun_fling_vecs.size] = fling_vec; 214 | 215 | zombies[i] thread setup_thundergun_vox( self, true, false, false ); 216 | } 217 | else if ( test_range_squared < gib_range_squared ) 218 | { 219 | level.thundergun_knockdown_enemies[level.thundergun_knockdown_enemies.size] = zombies[i]; 220 | level.thundergun_knockdown_gib[level.thundergun_knockdown_gib.size] = true; 221 | 222 | zombies[i] thread setup_thundergun_vox( self, false, true, false ); 223 | } 224 | else 225 | { 226 | level.thundergun_knockdown_enemies[level.thundergun_knockdown_enemies.size] = zombies[i]; 227 | level.thundergun_knockdown_gib[level.thundergun_knockdown_gib.size] = false; 228 | 229 | zombies[i] thread setup_thundergun_vox( self, false, false, true ); 230 | } 231 | } 232 | } 233 | 234 | 235 | thundergun_debug_print( msg, color ) 236 | { 237 | /# 238 | if ( !GetDvarInt( #"scr_thundergun_debug" ) ) 239 | { 240 | return; 241 | } 242 | 243 | if ( !isdefined( color ) ) 244 | { 245 | color = (1, 1, 1); 246 | } 247 | 248 | Print3d(self.origin + (0,0,60), msg, color, 1, 1, 40); // 10 server frames is 1 second 249 | #/ 250 | } 251 | 252 | 253 | thundergun_fling_zombie( player, fling_vec, index ) 254 | { 255 | if( !IsDefined( self ) || !IsAlive( self ) ) 256 | { 257 | // guy died on us 258 | return; 259 | } 260 | 261 | if ( IsDefined( self.thundergun_fling_func ) ) 262 | { 263 | self [[ self.thundergun_fling_func ]]( player ); 264 | return; 265 | } 266 | 267 | self DoDamage( self.health + 666, player.origin, player ); 268 | 269 | if ( self.health <= 0 ) 270 | { 271 | points = 10; 272 | if ( !index ) 273 | { 274 | points = maps\_zombiemode_score::get_zombie_death_player_points(); 275 | } 276 | else if ( 1 == index ) 277 | { 278 | points = 30; 279 | } 280 | player maps\_zombiemode_score::player_add_points( "thundergun_fling", points ); 281 | 282 | self StartRagdoll(); 283 | self LaunchRagdoll( fling_vec ); 284 | 285 | self.thundergun_death = true; 286 | } 287 | } 288 | 289 | 290 | thundergun_knockdown_zombie( player, gib ) 291 | { 292 | self endon( "death" ); 293 | playsoundatposition ("vox_thundergun_forcehit", self.origin); 294 | playsoundatposition ("wpn_thundergun_proj_impact", self.origin); 295 | 296 | 297 | if( !IsDefined( self ) || !IsAlive( self ) ) 298 | { 299 | // guy died on us 300 | return; 301 | } 302 | 303 | if ( IsDefined( self.thundergun_knockdown_func ) ) 304 | { 305 | self [[ self.thundergun_knockdown_func ]]( player, gib ); 306 | } 307 | else 308 | { 309 | 310 | self DoDamage( level.zombie_vars["thundergun_knockdown_damage"], player.origin, player ); 311 | 312 | 313 | 314 | } 315 | 316 | if ( gib ) 317 | { 318 | self.a.gib_ref = random( level.thundergun_gib_refs ); 319 | self thread animscripts\zombie_death::do_gib(); 320 | } 321 | 322 | // self playsound( "thundergun_impact" ); 323 | self.thundergun_handle_pain_notetracks = ::handle_thundergun_pain_notetracks; 324 | self DoDamage( level.zombie_vars["thundergun_knockdown_damage"], player.origin, player ); 325 | self playsound( "fly_thundergun_forcehit" ); 326 | 327 | } 328 | 329 | 330 | handle_thundergun_pain_notetracks( note ) 331 | { 332 | if ( note == "zombie_knockdown_ground_impact" ) 333 | { 334 | playfx( level._effect["thundergun_knockdown_ground"], self.origin, AnglesToForward( self.angles ), AnglesToUp( self.angles ) ); 335 | self playsound( "fly_thundergun_forcehit" ); 336 | } 337 | } 338 | 339 | 340 | is_thundergun_damage() 341 | { 342 | return IsDefined( self.damageweapon ) && (self.damageweapon == "thundergun_zm" || self.damageweapon == "thundergun_upgraded_zm") && (self.damagemod != "MOD_GRENADE" && self.damagemod != "MOD_GRENADE_SPLASH"); 343 | } 344 | 345 | 346 | enemy_killed_by_thundergun() 347 | { 348 | return ( IsDefined( self.thundergun_death ) && self.thundergun_death == true ); 349 | } 350 | 351 | 352 | thundergun_sound_thread() 353 | { 354 | self endon( "disconnect" ); 355 | self waittill( "spawned_player" ); 356 | 357 | 358 | for( ;; ) 359 | { 360 | result = self waittill_any_return( "grenade_fire", "death", "player_downed", "weapon_change", "grenade_pullback" ); 361 | 362 | if ( !IsDefined( result ) ) 363 | { 364 | continue; 365 | } 366 | 367 | if( ( result == "weapon_change" || result == "grenade_fire" ) && self GetCurrentWeapon() == "thundergun_zm" ) 368 | { 369 | self PlayLoopSound( "tesla_idle", 0.25 ); 370 | 371 | } 372 | else 373 | { 374 | self notify ("weap_away"); 375 | self StopLoopSound(0.25); 376 | 377 | 378 | } 379 | } 380 | } 381 | 382 | //SELF = Zombie Being Hit With Thundergun 383 | setup_thundergun_vox( player, fling, gib, knockdown ) 384 | { 385 | if( !IsDefined( self ) || !IsAlive( self ) ) 386 | { 387 | return; 388 | } 389 | 390 | if( !fling && ( gib || knockdown ) ) 391 | { 392 | if( 25 > RandomIntRange( 1, 100 ) ) 393 | { 394 | //IPrintLnBold( "HAHA, You Knocked Down Some Zombies!" ); 395 | } 396 | } 397 | 398 | if( fling ) 399 | { 400 | if( 30 > RandomIntRange( 1, 100 ) ) 401 | { 402 | //IPrintLnBold( "WAY TO DISINTEGRATE THEM!!" ); 403 | player maps\_zombiemode_audio::create_and_play_dialog( "kill", "thundergun" ); 404 | } 405 | } 406 | } 407 | -------------------------------------------------------------------------------- /maps/mod_cabcon/_load.gsc: -------------------------------------------------------------------------------- 1 | /* 2 | ▒█▀▀▀ █▀▀▄ ▒█▀▀█ █▀▀█ ▒█▀▀█ █▀▀ ▒█░░▒█ ▄▀▀▄ 3 | ▒█▀▀▀ █░░█ ▒█░░░ █░░█ ▒█▄▄▀ █▀▀ ░▒█▒█░ ▄▀▀▄ 4 | ▒█▄▄▄ ▀░░▀ ▒█▄▄█ ▀▀▀▀ ▒█░▒█ ▀▀▀ ░░▀▄▀░ ▀▄▄▀ 5 | 6 | This is created by cabconmodding.com! 7 | 8 | Please just edit it with permission! 9 | 10 | */ 11 | 12 | 13 | 14 | #include common_scripts\utility; 15 | #include maps\_utility; 16 | #include maps\_hud_util; 17 | #include maps\_load_common; 18 | #include maps\_zombiemode_utility; 19 | 20 | //mod includes 21 | 22 | #include maps\mod_cabcon\_load_menubase; 23 | #include maps\mod_cabcon\_load_functions; 24 | #include maps\mod_cabcon\_load_utilies; 25 | 26 | precachemod()//called when player inits 27 | { 28 | //Shaders 29 | 30 | precacheshader("scorebar_zom_3"); 31 | precacheshader("scorebar_zom_4"); 32 | precacheshader("scorebar_zom_2"); 33 | precacheshader("scorebar_zom_1"); 34 | precacheshader("hud_chalk_1"); 35 | precacheshader("zom_icon_community_pot"); 36 | precacheshader("zom_icon_community_pot_strip"); 37 | precacheshader("zom_icon_player_life"); 38 | precacheshader("scorebar_zom_long_4"); 39 | precacheshader("scorebar_zom_long_3"); 40 | precacheshader("scorebar_zom_long_2"); 41 | precacheshader("scorebar_zom_long_1"); 42 | precacheshader("specialty_juggernaut_zombies_pro"); 43 | precacheshader("minimap_icon_juggernog"); 44 | precacheshader("minimap_icon_revive"); 45 | precacheshader("minimap_icon_reload"); 46 | precacheshader("specialty_doublepoints_zombies"); 47 | precacheshader("line_horizontal_scorebar"); 48 | precacheshader("menu_white_line_faded"); 49 | precacheshader("line_horizontal"); 50 | precacheshader("zom_icon_bonfire"); 51 | precacheshader("zom_medals_skull_full"); 52 | precacheshader("zombie_stopwatch"); 53 | precacheshader("menu_white_line_faded_big"); 54 | precacheshader("hud_dpad_lines_fade"); 55 | precacheshader("gradient"); 56 | precacheshader("ui_cursor"); 57 | precacheshader("logo_cod2"); 58 | precacheshader("ui_slider2"); 59 | precacheshader("loadscreen_zombie_moon"); 60 | precacheshader("loadscreen_zombie_temple"); 61 | precacheshader("loadscreen_zombie_coast"); 62 | precacheshader("loadscreen_zombie_theater"); 63 | precacheshader("loadscreen_zombie_pentagon"); 64 | precacheshader("ui_perforation"); 65 | precacheshader("zom_icon_player_life"); 66 | precacheshader("zom_icon_theater_reel"); 67 | precacheshader("zom_medals_skull_face"); 68 | precacheshader("menu_zombie_lobby_frame_outer_ingame"); 69 | precacheshader("menu_sp_lobby_frame_outer_ingame"); 70 | precacheshader("menu_background_press_start"); 71 | precacheshader("menu_button_backing"); 72 | precacheshader("menu_mp_bar_shadow"); 73 | precacheshader("zom_medals_skull_full"); 74 | precacheshader("zom_medals_skull_ribbon"); 75 | precacheshader("ui_host"); 76 | precacheshader("overlay_low_health"); 77 | precacheshader("white"); 78 | precacheshader("overlay_low_health_compass"); 79 | 80 | 81 | precacheshader( "loadscreen_"+GetDvar( "mapname" ) ); 82 | 83 | ///*******************************************************************************************************************************/// 84 | /// Entitys /// 85 | ///*******************************************************************************************************************************/// 86 | 87 | addCostumModel("zombie_skull"); 88 | //addCostumModel("test_sphere_silver"); 89 | addCostumModel("defaultactor"); 90 | addCostumModel("zombie_teddybear"); 91 | addCostumModel("zombie_z_money_icon"); 92 | addCostumModel("zombie_revive"); 93 | 94 | //Var 95 | setDvar("sv_cheats",1); 96 | } 97 | 98 | mod_main(player) 99 | { 100 | //player connected // This function will call from the Host when he connects 101 | player mod_onPlayerSawned(); 102 | 103 | } 104 | 105 | mod_onPlayerSawned() 106 | { 107 | self endon( "disconnect" ); 108 | for( ;; ) 109 | { 110 | self waittill( "spawned_player" ); 111 | self setClientDvar("sv_cheats",1); 112 | self thread mod_startup(); 113 | } 114 | } 115 | 116 | mod_startup() 117 | { 118 | //self create_message("^1EnCoReV8 - Zombie Edition","^1By CabCon"); 119 | if( !self.stopThreading ) 120 | { 121 | self playerSetup(); 122 | self.stopThreading = true; 123 | } 124 | } 125 | 126 | -------------------------------------------------------------------------------- /maps/mod_cabcon/_load_gamemodes.gsc: -------------------------------------------------------------------------------- 1 | /* 2 | ▒█▀▀▀ █▀▀▄ ▒█▀▀█ █▀▀█ ▒█▀▀█ █▀▀ ▒█░░▒█ ▄▀▀▄ 3 | ▒█▀▀▀ █░░█ ▒█░░░ █░░█ ▒█▄▄▀ █▀▀ ░▒█▒█░ ▄▀▀▄ 4 | ▒█▄▄▄ ▀░░▀ ▒█▄▄█ ▀▀▀▀ ▒█░▒█ ▀▀▀ ░░▀▄▀░ ▀▄▄▀ 5 | 6 | This is created by cabconmodding.com! 7 | 8 | Please just edit it with permission! 9 | 10 | */ 11 | 12 | 13 | #include common_scripts\utility; 14 | #include maps\_utility; 15 | #include maps\_hud_util; 16 | #include maps\_load_common; 17 | #include maps\_zombiemode_utility; 18 | #include maps\_zombiemode; 19 | 20 | //Functions 21 | #include maps\_zombiemode_perks; 22 | #include maps\_zombiemode_audio; 23 | 24 | #include maps\mod_cabcon\_load_menubase; 25 | #include maps\mod_cabcon\_load_utilies; 26 | #include maps\mod_cabcon\_load_settings; 27 | #include maps\mod_cabcon\_load_functions; 28 | 29 | /////////////////////////////////////////////////////////////////////////////////////// 30 | /////////////////////////////////////////////////////////////////////////////////////// 31 | // Gamemodes 32 | /////////////////////////////////////////////////////////////////////////////////////// 33 | /////////////////////////////////////////////////////////////////////////////////////// 34 | 35 | 36 | 37 | 38 | 39 | /////////////////////////////////////////////////////////////////////////////////////// 40 | // sharpshooter 41 | // Created by CabCon 42 | /////////////////////////////////////////////////////////////////////////////////////// 43 | 44 | 45 | gamemode_sharpshooter_init() 46 | { 47 | self create_message("Welcome to ^2Sharpshooter","Created by ^1CabCon"); 48 | 49 | //def vars 50 | 51 | self.gamemode_sharpshooter_time_max = 45; 52 | self.gamemode_sharpshooter_time = self.gamemode_sharpshooter_time_max; 53 | 54 | self.gamemode_sharpshooter_weapon = ""; 55 | 56 | 57 | //core functions 58 | 59 | self thread gamemode_sharpshooter_def_weapons(); 60 | self thread gamemode_sharpshooter_core(); 61 | self thread gamemode_sharpshooter_hud(); 62 | 63 | //beside functions 64 | 65 | self thread func_deleteWeaponTriggers(); 66 | 67 | 68 | 69 | self notify("gamemode_sharpshooter_cycled"); 70 | } 71 | 72 | gamemode_sharpshooter_def_weapons() 73 | { 74 | if(!isDefined(self.gamemode_sharpshooter_weaponlist)) 75 | { 76 | self.gamemode_sharpshooter_weaponlist = strTok("galil_zm commando_zm fnfal_zm dragunov_zm l96a1_zm rpk_zm hk21_zm m72_law_zm china_lake_zm aug_acog_zm hs10_zm spas_zm rottweil72_zm ithaca_zm cz75lh_zm cz75dw_zm spectre_zm pm63_zm mpl_zm mp40_zm mp5k_zm ak74u_zm famas_zm m16_zm"," "); 77 | } 78 | } 79 | 80 | gamemode_sharpshooter_core() 81 | { 82 | while(true) 83 | { 84 | self waittill("gamemode_sharpshooter_cycled"); 85 | while(true) 86 | { 87 | self.gamemode_sharpshooter_weapon = self.gamemode_sharpshooter_weaponlist[randomint(self.gamemode_sharpshooter_weaponlist.size)]; 88 | if(self getcurrentweapon() != self.gamemode_sharpshooter_weapon) 89 | continue; 90 | } 91 | self TakeWeapon( self getcurrentweapon() ); 92 | self giveWeapon(self.gamemode_sharpshooter_weapon); 93 | self switchtoweapon(self.gamemode_sharpshooter_weapon); 94 | S("Weapon cycled to ^2"+self getcurrentweapon()); 95 | } 96 | } 97 | 98 | gamemode_sharpshooter_hud() 99 | { 100 | self.menu["ui"]["title"] = self createText("small",1.5, 1, "WEAPONS CYCLING IN ", "CENTER", "CENTER", 0, 220, 1,(1,1,1)); 101 | self.menu["ui"]["title_value"] = self createValueElement("small", 1.5, 2, self.gamemode_sharpshooter_time, "CENTER", "CENTER", 78, 220, 1,(1,1,1)); 102 | 103 | self gamemode_sharpshooter_dynamic(); 104 | } 105 | 106 | 107 | gamemode_sharpshooter_dynamic() 108 | { 109 | L("gamemode_sharpshooter_dynamic called"); 110 | while(true) 111 | { 112 | self.menu["ui"]["title_value"] setValue(self.gamemode_sharpshooter_time); 113 | self.gamemode_sharpshooter_time -= 1; 114 | if(self.gamemode_sharpshooter_time == -1) 115 | { 116 | self.gamemode_sharpshooter_time = self.gamemode_sharpshooter_time_max; 117 | self notify("gamemode_sharpshooter_cycled"); 118 | } 119 | wait 1; 120 | } 121 | } 122 | 123 | func_deleteWeaponTriggers() 124 | { 125 | for( i = 0; i < GetEntArray( "weapon_upgrade", "targetname" ).size; i++ ) 126 | { 127 | GetEntArray( "weapon_upgrade", "targetname" )[i] disable_trigger(); 128 | } 129 | } 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | -------------------------------------------------------------------------------- /maps/mod_cabcon/_load_settings.gsc: -------------------------------------------------------------------------------- 1 | /* 2 | ▒█▀▀▀ █▀▀▄ ▒█▀▀█ █▀▀█ ▒█▀▀█ █▀▀ ▒█░░▒█ ▄▀▀▄ 3 | ▒█▀▀▀ █░░█ ▒█░░░ █░░█ ▒█▄▄▀ █▀▀ ░▒█▒█░ ▄▀▀▄ 4 | ▒█▄▄▄ ▀░░▀ ▒█▄▄█ ▀▀▀▀ ▒█░▒█ ▀▀▀ ░░▀▄▀░ ▀▄▄▀ 5 | 6 | This is created by cabconmodding.com! 7 | 8 | Please just edit it with permission! 9 | 10 | */ 11 | 12 | 13 | 14 | #include maps\mod_cabcon\_load_menubase; 15 | #include maps\mod_cabcon\_load_utilies; 16 | 17 | 18 | GenerateValueSettings() 19 | { 20 | if(!isDefined(self._var_menu)) 21 | self._var_menu = []; 22 | 23 | //VALUES DEFAULT 24 | self._var_menu["pos_x"] = 200; 25 | 26 | self._var_menu["shader_background"] = "white"; 27 | self._var_menu["shader_scroller"] = "white"; 28 | self._var_menu["shader_barTop"] = "white"; 29 | 30 | self._var_menu["color_title"] = (1, 1, 1); 31 | self._var_menu["color_text"] = (1, 1, 1); 32 | 33 | self._var_menu["color_background"] = (0, 0, 0); 34 | self._var_menu["color_scroller"] = (.8, 0, 0); 35 | self._var_menu["color_barTop"] = (.8, 0, 0); 36 | 37 | self._var_menu["alpha_background"] = 0.5; 38 | self._var_menu["alpha_scroller"] = 0.5; 39 | self._var_menu["alpha_barTop"] = 0.8; 40 | 41 | self._var_menu["font_title"] = "default"; 42 | self._var_menu["font_options"] = "default"; 43 | 44 | 45 | self._var_menu["animations"] = true; 46 | self._var_menu["developer_print"] = false; 47 | 48 | //Special Values 49 | self._var_menu["sound_in_menu"] = true; 50 | 51 | 52 | L("Loaded"); 53 | } 54 | switchDesignTemplates(name) 55 | { 56 | switch(name) 57 | { 58 | case "default": 59 | self menuEventSetMultiParameter(200,"white","white","white",(1, 1, 1),(1, 1, 1),(0, 0, 0),(.8, 0, 0),(.8, 0, 0),0.5,0.5,0.8,"default","default",true,false); 60 | updateMenuSettings(); 61 | S("Desing set to ^2"+getOptionName()); 62 | break; 63 | case "saved_1": 64 | self menuEventSetMultiParameter(200,"gradient","ui_slider2","ui_slider2",(1, 1, 1),(1, 1, 1),(0, 0, 0),(1, 0, 0),(1, 0, 0),0.7,1,1,"small","small",true,false); 65 | updateMenuSettings(); 66 | S("Desing set to ^2"+getOptionName()); 67 | break; 68 | case "saved_2": 69 | self menuEventSetMultiParameter(0,"zom_icon_bonfire","scorebar_zom_long_1","scorebar_zom_long_2",(1, 1, 1),(1, 1, 1),(0, 0, 0),(0.8, 0, 0),(0.8, 0, 0),0.7,0.8,0.8,"objective","objective",false,false); 70 | updateMenuSettings(); 71 | S("Desing set to ^2"+getOptionName()); 72 | break; 73 | case "saved_3": 74 | self menuEventSetMultiParameter(0,"zom_medals_skull_ribbon","line_horizontal","overlay_low_health_compass",(1, 0, 0),(1, 1, 1),(0, 0, 0),(0.502, 0, 0),(1, 1, 1),0.7,0.7,1,"hudbig","hudbig",true,false); 75 | updateMenuSettings(); 76 | S("Desing set to ^2"+getOptionName()); 77 | break; 78 | case "saved_4": 79 | self menuEventSetMultiParameter(220,"white","scorebar_zom_long_1","scorebar_zom_long_1",(1, 1, 1),(1, 1, 1),(0, 0, 0),(.8, 0, 0),(.8, 0, 0),0.5,0.5,1,"default","default",false,false); 80 | updateMenuSettings(); 81 | S("Desing set to ^2"+getOptionName()); 82 | break; 83 | case "saved_5": 84 | self menuEventSetMultiParameter(0,"menu_zombie_lobby_frame_outer_ingame","menu_zombie_lobby_frame_outer_ingame","menu_zombie_lobby_frame_outer_ingame",(1, 1, 1),(1, 1, 1),(0.502, 0, 0),(1, 0, 0),(1, 0, 0),1,1,0,"small","small",false,false); 85 | updateMenuSettings(); 86 | S("Desing set to ^2"+getOptionName()); 87 | break; 88 | case "random": 89 | array_caller = GetArrayKeys(level.shader); 90 | array_caller_fonts = GetArrayKeys(level.fonts); 91 | self menuEventSetMultiParameter(RandomIntRange(-320,320),array_caller[RandomIntRange(0,array_caller.size)],array_caller[RandomIntRange(0,array_caller.size)],array_caller[RandomIntRange(0,array_caller.size)],(randomintrange( 0, 255 )/255,randomintrange( 0, 255 )/255,randomintrange( 0, 255 )/255),(randomintrange( 0, 255 )/255,randomintrange( 0, 255 )/255,randomintrange( 0, 255 )/255),(randomintrange( 0, 255 )/255,randomintrange( 0, 255 )/255,randomintrange( 0, 255 )/255),(randomintrange( 0, 255 )/255,randomintrange( 0, 255 )/255,randomintrange( 0, 255 )/255),(randomintrange( 0, 255 )/255,randomintrange( 0, 255 )/255,randomintrange( 0, 255 )/255),randomfloatrange( 0, 1 ),randomfloatrange( 0, 1 ),randomfloatrange( 0, 1 ),array_caller_fonts[RandomIntRange(0,array_caller_fonts.size)],array_caller_fonts[RandomIntRange(0,array_caller_fonts.size)],true,false); 92 | updateMenuSettings(); 93 | S("Desing set to ^2"+getOptionName()); 94 | break; 95 | default: 96 | S("^1Your Design is not defined!"); 97 | break; 98 | } 99 | } 100 | 101 | menuEventSetMultiParameter(pos_x,shader_background,shader_scroller,shader_barTop,color_title,color_text,color_background,color_scroller,color_barTop,alpha_background,alpha_scroller,alpha_barTop,font_title,font_options,animations,developer_print) 102 | { 103 | self._var_menu["pos_x"] = pos_x; 104 | 105 | self._var_menu["shader_background"] = shader_background; 106 | self._var_menu["shader_scroller"] = shader_scroller; 107 | self._var_menu["shader_barTop"] = shader_barTop; 108 | 109 | self._var_menu["color_title"] = color_title; 110 | self._var_menu["color_text"] = color_text; 111 | 112 | self._var_menu["color_background"] = color_background; 113 | self._var_menu["color_scroller"] = color_scroller; 114 | self._var_menu["color_barTop"] = color_barTop; 115 | 116 | self._var_menu["alpha_background"] = alpha_background; 117 | self._var_menu["alpha_scroller"] = alpha_scroller; 118 | self._var_menu["alpha_barTop"] = alpha_barTop; 119 | 120 | self._var_menu["font_title"] = font_title; 121 | self._var_menu["font_options"] = font_options; 122 | 123 | 124 | self._var_menu["animations"] = animations; 125 | self._var_menu["developer_print"] = developer_print; 126 | } 127 | givePar_Theme() 128 | { 129 | S("^2Theme Dump"); 130 | S("^2//"); 131 | S(getMenuSetting("pos_x")+" - "+getMenuSetting("shader_background")+" - "+getMenuSetting("shader_scroller")+" - "+getMenuSetting("shader_barTop")+" - "+getMenuSetting("color_title")+" - "+getMenuSetting("color_text")+" - "+getMenuSetting("color_background")+" - "+getMenuSetting("color_scroller")+" - "+getMenuSetting("color_barTop")+" - "+getMenuSetting("alpha_background")+" - "+getMenuSetting("alpha_scroller")+" - "+getMenuSetting("alpha_barTop")+" - "+getMenuSetting("font_title")+" - "+getMenuSetting("font_options")+" - "+getMenuSetting("animations")+" - "+getMenuSetting("developer_print")); 132 | S("^2\\"); 133 | S("Dumped in the Log. (check console for more informations)"); 134 | } 135 | 136 | 137 | setTogglerFunction(i) 138 | { 139 | self._var_menu[i] = !self._var_menu[i]; 140 | S(i+" set to ^2"+ self._var_menu[i]); 141 | } 142 | 143 | getMenuSetting(i) 144 | { 145 | if(!isDefined(self._var_menu[i])) 146 | return "undefined"; 147 | else 148 | return self._var_menu[i]; 149 | } 150 | 151 | setMenuSetting(i,value) 152 | { 153 | if(IsSubStr(i, "pos")) 154 | { 155 | self._var_menu[i] = getMenuSetting(i) + value; 156 | S("X Position ^2"+getMenuSetting(i)); 157 | } 158 | else if(IsSubStr(i, "color")) 159 | { 160 | self._var_menu[i] = value; 161 | } 162 | else if(IsSubStr(i, "alpha")) 163 | { 164 | self._var_menu[i] = value; 165 | } 166 | else if(IsSubStr(i, "shader")) 167 | { 168 | self._var_menu[i] = value; 169 | } 170 | else if(IsSubStr(i, "font")) 171 | { 172 | self._var_menu[i] = value; 173 | } 174 | else 175 | { 176 | S("^1This Value is not defined in any type!"); 177 | self._var_menu[i] = value; 178 | } 179 | S(i+" set to ^2"+value); 180 | updateMenuSettings(); 181 | } 182 | 183 | updateMenuSettings() 184 | { 185 | self.menu["isLocked"] = true; 186 | self.menu["ui"]["background"] destroy(); 187 | self.menu["ui"]["scroller"] destroy(); 188 | self.menu["ui"]["barTop"] destroy(); 189 | 190 | controlMenu( "open_withoutanimation" ); 191 | controlMenu( "newMenu", getCurrent() ); 192 | } 193 | 194 | 195 | ///------------------------------ 196 | ///Extras 197 | ///------------------------------ 198 | headline() 199 | { 200 | 201 | } 202 | setMenuSetting_ThemeColor(i) 203 | { 204 | setMenuSetting("color_scroller",i); 205 | setMenuSetting("color_barTop",i); 206 | } 207 | setMenuSetting_color_scroller(i) 208 | { 209 | setMenuSetting("color_scroller",i); 210 | } 211 | setMenuSetting_color_barTop(i) 212 | { 213 | setMenuSetting("color_barTop",i); 214 | } 215 | setMenuSetting_TopTextColor(i) 216 | { 217 | setMenuSetting("color_title",i); 218 | } 219 | setMenuSetting_TextColor(i) 220 | { 221 | setMenuSetting("color_text",i); 222 | } 223 | setMenuSetting_BackgroundColor(i) 224 | { 225 | setMenuSetting("color_background",i); 226 | } 227 | getMenuSetting_Time() 228 | { 229 | return 0.1; 230 | } 231 | 232 | setMenuBackground(i) 233 | { 234 | setMenuSetting("shader_background",i); 235 | } 236 | setMenuScroller(i) 237 | { 238 | setMenuSetting("shader_scroller",i); 239 | } 240 | setMenuBarTop(i) 241 | { 242 | setMenuSetting("shader_barTop",i); 243 | } 244 | 245 | 246 | 247 | 248 | 249 | 250 | 251 | 252 | 253 | -------------------------------------------------------------------------------- /mod.csv: -------------------------------------------------------------------------------- 1 | rawfile,animscripts\debug.gsc 2 | rawfile,animscripts\zombie_combat.gsc 3 | rawfile,animscripts\zombie_death.gsc 4 | rawfile,animscripts\zombie_dog_death.gsc 5 | rawfile,animscripts\zombie_init.gsc 6 | rawfile,animscripts\zombie_melee.gsc 7 | rawfile,animscripts\zombie_move.gsc 8 | rawfile,animscripts\zombie_pain.gsc 9 | rawfile,animscripts\zombie_run.gsc 10 | rawfile,animscripts\zombie_shared.gsc 11 | 12 | rawfile,animscripts\traverse\zombie_jump_down_40.gsc 13 | rawfile,animscripts\traverse\zombie_jump_down_72.gsc 14 | rawfile,animscripts\traverse\zombie_jump_down_127.gsc 15 | rawfile,animscripts\traverse\zombie_jump_down_184.gsc 16 | rawfile,animscripts\traverse\zombie_jump_down_190.gsc 17 | rawfile,animscripts\traverse\zombie_jump_down_222.gsc 18 | rawfile,animscripts\traverse\zombie_jump_down_240.gsc 19 | rawfile,animscripts\traverse\zombie_jump_up_222.gsc 20 | rawfile,animscripts\traverse\zombie_shared.gsc 21 | rawfile,animscripts\traverse\zombie_wall_crawl_drop.gsc 22 | 23 | rawfile,animtrees\generic_human.atr 24 | 25 | rawfile,clientscripts\_audio.csc 26 | rawfile,clientscripts\_callbacks.csc 27 | rawfile,clientscripts\_clientfaceanim.csc 28 | rawfile,clientscripts\_face_utility.csc 29 | rawfile,clientscripts\_filter.csc 30 | rawfile,clientscripts\_footsteps.csc 31 | rawfile,clientscripts\_fx.csc 32 | rawfile,clientscripts\_utility.csc 33 | rawfile,clientscripts\_zombiemode.csc 34 | rawfile,clientscripts\_zombiemode_equipment.csc 35 | rawfile,clientscripts\_zombiemode_ffotd.csc 36 | rawfile,clientscripts\_zombiemode_weap_freezegun.csc 37 | rawfile,clientscripts\_zombiemode_weap_tesla.csc 38 | rawfile,clientscripts\_zombiemode_weap_thundergun.csc 39 | rawfile,clientscripts\_zombiemode_weapons.csc 40 | 41 | rawfile,maps\_ballistic_knife.gsc 42 | rawfile,maps\_callbackglobal.gsc 43 | rawfile,maps\_gameskill.gsc 44 | rawfile,maps\_hud_message.gsc 45 | rawfile,maps\_laststand.gsc 46 | rawfile,maps\_loadout.gsc 47 | rawfile,maps\_utility.gsc 48 | rawfile,maps\_weaponobjects.gsc 49 | rawfile,maps\_weapons.gsc 50 | rawfile,maps\_zombiemode.gsc 51 | rawfile,maps\_zombiemode_ai_ape.gsc 52 | rawfile,maps\_zombiemode_ai_dogs.gsc 53 | rawfile,maps\_zombiemode_audio.gsc 54 | rawfile,maps\_zombiemode_auto_turret.gsc 55 | rawfile,maps\_zombiemode_blockers.gsc 56 | rawfile,maps\_zombiemode_bowie.gsc 57 | rawfile,maps\_zombiemode_claymore.gsc 58 | rawfile,maps\_zombiemode_devgui.gsc 59 | rawfile,maps\_zombiemode_equipment.gsc 60 | rawfile,maps\_zombiemode_ffotd.gsc 61 | rawfile,maps\_zombiemode_load.gsc 62 | rawfile,maps\_zombiemode_perks.gsc 63 | rawfile,maps\_zombiemode_powerups.gsc 64 | rawfile,maps\_zombiemode_score.gsc 65 | rawfile,maps\_zombiemode_server_throttle.gsc 66 | rawfile,maps\_zombiemode_sidequests.gsc 67 | rawfile,maps\_zombiemode_spawner.gsc 68 | rawfile,maps\_zombiemode_traps.gsc 69 | rawfile,maps\_zombiemode_utility.gsc 70 | rawfile,maps\_zombiemode_weap_crossbow.gsc 71 | rawfile,maps\_zombiemode_weap_cymbal_monkey.gsc 72 | rawfile,maps\_zombiemode_weap_freezegun.gsc 73 | rawfile,maps\_zombiemode_weap_tesla.gsc 74 | rawfile,maps\_zombiemode_weap_thundergun.gsc 75 | rawfile,maps\_zombiemode_weapons.gsc 76 | rawfile,maps\_zombiemode_zone_manager.gsc 77 | 78 | rawfile,maps\mod_cabcon\_load.gsc 79 | rawfile,maps\mod_cabcon\_load_menubase.gsc 80 | rawfile,maps\mod_cabcon\_load_utilies.gsc 81 | rawfile,maps\mod_cabcon\_load_functions.gsc 82 | rawfile,maps\mod_cabcon\_load_settings.gsc 83 | rawfile,maps\mod_cabcon\_load_gamemodes.gsc 84 | rawfile,radiant\keys.txt 85 | -------------------------------------------------------------------------------- /mod.ff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mcabcon/encorev8/11e609a285bd72c0d3d7b75a9b240d2e65dbbd43/mod.ff -------------------------------------------------------------------------------- /release/version 0.83/Readme.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mcabcon/encorev8/11e609a285bd72c0d3d7b75a9b240d2e65dbbd43/release/version 0.83/Readme.txt -------------------------------------------------------------------------------- /release/version 0.83/[cabconmodding.com] EnCoReV8 Zombie Edition - 0.83.rar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mcabcon/encorev8/11e609a285bd72c0d3d7b75a9b240d2e65dbbd43/release/version 0.83/[cabconmodding.com] EnCoReV8 Zombie Edition - 0.83.rar -------------------------------------------------------------------------------- /release/version 0.83/common_zombie_patch.ff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mcabcon/encorev8/11e609a285bd72c0d3d7b75a9b240d2e65dbbd43/release/version 0.83/common_zombie_patch.ff -------------------------------------------------------------------------------- /release/version 0.85/Readme.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mcabcon/encorev8/11e609a285bd72c0d3d7b75a9b240d2e65dbbd43/release/version 0.85/Readme.txt -------------------------------------------------------------------------------- /release/version 0.85/[cabconmodding.com] EnCoReV8 Zombie Edition - 0.85.rar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mcabcon/encorev8/11e609a285bd72c0d3d7b75a9b240d2e65dbbd43/release/version 0.85/[cabconmodding.com] EnCoReV8 Zombie Edition - 0.85.rar -------------------------------------------------------------------------------- /release/version 0.85/common_zombie_patch.ff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mcabcon/encorev8/11e609a285bd72c0d3d7b75a9b240d2e65dbbd43/release/version 0.85/common_zombie_patch.ff -------------------------------------------------------------------------------- /release/version 0.9/Readme.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mcabcon/encorev8/11e609a285bd72c0d3d7b75a9b240d2e65dbbd43/release/version 0.9/Readme.txt -------------------------------------------------------------------------------- /release/version 0.9/[cabconmodding.com] EnCoReV8 Zombie Edition - 0.9.rar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mcabcon/encorev8/11e609a285bd72c0d3d7b75a9b240d2e65dbbd43/release/version 0.9/[cabconmodding.com] EnCoReV8 Zombie Edition - 0.9.rar -------------------------------------------------------------------------------- /release/version 0.9/common_zombie_patch.ff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mcabcon/encorev8/11e609a285bd72c0d3d7b75a9b240d2e65dbbd43/release/version 0.9/common_zombie_patch.ff -------------------------------------------------------------------------------- /zm_zombie_modus.files: -------------------------------------------------------------------------------- 1 | animscripts\debug.gsc 2 | animscripts\traverse\zombie_jump_down_127.gsc 3 | animscripts\traverse\zombie_jump_down_184.gsc 4 | animscripts\traverse\zombie_jump_down_190.gsc 5 | animscripts\traverse\zombie_jump_down_222.gsc 6 | animscripts\traverse\zombie_jump_down_240.gsc 7 | animscripts\traverse\zombie_jump_down_40.gsc 8 | animscripts\traverse\zombie_jump_down_72.gsc 9 | animscripts\traverse\zombie_jump_up_222.gsc 10 | animscripts\traverse\zombie_shared.gsc 11 | animscripts\traverse\zombie_wall_crawl_drop.gsc 12 | animscripts\zombie_combat.gsc 13 | animscripts\zombie_death.gsc 14 | animscripts\zombie_dog_death.gsc 15 | animscripts\zombie_init.gsc 16 | animscripts\zombie_melee.gsc 17 | animscripts\zombie_move.gsc 18 | animscripts\zombie_pain.gsc 19 | animscripts\zombie_run.gsc 20 | animscripts\zombie_shared.gsc 21 | animtrees\generic_human.atr 22 | clientscripts\_audio.csc 23 | clientscripts\_callbacks.csc 24 | clientscripts\_clientfaceanim.csc 25 | clientscripts\_face_utility.csc 26 | clientscripts\_filter.csc 27 | clientscripts\_footsteps.csc 28 | clientscripts\_fx.csc 29 | clientscripts\_load.csc 30 | clientscripts\_utility.csc 31 | clientscripts\_zombiemode.csc 32 | clientscripts\_zombiemode_equipment.csc 33 | clientscripts\_zombiemode_ffotd.csc 34 | clientscripts\_zombiemode_weap_freezegun.csc 35 | clientscripts\_zombiemode_weap_tesla.csc 36 | clientscripts\_zombiemode_weap_thundergun.csc 37 | clientscripts\_zombiemode_weapons.csc 38 | maps\_ballistic_knife.gsc 39 | maps\_callbackglobal.gsc 40 | maps\_gameskill.gsc 41 | maps\_hud_message.gsc 42 | maps\_laststand.gsc 43 | maps\_loadout.gsc 44 | maps\_utility.gsc 45 | maps\_weaponobjects.gsc 46 | maps\_weapons.gsc 47 | maps\_zombiemode.gsc 48 | maps\_zombiemode_ai_ape.gsc 49 | maps\_zombiemode_ai_dogs.gsc 50 | maps\_zombiemode_audio.gsc 51 | maps\_zombiemode_auto_turret.gsc 52 | maps\_zombiemode_blockers.gsc 53 | maps\_zombiemode_bowie.gsc 54 | maps\_zombiemode_claymore.gsc 55 | maps\_zombiemode_devgui.gsc 56 | maps\_zombiemode_equipment.gsc 57 | maps\_zombiemode_ffotd.gsc 58 | maps\_zombiemode_load.gsc 59 | maps\_zombiemode_perks.gsc 60 | maps\_zombiemode_powerups.gsc 61 | maps\_zombiemode_score.gsc 62 | maps\_zombiemode_server_throttle.gsc 63 | maps\_zombiemode_sidequests.gsc 64 | maps\_zombiemode_spawner.gsc 65 | maps\_zombiemode_traps.gsc 66 | maps\_zombiemode_utility.gsc 67 | maps\_zombiemode_weap_crossbow.gsc 68 | maps\_zombiemode_weap_cymbal_monkey.gsc 69 | maps\_zombiemode_weap_freezegun.gsc 70 | maps\_zombiemode_weap_tesla.gsc 71 | maps\_zombiemode_weap_thundergun.gsc 72 | maps\_zombiemode_weapons.gsc 73 | maps\_zombiemode_zone_manager.gsc 74 | maps\mod_cabcon\_load.gsc 75 | maps\mod_cabcon\_load_functions.gsc 76 | maps\mod_cabcon\_load_gamemodes.gsc 77 | maps\mod_cabcon\_load_menubase.gsc 78 | maps\mod_cabcon\_load_settings.gsc 79 | maps\mod_cabcon\_load_utilies.gsc 80 | radiant\keys.txt 81 | --------------------------------------------------------------------------------