Web alhem.net

Robot.cpp

Go to the documentation of this file.

//#include <stdio.h>

#include <Base64.h>
#include "Robot.h"


Robot::Robot(Map& m,const std::string& xmlfile) : MapObject(m)
,m_config(xmlfile)
,m_code(NULL)
,m_life(*this)
,m_radar(*this)
,m_turret(*this)
,m_gun(*this)
,m_shields(*this)
,m_power_level(0)
,m_max_power_level(10000)
,m_charge_rate(1000)
,m_current_heading(0)
,m_set_heading(m_current_heading)
,m_turn_rate(12)
{
        m_code = new CodeTool(m_config);
        m_code -> SetRobot( this );
}


Robot::~Robot()
{
        delete m_code;
}


void Robot::Tick(long usec)
{
        // Robot: charge
        {
                double x = (usec * m_charge_rate) / 1000000;
                m_power_level += x;
                if (m_power_level > m_max_power_level)
                        m_power_level = m_max_power_level;
        }
        // Robot: turn
        {
                double diff_cw = m_set_heading - m_current_heading;
                if (diff_cw < 0)
                        diff_cw += 360;
                if (diff_cw >= 0.1 && diff_cw <= 180)
                {
                        // cw turn
                        double angl = (usec * m_turn_rate) / 1000000; // 12 degrees/sec
                        angl = (angl < diff_cw) ? angl : diff_cw;
                        double powr = (angl * 550) / m_turn_rate; // 550 power units / 12 degrees
                        // ...
                        if (UsePower(powr))
                        {
                                m_current_heading += angl;
                                if (m_current_heading >= 360)
                                        m_current_heading -= 360;
                                double diff = m_current_heading - m_set_heading;
                                if (diff < 0)
                                        diff *= -1;
                                if (diff < 0.1)
                                {
                                        Call( "OnTurnComplete" );
                                }
                        }
                }
                else
                if (diff_cw >= 0.1)
                {
                        // ccw turn
                        double diff_ccw = m_current_heading - m_set_heading;
                        if (diff_ccw < 0)
                                diff_ccw += 360;
                        double angl = (usec * m_turn_rate) / 1000000; // 12 degrees/sec
                        angl = (angl < diff_ccw) ? angl : diff_ccw;
                        double powr = (angl * 550) / m_turn_rate; // 550 power units / 12 degrees
                        // ...
                        if (UsePower(powr))
                        {
                                m_current_heading -= angl;
                                if (m_current_heading < 0)
                                        m_current_heading += 360;
                                double diff = m_current_heading - m_set_heading;
                                if (diff < 0)
                                        diff *= -1;
                                if (diff < 0.1)
                                {
                                        Call( "OnTurnComplete" );
                                }
                        }
                }
        }

        // Robot parts Tick
        m_shields.Tick( usec );
        m_radar.Tick( usec );
        m_turret.Tick( usec );
        m_gun.Tick( usec );
        m_life.Tick( usec );
}


void Robot::AddObject(MapObject *p)
{
        m_inventory.push_back(p);
}


bool Robot::UsePower(double units)
{
        if (m_power_level < units)
        {
                Call( "OnOutOfPower" );
                return false;
        }
        m_power_level -= units;
        return true;
}


void Robot::Call(const std::string& method)
{
        m_code -> Call( method );
}


long Robot::get_property(int prop)
{
        switch (prop)
        {
        case 1: // ok
                return m_life.Ok();
        case 2: // damage
                return m_life.GetDamage();
        case 3: // repair_rate
                return m_life.GetRepairRate();
        case 4: // inventory
                break;
        case 5: // power 0 .. 100 %
                return (int)((100 * m_power_level) / m_max_power_level);
        case 6: // charging
                return (m_power_level < m_max_power_level) ? true : false;
        }
        return 0;
}


void Robot::set_property(int prop,long value)
{
        switch (prop)
        {
        case 1: // ok
                break;
        case 2: // damage
                break;
        case 3: // repair_rate
                m_life.SetRepairRate(value);
                break;
        }
}


long Robot::call_method(int method,stack_v&)
{
}


long Robot::get_property(const std::string& prop)
{
}

---

Page, code, and content Copyright (C) 2004 by Anders Hedström