Раздатчик

#include < amxmodx >
#include < amxmisc >

#include < fakemeta >
#include < fakemeta_util >
#include < cstrike >
#include < engine >
#include < hamsandwich >

#include < xs >
#include <dhudmessage>

#define BREAK_COMPUTER		6
#define MAX_PLAYERS		32 + 1

#define is_valid_player(%1) ( 1 <= %1 <= gMaxPlayers )

new const gDamageSounds[ ][ ] = 
{
	"debris/metal1.wav",
	"debris/metal2.wav",
	"debris/metal3.wav"
};

new const gDispenserClassname[ ] = "NiceDispenser";

new const gDispenserActive[ ] = "csdm/dispenser.wav";
new const gDispenserMdl[ ] = "models/csdm/dispenser.mdl";
new const gDispenserMdl2[ ] = "models/csdm/dispenser_2.mdl";
new const gMetalGibsMdl[ ] = "models/computergibs.mdl";
new const gHealingSprite[ ] = "sprites/dispenser.spr";
new const gExploSprite[ ] = "sprites/dispexplo.spr";

new gHealingBeam;
new gExploSpr;
new gMetalGibs;
new gMaxPlayers;
new gHudSync;

#define DISPENSER_COST 		4000
#define DISPENSER_UPGCOST 	6000
#define DISPENSER_HP_1		500
#define DISPENSER_HP_2		1000
#define DISPENSER_RADIUS_1	700.0
#define DISPENSER_RADIUS_2	1000.0
#define PLAYER_HP_1			130
#define PLAYER_HP_2			170
#define PLAYER_AP_1			130
#define PLAYER_AP_2			170
#define PLAYER_TAKEHP_1		1.0
#define PLAYER_TAKEHP_2		2.0
#define PLAYER_TAKEAP_1		1.0
#define PLAYER_TAKEAP_2		2.0

new Float:gDispenserOrigin[ MAX_PLAYERS ][ 3 ];
new gBeamcolor[ MAX_PLAYERS ][ 3 ];

new bool:bDispenserBuild[ MAX_PLAYERS ];

public plugin_init( )
{
	register_plugin( "Build Dispenser", "1.0.5", "tuty" );
	
	register_event( "TextMsg", "EVENT_TextMsg", "a", "2&#Game_C", "2&#Game_w", "2&#Game_will_restart_in" );
	register_logevent( "LOG_RoundEnd", 2, "1=Round_End" );

	register_forward ( FM_TraceLine, "fw_TraceLine_Post", 1 )

	RegisterHam( Ham_TakeDamage, "func_breakable", "bacon_TakeDamage", 1 );
	RegisterHam( Ham_TakeDamage, "func_breakable", "bacon_TakeDamagePre", 0 );
	
	register_think( gDispenserClassname, "DispenserThink" );
	register_touch ( gDispenserClassname, "player", "fw_DispenserTouch" )
	register_clcmd( "build_dispenser", "CommandDispenserBuild" );
	
	gMaxPlayers = get_maxplayers( );
	gHudSync = CreateHudSyncObj( );
}

public client_connect( id )
{
	bDispenserBuild[ id ] = false;
}

public client_disconnect( id )
{
	BreakAllPlayerDispensers(id)
}

public plugin_precache( )
{	
	gHealingBeam = precache_model( gHealingSprite );
	gExploSpr = precache_model( gExploSprite );
	gMetalGibs = precache_model( gMetalGibsMdl );
	
	precache_model( gDispenserMdl );
	precache_model( gDispenserMdl2 );
	precache_sound( gDispenserActive );
	
	new i;
	for( i = 0; i < sizeof gDamageSounds; i++ )
	{
		precache_sound( gDamageSounds[ i ] );
	}
}

