[Release] Health Icon (By Yamato)

[Yamato]

This is a super site Rendflex, thanks for linking it in.

This icon means you can die by a train?

If yes, then where are the trains from the game?

_nightshift.gsc (skidrow) There is a train leftover there, they wanted to add a train which has the ability to run over players

[estebespt]

This is a super site Rendflex, thanks for linking it in.

This icon means you can die by a train?

If yes, then where are the trains from the game?

_nightshift.gsc (skidrow) There is a train leftover there, they wanted to add a train which has the ability to run over players

Where? :O that was likely on derail i never noticed nothing related to a train on skidrow

[Yamato]

Where? :O that was likely on derail i never noticed nothing related to a train on skidrow

It wasnt implemented into game, I made a mistake, it is in _train.gsc (skidrow fastfile)

Spoiler (Click to View)

Code:

#include maps\mp\_utility;
#include common_scripts\utility;

SOUND_DELAY_MIN = 0.1;
SOUND_DELAY_MAX = 1;

init()
{
    train = getEnt( "the_l_train", "targetname" );
    assertex( isdefined( train ), "Calling to setup train in map without having the train in map! [targetname: the_l_train]" );
    train thread train_setup();
}

train_setup()
{
    precacheItem( "train_mp" );    
    
    delay_until_first_train = 2;
    Units_per_second = 1200;// train speed
    train_cars = 24;
    distance_between_cars = 368;
    eq_radius = 900;//     radius of earthquakes broadcast from the train tracks

    min_time_between_trains = 100;
    max_time_between_trains = 200;

    lead_in_dist = 8000;
    lead_out_dist = 4000;

    train_car_sound_interval = 3;
    
    flag_init( "train_running" );

    yaw = self.angles[ 1 ];
    while ( yaw >= 90 )
    {
        yaw -= 90;
    }
    assertEx( yaw == 0, "Trains must have a yaw of 0, 90, 180, or 270 currently( for collision purposes )" );

    wheels = getentarray( "wheel", "targetname" );
    wheel_model = wheels[ 0 ].model;
    wheel_offset = [];
    foreach ( wheel in wheels )
    {
        wheel linkto( self );
        wheel.offset = self.origin - wheel.origin;
    }

    // ****************
    // Set up the other cars
    // ****************    
    forward = anglestoforward( self.angles );
    forward *= distance_between_cars;
    car_separation_vec = forward;
    cars = [];
    for ( i = 0; i < train_cars - 1; i++ )// - 1 car self is the lead car
    {
        car = spawn( "script_model", self.origin - car_separation_vec );
        car.angles = self.angles;
        car setmodel( self.model );
        car linkto( self );
        car_separation_vec += forward;
        cars[ cars.size ] = car;
        car.wheels = [];

        foreach ( owner_wheel in wheels )
        {
            wheel = spawn( "script_model", car.origin + owner_wheel.offset );
            wheel setmodel( wheel_model );
            wheel.angles = owner_wheel.angles;
            wheel linkto( car );
            car.wheels[ car.wheels.size ] = wheel;
        }
    }

    // ****************
    // The start and end points for the train, set from script origins
    // ****************    
    start = getent( self.target, "targetname" );
    start.origin = ( start.origin[ 0 ], start.origin[ 1 ], self.origin[ 2 ] );
    
    end = getent( start.target, "targetname" );
    end.origin = ( end.origin[ 0 ], end.origin[ 1 ], self.origin[ 2 ] );
    forward = anglestoforward( self.angles );
    start.origin = start.origin - forward * lead_in_dist;
    end.origin = end.origin + forward * lead_out_dist;

    track_dist = distance( start.origin, end.origin );
    travel_dist = track_dist + train_cars * distance_between_cars;
    travel_time = travel_dist / Units_per_second;
    track_time = track_dist / Units_per_second;
    full_train_time = train_cars * distance_between_cars / Units_per_second;



    // ****************
    // set up the earthquakes that play to make the train tracks rattle
    // ****************    
    distance_between_eq_orgs = eq_radius * 0.5;
    eq_count = track_dist / distance_between_eq_orgs;

    // the amount of time it takes for all the EQs to start before the train moves in
    delay_between_eqs = track_time / eq_count;
    travel_time_segment = track_time / eq_count;
    min_time_between_trains -= track_time;
    if ( min_time_between_trains < 0.1 )
        min_time_between_trains = 0.1;
    max_time_between_trains -= track_time;
    if ( max_time_between_trains < min_time_between_trains )
        max_time_between_trains = min_time_between_trains + 0.1;

    eq_points = [];
    for ( i = 0; i < eq_count; i++ )
    {
        progress = i / eq_count;
        eq_points[ i ] = start.origin * ( 1 - progress ) + end.origin * progress;
    }

    self.cars = cars;
    self.wheels = wheels;

    self.origin = start.origin;
    wait( delay_until_first_train );
    
    for ( ;; )
    {
        hide_trains();
        wait( 0.05 );
        self.origin = start.origin;


        // First there is a lead in of small EQs to shake the platform
        timer = gettime();
        for ( i = 0; i < eq_count; i++ )
        {
            thread train_eq( eq_points[ i ], eq_radius, track_time, full_train_time );
            wait( delay_between_eqs );
        }

        show_trains();
        thread train_kills_players( train_cars, distance_between_cars );
        thread train_spawns_dust();

        // Now the train goes by
        self moveto( end.origin + car_separation_vec, travel_time );
        train_play_sounds( train_car_sound_interval );
        
        wait( travel_time );
        hide_trains();

        train_stop_sounds( train_car_sound_interval );

        flag_set( "train_running" );
        self notify( "train_stops_killing_players" );
        // Wait until the next train
        wait( randomfloatrange( min_time_between_trains, max_time_between_trains ) );
    }
}

