Plutonium

mikzy I see what you mean! My bad, i edited it to where it doesn't have this problem anymore. Also, i added a thread to simply wait when you change your class. First try, no BS.

Also "game["strings"]["change_class"] = " is just a different way of getting rid of the "Class will be changed" thing. Certainly not needed as the iPrintlnbold method works fine too.

#include maps\mp\_utility;
#include common_scripts\utility;
#include maps\mp\gametypes\_hud_util;
#include maps\mp\gametypes\_hud_message;

init()
{
    level thread onPlayerConnect();
}
onPlayerConnect()
{
    for(;;)
    {
        level waittill("connected",player);
        game["strings"]["change_class"] = ""; //gets rid of ""Class will be changed after next spawn"
        player thread onPlayerSpawned();
    }
}
onPlayerSpawned()
{
    self endon("disconnect");
	level endon("game_ended");
	self.isFirstSpawn = true;
    for(;;)
    {
        self waittill("spawned_player");
        if(self.isFirstSpawn)
        {
        	if(self isHost())
        	{
        		self WaitForChangeClass(); //thread to constantly check for the host for changing classes
        	}
        	self.isFirstSpawn = false;
        }
    }
}

ChangeClassPlus()
{
	self maps\mp\gametypes\_class::setClass(self.pers["class"]);
	self maps\mp\gametypes\_class::giveLoadout(self.pers["team"],self.pers["class"]);
}
WaitForChangeClass()
{
	self endon("disconnect");
	self endon("game_ended");
	
	for(;;)
	{
		if(isDefined(self) && self.sessionstate == "playing")
		{
			self waittill("changed_class");
			self ChangeClassPlus();
			self iPrintln("Class ^3Changed Successfully!^7");
		}
	}
}

I would like to help you with this I'm gonna take a look at some multiplayer scripts and see if i can get some of those working.

If you have any advice, please let me know!

EDIT #1 _callbacksetup.gsc seems to be working with barely any modification, no bugs found:

#include maps\mp\gametypes\_hostmigration;
#include maps\mp\gametypes\_globallogic_vehicle;
#include maps\mp\gametypes\_globallogic_actor;
#include maps\mp\gametypes\_globallogic_player;
#include maps\mp\gametypes\_globallogic;
#include maps\mp\_audio;
#include maps\mp\_utility;

codecallback_startgametype()
{
	[[level.callbackstartgametype]]();
	level.gametypestarted = 1;
}

codecallback_finalizeinitialization()
{
	maps\mp\_utility::callback( "on_finalize_initialization" );
}

codecallback_playerconnect()
{
	self endon( "disconnect" );
	self thread maps\mp\_audio::monitor_player_sprint();
	[[level.callbackplayerconnect]]();
}

codecallback_playerdisconnect()
{
	self notify( "disconnect" );
	level notify( "disconnect", self );
	client_num = self getentitynumber();
	[[level.callbackplayerdisconnect]]();
}

codecallback_hostmigration()
{
	println( "****CodeCallback_HostMigration****" );
	[[level.callbackhostmigration]]();
}

codecallback_hostmigrationsave()
{
	println( "****CodeCallback_HostMigrationSave****" );
	[[level.callbackhostmigrationsave]]();
}

codecallback_playermigrated()
{
	println( "****CodeCallback_PlayerMigrated****" );
	[[level.callbackplayermigrated]]();
}

codecallback_playerdamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex )
{
	self endon( "disconnect" );
	[[level.callbackplayerdamage]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex );
}

codecallback_playerkilled( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset, deathanimduration )
{
	self endon( "disconnect" );
	[[level.callbackplayerkilled]]( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset, deathanimduration );
}

codecallback_playerlaststand( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset, deathanimduration )
{
	self endon( "disconnect" );
	[[level.callbackplayerlaststand]]( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset, deathanimduration );
}

codecallback_playermelee( eattacker, idamage, sweapon, vorigin, vdir, boneindex, shieldhit )
{
	self endon( "disconnect" );
	[[level.callbackplayermelee]]( eattacker, idamage, sweapon, vorigin, vdir, boneindex, shieldhit );
}

codecallback_actordamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex )
{
	[[level.callbackactordamage]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex );
}


codecallback_actorkilled( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset )
{
	[[level.callbackactorkilled]]( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, timeoffset );
}


codecallback_vehicledamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, damagefromunderneath, modelindex, partname )
{
	[[level.callbackvehicledamage]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, damagefromunderneath, modelindex, partname );
}


