/* server/entities/mystery_box.qc Mystery Box Entity Logic Copyright (C) 2021-2023 NZ:P Team This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to: Free Software Foundation, Inc. 59 Temple Place - Suite 330 Boston, MA 02111-1307, USA */ void(vector where, float time_alive) SpawnSpark; void() MBOX_Touch; #define MBOX_SPAWNFLAG_NOTHERE 1 #define MBOX_SPAWNFLAG_NOLIGHT 2 // // MBOX_UpdateGlowFrame() // Updates the Glow model frame to match // the box if it exists. // void() MBOX_UpdateGlowFrame = { if (self.goaldummy) self.goaldummy.frame = self.frame; }; // // MBOX_PlayOpenAnimation() // Plays the open animation for the Mystery Box, // frames 1-8. // void() MBOX_PlayOpenAnimation = [1, MBOX_OpenAnimation2 ] { self.frame = 1; MBOX_UpdateGlowFrame(); Light_Yellow(self); }; void() MBOX_OpenAnimation2 = [2, MBOX_OpenAnimation3 ] { self.frame = 2; MBOX_UpdateGlowFrame(); }; void() MBOX_OpenAnimation3 = [3, MBOX_OpenAnimation4 ] { self.frame = 3; MBOX_UpdateGlowFrame(); }; void() MBOX_OpenAnimation4 = [4, MBOX_OpenAnimation5 ] { self.frame = 4; MBOX_UpdateGlowFrame(); }; void() MBOX_OpenAnimation5 = [5, MBOX_OpenAnimation6 ] { self.frame = 5; MBOX_UpdateGlowFrame(); }; void() MBOX_OpenAnimation6 = [6, MBOX_OpenAnimation7 ] { self.frame = 6; MBOX_UpdateGlowFrame(); }; void() MBOX_OpenAnimation7 = [7, MBOX_OpenAnimation8 ] { self.frame = 7; MBOX_UpdateGlowFrame(); }; void() MBOX_OpenAnimation8 = [8, SUB_Null ] { self.frame = 8; MBOX_UpdateGlowFrame(); }; // // MBOX_WaitEnd() // Ends the per-use delay for the Mystery Box. // void() MBOX_WaitEnd = { self.boxstatus = 0; self.think = SUB_Null; } // // MBOX_Reset() // Resets the Mystery Box to be ready for // another use. // inline void() MBOX_Reset = { self.frame = 0; self.boxstatus = -1; // Add a 3 second delay before the Mystery Box // can be interact with again. self.think = MBOX_WaitEnd; self.nextthink = time + 3; }; // // MBOX_PlayCloseAnimation() // Plays the open animation for the Mystery Box, // frames 9-12. // void() MBOX_PlayCloseAnimation = [9, MBOX_CloseAnimation2 ] { self.frame = 9; MBOX_UpdateGlowFrame(); sound (self, CHAN_ITEM, mystery_box_close_sound, 1, ATTN_NORM); Light_None(self); }; void() MBOX_CloseAnimation2 = [10, MBOX_CloseAnimation3 ] { self.frame = 10; MBOX_UpdateGlowFrame(); }; void() MBOX_CloseAnimation3 = [10, MBOX_CloseAnimation4 ] { self.frame = 11; MBOX_UpdateGlowFrame(); }; void() MBOX_CloseAnimation4 = [10, MBOX_Reset ] { self.frame = 12; MBOX_UpdateGlowFrame(); }; // // MBOX_FreeEnt(ent) // Marks an MBOX entity as able to be used. // void(entity ent) MBOX_FreeEnt = { setmodel(ent, ""); ent.classname = "freeMboxEntity"; ent.touch = SUB_Null; ent.think = SUB_Null; ent.effects = 0; #ifdef FTE ent.alpha = 1; #endif // FTE }; // // MBOX_GetFreeEnt() // Returns an MBOX entity to use. // entity() MBOX_GetFreeEnt = { entity ent; ent = find(world, classname, "freeMboxEntity"); if (ent == world) error("MBOX_GetFreeEnt: No free MBOX Entity. (Hacks?)\n"); return ent; }; // // MBOX_GetRandomBoxWeapon(user) // Returns a weapon from the Mystery Box allow-list // that the user is not holding. // float(entity user) MBOX_GetRandomBoxWeapon = { float weapon_index = rint((random() * (MAX_BOX_WEAPONS - 1))); float weapon_id = mystery_box_weapons[weapon_index].weapon_id; float weapon_allowed = mystery_box_weapons[weapon_index].allowed && !mystery_box_weapons[weapon_index].already_obtained; if (weapon_allowed == true && !Weapon_PlayerHasWeapon(user, weapon_id, true)) return weapon_id; else return MBOX_GetRandomBoxWeapon(user); }; // // Reset_MBox() // Resets the Mystery Box to it's inital State. // void() Reset_MBox = { entity tempe; self.velocity = '0 0 0'; tempe = self; self = self.owner; MBOX_PlayCloseAnimation(); self = tempe; self.owner.owner = world; self.owner.boxstatus = 0; MBOX_FreeEnt(self); } // // Float_Decreate() // Make the Gun in the Box slowly descend, eventually // resetting the Box. // void() Float_Decrease = { makevectors(self.angles); self.velocity = v_up*-5; self.nextthink = time + 7; self.think = Reset_MBox; } // // findboxspot() // Locate a new MBox spot and turn this spot into // a tp_spot. // void() findboxspot = { local entity newspot; local float box = rint(random(mystery_box_count)); newspot = mystery_boxes[box]; // Ensure the spot we choose is valid. while(newspot == world || newspot == self.owner) { box = rint(random(mystery_box_count)); newspot = mystery_boxes[box]; } // Make our current spot a tp_spot self.owner.model = "models/props/teddy.mdl"; self.owner.frame = 2; setmodel(self.owner, self.owner.model); self.owner.classname = "mystery_box_tp_spot"; self.owner.touch = SUB_Null; self.owner.angles_y -= 90; Light_None(self.owner); newspot.angles_y += 90; // Spawn the Box Glow if permitted if (!(self.owner.spawnflags & MBOX_SPAWNFLAG_NOLIGHT)) { entity g; g = MBOX_GetFreeEnt(); g.classname = "mystery_glow"; newspot.goaldummy = g; setmodel(g, mystery_box_glow_model); setorigin(g,newspot.origin); g.angles = newspot.angles; #ifdef FTE g.alpha = 0.5; #endif // FTE } // Remove teddy MBOX_FreeEnt(self); // Set some values and change the found Spot to an MBox newspot.spins = 0; newspot.boxstatus = 0; newspot.touch = MBOX_Touch; newspot.solid=SOLID_TRIGGER; newspot.classname = "mystery"; newspot.spawnflags = self.owner.spawnflags; setorigin(newspot, newspot.origin); setmodel (newspot, mystery_box_model); newspot.frame = 0; setsize (newspot, VEC_HULL2_MIN, VEC_HULL2_MAX); } // // MBOX_MakeActive() // Sets the Mystery Box touch to MBOX_Touch (delay) // void() MBOX_MakeActive = { self.touch = MBOX_Touch; } // // MBOX_FindNewSpot() // Locate a new location for the Mystery Box. // void() MBOX_FindNewSpot = { entity new_box = world; // Find a new Mystery Box location while(new_box == world || new_box == self) { float box_index = rint(random(mystery_box_count)); new_box = mystery_boxes[box_index]; } // Stupid Teddy Bear being rotated!! new_box.angles_y += 90; // Convert the spawn to a Mystery Box new_box.spawnflags = self.spawnflags; new_box.spins = new_box.boxstatus = 0; new_box.think = MBOX_MakeActive; new_box.nextthink = time + 2; new_box.solid = SOLID_TRIGGER; new_box.classname = "mystery"; new_box.frame = 0; setmodel(new_box, mystery_box_model); setsize(new_box, VEC_HULL2_MIN, VEC_HULL2_MAX); // Spawn the Box Glow if permitted if (!(new_box.spawnflags & MBOX_SPAWNFLAG_NOLIGHT)) { entity light; light = MBOX_GetFreeEnt(); light.classname = "mystery_glow"; new_box.goaldummy = light; setmodel(light, mystery_box_glow_model); setorigin(light, new_box.origin); light.angles = new_box.angles; light.effects = EF_FULLBRIGHT; #ifdef FTE light.alpha = 0.5; #endif // FTE } // Spawn some sparkles so it doesn't just "appear" SpawnSpark(new_box.origin, 0.75); // "Woosh" Effect sound(new_box, CHAN_AUTO, "sounds/pu/drop.wav", 1, ATTN_NORM); } // // MBOX_StopFlying() // We've done our dance, go away and // delay respawning. // void() MBOX_StopFlying = { // Spark Effect SpawnSpark(self.origin, 0.75); // "Woosh" Effect sound(self, CHAN_AUTO, "sounds/pu/drop.wav", 1, ATTN_NORM); // Disappear! self.model = "models/props/teddy.mdl"; setmodel(self, self.model); self.frame = 2; // Clean up self.origin = self.oldvelocity; self.angles = self.movement; self.velocity = 0; self.angles_y -= 90; self.classname = "mystery_box_tp_spot"; self.touch = SUB_Null; // 12 Second delay to finding a new spot self.think = MBOX_FindNewSpot; self.nextthink = time + 12; } // // MBOX_AnimateFly() // Rotate the Mystery Box as it flies away. // void() MBOX_AnimateFly = { if (self.score == 0) self.angles_x += 6; else self.angles_x -= 6; if (self.angles_x - self.movement_x >= 20) self.score = 1; else if (self.angles_x - self.movement_x <= -20) self.score = 0; if(self.ltime < time) { MBOX_StopFlying(); } else { self.nextthink = time + 0.05; } } // // MBOX_FlyAway() // The actual leave animation. // void() MBOX_FlyAway = { // Begin rising makevectors(self.angles); self.movetype = MOVETYPE_NOCLIP; self.velocity = v_up * 7; // Animation lasts 4 seconds self.ltime = time + 4; // Animation Update self.think = MBOX_AnimateFly; self.nextthink = time + 0.05; } // // MBOX_Leave() // Starts Mystery Box Leave animation. // void() MBOX_Leave = { // Broadcast the laughter sound(self, CHAN_ITEM, "sounds/pu/byebye.wav", 1, ATTN_NONE); // "Woosh" Effect sound(self, CHAN_AUTO, "sounds/pu/drop.wav", 1, ATTN_NORM); // Spark Effect SpawnSpark(self.origin, 0.75); // Turn off Light & Glow Light_None(self); if (!(self.spawnflags & MBOX_SPAWNFLAG_NOLIGHT)) if (self.goaldummy != world) MBOX_FreeEnt(self.goaldummy); // Save old position and angle self.oldvelocity = self.origin; self.movement = self.angles; // Start flying self.think = MBOX_FlyAway; self.nextthink = time + 0.05; } // // MBOX_TeddyDespawn() // Frees the Teddy Bear entity. // void() MBOX_TeddyDespawn = { self.velocity = 0; MBOX_FreeEnt(self); } // // MBOX_TeddyLeave() // Make the Teddy Bear float away and start the // timer for the Mystery Box to follow. // void() MBOX_TeddyLeave = { // Fly slowly self.velocity = v_up*75; self.think = MBOX_TeddyDespawn; self.nextthink = time + 5; // Linger for 3 seconds, and then the Box follows. self.owner.think = MBOX_Leave; self.owner.nextthink = time + 3; } // // MBOX_PresentTeddy() // Lets the Teddy Bear idle for a few seconds, // return player points, kick-off leave. // void() MBOX_PresentTeddy = { // Return the Player's points. addmoney(self.owner.owner, mystery_box_cost, 0); // Broadcast the bad luck. sound(self, CHAN_ITEM, "sounds/misc/buy.wav", 1, ATTN_NONE); sound(self, 2, "sounds/misc/giggle.wav", 1, ATTN_NONE); // Linger for 2 seconds, and then fly away. self.think = MBOX_TeddyLeave; self.nextthink = time + 2; } // // MBOX_GetLeaveChancePercentage() // Generates a percentage chance for the Mystery Box // to leave. // float(float uses) MBOX_GetLeaveChancePercentage = { // If there's only one Mystery Box, never try to leave. // Additionally, you're always given 4 free uses. if (mystery_box_count == 1 || uses <= 4) return 0; float chance_to_leave = 0; // There is a hardcoded 100% chance to leave after 8 uses // if the box hasn't moved yet in a game. if (mystery_box_leave_count == 0 && uses >= 8) chance_to_leave = 100; // There's a 15% chance for leaving if this is between the uses // of 4 and 8. if (uses >= 4 && uses < 8) chance_to_leave = 15; // Mystery Box behavior changes after it leaves for the first time if (mystery_box_leave_count > 0) { // 30% chance of leaving between uses 8 and 12. if (uses >= 8 && uses < 12) chance_to_leave = 30; // 50% chance after the 12th use. else if (uses >= 12) chance_to_leave = 50; } return chance_to_leave/100; } void() Float_Change = { float tempf; string temps; float leave_chance; tempf = MBOX_GetRandomBoxWeapon(self.owner.owner); temps = GetWeaponModel(tempf, 1); setmodel (self, temps); self.boxstatus = self.boxstatus + 0.01; if (self.wait <= time) { leave_chance = MBOX_GetLeaveChancePercentage(self.owner.spins); self.velocity = '0 0 0'; if (random() > leave_chance) { //teddy gen threshold, high means less chance self.owner.boxstatus = 2; self.weapon = tempf; self.nextthink = time + 5; self.think = Float_Decrease; //bprint(PRINT_HIGH, "spot not found, or teddygun is > 0.7\n"); return; } else { addmoney(self.owner.owner, mystery_box_cost, 0); self.model = "models/props/teddy.mdl"; setmodel(self, self.model); self.angles_y = self.angles_y - 90; self.nextthink = time + 1; self.think = MBOX_PresentTeddy; mystery_box_leave_count++; if (mystery_box_leave_count >= 10) GiveAchievement(11); return; } } if (self.ltime <= time) { self.velocity_z = self.velocity_z*0.5; self.ltime = 0.5; } self.nextthink = time + self.boxstatus; self.think = Float_Change; } void() finish_mbox_setup = { // Temporary hack for random box spawns until rewrite - Mikey (27/03/2023, DD/MM/YYYY) if(self.spawnflags & MBOX_SPAWNFLAG_NOTHERE) { entity temp = MBOX_GetFreeEnt(); temp.classname = "mystery_helper"; temp.owner = self; temp.think = findboxspot; temp.nextthink = time + 0.1; } else if(!(self.spawnflags & MBOX_SPAWNFLAG_NOLIGHT)) { entity g = MBOX_GetFreeEnt(); g.classname = "mystery_glow"; self.goaldummy = g; setmodel(g, mystery_box_glow_model); setorigin(g,self.origin); g.angles = self.angles; g.effects = EF_FULLBRIGHT; #ifdef FTE g.alpha = 0.5; #endif // FTE } } // // MBOX_AllocateTempEntities() // Spawns in all of the temp entities that are // used for the floating weapons, teddy bear, // and glow. // void() MBOX_AllocateTempEntities = { self.think = SUB_Null; for (float i = 0; i < mystery_box_count * 3; i++) { entity tempe = spawn(); tempe.classname = "freeMboxEntity"; } finish_mbox_setup(); }; void() Create_Floating_Weapon = { entity gun; float tempf; string temps; tempf = MBOX_GetRandomBoxWeapon(self.owner.owner); temps = GetWeaponModel(tempf, 1); gun = MBOX_GetFreeEnt(); gun.classname = "mystery_weapon"; setorigin (gun, self.origin); setmodel (gun, temps); setsize (gun, '0 0 0', '0 0 0'); gun.angles = self.angles; gun.movetype = MOVETYPE_NOCLIP; gun.solid = SOLID_NOT; makevectors(self.angles); gun.velocity = v_up*15; gun.owner = self; self.boxweapon = gun; gun.ltime = time+2; gun.boxstatus = 0.01; gun.wait = time + 5; gun.nextthink = time + 0.01; gun.think = Float_Change; } void() mystery_box_tp_spot = { precache_model ("models/props/teddy.mdl"); precache_sound ("sounds/pu/byebye.wav"); precache_sound ("sounds/misc/giggle.wav"); self.solid=SOLID_TRIGGER; self.classname = "mystery_box_tp_spot"; setorigin(self, self.origin); setmodel (self, "models/props/teddy.mdl"); setsize (self, VEC_HULL2_MIN, VEC_HULL2_MAX); if (self.model == "models/props/teddy.mdl") { self.frame = 2; self.angles_y -= 90; } mystery_boxes[mystery_box_count] = self; mystery_box_count++; }; void() MBOX_UpdatePosessionStatus = { entity player = find(world, classname, "player"); while(player != world) { for(float i = 0; i < MAX_BOX_WEAPONS; i++) { float weapon_id = mystery_box_weapons[i].weapon_id; mystery_box_weapons[i].already_obtained = false; if (Weapon_PlayerHasWeapon(player, weapon_id, true) && WepDef_OnlyOneAllowed(weapon_id)) { mystery_box_weapons[i].already_obtained = true; } } player = find(player, classname, "player"); } } void() MBOX_Touch = { entity tempe; if (other.classname != "player" || other.downed) return; if (!self.boxstatus) { useprint (other, 6, mystery_box_cost, 0); } if (self.boxstatus == 2 && self.owner == other) { #ifndef FTE other.Weapon_Name_Touch = GetWeaponName(self.boxweapon.weapon); #endif // FTE useprint (other, 7, 0, self.boxweapon.weapon); } if (other.button7 && !other.semiuse) { other.semiuse = true; if (!self.boxstatus) { if (other.points >= mystery_box_cost) { sound (self, CHAN_ITEM, mystery_box_open_sound, 1, ATTN_NORM); addmoney(other, -mystery_box_cost, FALSE); self.boxstatus = 1; self.owner = other; MBOX_PlayOpenAnimation(); Create_Floating_Weapon(); MBOX_UpdatePosessionStatus(); self.spins++; } else { centerprint (other, STR_NOTENOUGHPOINTS); sound(other, 0, "sounds/misc/denybuy.wav", 1, 1); } } if (self.boxstatus == 2) { if (self.owner == other) { other.reload_delay = 0; self.owner = world; sound(self, 0,"sounds/misc/ching.wav", 1, 1); tempe = self; self = other; Weapon_GiveWeapon(tempe.boxweapon.weapon, 0, 0); self = tempe; MBOX_FreeEnt(self.boxweapon); MBOX_PlayCloseAnimation(); } } } } // // MBOX_GetWeaponIDFromMB1(mbox_id) // .mbox weapon IDs did not 100% correlate // to internal weapon IDs, so this converts // them appropriately. // float MBOX_GetWeaponIDFromMB1(float mbox_id) = { switch(mbox_id) { case 0: return W_COLT; case 1: return W_KAR; case 2: return W_DB; case 3: return W_MG; case 4: return W_RAY; case 5: return W_THOMPSON; case 6: return W_M2; case 7: return W_PPSH; case 8: return W_SAWNOFF; case 9: return W_TESLA; case 10: return W_M1A1; case 11: return W_GEWEHR; case 12: return W_FG; case 13: return W_BROWNING; case 14: return W_KAR_SCOPE; case 15: return W_357; case 16: return W_STG; case 17: return W_PANZER; case 18: return W_BK; case 19: return W_PTRS; case 20: return W_MP40; case 21: return W_TRENCH; case 22: return W_BAR; case 23: return W_M1; case 24: return W_TYPE; case 25: return W_MP5K; case 26: return W_SPRING; default: return W_COLT; } return W_COLT; } // // MBOX_PrecacheWeaponData() // Iterates through the weapon array and // allocates necessary content for each // allowed weapon. // void() MBOX_PrecacheWeaponContent = { for (float i = 0; i < MAX_BOX_WEAPONS; i++) { if (mystery_box_weapons[i].allowed == true) { precache_model(GetWeaponModel(mystery_box_weapons[i].weapon_id, 0)); precache_model(GetWeaponModel(mystery_box_weapons[i].weapon_id, 1)); precache_extra(mystery_box_weapons[i].weapon_id); } } } // // MBOX_ParseMB1File(mbox_file) // Parses the old (2014) .mbox file and loads // it into the necessary structure. // void(float mbox_file) MBOX_ParseMB1File = { string file_line; // Parse the .mbox line-by-line and fill the data structure. for (float i = 0; i < MAX_BOX_WEAPONS; i++) { file_line = strtrim((fgets(mbox_file))); mystery_box_weapons[i].weapon_id = MBOX_GetWeaponIDFromMB1(i); mystery_box_weapons[i].allowed = stof(file_line); mystery_box_weapons[i].rarity = -1; } // Precache the allowed weapons MBOX_PrecacheWeaponContent(); } // // MBOX_GetUnusedWeaponID() // Returns a weapon ID for a potential // box weapon that is not currently // in the list. // float() MBOX_GetUnusedWeaponID = { // Iterate over every potential Box Weapon for (float i = 0; i < MAX_BOX_WEAPONS; i++) { float weapon_in_use = false; float weapon_id = MBOX_GetWeaponIDFromMB1(i); // Now over every weapon in the list for (float j = 0; j < MAX_BOX_WEAPONS; j++) { if (mystery_box_weapons[j].weapon_id == weapon_id) weapon_in_use = true; } if (weapon_in_use == false) { return weapon_id; } } error("MBOX_GetunusedWeaponID: Could not find a free weapon slot!\n"); return 0; } // // MBOX_ParseMB2File(mbox_file) // Parses the current .mb2 file and loads it // into the necessary structure. // void(float mbox_file) MBOX_ParseMB2File = { string file_line; // Read the first line: It's our "header", should be // "nzp_mbox2". file_line = strtrim((fgets(mbox_file))); if (file_line != "nzp_mbox2") error(strcat("MBOX_ParseMB2File: Expected \"nzp_mbox2\" but got ", file_line)); // Read each line of the file in a loop float finished_parsing = false; float parsing_state = 0; float is_allow_not_deny = false; float weapons_parsed = 0; float weapon_id = 0; while(!finished_parsing) { // Grab a new line file_line = fgets(mbox_file); // End of file. if not (file_line) { finished_parsing = true; break; } file_line = strzone(strtrim(file_line)); // Check for comments, they always start with '#'. // Also ignore whitespace. string first_char = strzone(substring(file_line, 0, 1)); if (first_char == "#" || file_line == "") { continue; } strunzone(first_char); // // Actual Content Parsing // // Retrieving if its an allow or deny list. if (parsing_state == 0) { if (file_line == "allow:") is_allow_not_deny = true; else if (file_line == "deny:") is_allow_not_deny = false; else error(strcat("MBOX_ParseMB2File: Not an allow/deny specifier - ", file_line)); // Now that we know the list, we can begin // parsing the weapons inside of it. parsing_state++; } else if (parsing_state == 1) { // Get the weapon ID from it's name. weapon_id = WepDef_GetWeaponIDFromName(file_line); if (weapon_id == W_NOWEP) error(strcat("MBOX_ParseMB2File: Not a weapon - ", file_line)); // Fill the list with it. mystery_box_weapons[weapons_parsed].weapon_id = weapon_id; mystery_box_weapons[weapons_parsed].allowed = is_allow_not_deny; weapons_parsed++; } strunzone(file_line); } // At this point, the file has been parsed with all of the // allowed/denied weapons, now we have to automatically // fill in the rest for the opposite list. for (float i = weapons_parsed; i < MAX_BOX_WEAPONS; i++) { // We need to pick an ID to assign that hasn't already // been used. weapon_id = MBOX_GetUnusedWeaponID(); mystery_box_weapons[i].weapon_id = weapon_id; mystery_box_weapons[i].allowed = !is_allow_not_deny; } // Precache the allowed weapons MBOX_PrecacheWeaponContent(); } // // MBOX_LoadData() // Seeks for either an .mb2 or .mbox file, // and adds the contents into the Mystery Box // weapon list. // void() MBOX_LoadData = { float mbox_file; string file_path; // Attempt 1: Seek for maps/mapname.mb2 (mbox-2) file_path = strcat(mapname, ".mb2"); file_path = strcat("maps/", file_path); mbox_file = fopen(file_path, FILE_READ); if (mbox_file != -1) { MBOX_ParseMB2File(mbox_file); fclose(mbox_file); return; } // Attempt 2: Seek for maps/mapname.mbox (mbox-1) file_path = strcat(mapname, ".mbox"); file_path = strcat("maps/", file_path); mbox_file = fopen(file_path, FILE_READ); if (mbox_file != -1) { MBOX_ParseMB1File(mbox_file); fclose(mbox_file); return; } // Attempt 3: Include All Weapons for (float i = 0; i < MAX_BOX_WEAPONS; i++) { mystery_box_weapons[i].weapon_id = MBOX_GetWeaponIDFromMB1(i); mystery_box_weapons[i].allowed = true; mystery_box_weapons[i].rarity = -1; } // Precache it all. MBOX_PrecacheWeaponContent(); // Close the file pointer just in case. fclose(mbox_file); } void() mystery_box = { // Load and cache all of the allowed weapons into the hunk. MBOX_LoadData(); // // Set Default Stats for Compatibility // // Model if (!self.model) { self.model = "models/machines/mystery.mdl"; } // Light Model if (!self.weapon2model) { self.weapon2model = "models/machines/mglow$.mdl"; } // Cost if (!self.cost) { self.cost = 950; } // Open Sound if (!self.oldmodel) { self.oldmodel = "sounds/machines/mbox_open.wav"; } // Close Sound if (!self.powerup_vo) { self.powerup_vo = "sounds/machines/mbox_close.wav"; } // Store the custom presentation as globals mystery_box_model = self.model; mystery_box_glow_model = self.weapon2model; mystery_box_open_sound = self.oldmodel; mystery_box_close_sound = self.powerup_vo; mystery_box_cost = self.cost; precache_model(mystery_box_model); if (!(self.spawnflags & MBOX_SPAWNFLAG_NOLIGHT)) precache_model (mystery_box_glow_model); precache_sound(mystery_box_open_sound); precache_sound(mystery_box_close_sound); self.solid = SOLID_TRIGGER; self.classname = "mystery"; setorigin(self, self.origin); setmodel (self, mystery_box_model); setsize (self, VEC_HULL2_MIN, VEC_HULL2_MAX); self.touch = MBOX_Touch; mystery_box_start_origin = self.origin; mystery_boxes[mystery_box_count] = self; mystery_box_count++; self.think = MBOX_AllocateTempEntities; self.nextthink = time + 0.2; };