source: trunk/orbital/snake.h @ 1510 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.Compile("sc#d91"
                           "[afcb30 3 3 .8]"
                           "sc#cca"
                           "[afcb10 10 10 1]"
                           "[afcb.4 .4 12 .4 tz3 tx8 mx]"
                           "[afcb.4 .4 12 .4 tz3 tx12 mx]"
                           "sc#69c9"
                           "[afcb5 8 8 1 ty3 tz3]");

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

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

        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 += 4.f * seconds;

        /* Destruction test */
        if (!m_stick)
            m_stick = Input::TrackStick();
        bool fire = m_stick && m_stick->GetButtonCount() >= 12
                            && 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((float)m_nodes.Count() - 2.0f);
            m_nodes[tohit].m4 += 150.f;
            m_nodes[tohit + 1].m4 += 150.f;
        }

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

        m_velocity = 120.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 = (float)length(new_delta);
            if (new_distance > 12.f)
            {
                new_delta /= new_distance;
                new_distance = std::max(12.f, new_distance - seconds * 160.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.MeshConvert();
            m_body.MeshConvert();
            m_tail.MeshConvert();
            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 / (float)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:
    EasyMesh 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__ */