Jump to content

unstable red saber blade appearing like a blue saber blade in menu

swegmaster

By swegmaster
in Coding and Scripts

Recommended Posts

swegmaster Mentor

swegmaster

Posted
  • Author
Posted (edited)

okay, i'll say this: i wrote the code exactly as asgaraths tutorial said, and it worked fine in-game, but on saber customization menus, it does not show up, it shows up as the blue blade, however, since i changed the ui_saber to try to get it to work again, it still does not show up, and i get a build fail error, which causes the in-game to not load up, only the menus, and heres the code i changed in ui_saber.cpp:

 

also, its unstablered im adding

 

 

/*
===========================================================================
Copyright (C) 2000 - 2013, Raven Software, Inc.
Copyright (C) 2001 - 2013, Activision, Inc.
Copyright (C) 2013 - 2015, OpenJK contributors

This file is part of the OpenJK source code.

OpenJK is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License version 2 as
published by the Free Software Foundation.

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, see <http://www.gnu.org/licenses/>.
===========================================================================
*/

/*
=======================================================================

USER INTERFACE SABER LOADING & DISPLAY CODE

=======================================================================
*/

// leave this at the top of all UI_xxxx files for PCH reasons...
//
#include "../server/exe_headers.h"
#include "ui_local.h"
#include "ui_shared.h"
#include "../ghoul2/G2.h"

#define MAX_SABER_DATA_SIZE 0x80000
char SaberParms[MAX_SABER_DATA_SIZE];
qboolean ui_saber_parms_parsed = qfalse;

static qhandle_t redSaberGlowShader;
static qhandle_t redSaberCoreShader;
static qhandle_t orangeSaberGlowShader;
static qhandle_t orangeSaberCoreShader;
static qhandle_t yellowSaberGlowShader;
static qhandle_t yellowSaberCoreShader;
static qhandle_t greenSaberGlowShader;
static qhandle_t greenSaberCoreShader;
static qhandle_t blueSaberGlowShader;
static qhandle_t blueSaberCoreShader;
static qhandle_t purpleSaberGlowShader;
static qhandle_t purpleSaberCoreShader;
static qhandle_t unstableredSaberGlowShader;
static qhandle_t unstableredSaberCoreShader;
void UI_CacheSaberGlowGraphics( void )
{//FIXME: these get fucked by vid_restarts
redSaberGlowShader = re.RegisterShader( "gfx/effects/sabers/red_glow" );
redSaberCoreShader = re.RegisterShader( "gfx/effects/sabers/red_line" );
orangeSaberGlowShader = re.RegisterShader( "gfx/effects/sabers/orange_glow" );
orangeSaberCoreShader = re.RegisterShader( "gfx/effects/sabers/orange_line" );
yellowSaberGlowShader = re.RegisterShader( "gfx/effects/sabers/yellow_glow" );
yellowSaberCoreShader = re.RegisterShader( "gfx/effects/sabers/yellow_line" );
greenSaberGlowShader = re.RegisterShader( "gfx/effects/sabers/green_glow" );
greenSaberCoreShader = re.RegisterShader( "gfx/effects/sabers/green_line" );
blueSaberGlowShader = re.RegisterShader( "gfx/effects/sabers/blue_glow" );
blueSaberCoreShader = re.RegisterShader( "gfx/effects/sabers/blue_line" );
purpleSaberGlowShader = re.RegisterShader( "gfx/effects/sabers/purple_glow" );
purpleSaberCoreShader = re.RegisterShader( "gfx/effects/sabers/purple_line" );
unstableredSaberGlowShader = re.RegisterShader( "gfx/effects/sabers/unstablered_glow" );
unstableredSaberCoreShader = re.RegisterShader( "gfx/effects/sabers/unstablered_line" );
}

qboolean UI_ParseLiteral( const char **data, const char *string )
{
const char *token;

token = COM_ParseExt( data, qtrue );
if ( token[0] == 0 )
{
ui.Printf( "unexpected EOF\n" );
return qtrue;
}

if ( Q_stricmp( token, string ) )
{
ui.Printf( "required string '%s' missing\n", string );
return qtrue;
}

return qfalse;
}