train_play_sound_delayed( alias )
{
    wait( randomfloatrange( SOUND_DELAY_MIN, SOUND_DELAY_MAX ) );    
    self playLoopSound( alias );
}

train_play_sounds( max )
{    
    self thread train_play_sound_delayed( "veh_train_eng_dist1_loop" );
    self thread train_play_sound_delayed( "veh_train_eng_dist2_loop" );
    self thread train_play_sound_delayed( "veh_train_eng_mid_loop" );
    self thread train_play_sound_delayed( "veh_train_eng_close1_loop" );
    self thread train_play_sound_delayed( "veh_train_eng_close2_loop" );
    
    // dont play sounds on every car
    count = 0;
    for ( i = 0; i < self.cars.size; i++ )
    {
        count++;
        if ( count < max )
            continue;
        count = 0;
    
        self.cars[ i ] thread train_play_sound_delayed( "veh_train_car_dist_loop" );
        self.cars[ i ] thread train_play_sound_delayed( "veh_train_car_mid_loop" );
        self.cars[ i ] thread train_play_sound_delayed( "veh_train_car_close_loop" );
    }
}

train_stop_sounds( max )
{
    self stopLoopSound( "veh_train_eng_dist1_loop" );  
    self stopLoopSound( "veh_train_eng_dist2_loop" );  
    self stopLoopSound( "veh_train_eng_mid_loop" );    
    self stopLoopSound( "veh_train_eng_close1_loop" );  
    self stopLoopSound( "veh_train_eng_close2_loop" );  

    count = 0;
    for ( i = 0; i < self.cars.size; i++ )
    {
        count++;
        if ( count < max )
            continue;
        count = 0;
    
        self.cars[ i ] stopLoopSound( "veh_train_car_dist_loop" );
        self.cars[ i ] stopLoopSound( "veh_train_car_mid_loop" );
        self.cars[ i ] stopLoopSound( "veh_train_car_close_loop" );
    }
}

hide_trains()
{
    // Hide the train while it warps to position
    self hide();
    foreach ( wheel in self.wheels )
    {
        wheel hide();
    }
    foreach ( car in self.cars )
    {
        car hide();
        foreach ( wheel in car.wheels )
        {
            wheel hide();
        }
    }
}

show_trains()
{
    // show the train while it warps to position
    self show();
    foreach ( wheel in self.wheels )
    {
        wheel show();
    }
    foreach ( car in self.cars )
    {
        car show();
        foreach ( wheel in car.wheels )
        {
            wheel show();
        }
    }
}