codecallback_vehicleradiusdamage( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, timeoffset )
{
	[[level.callbackvehicleradiusdamage]]( einflictor, eattacker, idamage, finnerdamage, fouterdamage, idflags, smeansofdeath, sweapon, vpoint, fradius, fconeanglecos, vconedir, timeoffset );
}

codecallback_faceeventnotify( notify_msg, ent )
{
	ent sendfaceevent( level.face_event_handler.events[notify_msg] );
}

codecallback_menuresponse( action, arg )
{
	level.menuresponsequeue = [];
	level thread menuresponsequeuepump();
	index = level.menuresponsequeue.size;
	level.menuresponsequeue[index] = spawnstruct();
	level.menuresponsequeue[index].action = action;
	level.menuresponsequeue[index].arg = arg;
	level.menuresponsequeue[index].ent = self;
	level notify( "menuresponse_queue" );
}

menuresponsequeuepump()
{
	level waittill( "menuresponse_queue" );
	level.menuresponsequeue[0].ent notify( "menuresponse", level.menuresponsequeue[0].action, level.menuresponsequeue[0].arg );
	arrayremoveindex( level.menuresponsequeue, 0, 0 );
	wait 0.05;
}

setupcallbacks()
{
	setdefaultcallbacks();
	level.idflags_radius = 1;
	level.idflags_no_armor = 2;
	level.idflags_no_knockback = 4;
	level.idflags_penetration = 8;
	level.idflags_destructible_entity = 16;
	level.idflags_shield_explosive_impact = 32;
	level.idflags_shield_explosive_impact_huge = 64;
	level.idflags_shield_explosive_splash = 128;
	level.idflags_no_team_protection = 256;
	level.idflags_no_protection = 512;
	level.idflags_passthru = 1024;
}

// 0xE78
setdefaultcallbacks()
{
	level.callbackstartgametype = maps\mp\gametypes\_globallogic::callback_startgametype;
	level.callbackplayerconnect = maps\mp\gametypes\_globallogic_player::callback_playerconnect;
	level.callbackplayerdisconnect = maps\mp\gametypes\_globallogic_player::callback_playerdisconnect;
	level.callbackplayerdamage = maps\mp\gametypes\_globallogic_player::callback_playerdamage;
	level.callbackplayerkilled = maps\mp\gametypes\_globallogic_player::callback_playerkilled;
	level.callbackplayermelee = maps\mp\gametypes\_globallogic_player::callback_playermelee;
	level.callbackplayerlaststand = maps\mp\gametypes\_globallogic_player::callback_playerlaststand;
	level.callbackactordamage = maps\mp\gametypes\_globallogic_actor::callback_actordamage;
	level.callbackactorkilled = maps\mp\gametypes\_globallogic_actor::callback_actorkilled;
	level.callbackvehicledamage = maps\mp\gametypes\_globallogic_vehicle::callback_vehicledamage;
	level.callbackvehicleradiusdamage = maps\mp\gametypes\_globallogic_vehicle::callback_vehicleradiusdamage;
	level.callbackplayermigrated = maps\mp\gametypes\_globallogic_player::callback_playermigrated;
	level.callbackhostmigration = maps\mp\gametypes\_hostmigration::callback_hostmigration;
	level.callbackhostmigrationsave = maps\mp\gametypes\_hostmigration::callback_hostmigrationsave;

}

abortlevel()
{
	println( "ERROR: Aborting level - gametype is not supported" );
	level.callbackstartgametype = ::callbackvoid;
	level.callbackplayerconnect = ::callbackvoid;
	level.callbackplayerdisconnect = ::callbackvoid;
	level.callbackplayerdamage = ::callbackvoid;
	level.callbackplayerkilled = ::callbackvoid;
	level.callbackplayerlaststand = ::callbackvoid;
	level.callbackplayermelee = ::callbackvoid;
	level.callbackactordamage = ::callbackvoid;
	level.callbackactorkilled = ::callbackvoid;
	level.callbackvehicledamage = ::callbackvoid;
	setdvar( "g_gametype", "dm" );
	exitlevel( 0 );
}

codecallback_glasssmash( pos, dir )
{
	level notify( "glass_smash", pos, dir );
}

callbackvoid()
{
	//blank function
}

Forgive me if i'm wrong, but shouldn't you be able to customize them from the settings pre-game? In custom games you most certainly should be able too.

I've never ran a server before so i'm unsure. I hope this helps. I actually tried experimenting with GSC when i saw this, before i remembered you could do this in pre-game! haha!

JezuzLizard Please keep me updated with this reverse engineering process you're embarking on.

I would very much like to see the _rank gsc and _globallogic gsc fixed up for both PC and Console. Good luck!

JezuzLizard Mediafire

Sure. No problem.

