source: trunk/orbital/player.h @ 1520 Tweet

//
// Orbital
//
// Copyright: (c) 2009-2012 Cédric Lecacheur <jordx@free.fr>
//            (c) 2009-2012 Benjamin Huet <huet.benjamin@gmail.com>
//            (c) 2012 Sam Hocevar <sam@hocevar.net>
//

/* FIXME: this file is pure crap; it's only a test. */

#if !defined __PLAYER_H__
#define __PLAYER_H__

class Player : public WorldEntity
{
public:
    Player(int type)
      : m_type(type),
        m_stick(0),
        m_damped_stick(0),
        m_move_rotation(0),
        m_exhaust_rotation(0),
        move_rotation_timer(0),
        m_ready(false)
    {
        if (type == 0)
        {
            /* Red Mesh */
            m_ship_mesh.Compile("[sc#c32 afcb3 6 7 .4 t0 0 7"
                                " sc#fff afcb3 4 4 .4 t4 0 -4 mx]"
                                "[sc#c32 afcb3 6 5 .4 sc#fff afcb2 3 9 .4]"
                                "[sc#fff ac4 15 .2 .6 1 1 tz-2"
                                " ac4 15 .2 .6 1 1 rx90 t0 -2 -7]");

            m_exhaust_mesh.Compile("oifds9898432890fds");
            m_exhaust_mesh.Compile("[sc#0ff scb#000 ac5 15 0 1.5 0 1"
                                   " ac7 35 1.1 4 0 1 rx90 tz27]");

            m_option_mesh.Compile("sc#c32[afcb5 1 3 0.6]"
                                  "sc#fff[afcb1 5 3 0.6 tz-1]");
        }
        else
        {
            /* Blue Mesh */
            m_ship_mesh.Compile("[sc#fff scb#fff ac4 15 .2 .6 1 1 t0 0 -4"
                                " ac4 1.5 .2 .6 1 1 rx90 t1.3 -2 -6"
                                " afcb3 6 5 .4 t0 0 -7"
                                " sc#229 afcb3 4 7 .4 t4 0 0 mx]"
                                "[afcb3 6 5 .4 sc#fff afcb2 3 9 .4]");

            m_exhaust_mesh.Compile("[sc#0ff scb#000 ac5 10 0 1.5 0 1"
                                   " ac7 25 1.1 4 0 1 rx90 tz19]");

            m_option_mesh.Compile("sc#229[afcb5 1 3 0.6]"
                                  "sc#fff[afcb1 5 3 0.6 tz-1]");
        }

        m_laser_mesh.Compile("[sc#fff scb#000 aq8 1 sx0.25 tx-3 sc#f00"
                             " aq8 1 tx4 sz50 sx0.3 tz-200 mx as10 12 8 1 1]");

        m_position = vec3(0.f + type * 80.f, 3.5f + 50.f, 0.f);

        m_options.Push(m_position, vec3(0.f, 0.f, 0.f));
        m_options.Push(m_position, vec3(0.f, 0.f, 0.f));
        m_options.Push(m_position, vec3(0.f, 0.f, 0.f));
        m_options.Push(m_position, vec3(0.f, 0.f, 0.f));
    }

    ~Player()
    {
        if (m_stick)
            Input::UntrackStick(m_stick);
    }

