source: trunk/orbital/snake.h @ 1433 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 __SNAKE_H__
#define __SNAKE_H__

class Snake : public WorldEntity
{
public:
    Snake(int nodes)
      : m_steer(0.f),
        m_stick(0),
        m_ready(false)
    {
        m_head.SendCommand("sc#d91,"
                           "afcb30,3,3,.8,fl,"
                           "sc#cca,"
                           "afcb10,10,10,1,fl,"
                           "afcb.4,.4,12,.4,tz3,tx8,mx,fl,"
                           "afcb.4,.4,12,.4,tz3,tx12,mx,fl,"
                           "sc#69c9,"
                           "afcb5,8,8,1,ty3,tz3,fl");

        m_body.SendCommand("sc#d91,"
                           "afcb3,20,3,.8,afcb20,3,3,.8,fl,"
                           "sc#cca,"
                           "afcb6,6,12,1,fl,"
                           "afcb.4,.4,7,.4,ty8,my,fl,"
                           "afcb.4,.4,7,.4,tx8,mx,fl");

        m_tail.SendCommand("sc#cca,"
                           "afcb6,6,10,1,tz-1,fl,"
                           "afcb.4,.4,8,.4,tz-1,ty8,fl,"
                           "afcb.4,.4,8,.4,tz-1,ty12,fl,"
                           "afcb.4,.4,8,.4,tz-1,tx8,fl,"
                           "afcb.4,.4,8,.4,tz-1,tx12,fl,"
                           "sc#d91,"
                           "afcb3,15,3,.8,ty8,fl,"
                           "afcb15,3,3,.8,tx8,fl");

        m_position = vec3(RandF(0.f, 100.f), 20.f, RandF(150.f, 250.f));
        m_rotation = quat::rotate(RandF(30.f, 70.f), 0.f, 1.f, 0.f);;

        /* The last node is actually the tail */
        for (int i = 0; i < nodes; i++)
            m_nodes.Push(m_rotation.transform(vec3(-12.f, 0.f, 0.f)),
                         0.f, 100.f, 0.f);
        m_nodes.Push(vec3(0.f, 0.f, 0.f), 45.f, 100.f, 0.f);
    }

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

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

    vec3 GetBarycenter()
    {
        vec3 new_camera_pos = m_position;
        for (int i = 0; i < m_nodes.Count(); i++)
            new_camera_pos += m_nodes[i].m1;
        new_camera_pos /= (float)(m_nodes.Count() + 1);

        return new_camera_pos;
    }

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

        m_steer += 2.f * seconds;

        /* Destruction test */
        if (!m_stick)
            m_stick = Input::TrackStick();
        bool fire = m_stick && m_stick->GetButtonCount() >= 4
                            && m_stick->GetButton(12);
        fire = fire || Input::GetButtonState(305 /* Right Ctrl */);
        if (fire && (int)m_steer != (int)(m_steer - 2.f * seconds))
        {
            int tohit = (int)RandF(m_nodes.Count() - 2);
            m_nodes[tohit].m4 += 150.f;
            m_nodes[tohit + 1].m4 += 150.f;
        }

        float test = sinf(m_steer) * 100.f + 30.f;
        m_rotation *= quat::rotate(seconds * test, vec3(0, 1, 0));

        m_velocity = 60.f * m_rotation.transform(vec3(0, 0, 1));
        vec3 deltapos = seconds * m_velocity;
        m_position += deltapos;

        /* Remove dead nodes */
        for (int i = m_nodes.Count(); i--; )
        {
            if (m_nodes[i].m3 < 0.f)
            {
                m_nodes[i + 1].m1 += m_nodes[i].m1;
                m_nodes.Remove(i);
            }
        }

        /* Regrow! FIXME: just a test */
        if (m_nodes.Count() < 5)
        {
            m_nodes.Empty();
            for (int i = 0; i < 35; i++)
                m_nodes.Push(m_rotation.transform(vec3(-12.f, 0.f, 0.f)),
                             0.f, 100.f, 0.f);
            m_nodes.Push(vec3(0.f, 0.f, 0.f), 45.f, 100.f, 0.f);
        }

        for (int i = 0; i < m_nodes.Count(); i++)
        {
            /* The current node is dragged by the previous one */
            vec3 new_delta = m_nodes[i].m1 - deltapos;
            float new_distance = length(new_delta);
            if (new_distance > 12.f)
            {
                new_delta /= new_distance;
                new_distance = std::max(12.f, new_distance - seconds * 80.f);
                new_delta *= new_distance;
            }
            deltapos = new_delta + deltapos - m_nodes[i].m1;
            m_nodes[i].m1 = new_delta;

            /* If the current node is not the tail, rotate */
            if (i != m_nodes.Count() - 1)
                m_nodes[i].m2 += seconds * ((i & 1) ? 200.f : -200.f);

            /* Apply damage */
            float damage = std::min(m_nodes[i].m4, 80.f * seconds);
            m_nodes[i].m3 -= damage;
            m_nodes[i].m4 -= damage;
        }
    }

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

        if (!m_ready)
        {
            m_head.SendCommand("irb");
            m_body.SendCommand("irb");
            m_tail.SendCommand("irb");
            m_ready = true;
        }

        vec3 pos = m_position;
        quat rot = m_rotation;
        float y_angle = 0.f;
        mat4 model = mat4::translate(pos) * mat4(rot);
        m_head.Render(model);

        for (int i = 0; i < m_nodes.Count(); i++)
        {
            pos += m_nodes[i].m1;
            y_angle = (180.f / M_PI) * atan2(m_nodes[i].m1.x, m_nodes[i].m1.z);
            rot = quat::rotate(y_angle, 0.f, 1.f, 0.f)
                * quat::rotate(m_nodes[i].m2, 0.f, 0.f, 1.f);
            model = mat4::translate(pos) * mat4(rot);
            if (i != m_nodes.Count() - 1 && m_nodes[i].m4)
                m_body.Render(model, sin(2.f * m_nodes[i].m3) * .5f + .5f);
            else if (i != m_nodes.Count() - 1)
                m_body.Render(model);
            else
                m_tail.Render(model);
        }
    }

private:
    Mesh m_head, m_body, m_tail;
    float m_steer;
    /* List of nodes (position, self-rotation angle, life, damage) */
    Array<vec3, float, float, float> m_nodes;
    /* Test */
    Stick *m_stick;
    bool m_ready;
};

#endif /* __SNAKE_H__ */