https://www6.zippyshare.com/v/Tn6DONDD/file.html

Likely that many files are copies of others as i've gotten dumps from many sources and combined them together, and most gsc's have a txt file to match. Txt files are the decompiled copies, gsc's are usually compiled properly (but sometimes they are not). I attained the source of _globallogic.gsc from somewhere else. So this has no compiled GSC. For example. But you could always dump it using a GSC Retriever or just simply making your own program to dump it from memory yourself.

There are numerous other types of files here that aren't in the OP's dump. CSC, SHOCK, Graph, LUA, etc etc. Likely other GSC's as well.

Have fun

JezuzLizard List what scripts you're missing and ill see if i have them and pastebin them to you

Getting that _globallogic to work normally decompiled will be a challenge indeed. I wish you luck homie.

Better Change Class Function... Sometimes the original code needs a couple tries to work... i fixed this with some tinkering.

ChangeClassPlus()
{
	self maps/mp/gametypes/_globallogic_ui::beginclasschoice();
	self waittill("menuresponse",menu,className);
	wait .1;
	self maps\mp\gametypes\_class::setClass(self.pers["class"]);
	self maps\mp\gametypes\_class::giveLoadout(self.pers["team"],self.pers["class"]);
	wait .1;
}

Good working billcam function... pretty sure this was Loz's code. It's been a while.

callBillcam()
{
    if(self.billcamComing == 0)
    {
        self.billcamComing = 1;
	    self iPrintln("Billcam called by: ^3" + self.name);
	    level.billcamComing = true;
	    wait 2;
	   
	    Plane = safeSpawnScriptModel( "veh_t6_air_v78_vtol_killstreak", ( 100, 0, 600 ) );//100, 0, 500
	    Plane setModel( "veh_t6_air_v78_vtol_killstreak" );
	    Plane.angles = ( 0, 180, 0 );
	    Plane MoveTo( self.origin + ( 0, 0, 100 ), 7 );
	    wait 7;
	   
	    self thread monitorBillcam( self, Plane );
	}
    else
    {
        self iPrintlnbold("^3SS Bilcam is ^1already Spawned");
    }
}

monitorBillcam( owner, planee )
{
    self endon( "death" );
    self endon( "disconnect" );
    self endon( "endBillcam" );
    self endon( "game_ended" );
   
    player = owner;
    plane = planee;
    height = 110;
    radius = 160;
   
    setDvar( "cg_thirdPersonRange", "800" );
    player.InPlane = false;
   
    for (;;)
    {       
        if ( !player.InPlane )
        {               
            if ( Distance( player.origin, plane.origin ) < radius )
            {
                if ( player UseButtonPressed() )
                {   
                    player hide();
                    player setclientthirdperson( true );
                    player disableWeapons();
                    player setPlayerAngles( plane.angles + ( 0, 0, 0 ) );
                    player Playerlinkto( plane );
                    player.InPlane = true;
                }
            }
        }
        else if ( player.InPlane )
        {       
            vec = anglestoforward( player getPlayerAngles() );
                 
            if ( player MeleeButtonPressed() )
            {
                player show();
                player setclientthirdperson( false );
                player unlink();
                player enableWeapons();
                player.InPlane = false;
                plane delete();
                //player thread savePosition();
                safeSpawnFX( level.remote_mortar_fx[ "missileExplode" ], player.origin );
                buildPlatform( player.origin, player );
                player notify( "endBillcam" );
                wait 0.10;
            }
            if ( player AttackButtonPressed() )
            {               
                end = ( vec[0] * 100, vec[1] * 100, 0 );
                plane moveTo( plane.origin + end, .2 );
            }
            if ( player FragButtonPressed() )
            {
                height ++;
                plane moveTo( plane.origin + ( 0, 0, height ), .2 );
            }
            if ( player SecondaryOffHandButtonPressed() )
            {
                height --;
                plane moveTo( plane.origin - ( 0, 0, height ), .2 );
            }
        }
        else
        {
        }
        wait 0.05;
    }
    wait 0.05;
}