train_spawns_dust()
{
    if ( !isdefined( level._effect[ "train_dust" ] ) )
        return;
        
    range = 40;
    self endon( "train_stops_killing_players" );
    
    for ( ;; )
    {
        /*
        for ( i = 0; i < 10; i ++ )
        {
            x = randomfloatrange( self.min_x, self.max_x );
            y = randomfloatrange( self.min_y, self.max_y );
            PlayFX( level._effect[ "train_dust" ], ( x, y, self.origin[ 2 ] - 30 ) );
        }
        */

        count = randomintrange( 1, 3 ); // which means 1 to 2 fx per frame
        for ( i = 0; i < count; i ++ )
        {
            x = randomfloatrange( self.min_x - range, self.max_x + range );
            y = randomfloatrange( self.min_y - range, self.max_y + range );
            PlayFX( level._effect[ "train_dust_linger" ], ( x, y, self.origin[ 2 ] - 10 ) );
        }
        wait( 0.05 );
    }
}

train_kills_players( train_cars, distance_between_cars )
{
    // find the extents of the train, presuming it is going straight n/s/e/w and then test vs player origins to see
    // if they should be run over
    train_width = 68;
    self endon( "train_stops_killing_players" );

    forward = anglestoforward( self.angles );
    right = anglestoright( self.angles );
    full_car_vec = forward * distance_between_cars;
    half_car_vec = full_car_vec * 0.5;
    train_width_vec = right * train_width;

    sides = [];
    sides[ "front" ] = self.origin + half_car_vec;
    sides[ "rear" ] = self.origin + train_cars * full_car_vec * - 1;
    sides[ "right" ] = self.origin + train_width_vec;
    sides[ "left" ] = self.origin - train_width_vec;
    start = self.origin;

    max_x = sides[ "front" ][ 0 ];
    min_x = sides[ "front" ][ 0 ];
    max_y = sides[ "front" ][ 1 ];
    min_y = sides[ "front" ][ 1 ];
    foreach ( side in sides )
    {
        if ( side[ 0 ] > max_x )
            max_x = side[ 0 ];
        if ( side[ 0 ] < min_x )
            min_x = side[ 0 ];
        if ( side[ 1 ] > max_y )
            max_y = side[ 1 ];
        if ( side[ 1 ] < min_y )
            min_y = side[ 1 ];
    }

    for ( ;; )
    {
        dif = start - self.origin;
        start = self.origin;
        max_x -= dif[ 0 ];
        min_x -= dif[ 0 ];
        max_y -= dif[ 1 ];
        min_y -= dif[ 1 ];
        
        // store it for the dust fx
        self.min_x = min_x;
        self.max_x = max_x;
        self.min_y = min_y;
        self.max_y = max_y;
        
        //print3d( ( max_x, max_y, self.origin[ 2 ] ), " * " );
        //print3d( ( min_x, max_y, self.origin[ 2 ] ), " * " );
        //print3d( ( max_x, min_y, self.origin[ 2 ] ), " * " );
        //print3d( ( min_x, min_y, self.origin[ 2 ] ), " * " );

        hit_ents = [];

        foreach ( player in level.players )
        {
            if ( !isalive( player ) )
                continue;
            if ( player.sessionstate != "playing" )
                continue;
            if ( !train_hits( player, min_x, min_y, max_x, max_y ) )
                continue;
                
            player playsound( "melee_knife_hit_watermelon" );

            pos = get_damageable_player_pos( player );
            hit_ents[ hit_ents.size ] = get_damageable_player( player, pos );
        }

        grenades = getentarray( "grenade", "classname" );
        foreach ( grenade in grenades )
        {
            if ( !train_hits( grenade, min_x, min_y, max_x, max_y ) )
                continue;

            pos = get_damageable_grenade_pos( grenade );
            hit_ents[ hit_ents.size ] = get_damageable_grenade( grenade, pos );
        }
    
        foreach ( ent in hit_ents )
        {                
            ent.damage = 5000;
            ent.pos = self.origin;
            ent.damageOwner = self;
            ent.eInflictor = self;

            ent maps\mp\gametypes\_weapons::damageEnt(
                ent.eInflictor, // eInflictor = the entity that causes the damage (e.g. a claymore)
                ent.damageOwner, // eAttacker = the player that is attacking
                ent.damage, // iDamage = the amount of damage to do
                "MOD_PROJECTILE_SPLASH", // sMeansOfDeath = string specifying the method of death (e.g. "MOD_PROJECTILE_SPLASH")
                "train_mp", // sWeapon = string specifying the weapon used (e.g. "claymore_mp")
                ent.pos, // damagepos = the position damage is coming from
                vectornormalize(ent.damageCenter - ent.pos) // damagedir = the direction damage is moving in
            );            
        }
                
        wait( 0.05 );
    }
}