public fw_TraceLine_Post ( Float:v1[3], Float:v2[3], noMonsters, id )
{
	if ( !is_valid_player ( id ) || is_user_bot ( id ) || !is_user_alive ( id ) )
		return FMRES_IGNORED

	new iHitEnt = get_tr ( TR_pHit )

	if ( iHitEnt <= gMaxPlayers || !pev_valid ( iHitEnt ) )
		return FMRES_IGNORED

	new sClassname[32]
	pev ( iHitEnt, pev_classname, sClassname, charsmax ( sClassname ) )

	if ( !equal ( sClassname, gDispenserClassname ) )
		return FMRES_IGNORED

	new iTeam = pev ( iHitEnt, pev_iuser4 )

	if ( _:cs_get_user_team ( id ) != iTeam )
	         return FMRES_IGNORED

	new iHealth = pev ( iHitEnt, pev_health )

	if ( iHealth <= 0 )
		return FMRES_IGNORED

	new iOwner = pev ( iHitEnt, pev_iuser2 )

	if ( !is_user_connected ( iOwner ) )
		return FMRES_IGNORED

	new sName[33]
	get_user_name ( iOwner, sName, charsmax ( sName ) )
	new iLevel = pev ( iHitEnt, pev_iuser3 )

	set_dhudmessage ( iTeam == 1 ? 150 : 0, 0, iTeam == 2 ? 150 : 0, -1.0, 0.35, 0, 0.0, 0.6, 0.0, 0.0 )
	show_dhudmessage ( id, "Установил: %s^nЗдоровье: %d/%d", sName, iHealth, iLevel == 1 ? DISPENSER_HP_1 : DISPENSER_HP_2 )
	show_dhudmessage ( id, "^n^nУровень: %d", iLevel )

	return FMRES_IGNORED
}

public bacon_TakeDamagePre( ent, idinflictor, idattacker, Float:damage, damagebits )
{
	new szClassname[ 32 ];
	pev( ent, pev_classname, szClassname, charsmax( szClassname ) );
	
	if( equal( szClassname, gDispenserClassname ) )
	{
		new iOwner = pev( ent, pev_iuser2 );

		if(!is_user_connected(iOwner) || 1 > iOwner > 32 || !is_user_connected(idattacker) || 1 > idattacker > 32)
			return HAM_SUPERCEDE
		
		if(cs_get_user_team(iOwner)==cs_get_user_team(idattacker) && idattacker != iOwner)
			return HAM_SUPERCEDE
	}
	return HAM_IGNORED	
}

public bacon_TakeDamage( ent, idinflictor, idattacker, Float:damage, damagebits )
{
	if ( !pev_valid ( ent ) )
		return HAM_IGNORED

	new szClassname[ 32 ];
	pev( ent, pev_classname, szClassname, charsmax( szClassname ) );
	
	if( equal( szClassname, gDispenserClassname ) )
	{
		new iOwner = pev( ent, pev_iuser2 );

		if(!is_user_connected(iOwner) || 1 > iOwner > 32 || !is_user_connected(idattacker) || 1 > idattacker > 32)
			return HAM_SUPERCEDE
		
		if(cs_get_user_team(iOwner)==cs_get_user_team(idattacker) && idattacker != iOwner)
			return HAM_SUPERCEDE
		
		if( pev( ent, pev_health ) <= 0.0 )
		{
			new szName[ 32 ];
			get_user_name( idattacker, szName, charsmax( szName ) );

			new Float:flOrigin[ 3 ];
			pev( ent, pev_origin, flOrigin );
				
			UTIL_BreakModel( flOrigin, gMetalGibs, BREAK_COMPUTER );
			set_pev( ent, pev_flags, pev( ent, pev_flags ) | FL_KILLME );

			if( idattacker == iOwner )
			{
				ChatColor ( iOwner, "^3[^4Действие^3]^1 Вы уничтожили собственный раздатчик!")
			}

			else
			{
				ChatColor ( iOwner, "^3[^4Действие^3]^1 %s уничтожил ваш раздатчик!", szName)
			}

			client_cmd( iOwner, "speak ^"vox/bizwarn computer destroyed^"" );
			bDispenserBuild[ iOwner ] = false;
		}
		
		emit_sound( ent, CHAN_STATIC, gDamageSounds[ random_num( 0, charsmax( gDamageSounds ) ) ], VOL_NORM, ATTN_NORM, 0, PITCH_NORM );	
	}
	return HAM_IGNORED
}