    char const *GetName() { return "<ship>"; }

protected:
    virtual void TickGame(float seconds)
    {
        WorldEntity::TickGame(seconds);

        float updown = (float)(Input::GetButtonState(273 /*SDLK_UP*/) - Input::GetButtonState(274 /*SDLK_DOWN*/));
        float rightleft = (float)(Input::GetButtonState(275 /*SDLK_RIGHT*/) - Input::GetButtonState(276 /*SDLK_LEFT*/));

        if (!m_stick)
            m_stick = Input::TrackStick();
        if (m_stick && m_stick->GetAxisCount() >= 4)
        {
            rightleft += 1.f * m_stick->GetAxis(m_type * 2 + 0);
            updown += -1.f * m_stick->GetAxis(m_type * 2 + 1);
        }

        /* Clamp direction at 45-degree multiples */
        if (rightleft * rightleft + updown * updown > 0.2f)
        {
            float angle = lol::atan2(updown, rightleft);
            angle = (float)((int)(angle / ((float)M_PI / 4.f) + 8.5f) * ((float)M_PI / 4.f));
            rightleft = lol::cos(angle);
            updown = lol::sin(angle);
        }
        else
        {
            rightleft = updown = 0.f;
        }

        m_damped_stick.x = m_damped_stick.x + (seconds / (seconds + 0.18f)) * (rightleft - m_damped_stick.x);
        m_damped_stick.z = m_damped_stick.z + (seconds / (seconds + 0.18f)) * (updown - m_damped_stick.z);
        vec3 applied_stick = vec3(std::abs(m_damped_stick.x), 0.0f, m_damped_stick.z);
        vec3 offset = vec3(((m_damped_stick.x < 0.0f)?(std::abs(m_damped_stick.x) * 30.f):(0.f)), 0.0f, 0.0f);

        for (int i = 0; i < m_options.Count(); i++)
        {
            vec3 rot[4] = {
                vec3(20.f, 0.f, 0.f),
                vec3(-20.f, 0.f, 0.f),
                vec3(20.f, 0.f, 0.f),
                vec3(-20.f, 0.f, 0.f) };

            vec3 pos[4] = {
                vec3(11.f, 0.f, 0.f),
                vec3(-11.f, 0.f, 0.f),
                vec3(21.f, 0.f, 0.f),
                vec3(-21.f, 0.f, 0.f) };

            vec3 move_pos[4] = {
                vec3( -8.f, 0.f, -5.f),
                vec3(-19.f, 0.f, -5.f),
                vec3(  3.f, 0.f, 5.f),
                vec3(-30.f, 0.f, 5.f) };

            /* FIXME: this is not delta-timed */
            vec3 target_pos = m_position + pos[i] + (move_pos[i] - pos[i]) * applied_stick + offset;
            m_options[i].m1 = m_options[i].m1 + (seconds / (seconds + 0.1f)) * (target_pos - m_options[i].m1);
            m_options[i].m2[0] = rot[i][0] + (((m_damped_stick.x < 0.0f)?(20.0f):(-20.0f)) - rot[i][0]) * std::abs(m_damped_stick.x);

            if (m_damped_stick.x < 0.3f && m_damped_stick.x > -0.3f)
                m_options[i].m2[2] += seconds * (i & 1 ? 600.f : -600.f);
            else
                m_options[i].m2[2] += seconds * ((m_damped_stick.x < 0.0f)?(600.0f):(-600.0f));
        }

        if (m_damped_stick.x > 0.5f || m_damped_stick.x < -0.5f)
        {
            if (move_rotation_timer > 0.8f)
                m_move_rotation.z += m_damped_stick.x * -420.f * seconds;
            else
                move_rotation_timer += seconds;
        }
        else
        {
            move_rotation_timer = 0.0f;
            m_move_rotation.z -= m_move_rotation.z * (seconds / (seconds + 0.2f));
        }

        m_exhaust_rotation.z += 600.0f * seconds;

        if (m_move_rotation.z > 180.f)
            m_move_rotation.z -= 360.f;
        else if (m_move_rotation.z < -180.f)
            m_move_rotation.z += 360.f;

        if (m_exhaust_rotation.z > 180.f)
            m_exhaust_rotation.z -= 360.f;
        else if (m_exhaust_rotation.z < -180.f)
            m_exhaust_rotation.z += 360.f;

        m_rotation = quat::fromeuler_xyz(vec3(((m_damped_stick.z <= 0.0f)?(m_damped_stick.z):(0.0f)) * -60.0f, 0.f, m_damped_stick.x * -50.0f) + m_move_rotation);

        if (m_type == 0)
            m_position += vec3(rightleft, 0.f, -updown) * 340.f * seconds;
        else
            m_position += vec3(rightleft, 0.f, -updown) * 240.f * seconds;
    }

    virtual void TickDraw(float seconds)
    {
        WorldEntity::TickDraw(seconds);

        if (!m_ready)
        {
            m_ship_mesh.MeshConvert();
            m_option_mesh.MeshConvert();
            m_laser_mesh.MeshConvert();
            m_exhaust_mesh.MeshConvert();
            m_ready = true;
        }

        mat4 model = mat4::translate(m_position) * mat4(m_rotation);

        m_ship_mesh.Render(model);

        if (m_type == 0)
        {
            m_exhaust_mesh.Render(model * mat4::translate(vec3(-4.f,0.f,0.f)) * mat4::fromeuler_xyz(m_exhaust_rotation * -1.0f));
            m_exhaust_mesh.Render(model * mat4::translate(vec3( 4.f,0.f,0.f)) * mat4::fromeuler_xyz(m_exhaust_rotation));
        }
        else
            m_exhaust_mesh.Render(model * mat4::fromeuler_xyz(m_exhaust_rotation));

        for (int i = 0; i < m_options.Count(); i++)
        {
            mat4 t = mat4::translate(m_options[i].m1);

            bool fire = m_stick && m_stick->GetButtonCount() >= 12
                                && m_stick->GetButton(12);
            fire = fire || Input::GetButtonState(305 /* Right Ctrl */);
            if (fire)
                m_laser_mesh.Render(t);

            t *= mat4::fromeuler_yxz(m_options[i].m2);
            m_option_mesh.Render(t);
        }
    }

private:
    int m_type;
    EasyMesh m_ship_mesh, m_option_mesh, m_laser_mesh, m_exhaust_mesh;
    Stick *m_stick;

    Array<vec3, vec3> m_options;

    vec3 m_damped_stick;
    vec3 m_move_rotation;
    vec3 m_exhaust_rotation;
    float move_rotation_timer;

    bool m_ready;
};

#endif /* __PLAYER_H__ */