qboolean UI_SaberParseParm( const char *saberName, const char *parmname, char *saberData )
{
const char *token;
const char *value;
const char *p;

if ( !saberName || !saberName[0] )
{
return qfalse;
}

//try to parse it out
p = SaberParms;
COM_BeginParseSession();

// look for the right saber
while ( p )
{
token = COM_ParseExt( &p, qtrue );
if ( token[0] == 0 )
{
COM_EndParseSession( );
return qfalse;
}

if ( !Q_stricmp( token, saberName ) )
{
break;
}

SkipBracedSection( &p );
}
if ( !p )
{
COM_EndParseSession( );
return qfalse;
}

if ( UI_ParseLiteral( &p, "{" ) )
{
COM_EndParseSession( );
return qfalse;
}

// parse the saber info block
while ( 1 )
{
token = COM_ParseExt( &p, qtrue );
if ( !token[0] )
{
ui.Printf( S_COLOR_RED"ERROR: unexpected EOF while parsing '%s'\n", saberName );
COM_EndParseSession( );
return qfalse;
}

if ( !Q_stricmp( token, "}" ) )
{
break;
}

if ( !Q_stricmp( token, parmname ) )
{
if ( COM_ParseString( &p, &value ) )
{
continue;
}
strcpy( saberData, value );
COM_EndParseSession( );
return qtrue;
}

SkipRestOfLine( &p );
continue;
}

COM_EndParseSession( );
return qfalse;
}

qboolean UI_SaberProperNameForSaber( const char *saberName, char *saberProperName )
{
return UI_SaberParseParm( saberName, "name", saberProperName );
}

qboolean UI_SaberModelForSaber( const char *saberName, char *saberModel )
{
return UI_SaberParseParm( saberName, "saberModel", saberModel );
}

qboolean UI_SaberSkinForSaber( const char *saberName, char *saberSkin )
{
return UI_SaberParseParm( saberName, "customSkin", saberSkin );
}

qboolean UI_SaberTypeForSaber( const char *saberName, char *saberType )
{
return UI_SaberParseParm( saberName, "saberType", saberType );
}

int UI_SaberNumBladesForSaber( const char *saberName )
{
char numBladesString[8]={0};
UI_SaberParseParm( saberName, "numBlades", numBladesString );
int numBlades = atoi( numBladesString );
if ( numBlades < 1 )
{
numBlades = 1;
}
else if ( numBlades > 8 )
{
numBlades = 8;
}
return numBlades;
}

qboolean UI_SaberShouldDrawBlade( const char *saberName, int bladeNum )
{
int bladeStyle2Start = 0, noBlade = 0;
char bladeStyle2StartString[8]={0};
char noBladeString[8]={0};
UI_SaberParseParm( saberName, "bladeStyle2Start", bladeStyle2StartString );
if ( bladeStyle2StartString[0] )
{
bladeStyle2Start = atoi( bladeStyle2StartString );
}
if ( bladeStyle2Start
&& bladeNum >= bladeStyle2Start )
{//use second blade style
UI_SaberParseParm( saberName, "noBlade2", noBladeString );
if ( noBladeString[0] )
{
noBlade = atoi( noBladeString );
}
}
else
{//use first blade style
UI_SaberParseParm( saberName, "noBlade", noBladeString );
if ( noBladeString[0] )
{
noBlade = atoi( noBladeString );
}
}
return ((qboolean)(noBlade==0));
}

float UI_SaberBladeLengthForSaber( const char *saberName, int bladeNum )
{
char lengthString[8]={0};
float length = 40.0f;
UI_SaberParseParm( saberName, "saberLength", lengthString );
if ( lengthString[0] )
{
length = atof( lengthString );
if ( length < 0.0f )
{
length = 0.0f;
}
}

UI_SaberParseParm( saberName, va("saberLength%d", bladeNum+1), lengthString );
if ( lengthString[0] )
{
length = atof( lengthString );
if ( length < 0.0f )
{
length = 0.0f;
}
}

return length;
}

float UI_SaberBladeRadiusForSaber( const char *saberName, int bladeNum )
{
char radiusString[8]={0};
float radius = 3.0f;
UI_SaberParseParm( saberName, "saberRadius", radiusString );
if ( radiusString[0] )
{
radius = atof( radiusString );
if ( radius < 0.0f )
{
radius = 0.0f;
}
}

UI_SaberParseParm( saberName, va("saberRadius%d", bladeNum+1), radiusString );
if ( radiusString[0] )
{
radius = atof( radiusString );
if ( radius < 0.0f )
{
radius = 0.0f;
}
}

return radius;
}

