POJ2729 Robocode（离散化与模拟-----提醒曾经爱玩游戏的自己没做出这个

题目链接 ：http://poj.org/problem?id=2729

题目很长，有不少也是废话。类似小时候玩的坦克大战。每个坦克速度为10，炮弹速度为20.子弹出界就消失，坦克出不了界限。相向的子弹碰撞不会消失（区别与小时候的游戏，炮弹可以抵消）。 

坦克可以90转向...不少条件题目中仔细读可以知道。

在这里需要注意的是，由于炮弹速度和坦克移动的速度不一致，导致对于一个时间单位，坦克与子弹在坐标上的处理挺困难。因为如果子弹在最左小角，向右边发射，坦克刚好在子弹右边一个单位，而坦克正好向左边运动，那么它们的碰撞点将会在一个距离单位的中间偏右2/3处，碰撞时间为1/3个单位时间;还有。如果坦克不动，则碰撞时间为1/2;因此我们取二者最大公约数1/6为时间单位。这样处理适合碰撞时间和地点。

因此，120的长度将扩大为720,相当于原来的每一格变成了6小格。坦克每6个时间单位走6格，即原来的一个时间单位走一格。

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
using namespace std;

struct Spirit // 坦克和子弹都从这个类派生
{
    int x, y; // 位置
    int face; // 前进方向
};
struct Bullet : public Spirit // 子弹类
{

};
struct Tank : public Spirit // 坦克类
{
    string name; // 坦克名称
    bool move; // 标记坦克是移动还是静止
    Bullet CreateBullet(); // 坦克发射一枚子弹
};
Bullet Tank::CreateBullet() // 坦克发射一枚子弹，刚发射的时候子弹的位置和前进方向和坦克是一样的
{
    Bullet b;
    b.x = x;
    b.y = y;
    b.face = face;
    return b;
}

struct Command // 命令类
{
    int time; // 执行时刻
    string name; // 相应的坦克
    string type; // 命令类型
    int angle; // 如果是转向，标记转了多少度
};

class Robocode // 解题类
{
protected:
    const int h; // 地图高度（离散化之后）
    const int w; // 地图宽度（离散化之后）
    int n; // 坦克数量
    int m; // 指令数量
    vector<Tank> tanks; // 坦克集合向量
    vector<Bullet> bullets; // 子弹集合向量
    vector<Command> commands; // 命令集合向量
    int** tankmap; // tankmap[i][j]表示第i行第j列的坦克在对应的向量中的下标，如果是-1则表示第i行第j列没有坦克
    int** bulletmap; // bulletmap[i][j]表示第i行第j列有没有子弹，如是是1表示第i行第j列有子弹，如果是-1则表示第i行第j列没有子弹
    // void InitBullet();
    void Explode(); // 检查子弹会不会击中坦克，以及击中后的处理
    void ExcuteCmd(const Command& cmd); // 执行命令cmd
    void UpdateBullet(); // 更新子弹集合在某一时刻的位置信息
    void UpdateTank(); // 更新坦克集合在某一时刻的位置信息
public:
    Robocode(int n, int m, const vector<Tank>& tanks, const vector<Command>& commands); // 构造方法
    ~Robocode(); // 析构方法
    void Run(); // 模拟过程
    void Output() const; //输出结果
};

Robocode::Robocode(int n, int m, const vector<Tank>& tanks, const vector<Command>& commands) 
    :h(12 * 6 + 1), w(12 * 6 + 1) // 注意高度和宽度做离散化处理，要乘上6（想想为什么）
{
    this->n = n;
    this->m = m;
    this->tanks.reserve(n);
    this->commands.reserve(m);
    tankmap = new int*[h];
    for (int i = 0; i < h; i++)
    {
        tankmap[i] = new int[w];
    }
    bulletmap = new int*[h];
    for (int i = 0; i < h; i++)
    {
        bulletmap[i] = new int[w];
    }
    this->tanks.assign(tanks.begin(), tanks.end());
    this->commands.assign(commands.begin(), commands.end());
    for (int i = 0; i < h; i++)
    {
        for (int j = 0; j < w; j++)
        {
            tankmap[i][j] = -1;
        }
    }
    for (int i = 0; i < h; i++)
    {
        for (int j = 0; j < w; j++)
        {
            bulletmap[i][j] = -1;
        }
    }
    // 对坦克的位置信息进行离散化处理
    for (unsigned int i = 0; i < this->tanks.size(); i++)
    {
        this->tanks[i].x = (this->tanks[i].x / 10) * 6;
        this->tanks[i].y = (this->tanks[i].y / 10) * 6;
        this->tanks[i].move = false;
        tankmap[this->tanks[i].x][this->tanks[i].y] = i;
    }
    // 对时间进行离散化处理
    for (unsigned int i = 0; i < this->commands.size(); i++)
    {
        this->commands[i].time *= 6;
    }
}
Robocode::~Robocode()
{
    for (int i = 0; i < h; i++)
    {
        delete[] tankmap[i];
    }
    delete[] tankmap;
    for (int i = 0; i < h; i++)
    {
        delete[] bulletmap[i];
    }
    delete[] bulletmap;
}
//void Robocode::InitBullet()
//{
//    for (int i = 0; i < h; i++)
//    {
//        for (int j = 0; j < w; j++)
//        {
//            bulletmap[i][j] = -1;
//        }
//    }
//    for (unsigned int i = 0; i < bullets.size(); i++)
//    {
//        bulletmap[bullets[i].x][bullets[i].y] = 1;
//    }
//}