public CommandDispenserBuild( id )
{
	if( !is_user_alive( id ) )
	{
		return PLUGIN_CONTINUE;
	}
	
	if( !( pev( id, pev_flags ) & FL_ONGROUND ) )
	{
		ChatColor ( id, "^3[^4Информация^3]^1 Вы можете построить раздатчик только на земле!")
		
		return PLUGIN_HANDLED;
	}

	if( bDispenserBuild[ id ] == true )
	{
		ChatColor ( id, "^3[^4Информация^3]^1 Вы уже построили раздатчик!")
		
		return PLUGIN_HANDLED;
	}

	new iMoney = cs_get_user_money( id );
	
	if( iMoney < DISPENSER_COST )
	{
		ChatColor ( id, "^3[^4Информация^3]^1 У тебя не хватает денег! (нужно %d$)", DISPENSER_COST )
		
		return PLUGIN_HANDLED;
	}

	new Float:playerOrigin[3]
	entity_get_vector(id, EV_VEC_origin, playerOrigin)
	
  	new Float:vNewOrigin[3]
	new Float:vTraceDirection[3]
	new Float:vTraceEnd[3]
	new Float:vTraceResult[3]
	velocity_by_aim(id, 64, vTraceDirection) // get a velocity in the directino player is aiming, with a multiplier of 64...
	vTraceEnd[0] = vTraceDirection[0] + playerOrigin[0] // find the new max end position
	vTraceEnd[1] = vTraceDirection[1] + playerOrigin[1]
	vTraceEnd[2] = vTraceDirection[2] + playerOrigin[2]
	trace_line(id, playerOrigin, vTraceEnd, vTraceResult) // trace, something can be in the way, use hitpoint from vTraceResult as new origin, if nothing's in the way it should be same as vTraceEnd
	vNewOrigin[0] = vTraceResult[0]// just copy the new result position to new origin
	vNewOrigin[1] = vTraceResult[1]// just copy the new result position to new origin
	vNewOrigin[2] = playerOrigin[2] // always build in the same height as player.
	
	if (CreateDispanser(vNewOrigin, id))
		cs_set_user_money(id, cs_get_user_money(id) - DISPENSER_COST)
	else
		ChatColor ( id, "^3[^4Информация^3]^1 Здесь не получается установить раздатчик!")
	
	return PLUGIN_HANDLED;
}


stock bool:CreateDispanser(Float:origin[3], creator) 
{
	if (point_contents(origin) != CONTENTS_EMPTY || TraceCheckCollides(origin, 35.0)) 
	{
		return false
	}
	
	new Float:hitPoint[3], Float:originDown[3]
	originDown = origin
	originDown[2] = -5000.0 // dunno the lowest possible height...
	trace_line(0, origin, originDown, hitPoint)
	new Float:baDistanceFromGround = vector_distance(origin, hitPoint)
	
	new Float:difference = 20.0 - baDistanceFromGround
	if (difference < -1 * 20.0 || difference > 20.0) return false
	
	new iEntity = create_entity( "func_breakable" );
	
	if( !pev_valid( iEntity ) )
		 return false
	
	set_pev( iEntity, pev_classname, gDispenserClassname );
	engfunc( EngFunc_SetModel, iEntity, gDispenserMdl );
	engfunc( EngFunc_SetSize, iEntity, Float:{ -20.0, -10.0, 0.0 }, Float:{ 20.0, 10.0, 67.0 } );
	set_pev( iEntity, pev_origin, origin );
	set_pev( iEntity, pev_solid, SOLID_SLIDEBOX );
	set_pev( iEntity, pev_movetype, MOVETYPE_FLY );
	set_pev( iEntity, pev_health, float(DISPENSER_HP_1) );
	set_pev( iEntity, pev_takedamage, 2.0 );
	set_pev( iEntity, pev_iuser2, creator );
	set_pev( iEntity, pev_iuser3, 1 );
	set_pev( iEntity, pev_iuser4, get_user_team(creator) );
	set_pev( iEntity, pev_nextthink, get_gametime( ) + 0.1 );
	engfunc( EngFunc_DropToFloor, iEntity );	
	
	gDispenserOrigin[ creator ][ 0 ] = origin[ 0 ];
	gDispenserOrigin[ creator ][ 1 ] = origin[ 1 ];
	gDispenserOrigin[ creator ][ 2 ] = origin[ 2 ];
	
	bDispenserBuild[ creator ] = true;
	
	switch( cs_get_user_team( creator ) )
	{
		case CS_TEAM_T:
		{
			gBeamcolor[ creator ][ 0 ] = 255, gBeamcolor[ creator ][ 1 ] = 0, gBeamcolor[ creator ][ 2 ] = 0;
			set_rendering( iEntity, kRenderFxGlowShell, gBeamcolor[ creator ][ 0 ], gBeamcolor[ creator ][ 1 ], gBeamcolor[ creator ][ 2 ], kRenderNormal, 3 );
		}
		
		case CS_TEAM_CT:
		{
			gBeamcolor[ creator ][ 0 ] = 0, gBeamcolor[ creator ][ 1 ] = 0, gBeamcolor[ creator ][ 2 ] = 255;
			set_rendering( iEntity, kRenderFxGlowShell, gBeamcolor[ creator ][ 0 ], gBeamcolor[ creator ][ 1 ], gBeamcolor[ creator ][ 2 ], kRenderNormal, 3 );
		}
	}
	emit_sound( iEntity, CHAN_STATIC, gDispenserActive, VOL_NORM, ATTN_NORM, 0, PITCH_NORM );
	
	return true;
}

