root/lang/cplusplus/hebilife/snake.cpp @ 16006

#include <iostream>

using namespace std;


#include "field.h"
#include "snake.h"


Snake::Snake(int _id, Field *_field)
        : id(_id),
        field(_field),
        is_dead(false)
{

        // ����������   int r = field->random(4);
        switch ( r )
        {
                case 0:
                        direction_x = 0;
                        direction_y = 1;
                        break;
                case 1:
                        direction_x = 1;
                        direction_y = 0;
                        break;
                case 2:
                        direction_x = 0;
                        direction_y = -1;
                        break;
                case 3:
                        direction_x = -1;
                        direction_y = 0;
                        break;
                default:
                        break;
        }

        // ��W�̏���     length = field->random(field->LENGTH_MAX-1) + 1;
        body_x[0] = field->random(field->size_x-length);
        body_y[0] = field->random(field->size_y-length);
        for ( int i = 1 ; i < length ; i ++ )
        {
                body_x[i] = body_x[i-1] - direction_x;
                body_y[i] = body_y[i-1] - direction_y;
        }
        for ( int i = length ; i < 100 ; i ++ )
        {
                body_x[i] = -1;
                body_y[i] = -1;
        }
}

// ������Ƃ��Ďւ𐶐�
Snake::Snake(int _id, Field *_field, Snake *s)
        : id(_id),
        field(_field),
        is_dead(false)
{
        length = s->length / 2;
        for ( int i = 0 ; i < length ; i ++ )
        {
                body_x[i] = s->pre_body_x[i + length];
                body_y[i] = s->pre_body_y[i + length];
                pre_body_x[i] = body_x[i];
                pre_body_y[i] = body_y[i];
        }
        for ( int i = length ; i < 100 ; i ++ )
        {
                body_x[i] = -1;
                body_y[i] = -1;
        }

        // ����������   direction_x = s->pre_body_x[length - 1] - s->pre_body_x[length];
        direction_y = s->pre_body_y[length - 1] - s->pre_body_y[length];

        brain.copy(&s->brain);
}

// step�����Ɉ��q�ɂ��s����肵�A���ɍs������void Snake::pre_move()
{
        if ( is_dead )
                return;

        // body��_body�ɃR�s�[
        for ( int i = 0 ; i < length ; i ++ )
        {
                pre_body_x[i] = body_x[i];
                pre_body_y[i] = body_y[i];
        }

        // ����������   int x = body_x[0];
        int y = body_y[0];
        int input[NN::N_NEURON];

        // ������ėV�ԏꏊ
//    input[0] = field->getHazard(x+direction_y,y-direction_x+direction_y) ? 1 : 0;
//    input[1] = field->getHazard(x+direction_y,y+direction_x+direction_y) ? 1 : 0;
        input[0] = field->getHazard(x+direction_y,y-direction_x) ? 1 : 0;
        input[1] = field->getHazard(x+direction_x*3,y+direction_y*3) ? 1 : 0;
        input[2] = field->getHazard(x+direction_y,y+direction_x) ? 1 : 0;
//    input[3] = field->getHazard(x+direction_x,y+direction_y*2) ? 1 : 0;
//    input[4] = field->getHazard(x+direction_x,y+direction_y*3) ? 1 : 0;
        int output = brain.input_and_output(input);

        if ( output == 1 )
        {
                int temp = direction_x;
                direction_x = direction_y;
                direction_y = - temp;
        }
        else if ( output == 2 )
        {
                int temp = direction_x;
                direction_x = - direction_y;
                direction_y = temp;
        }

        // �����_���ɓ���
//    if ( field->random(10) == 0 )
//    {
//        int r = field->random(4);
//        switch ( r )
//        {
//            case 0:
//                if ( direction_x == 0 && direction_y == -1 )
//                    break;
//                direction_x = 0;
//                direction_y = 1;
//                break;
//            case 1:
//                if ( direction_x == -1 && direction_y == 0 )
//                    break;
//                direction_x = 1;
//                direction_y = 0;
//                break;
//            case 2:
//                if ( direction_x == 0 && direction_y == 1 )
//                    break;
//                direction_x = 0;
//                direction_y = -1;
//                break;
//            case 3:
//                if ( direction_x == 1 && direction_y == 0 )
//                    break;
//                direction_x = -1;
//                direction_y = 0;
//                break;
//            default:
//                break;
//        }
//    }

        // ���̕�����
        for ( int i = length ; i > 0 ; i -- )
        {
                pre_body_x[i] = pre_body_x[i-1];
                pre_body_y[i] = pre_body_y[i-1];
        }
        pre_body_x[0] += direction_x;
        pre_body_y[0] += direction_y;

        // wrap
        // �[�̓��b�v����        if ( pre_body_x[0] == -1 )
                pre_body_x[0] = field->size_x - 1;
        if ( pre_body_y[0] == -1 )
                pre_body_y[0] = field->size_y - 1;
        if ( pre_body_x[0] == field->size_x )
                pre_body_x[0] = 0;
        if ( pre_body_y[0] == field->size_y )
                pre_body_y[0] = 0;

//    if ( output == 3 && length >= field->length_max )
//        segmentation();
}

void Snake::step()
{
        if ( is_dead )
                return;

        if ( field->isDead(id) )
        {
                die();
                return;
        }
        else if ( field->canEat(id) )
        {
                eat();
                if ( length >= Field::LENGTH_MAX )
                        segmentation();
        }
        move();
}

// pre_move �Ō��肵���s����ۂɍs��
void Snake::move()
{
        if ( is_dead )
                return;

        for ( int i = 0 ; i < length ; i ++ )
        {
                body_x[i] = pre_body_x[i];
                body_y[i] = pre_body_y[i];
        }
}

void Snake::die()
{
        is_dead = true;

        for ( int i = 0 ; i < length; i ++ )
        {
                field->foods[body_x[i]][body_y[i]] = true;
        }
}

void Snake::eat()
{
        length++;
        if ( length == 100 )
                length --;
        field->foods[pre_body_x[0]][pre_body_y[0]] = false;
}

// ����oid Snake::segmentation()
{
        field->makeSnake(this);
        length /= 2;
}