void UI_SaberLoadParms( void )
{
int len, totallen, saberExtFNLen, fileCnt, i;
char *buffer, *holdChar, *marker;
char saberExtensionListBuf[2048]; // The list of file names read in

//ui.Printf( "UI Parsing *.sab saber definitions\n" );

ui_saber_parms_parsed = qtrue;
UI_CacheSaberGlowGraphics();

//set where to store the first one
totallen = 0;
marker = SaberParms;
marker[0] = '\0';

//now load in the sabers
fileCnt = ui.FS_GetFileList("ext_data/sabers", ".sab", saberExtensionListBuf, sizeof(saberExtensionListBuf) );

holdChar = saberExtensionListBuf;
for ( i = 0; i < fileCnt; i++, holdChar += saberExtFNLen + 1 )
{
saberExtFNLen = strlen( holdChar );

len = ui.FS_ReadFile( va( "ext_data/sabers/%s", holdChar), (void **) &buffer );

if ( len == -1 )
{
ui.Printf( "UI_SaberLoadParms: error reading %s\n", holdChar );
}
else
{
if ( totallen && *(marker-1) == '}' )
{//don't let it end on a } because that should be a stand-alone token
strcat( marker, " " );
totallen++;
marker++;
}
len = COM_Compress( buffer );

if ( totallen + len >= MAX_SABER_DATA_SIZE ) {
Com_Error( ERR_FATAL, "UI_SaberLoadParms: ran out of space before reading %s\n(you must make the .npc files smaller)", holdChar );
}
strcat( marker, buffer );
ui.FS_FreeFile( buffer );

totallen += len;
marker += len;
}
}
}

void UI_DoSaber( vec3_t origin, vec3_t dir, float length, float lengthMax, float radius, saber_colors_t color )
{
vec3_t mid, rgb={1,1,1};
qhandle_t blade = 0, glow = 0;
refEntity_t saber;
float radiusmult;

if ( length < 0.5f )
{
// if the thing is so short, just forget even adding me.
return;
}

// Find the midpoint of the saber for lighting purposes
VectorMA( origin, length * 0.5f, dir, mid );

switch( color )
{
case SABER_RED:
glow = redSaberGlowShader;
blade = redSaberCoreShader;
VectorSet( rgb, 1.0f, 0.2f, 0.2f );
break;
case SABER_ORANGE:
glow = orangeSaberGlowShader;
blade = orangeSaberCoreShader;
VectorSet( rgb, 1.0f, 0.5f, 0.1f );
break;
case SABER_YELLOW:
glow = yellowSaberGlowShader;
blade = yellowSaberCoreShader;
VectorSet( rgb, 1.0f, 1.0f, 0.2f );
break;
case SABER_GREEN:
glow = greenSaberGlowShader;
blade = greenSaberCoreShader;
VectorSet( rgb, 0.2f, 1.0f, 0.2f );
break;
case SABER_BLUE:
glow = blueSaberGlowShader;
blade = blueSaberCoreShader;
VectorSet( rgb, 0.2f, 0.4f, 1.0f );
break;
case SABER_PURPLE:
glow = purpleSaberGlowShader;
blade = purpleSaberCoreShader;
VectorSet( rgb, 0.9f, 0.2f, 1.0f );
break;
case SABER_UNSTABLERED:
glow = unstableredSaberGlowShader;
blade = unstableredSaberCoreShader;
VectorSet( rgb, 1.0f, 0.2f, 0.2f );
break;
}

// always add a light because sabers cast a nice glow before they slice you in half!! or something...
/*
if ( doLight )
{//FIXME: RGB combine all the colors of the sabers you're using into one averaged color!
cgi_R_AddLightToScene( mid, (length*2.0f) + (random()*8.0f), rgb[0], rgb[1], rgb[2] );
}
*/

memset( &saber, 0, sizeof( refEntity_t ));

// Saber glow is it's own ref type because it uses a ton of sprites, otherwise it would eat up too many
// refEnts to do each glow blob individually
saber.saberLength = length;

// Jeff, I did this because I foolishly wished to have a bright halo as the saber is unleashed.
// It's not quite what I'd hoped tho. If you have any ideas, go for it! --Pat
if (length < lengthMax )
{
radiusmult = 1.0 + (2.0 / length); // Note this creates a curve, and length cannot be < 0.5.
}
else
{
radiusmult = 1.0;
}

float radiusRange = radius * 0.075f;
float radiusStart = radius-radiusRange;

saber.radius = (radiusStart + crandom() * radiusRange)*radiusmult;
//saber.radius = (2.8f + crandom() * 0.2f)*radiusmult;


VectorCopy( origin, saber.origin );
VectorCopy( dir, saber.axis[0] );
saber.reType = RT_SABER_GLOW;
saber.customShader = glow;
saber.shaderRGBA[0] = saber.shaderRGBA[1] = saber.shaderRGBA[2] = saber.shaderRGBA[3] = 0xff;
//saber.renderfx = rfx;

DC->addRefEntityToScene( &saber );

// Do the hot core
VectorMA( origin, length, dir, saber.origin );
VectorMA( origin, -1, dir, saber.oldorigin );
saber.customShader = blade;
saber.reType = RT_LINE;
radiusStart = radius/3.0f;
saber.radius = (radiusStart + crandom() * radiusRange)*radiusmult;
// saber.radius = (1.0 + crandom() * 0.2f)*radiusmult;

DC->addRefEntityToScene( &saber );
}