public DispenserThink( iEnt )
{
	if( pev_valid( iEnt ) )
	{
		static iOwner; iOwner = pev( iEnt, pev_iuser2 )

		if ( !is_user_connected ( iOwner ) )
			return PLUGIN_CONTINUE

		new id, iLevel = pev ( iEnt, pev_iuser3 );
		new Float:fRadius = iLevel == 1 ? DISPENSER_RADIUS_1 : DISPENSER_RADIUS_2
		new iHealth = iLevel == 1 ? PLAYER_HP_1 : PLAYER_HP_2
		new iArmor = iLevel == 1 ? PLAYER_AP_1 : PLAYER_AP_2
		new Float:fTakeHp = iLevel == 1 ? PLAYER_TAKEHP_1 : PLAYER_TAKEHP_2
		new Float:fTakeAp = iLevel == 1 ? PLAYER_TAKEAP_1 : PLAYER_TAKEAP_2

		for( id = 1; id <= gMaxPlayers; id++ )
		{
			if ( !is_user_connected ( id ) )
				continue

			if( is_user_alive( id ) && cs_get_user_team( id ) == cs_get_user_team( iOwner ) )
			{
				new Float:flOrigin[ 3 ];
				pev( id, pev_origin, flOrigin );
				
				if( get_distance_f( gDispenserOrigin[ iOwner ], flOrigin ) <= fRadius )
				{
					if( UTIL_IsVisible( id, iEnt ) )
					{
						if( pev(id, pev_health) < iHealth )
						{
							set_pev(id, pev_health, floatmin(pev(id, pev_health) + fTakeHp, float(iHealth)) );
						}
					
						if( pev(id, pev_armorvalue) < iArmor )
						{
							set_pev(id, pev_armorvalue, floatmin(pev(id, pev_armorvalue) + fTakeAp, float(iArmor)) );
						}
						
						new bool:BigBeam = pev(id, pev_armorvalue) < float(iArmor) || pev(id, pev_health) < float(iHealth) ? true : false
						
						UTIL_BeamEnts( flOrigin, gDispenserOrigin[ iOwner ], gBeamcolor[ iOwner ][ 0 ], gBeamcolor[ iOwner ][ 1 ], gBeamcolor[ iOwner ][ 2 ],  gHealingBeam, BigBeam ? 60 : 20, BigBeam ? 1 : 11);
					}
				}
			}
		}
		
		set_hudmessage( gBeamcolor[ iOwner ][ 0 ], gBeamcolor[ iOwner ][ 1 ], gBeamcolor[ iOwner ][ 2 ], 0.0, 0.24, 1, 6.0, 0.2 );
		ShowSyncHudMsg( iOwner, gHudSync, "Здоровье раздатчика: [%d]", pev(iEnt, pev_health) > 0 ? pev(iEnt, pev_health) : 0 );
		
		if(get_user_team(iOwner) != pev( iEnt, pev_iuser4))
		{
			BreakAllPlayerDispensers(iOwner);
			return PLUGIN_CONTINUE;
		}
		
		set_pev( iEnt, pev_nextthink, get_gametime( ) + 0.1 );
	}
	return PLUGIN_CONTINUE;
}