train_hits( entity, min_x, min_y, max_x, max_y )
{
    if ( entity.origin[ 2 ] < self.origin[ 2 ] - 5 )
        return false;

    if ( entity.origin[ 2 ] > self.origin[ 2 ] + 162 )
        return false;

    x = entity.origin[ 0 ];
    y = entity.origin[ 1 ];
    if ( x < min_x )
        return false;
    if ( y < min_y )
        return false;
    if ( x > max_x )
        return false;
    if ( y > max_y )
        return false;
    return true;
}


train_eq( origin, eq_radius, track_time, full_train_time )
{
    train_eq_lerp_for_time( origin, 0.0, 0.09, eq_radius, track_time, 0.5 );
    train_eq_for_time( origin, 0.17, eq_radius, full_train_time, 0.5 );
    train_eq_lerp_for_time( origin, 0.09, 0, eq_radius, track_time, 0.5 );
    //level notify( "stop_train_debug" + origin );
}

train_eq_for_time( origin, eq, eq_radius, eq_time, eq_time_slice )
{
    // earthquake makes the quake taper off over time so we
    // are going to do a lot of earthquakes to simulate a steady quake
    //thread print3d_eq( origin, eq );
    steps = int( eq_time / eq_time_slice );
    for ( i = 0; i < steps; i++ )
    {
        Earthquake( eq, eq_time_slice * 3, origin, eq_radius );
        wait( eq_time_slice );
    }
    remainder = eq_time - steps * eq_time_slice;
    if ( remainder > 0 )
    {
        wait( remainder );
    }
}

train_eq_lerp_for_time( origin, eq1, eq2, eq_radius, eq_time, eq_time_slice )
{
    // earthquake makes the quake taper off over time so we
    // are going to do a lot of earthquakes to simulate a steady quake
    //thread print3d_eq( origin, eq );
    steps = int( eq_time / eq_time_slice );
    for ( i = 0; i < steps; i++ )
    {
        progress = i / steps;
        eq = eq2 * progress + eq1 * ( 1 - progress );
        if ( eq > 0 )
            Earthquake( eq, eq_time_slice * 3, origin, eq_radius );
        wait( eq_time_slice );
    }
    remainder = eq_time - steps * eq_time_slice;
    if ( remainder > 0 )
    {
        wait( remainder );
    }
}

print3d_eq( origin, msg )
{
    level notify( "stop_train_debug" + origin );
    level endon( "stop_train_debug" + origin );
    for ( ;; )
    {
        Print3d( origin, msg );
        wait( 0.05 );
    }
}

[RaZ]

Where? :O that was likely on derail i never noticed nothing related to a train on skidrow

It wasnt implemented into game, I made a mistake, it is in _train.gsc (skidrow fastfile)

So with this code someone can make a working train in multiplayer?

a welcome message on a table at a railwaystation:
"Welcome you "+self.name+" here, with this train you can go to OMA City!"

Hmmm a new big map, with trains, oma-s and zombies.

[Yamato]

Where? :O that was likely on derail i never noticed nothing related to a train on skidrow

It wasnt implemented into game, I made a mistake, it is in _train.gsc (skidrow fastfile)

So with this code someone can make a working train in multiplayer?

a welcome message on a table at a railwaystation:
"Welcome you "+self.name+" here, with this train you can go to OMA City!"

Hmmm a new big map, with trains, oma-s and zombies.

The last time I tried to get the train working I was still a n00b But I dont think it will work, we would need a decent model and a long railway . The rest I think its easy.

[momo5502]

Nice