saber_colors_t TranslateSaberColor( const char *name )
{
if ( !Q_stricmp( name, "red" ) )
{
return SABER_RED;
}
if ( !Q_stricmp( name, "orange" ) )
{
return SABER_ORANGE;
}
if ( !Q_stricmp( name, "yellow" ) )
{
return SABER_YELLOW;
}
if ( !Q_stricmp( name, "green" ) )
{
return SABER_GREEN;
}
if ( !Q_stricmp( name, "blue" ) )
{
return SABER_BLUE;
}
if ( !Q_stricmp( name, "purple" ) )
{
return SABER_PURPLE;
}
if ( !Q_stricmp( name, "unstablered" ) )
{
return SABER_UNSTABLERED;
}
if ( !Q_stricmp( name, "random" ) )
{
return ((saber_colors_t)(Q_irand( SABER_ORANGE, SABER_PURPLE )));
}
return SABER_BLUE;
}

saberType_t TranslateSaberType( const char *name )
{
if ( !Q_stricmp( name, "SABER_SINGLE" ) )
{
return SABER_SINGLE;
}
if ( !Q_stricmp( name, "SABER_STAFF" ) )
{
return SABER_STAFF;
}
if ( !Q_stricmp( name, "SABER_BROAD" ) )
{
return SABER_BROAD;
}
if ( !Q_stricmp( name, "SABER_PRONG" ) )
{
return SABER_PRONG;
}
if ( !Q_stricmp( name, "SABER_DAGGER" ) )
{
return SABER_DAGGER;
}
if ( !Q_stricmp( name, "SABER_ARC" ) )
{
return SABER_ARC;
}
if ( !Q_stricmp( name, "SABER_SAI" ) )
{
return SABER_SAI;
}
if ( !Q_stricmp( name, "SABER_CLAW" ) )
{
return SABER_CLAW;
}
if ( !Q_stricmp( name, "SABER_LANCE" ) )
{
return SABER_LANCE;
}
if ( !Q_stricmp( name, "SABER_STAR" ) )
{
return SABER_STAR;
}
if ( !Q_stricmp( name, "SABER_TRIDENT" ) )
{
return SABER_TRIDENT;
}
if ( !Q_stricmp( name, "SABER_SITH_SWORD" ) )
{
return SABER_SITH_SWORD;
}
return SABER_SINGLE;
}

