#include <iostream>
#include <graphics.h>
#include <stdio.h>
#include <conio.h>
#include <vector>
#include <string>
using namespace std;

int idx_player_anim = 0;
const int player_anim_num = 6;//这里要把动画帧数定位const int才能放入数组括号中，int不行
IMAGE img_player_left[player_anim_num];
IMAGE img_player_right[player_anim_num];
POINT player_pos = { 500,500 };
int player_speed = 10;

#pragma comment(lib,"MSIMG32.LIB")//putimage不能处理透明度，要弄个能处理透明度的putimage函数
inline void putimage_alpha(int x, int y, IMAGE* img)
{
    int w = img->getwidth();
    int h = img->getheight();
    AlphaBlend(GetImageHDC(NULL), x, y, w, h, GetImageHDC(img), 0, 0, w, h, { AC_SRC_OVER,0,255,AC_SRC_ALPHA });
}

class Animation
{
public:
    Animation(LPCTSTR path, int num, int interval)//构造函数实现loadimage
    {
        interval_ms = interval;

        TCHAR path_file[256];
        for (size_t i = 0; i < num; i++)
        {
            _stprintf_s(path_file, path, i);
            IMAGE* frame = new IMAGE();
            loadimage(frame, path_file);
            frame_list.push_back(frame);
        }
    }
    ~Animation()
    {
        for (size_t i = 0; i < frame_list.size(); i++)
            delete frame_list[i];
    }
    void play(int x, int y, int delta)//实现putiamge
    {
        timer += delta;
        if (timer > interval_ms)
        {
            idx_frame = (idx_frame + 1) % player_anim_num;
            timer = 0;
        }
        putimage_alpha(x, y, frame_list[idx_frame]);
    }
private:
    int timer = 0;
    int idx_frame = 0;
    int interval_ms = 0;
    vector<IMAGE*> frame_list;
};//别漏;
Animation anim_left_player(_T("img/player_left_%d.png"), 6, 45);
Animation anim_right_player(_T("img/player_right_%d.png"), 6, 45);

int main()
{
    initgraph(1280, 720);
    IMAGE img_background;
    loadimage(&img_background, _T("img/background.png"));
    

    bool running = true;
    bool is_up = false;
    bool is_down = false;
    bool is_left = false;
    bool is_right = false;
    bool turn_left = true;
    bool turn_right = false;

    ExMessage msg;
    BeginBatchDraw();
    while (running)
    {
        DWORD start_time = GetTickCount();
        while (peekmessage(&msg))
        {
            if (msg.message == WM_KEYDOWN)
            {
                switch (msg.vkcode)
                {
                case VK_UP:
                    is_up = true;
                    break;
                case VK_DOWN:
                    is_down = true;
                    break;
                case VK_LEFT:
                    is_left = true;
                    turn_left = true;
                    turn_right = false;
                    break;
                case VK_RIGHT:
                    is_right = true;
                    turn_left = false;
                    turn_right = true;
                    break;
                }
            }
            if (msg.message == WM_KEYUP)
            {
                switch (msg.vkcode)
                {
                case VK_UP:
                    is_up = false;
                    break;
                case VK_DOWN:
                    is_down = false;
                    break;
                case VK_LEFT:
                    is_left = false;
                    break;
                case VK_RIGHT:
                    is_right = false;
                    break;
                }
            }
        }
        if (is_up) player_pos.y -= player_speed;
        if (is_down) player_pos.y += player_speed;
        if (is_left) player_pos.x -= player_speed;
        if (is_right) player_pos.x += player_speed;

        cleardevice();

        static int counter = 0;
        if (++counter % 5 == 0)
            idx_player_anim++;
        idx_player_anim = idx_player_anim % player_anim_num;
        putimage_alpha(0, 0, &img_background);
        if(turn_left) anim_left_player.play(player_pos.x, player_pos.y, 10);
        if(turn_right)anim_right_player.play(player_pos.x, player_pos.y, 10);
        

        FlushBatchDraw();

        DWORD end_time = GetTickCount();
        DWORD delta_time = end_time - start_time;
        if (delta_time < 1000 / 144)
        {
            Sleep(1000 / 144 - delta_time);
        }
    }
    EndBatchDraw();

    return 0;
}