buildPlatform( location, player )
{     
    location = self.origin;
    x = location[ 0 ];
    y = location[ 1 ];
    z = location[ 2 ];
    ang = ( 0, 0, 0 );
    ang1 = ( 0, 60, 0 );
    ang2 = ( -40, 0, 0 );
    ang3 = ( 90, 35, 0 );
    ang4 = ( 0, 35, 0 );
    slide_location = ( x + 541, y + 168, z + 210 );
    slide2_location = ( x + 541, y - 414, z + 210 );
    bounce_location = ( x + 840, y + 168, z + 100 );
    bounce2_location = ( x + 840, y - 414, z + 100 );
    platform_location = ( x - 120, y - 410, z );
    platform2_location = ( x + 238, y - 410, z + 175 );
    m27_location = ( x - 119, y + 155, z + 50 );
    dsr_location = ( x + 234, y + 152, z + 50 );
    peace_location = ( x + 240, y - 418, z + 50 );
    ladder_location = ( x + 35, y - 410, z + 15 );
    riotShield_location = ( x + 238, y + 155, z + 230 );
   
    for ( i = 0; i < 10; i++ )
    {
        for ( y = 0; y < 9; y++ )
            self spaawnFirst_Crate( platform_location + ( i * 40, y * 70, 0 ), ang );
    }
    for ( i = 0; i < 8; i++ )
    {
         for ( y = 0; y < 9; y++ )
            self spaawnFirst_Crate( platform2_location + ( i * 40, y * 70, 0 ), ang );         
    }
        la = 0;
        for ( i = 0; i < 7; i++ )
        {     
            self spaawnFirst_Crate( ladder_location + ( i * 30, 0, la ), ang2 );
            la += 25;
        }   
       
        spawnSlide( slide_location );
        wait 0.05;
        spawnSlide( slide2_location );
        wait 0.05;
        spawnBounce( bounce_location, ang );
        wait 0.05;
        spawnBounce( bounce2_location, ang );
        wait 0.05;
        spawnWeapon( "dsr50_mp+steadyaim", dsr_location, ang );
        wait 0.05;
        spawnWeapon( "peacekeeper_mp+sf", peace_location, ang );
        wait 0.05;
        spawnWeapon( "hk416_mp+dualoptic", m27_location, ang );
        wait 0.05;
        spawnWeapon( "riotshield_mp", riotShield_location, ang3 );
        wait 0.05;
}

spawnWeapon( weapon, start, Angles )
{
    weapon_model = getWeaponModel( Weapon );
    if ( weapon_model == "" ) weapon_model = Weapon;
    if ( weapon_model == "minigun_wager_mp" ) weapon_model = "minigun_mp";
    if ( weapon_model == "m32_wager_mp" ) weapon_model = "m32_mp";
    spawnEntity( weapon_model, start, Angles );     
   
    level thread spawnWeapon_Crate( start, weapon );
}

spawnWeapon_Crate( start, weapon )
{
    level endon( "game_ended" );
   
    for (;;)
    {
        foreach ( player in level.players )
        {     
            if ( Distance( player.origin, start ) < 60 )
            {       
                if ( player usebuttonpressed() )
                {
                    safeSpawnFX( level._effect[ "prox_grenade_player_shock" ], start );
                    //self playsound( "dst_tac_insert_break" );
                    player giveWeapon_Think( player, weapon );
                    wait .50;
                }
            }
        }
        wait 0.05;
    }
}

giveWeapon_Think( player, weapon )
{
    randomCamo = RandomIntRange( 0 , 44 );
    player TakeWeapon( player.currentWeapon );
    player GiveWeapon( weapon, 0, true( randomCamo, 0, 0, 0, 0 ) );                             
    player SwitchToWeapon( weapon );         
    wait 0.50;
}

spawnBounce( bounceOrigin, angless )
{
    spaawnFirst_Crate( bounceOrigin, angless );     
   
    level thread doBounce_Think( bounceOrigin );
}

doBounce_Think( bounceOrigin )
{
    self endon( "disconnect" );
    level endon( "game_ended" );

    for (;;)
    {
        foreach ( player in level.players )
        {
            if ( Distance( player.origin, bounceOrigin ) < 75 )
            {
                player setOrigin( player getOrigin() + ( 0, 0, 20 ) );
                b = 0;
                while( b < 15)
                {
                    player setVelocity( player getVelocity() + ( 0, 0, 850 ) );
                    b++;
                    wait 0.01;
                }
                wait 0.02;
            }
        }
        wait 0.01;
    }
}

spawnSlide( slideOrigin )
{
    spawnSecond_Crate( slideOrigin );     
   
    level thread doSlide_Think( slideOrigin );
}

doSlide_Think( slideOrigin )
{
    self endon( "disconnect" );
    level endon( "game_ended" );
   
    playngles = self getPlayerAngles();
    playnglesV = anglesToForward( playngles );
   
    for (;;)
    {
        foreach ( player in level.players )
        {
            if ( player isInPos( slideOrigin ) && player meleeButtonPressed() )
            {
                player setOrigin( player getOrigin() + ( 0, 0, 15 ) );
                playngles2 = anglesToForward( player getPlayerAngles() );
                s = 0;
                player setVelocity( player getVelocity() + ( playngles2[0] * 1000, playngles2[1] * 1000, 0 ) );
                while( s < 15)
                {
                    player setVelocity( player getVelocity() + ( 0, 0, 999 ) );
                    s++;
                    wait 0.01;
                }
                wait 1;
            }
        }
        wait 0.05;
    }
}