void UI_SaberDrawBlade( itemDef_t *item, char *saberName, int saberModel, saberType_t saberType, vec3_t origin, float curYaw, int bladeNum )
{
char bladeColorString[MAX_QPATH];
vec3_t angles={0};

if ( item->flags&(ITF_ISANYSABER) && item->flags&(ITF_ISCHARACTER) )
{ //it's bolted to a dude!
angles[YAW] = curYaw;
}
else
{
angles[PITCH] = curYaw;
angles[ROLL] = 90;
}

if ( saberModel >= item->ghoul2.size() )
{//uhh... invalid index!
return;
}

if ( (item->flags&ITF_ISSABER) && saberModel < 2 )
{
DC->getCVarString( "ui_saber_color", bladeColorString, sizeof(bladeColorString) );
}
else//if ( item->flags&ITF_ISSABER2 ) - presumed
{
DC->getCVarString( "ui_saber2_color", bladeColorString, sizeof(bladeColorString) );
}
saber_colors_t bladeColor = TranslateSaberColor( bladeColorString );

float bladeLength = UI_SaberBladeLengthForSaber( saberName, bladeNum );
float bladeRadius = UI_SaberBladeRadiusForSaber( saberName, bladeNum );
vec3_t bladeOrigin={0};
vec3_t axis[3]={};
mdxaBone_t boltMatrix;
qboolean tagHack = qfalse;

char *tagName = va( "*blade%d", bladeNum+1 );
int bolt = DC->g2_AddBolt( &item->ghoul2[saberModel], tagName );

if ( bolt == -1 )
{
tagHack = qtrue;
//hmm, just fall back to the most basic tag (this will also make it work with pre-JKA saber models
bolt = DC->g2_AddBolt( &item->ghoul2[saberModel], "*flash" );
if ( bolt == -1 )
{//no tag_flash either?!!
bolt = 0;
}
}

DC->g2_GetBoltMatrix( item->ghoul2, saberModel, bolt, &boltMatrix, angles, origin, uiInfo.uiDC.realTime, NULL, vec3_origin );//NULL was cgs.model_draw

// work the matrix axis stuff into the original axis and origins used.
DC->g2_GiveMeVectorFromMatrix(boltMatrix, ORIGIN, bladeOrigin);
DC->g2_GiveMeVectorFromMatrix(boltMatrix, NEGATIVE_X, axis[0]);//front (was NEGATIVE_Y, but the md3->glm exporter screws up this tag somethin' awful)
DC->g2_GiveMeVectorFromMatrix(boltMatrix, NEGATIVE_Y, axis[1]);//right
DC->g2_GiveMeVectorFromMatrix(boltMatrix, POSITIVE_Z, axis[2]);//up

float scale = DC->xscale;

if ( tagHack )
{
switch ( saberType )
{
case SABER_SINGLE:
case SABER_DAGGER:
case SABER_LANCE:
break;
case SABER_STAFF:
if ( bladeNum == 1 )
{
VectorScale( axis[0], -1, axis[0] );
VectorMA( bladeOrigin, 16*scale, axis[0], bladeOrigin );
}
break;
case SABER_BROAD:
if ( bladeNum == 0 )
{
VectorMA( bladeOrigin, -1*scale, axis[1], bladeOrigin );
}
else if ( bladeNum == 1 )
{
VectorMA( bladeOrigin, 1*scale, axis[1], bladeOrigin );
}
break;
case SABER_PRONG:
if ( bladeNum == 0 )
{
VectorMA( bladeOrigin, -3*scale, axis[1], bladeOrigin );
}
else if ( bladeNum == 1 )
{
VectorMA( bladeOrigin, 3*scale, axis[1], bladeOrigin );
}
break;
case SABER_ARC:
VectorSubtract( axis[1], axis[2], axis[1] );
VectorNormalize( axis[1] );
switch ( bladeNum )
{
case 0:
VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
VectorScale( axis[0], 0.75f, axis[0] );
VectorScale( axis[1], 0.25f, axis[1] );
VectorAdd( axis[0], axis[1], axis[0] );
break;
case 1:
VectorScale( axis[0], 0.25f, axis[0] );
VectorScale( axis[1], 0.75f, axis[1] );
VectorAdd( axis[0], axis[1], axis[0] );
break;
case 2:
VectorMA( bladeOrigin, -8*scale, axis[0], bladeOrigin );
VectorScale( axis[0], -0.25f, axis[0] );
VectorScale( axis[1], 0.75f, axis[1] );
VectorAdd( axis[0], axis[1], axis[0] );
break;
case 3:
VectorMA( bladeOrigin, -16*scale, axis[0], bladeOrigin );
VectorScale( axis[0], -0.75f, axis[0] );
VectorScale( axis[1], 0.25f, axis[1] );
VectorAdd( axis[0], axis[1], axis[0] );
break;
}
break;
case SABER_SAI:
if ( bladeNum == 1 )
{
VectorMA( bladeOrigin, -3*scale, axis[1], bladeOrigin );
}
else if ( bladeNum == 2 )
{
VectorMA( bladeOrigin, 3*scale, axis[1], bladeOrigin );
}
break;
case SABER_CLAW:
switch ( bladeNum )
{
case 0:
VectorMA( bladeOrigin, 2*scale, axis[0], bladeOrigin );
VectorMA( bladeOrigin, 2*scale, axis[2], bladeOrigin );
break;
case 1:
VectorMA( bladeOrigin, 2*scale, axis[0], bladeOrigin );
VectorMA( bladeOrigin, 2*scale, axis[2], bladeOrigin );
VectorMA( bladeOrigin, 2*scale, axis[1], bladeOrigin );
break;
case 2:
VectorMA( bladeOrigin, 2*scale, axis[0], bladeOrigin );
VectorMA( bladeOrigin, 2*scale, axis[2], bladeOrigin );
VectorMA( bladeOrigin, -2*scale, axis[1], bladeOrigin );
break;
}
break;
case SABER_STAR:
switch ( bladeNum )
{
case 0:
VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
break;
case 1:
VectorScale( axis[0], 0.33f, axis[0] );
VectorScale( axis[2], 0.67f, axis[2] );
VectorAdd( axis[0], axis[2], axis[0] );
VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
break;
case 2:
VectorScale( axis[0], -0.33f, axis[0] );
VectorScale( axis[2], 0.67f, axis[2] );
VectorAdd( axis[0], axis[2], axis[0] );
VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
break;
case 3:
VectorScale( axis[0], -1, axis[0] );
VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
break;
case 4:
VectorScale( axis[0], -0.33f, axis[0] );
VectorScale( axis[2], -0.67f, axis[2] );
VectorAdd( axis[0], axis[2], axis[0] );
VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
break;
case 5:
VectorScale( axis[0], 0.33f, axis[0] );
VectorScale( axis[2], -0.67f, axis[2] );
VectorAdd( axis[0], axis[2], axis[0] );
VectorMA( bladeOrigin, 8*scale, axis[0], bladeOrigin );
break;
}
break;
case SABER_TRIDENT:
switch ( bladeNum )
{
case 0:
VectorMA( bladeOrigin, 24*scale, axis[0], bladeOrigin );
break;
case 1:
VectorMA( bladeOrigin, -6*scale, axis[1], bladeOrigin );
VectorMA( bladeOrigin, 24*scale, axis[0], bladeOrigin );
break;
case 2:
VectorMA( bladeOrigin, 6*scale, axis[1], bladeOrigin );
VectorMA( bladeOrigin, 24*scale, axis[0], bladeOrigin );
break;
case 3:
VectorMA( bladeOrigin, -32*scale, axis[0], bladeOrigin );
VectorScale( axis[0], -1, axis[0] );
break;
}
break;
case SABER_SITH_SWORD:
//no blade
break;
default:
break;
}
}
if ( saberType == SABER_SITH_SWORD )
{//draw no blade
return;
}

UI_DoSaber( bladeOrigin, axis[0], bladeLength, bladeLength, bladeRadius, bladeColor );
}