// 判断有没有出现子弹打中坦克的情况，如果出现，进行处理
void Robocode::Explode()
{
    for (int i = 0; i < h; i++)
    {
        for (int j = 0; j < w; j++)
        {
            if (bulletmap[i][j] > -1 && tankmap[i][j] > -1) //离散化后的第i行第j列发生了子弹和坦克碰撞
            {
                for (unsigned int k = 0; k < bullets.size();) // 遍历子弹，注意for语句的表达式3空缺，不可直接写k++
                {
                    if (bullets[k].x == i && bullets[k].y == j) // 注意这里如果多个子弹和一辆坦克碰撞，都统统消失
                    {
                        bullets.erase(bullets.begin() + k); // 删除对应的子弹
                    }
                    else
                    {
                        k++;
                    }
                }
                bulletmap[i][j] = -1;  // 标记离散化后的第i行第j列已经没有子弹
                for (unsigned int k = 0; k < tanks.size();) // 遍历坦克，注意for语句的表达式3空缺，不可直接写k++
                {
                    if (tanks[k].x == i && tanks[k].y == j) // 注意这里如果多辆坦克和一个子弹碰撞，都统统消失
                    {
                        tanks.erase(tanks.begin() + k); // 删除对应的坦克
                    }
                    else
                    {
                        k++;
                    }
                }
                tankmap[i][j] = -1; // 标记离散化后的第i行第j列已经没有坦克
            }
        }
    }
}

// 执行命令cmd
void Robocode::ExcuteCmd(const Command& cmd)
{
    for (unsigned int i = 0; i < tanks.size(); i++)
    {
        if (cmd.name == tanks[i].name)
        {
            if (cmd.type == "MOVE") // 坦克移动，设置相应标志即可
            {
                tanks[i].move = true;
            }
            else if (cmd.type == "STOP") // 坦克停止，设置相应标志即可
            {
                tanks[i].move = false;
            }
            else if (cmd.type == "TURN") // 坦克转向处理，注意取模
            {
                tanks[i].face = (tanks[i].face + cmd.angle + 360) % 360;
            }
            else if (cmd.type == "SHOOT") // 大炮开兮轰他娘（张宗昌）
            {
                Bullet b = tanks[i].CreateBullet(); // 坦克产生子弹
                bullets.push_back(b); // 更新子弹向量
                bulletmap[b.x][b.y] = bullets.size() - 1; // 标记对应的行列位置有子弹，设置子弹的下标
            }
        }
    }
}

// 更新离散化后的某个时刻的子弹的位置信息
void Robocode::UpdateBullet()
{
    for (unsigned int i = 0; i < bullets.size(); )
    {
        // 反正子弹在消失以前总是飞的，所以上一时刻子弹i出现的位置和这一时刻子弹i出现的位置必定不一样，先把原先位置标记没有子弹
        bulletmap[bullets[i].x][bullets[i].y] = -1; 
        switch (bullets[i].face) // 根据子弹的前进方向判断子弹在这一时刻的位置
        {
        case 0:
            bullets[i].x += 2; // 注意离散化后，子弹每次移动2个单位
            if (bullets[i].x > w - 1) // 子弹向右飞出了区域，应从战场消失
            {
                bullets.erase(bullets.begin() + i);
            }
            else
            {
                bulletmap[bullets[i].x][bullets[i].y] = i; // 子弹向右到了下一个位置，更新相应的信息
                i++;
            }
            break;
        case 90:
            bullets[i].y += 2; // 注意离散化后，子弹每次移动2个单位
            if (bullets[i].y > h  - 1) // 子弹向下飞出了区域，应从战场消失
            {
                bullets.erase(bullets.begin() + i);
            }
            else
            {
                bulletmap[bullets[i].x][bullets[i].y] = i; // 子弹向下到了下一个位置，更新相应的信息
                i++;
            }
            break;
        case 180:
            bullets[i].x -= 2; // 注意离散化后，子弹每次移动2个单位
            if (bullets[i].x < 0) // 子弹向左飞出了区域，应从战场消失
            {
                bullets.erase(bullets.begin() + i);
            }
            else
            {
                bulletmap[bullets[i].x][bullets[i].y] = i; // 子弹向左到了下一个位置，更新相应的信息
                i++;
            }
            break;
        case 270:
            bullets[i].y -= 2; // 注意离散化后，子弹每次移动2个单位
            if (bullets[i].y < 0) // 子弹向上飞出了区域，应从战场消失
            {
                bullets.erase(bullets.begin() + i);
            }
            else
            {
                bulletmap[bullets[i].x][bullets[i].y] = i; // 子弹向上到了下一个位置，更新相应的信息
                i++;
            }
            break;
        }
    }
    //InitBullet();
}