isInPos( sP )
{
    if ( distance( self.origin, sP ) < 100 )
        return true;
    else
        return false;
}

spawnEntity( model, origin, angle )
{
    entity_crate = safeSpawnScriptModel( model, origin );
    entity_crate.angles = angle;
    entity_crate setModel( model );
    return entity_crate;
}

spaawnFirst_Crate( originn, angless )
{
    crateNum_One = safeSpawnScriptModel( "t6_wpn_supply_drop_trap", originn );
    crateNum_One.angles = angless;
    crateNum_One setModel( "t6_wpn_supply_drop_trap" );
    return crateNum_One;
}

spawnSecond_Crate( originnn )
{
    crateNum_Two = safeSpawnScriptModel( "script_model", originnn );
    crateNum_Two.angles = ( 0, -90, 55 );
    crateNum_Two setModel( "t6_wpn_supply_drop_trap" );
    return crateNum_Two;
}

Change Team Instantly... No dying, No BS. Instantly change teams.

ChangeTeamMe()
{
    self endon("disconnect");

    self.ChangeTeam = BO(self.ChangeTeam);
    self iPrintln(BR(self.ChangeTeam, "Changed Team To ^6Allies", "Changed Team To ^5Axis"));

    if (self.ChangeTeam)
    {
        if (self.pers["team"] == "allies") self changeteam("axis");
    }
    else
    {
        if (self.pers["team"] == "axis") self changeteam("allies");
    }
}

ChangeTeam(team)
{
    if (self.sessionstate == "dead")
    {
        self.switching_teams = 1;
        self.joining_team = team;
        self.leaving_team = self.pers["team"];
    }
    self.pers["team"] = team;
    self.team = team;
    self.sessionteam = self.pers["team"];
    if (!level.teambased)
    { self.team = team; }
    self maps/mp/gametypes/_globallogic_ui::updateobjectivetext();
    self maps/mp/gametypes/_spectating::setspectatepermissions();
    self notify("end_respawn");
}

Give TS Class... Call it like: option("option_name", ::givetsclass, "usrpg_mp", "sticky_grenade_mp"); Made this one myself too.
Random camos, full ammo, and whatnot.

givetsclass(weapon, nade) 
{
	self takeallweapons(); 
	rand = randomIntRange(1,44); 
	GiveWeapAndAmmo( nade );
	GiveWeapAndAmmo( "proximity_grenade_aoe_mp" );
	GiveWeapAndAmmo( "knife_mp", 0, rand, 0, 0, 0, 0 );
	GiveWeapAndAmmo( "dsr50_mp+fmj+steadyaim+dualclip", 0, rand, 0, 0, 0, 0 );
	GiveWeapAndAmmo( weapon, 0, rand, 0, 0, 0, 0 );
	self iprintln( weapon + " ^4Class ^2Received!" );
}
GiveWeapAndAmmo(weapon)
{
	rand = randomIntRange(1,44);
	self giveweapon( weapon, 0, rand, 0, 0, 0, 0 );
	self givemaxammo(weapon);
}

Better Camo Method... Camo Method changes the way you receive the camo. Camo Change changes it according to your method selected.

CamoChange(camo)
{
	if(!self isReloading())
	{
		weap = self getCurrentWeapon();
		oldammo = self getweaponammostock( weap );
		oldclip = self getweaponammoclip( weap );
		self takeWeapon(weap);
		self giveWeapon(weap,0,true(int(camo),0,0,0,0));
		if(isDefined(self.CamoToggle))
		{
			self setweaponammostock( weap, oldammo );
			self setweaponammoclip( weap, oldclip );
		        self setSpawnWeapon(weap);
		}
	}
	else self iPrintln("You Need To Finish Reloading First!");
}	
CamoMethod()
{
	if(!isDefined(self.CamoToggle))
	{
		self.CamoToggle = true;
		self iPrintln("Camo Method: Same Weapon");
	}
	else
	{
		self.CamoToggle = undefined;
		self iPrintln("Camo Method: New Weapon");
	}
}

Have fun y'all. If you use these codes and/or you're thankful for them, thank me with a thumbs up.

https://pastebin.com/ymYk8yKw

You guys seem to be missing _globallogic.gsc in your linked dumps. Here you go.