extern qboolean ItemParse_asset_model_go( itemDef_t *item, const char *name );
extern qboolean ItemParse_model_g2skin_go( itemDef_t *item, const char *skinName );
void UI_GetSaberForMenu( char *saber, int saberNum )
{
char saberTypeString[MAX_QPATH]={0};
saberType_t saberType = SABER_NONE;

if ( saberNum == 0 )
{
DC->getCVarString( "g_saber", saber, MAX_QPATH );
}
else
{
DC->getCVarString( "g_saber2", saber, MAX_QPATH );
}
//read this from the sabers.cfg
UI_SaberTypeForSaber( saber, saberTypeString );
if ( saberTypeString[0] )
{
saberType = TranslateSaberType( saberTypeString );
}

switch ( uiInfo.movesTitleIndex )
{

break;



if ( saberType != SABER_SINGLE )
{
Q_strncpyz(saber,"single_1",MAX_QPATH,qtrue);
}
break;

if ( saberType != SABER_SINGLE )
{
Q_strncpyz(saber,"single_1",MAX_QPATH,qtrue);
}
break;

if ( saberType == SABER_SINGLE || saberType == SABER_NONE )
{
Q_strncpyz(saber,"dual_1",MAX_QPATH,qtrue);
}
break;
}

}

void UI_SaberDrawBlades( itemDef_t *item, vec3_t origin, float curYaw )
{
//NOTE: only allows one saber type in view at a time
char saber[MAX_QPATH];
int saberNum = 0;
int saberModel = 0;
int numSabers = 1;

if ( (item->flags&ITF_ISCHARACTER)//hacked sabermoves sabers in character's hand
&& uiInfo.movesTitleIndex == 4 /*MD_DUAL_SABERS*/ )
{
numSabers = 2;
}

for ( saberNum = 0; saberNum < numSabers; saberNum++ )
{
if ( (item->flags&ITF_ISCHARACTER) )//hacked sabermoves sabers in character's hand
{
UI_GetSaberForMenu( saber, saberNum );
saberModel = saberNum + 1;
}
else if ( (item->flags&ITF_ISSABER) )
{
DC->getCVarString( "ui_saber", saber, sizeof(saber) );
saberModel = 0;
}
else if ( (item->flags&ITF_ISSABER2) )
{
DC->getCVarString( "ui_saber2", saber, sizeof(saber) );
saberModel = 0;
}
else
{
return;
}
if ( saber[0] )
{
int numBlades = UI_SaberNumBladesForSaber( saber );
if ( numBlades )
{//okay, here we go, time to draw each blade...
char saberTypeString[MAX_QPATH]={0};
UI_SaberTypeForSaber( saber, saberTypeString );
saberType_t saberType = TranslateSaberType( saberTypeString );
for ( int curBlade = 0; curBlade < numBlades; curBlade++ )
{
if ( UI_SaberShouldDrawBlade( saber, curBlade ) )
{
UI_SaberDrawBlade( item, saber, saberModel, saberType, origin, curYaw, curBlade );
}
}
}
}
}
}