public fw_DispenserTouch ( ent, id )
{
	if ( !pev_valid ( ent ) )
		return

	if ( !is_user_connected ( id ) || !is_user_alive ( id ) )
		return

	if ( pev ( ent, pev_iuser3 ) > 1 )
		return

	if ( pev ( ent, pev_iuser4 ) != _:cs_get_user_team ( id ) )
		return

	new iOwner = pev ( ent, pev_iuser2 )

	if ( iOwner == id )
		return

	new money = cs_get_user_money ( id )
	if ( money < DISPENSER_UPGCOST )
		return

	set_pev ( ent, pev_iuser3, 2 )
	set_pev ( ent, pev_health, float ( DISPENSER_HP_2 ) )
	engfunc( EngFunc_SetModel, ent, gDispenserMdl2 )
	engfunc( EngFunc_SetSize, ent, Float:{ -20.0, -10.0, 0.0 }, Float:{ 20.0, 10.0, 67.0 } )
	emit_sound( ent, CHAN_STATIC, gDispenserActive, VOL_NORM, ATTN_NORM, 0, PITCH_NORM )
	
	if ( !is_user_connected ( iOwner ) )
		return
	
	cs_set_user_money(id, money - DISPENSER_UPGCOST)
	
	new sUpgraderName[32]
	get_user_name ( id, sUpgraderName, charsmax ( sUpgraderName ) )
	client_print ( iOwner, print_center, "%s прокачал твой раздатчик до уровня 2", sUpgraderName )
}

public EVENT_TextMsg( )
{
	UTIL_DestroyDispensers( );
}

public LOG_RoundEnd( )
{
	UTIL_DestroyDispensers( );
}

stock UTIL_DestroyDispensers( )
{
	new iEnt = FM_NULLENT;
	
	while( ( iEnt = find_ent_by_class( iEnt, gDispenserClassname ) ) )
	{
		new iOwner = pev( iEnt, pev_iuser2 );
		
		bDispenserBuild[ iOwner ] = false;
		set_pev( iEnt, pev_flags, pev( iEnt, pev_flags ) | FL_KILLME );
	}
}

stock UTIL_BreakModel( Float:flOrigin[ 3 ], model, flags )
{
	engfunc( EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, flOrigin, 0 );
	write_byte( TE_BREAKMODEL );
	engfunc( EngFunc_WriteCoord, flOrigin[ 0 ] );
	engfunc( EngFunc_WriteCoord, flOrigin[ 1 ] );
	engfunc( EngFunc_WriteCoord, flOrigin[ 2 ] );
	write_coord( 16 );
	write_coord( 16 );
	write_coord( 16 );
	write_coord( random_num( -20, 20 ) );
	write_coord( random_num( -20, 20 ) );
	write_coord( 10 );
	write_byte( 10 );
	write_short( model );
	write_byte( 10 );
	write_byte( 9 );
	write_byte( flags );
	message_end( );
	
	engfunc( EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, flOrigin, 0 );
	write_byte(TE_SPRITE)
	engfunc( EngFunc_WriteCoord, flOrigin[ 0 ] );
	engfunc( EngFunc_WriteCoord, flOrigin[ 1 ] );
	engfunc( EngFunc_WriteCoord, flOrigin[ 2 ] );
	write_short( gExploSpr )
	write_byte( 15 )
	write_byte( 50 )
	message_end()
}

stock UTIL_BeamEnts( Float:flStart[ 3 ], Float:flEnd[ 3 ], r, g, b, sprite, width, ampl )
{
	engfunc( EngFunc_MessageBegin, MSG_PVS, SVC_TEMPENTITY, flStart );
	write_byte( TE_BEAMPOINTS );
	engfunc( EngFunc_WriteCoord, flStart[ 0 ] );
	engfunc( EngFunc_WriteCoord, flStart[ 1 ] );
	engfunc( EngFunc_WriteCoord, flStart[ 2 ] );
	engfunc( EngFunc_WriteCoord, flEnd[ 0 ] );
	engfunc( EngFunc_WriteCoord, flEnd[ 1 ] );
	engfunc( EngFunc_WriteCoord, flEnd[ 2 ] );
	write_short( sprite );
	write_byte( 5 );
	write_byte( 2 );
	write_byte( 1 );
	write_byte( width );
	write_byte( ampl );
	write_byte( r );
	write_byte( g );
	write_byte( b );
	write_byte( 130 );
	write_byte( 30 );
	message_end( );
}