// 更新某一时刻的坦克的位置信息
void Robocode::UpdateTank()
{
    for (unsigned int i = 0; i < tanks.size(); i++)
    {
        if (tanks[i].move) // 只处理在移动的坦克，有的坦克是静止的，不用处理
        {
            tankmap[tanks[i].x][tanks[i].y] = -1; // 移动的坦克肯定不在原先的位置了
            switch (tanks[i].face) // 根据坦克的前进方向判断坦克在这一时刻的位置
            {
            case 0: // 向右前进
                tanks[i].x += 1; // 注意离散化后，坦克每次移动1个单位
                if (tanks[i].x > w - 1) // 如果到达最右边的边界
                {
                    tanks[i].x = w - 1; // 不能穿越也不能消失，在右边界原地不动
                }
                break;
            case 90: // 向下前进
                tanks[i].y += 1; // 注意离散化后，坦克每次移动1个单位
                if (tanks[i].y > h - 1) // 如果到达最下边的边界
                {
                    tanks[i].y = h - 1; // 不能穿越也不能消失，在下边界原地不动
                }
                break;
            case 180:
                tanks[i].x -= 1; // 注意离散化后，坦克每次移动1个单位
                if (tanks[i].x < 0) // 如果到达最左边的边界
                {
                    tanks[i].x = 0; // 不能穿越也不能消失，在左边界原地不动
                }
                break;
            case 270:
                tanks[i].y -= 1; // 注意离散化后，坦克每次移动1个单位
                if (tanks[i].y < 0) // 如果到达最上边的边界
                {
                    tanks[i].y = 0; // 不能穿越也不能消失，在上边界原地不动
                }
                break;
            }
            tankmap[tanks[i].x][tanks[i].y] = i; // 在新位置标记坦克在坦克向量中的下标
        }
    }
}
void Robocode::Run()
{
    unsigned int cmdidx = 0;
    int time = 0;
    bullets.clear();
    for (int i = 0; i < h; i++)
    {
        for (int j = 0; j < w; j++)
        {
            bulletmap[i][j] = -1;
        }
    }
    while (true)
    {
        //InitBullet();
        Explode(); // 先处理这一时刻有没有子弹击中坦克的情况，why？

        //遍历命令向量，如果某个向量的执行时刻到了，就执行
        while (cmdidx < commands.size() && commands[cmdidx].time == time) 
        {
            ExcuteCmd(commands[cmdidx]);
            cmdidx++;
        }
        
        UpdateBullet(); // 更新子弹位置信息
        UpdateTank(); // 更新坦克位置信息
        //Explode();
        if (cmdidx >= commands.size()) //命令全部执行完了
        {
            if (bullets.size() > 0) // 让子弹再飞一会（姜文《让子弹飞》）
            {

            }
            else // 如果命令全部执行完了，子弹也飞完了，说明游戏结束
            {
                break;
            }
        }
        time++; // 时间单位计数器加1
    }
}

void Robocode::Output() const
{
    if (tanks.size() == 1)
    {
        cout << tanks[0].name << "\n";
    }
    else
    {
        cout << "NO WINNER!\n";
    }
}

int main()
{
    //ifstream cin("Text.txt");
    int n = 0;
    int m = 0;
    cin >> n >> m;
    while (n > 0 && m > 0)
    {
        vector<Tank> tanks;
        vector<Command> commands;
        for (int i = 0; i < n; i++)
        {
            Tank t;
            cin >> t.name >> t.x >> t.y >> t.face;
            tanks.push_back(t);
        }
        for (int i = 0; i < m; i++)
        {
            Command c;
            cin >> c.time >> c.name >> c.type;
            if (c.type == "TURN")
            {
                cin >> c.angle;
            }
            commands.push_back(c);
        }
        Robocode obj(n, m, tanks, commands);
        obj.Run();
        obj.Output();
        cin >> n >> m;
    }
    return 0;
}