void UI_SaberAttachToChar( itemDef_t *item )
{
int numSabers = 1;
int saberNum = 0;

if ( item->ghoul2.size() > 2 && item->ghoul2[2].mModelindex >=0 )
{//remove any extra models
DC->g2_RemoveGhoul2Model(item->ghoul2, 2);
}
if ( item->ghoul2.size() > 1 && item->ghoul2[1].mModelindex >=0)
{//remove any extra models
DC->g2_RemoveGhoul2Model(item->ghoul2, 1);
}

if ( uiInfo.movesTitleIndex == 4 /*MD_DUAL_SABERS*/ )
{
numSabers = 2;
}

for ( saberNum = 0; saberNum < numSabers; saberNum++ )
{
//bolt sabers
char modelPath[MAX_QPATH];
char skinPath[MAX_QPATH];
char saber[MAX_QPATH];

UI_GetSaberForMenu( saber, saberNum );

if ( UI_SaberModelForSaber( saber, modelPath ) )
{//successfully found a model
int g2Saber = DC->g2_InitGhoul2Model(item->ghoul2, modelPath, 0, 0, 0, 0, 0); //add the model
if (g2Saber)
{
//get the customSkin, if any
if ( UI_SaberSkinForSaber( saber, skinPath ) )
{
int g2skin = DC->registerSkin(skinPath);
DC->g2_SetSkin( &item->ghoul2[g2Saber], 0, g2skin );//this is going to set the surfs on/off matching the skin file
}
else
{
DC->g2_SetSkin( &item->ghoul2[g2Saber], -1, 0 );//turn off custom skin
}
int boltNum;
if ( saberNum == 0 )
{
boltNum = DC->g2_AddBolt(&item->ghoul2[0], "*r_hand");
}
else
{
boltNum = DC->g2_AddBolt(&item->ghoul2[0], "*l_hand");
}
re.G2API_AttachG2Model(&item->ghoul2[g2Saber], &item->ghoul2[0], boltNum, 0);
}
}
}
}

 

Edited by Circa
added code tags ;)
Asgarath83 Professional

Asgarath83

Posted
Posted

what are code tags and paste sites? also, i know one of the members in the comments of @@Asgarath83's tutorial had the same issue as me, but managed to fix it

 

When i make the tutorial about adding new saber colors, i did it because many peoples ask for this things. specially this was for a request of of the "epic challenge mod " i add some saber color and some weapons to SP code for this mod.

i admit that my saber tutorial is specified only for SP in game stuff. i never checked how to add new saber color to the menu of saber selection.

but i think you need to create a custom menu with new saber color icons that call an ui menu command.

this command need to be coded into the code for works fine. i am pretty busy these days and i cannot check this thing.

you can check how works the ui menu's code about the default saber colors and reply this for the new color you are created. 

it's however an unkwown field of SP code, i never dive about the user interface code of SP clients.

instead, if you saber is for Multiplayer, i am sorry, but i wrote that for single player side only  >.<

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
Go to topic listing
×
×
  • Create New...