stock bool:UTIL_IsVisible( index, entity, ignoremonsters = 0 )
{
	new Float:flStart[ 3 ], Float:flDest[ 3 ];
	pev( index, pev_origin, flStart );
	pev( index, pev_view_ofs, flDest );

	xs_vec_add( flStart, flDest, flStart );
    
	pev( entity, pev_origin, flDest );
	engfunc( EngFunc_TraceLine, flStart, flDest, ignoremonsters, index, 0 );
    
	new Float:flFraction;
	get_tr2( 0, TR_flFraction, flFraction );
	
	if( flFraction == 1.0 || get_tr2( 0, TR_pHit) == entity )
	{
		return true;
	}
    
	return false;
}

public BreakAllPlayerDispensers(id)
{
	static ent = -1
	
	while ((ent = find_ent_by_class(ent,  gDispenserClassname)))  
	{  
		if(pev( ent, pev_iuser2 ) != id)  
			continue  
		
		if(pev_valid(ent)) 
		{
			new Float:flOrigin[ 3 ];
			pev( ent, pev_origin, flOrigin );
			
			UTIL_BreakModel( flOrigin, gMetalGibs, BREAK_COMPUTER );
			set_pev( ent, pev_flags, pev( ent, pev_flags ) | FL_KILLME );
		}
	}  
	
	bDispenserBuild[ id ] = false;
}


bool:TraceCheckCollides(Float:origin[3], const Float:BOUNDS) {
	new Float:traceEnds[8][3], Float:traceHit[3], hitEnt
	traceEnds[0][0] = origin[0] - BOUNDS
	traceEnds[0][1] = origin[1] - BOUNDS
	traceEnds[0][2] = origin[2] - BOUNDS
	traceEnds[1][0] = origin[0] - BOUNDS
	traceEnds[1][1] = origin[1] - BOUNDS
	traceEnds[1][2] = origin[2] + BOUNDS
	traceEnds[2][0] = origin[0] + BOUNDS
	traceEnds[2][1] = origin[1] - BOUNDS
	traceEnds[2][2] = origin[2] + BOUNDS
	traceEnds[3][0] = origin[0] + BOUNDS
	traceEnds[3][1] = origin[1] - BOUNDS
	traceEnds[3][2] = origin[2] - BOUNDS
	traceEnds[4][0] = origin[0] - BOUNDS
	traceEnds[4][1] = origin[1] + BOUNDS
	traceEnds[4][2] = origin[2] - BOUNDS
	traceEnds[5][0] = origin[0] - BOUNDS
	traceEnds[5][1] = origin[1] + BOUNDS
	traceEnds[5][2] = origin[2] + BOUNDS
	traceEnds[6][0] = origin[0] + BOUNDS
	traceEnds[6][1] = origin[1] + BOUNDS
	traceEnds[6][2] = origin[2] + BOUNDS
	traceEnds[7][0] = origin[0] + BOUNDS
	traceEnds[7][1] = origin[1] + BOUNDS
	traceEnds[7][2] = origin[2] - BOUNDS

	for (new i = 0; i < 8; i++) {
		if (point_contents(traceEnds[i]) != CONTENTS_EMPTY)
			return true

		hitEnt = trace_line(0, origin, traceEnds[i], traceHit)
		if (hitEnt != 0)
			return true
		for (new j = 0; j < 3; j++) {
			if (traceEnds[i][j] != traceHit[j])
				return true
		}
	}

	return false
}

stock ChatColor(const id, const input[], any:...)
{
        new count = 1, players[32]
        static msg[191]
        vformat(msg, 190, input, 3)
       
        replace_all(msg, 190, "!g", "^4") // Green Color
        replace_all(msg, 190, "!y", "^1") // Default Color
        replace_all(msg, 190, "!team", "^3") // Team Color
        replace_all(msg, 190, "!team2", "^0") // Team2 Color
       
        if (id) players[0] = id; else get_players(players, count, "ch")
        {
                for (new i = 0; i < count; i++)
                {
                        if (is_user_connected(players[i]))
                        {
                                message_begin(MSG_ONE_UNRELIABLE, get_user_msgid("SayText"), _, players[i])
                                write_byte(players[i]);
                                write_string(msg);
                                message_end();
                        }
                }
        }
}