Tôi đang cố gắng tạo bản sao Snake bằng C++ và OpenGL/GLUT. Tuy nhiên, tôi gặp sự cố khi lập trình để cho phép khoảng thời gian ngắn giữa các Hành động đầu vào. Tôi đã thử một số phương pháp tính thời gian và cuối cùng tôi đã tạo được một lớp cho nó (hiển thị bên dưới). Đây có vẻ là cách tốt nhất để lập trình độ trễ đầu vào (thay vì glutTimerFunc() hoặc sleep()), vì bộ hẹn giờ chạy độc lập với vòng lặp trò chơi, thay vì tạm dừng toàn bộ chương trình. Điều này rất quan trọng vì tôi muốn người chơi có thể tạm dừng bất cứ lúc nào. Thật không may, hiện tại tôi cũng đang gặp vấn đề với cách tiếp cận này. Lớp hẹn giờ của tôi dường như bỏ qua giới hạn thời gian gấp đôi mà tôi đưa ra (được biểu thị đơn giản là gấp đôi "giới hạn").

Để kiểm tra lớp này, tôi thiết lập một chương trình bảng điều khiển lặp đơn giản hiển thị đầu vào được chỉ đạo từ người dùng khi bộ hẹn giờ đạt đến giới hạn thời gian. Nó sẽ hiển thị đầu vào cứ sau 0,33 giây. Thay vào đó, nó hiển thị đầu vào ở các khoảng thời gian cố định khoảng 0,8 giây, bất kể giá trị của giới hạn thời gian. Tại sao nó không hiển thị dữ liệu đầu vào ở một khoảng thời gian nhất định và tại sao nó lại có giới hạn thời gian riêng?

Đây cũng là dự án C++/OpenGL lớn đầu tiên của tôi mà không có hướng dẫn, vì vậy mọi nhận xét hoặc đề xuất về mã/cách tiếp cận của tôi đều được hoan nghênh!

#include 
#include "timer.h"
// Bao gồm tất cả các file cần thiết cho OpenGL/GLUT tại đây.

using namespace std;

Hẹn giờ hẹn giờ;

// Chèn mã OpenGL/GLUT cần thiết để hiển thị/lặp lại ở đây.

cập nhật void(giá trị int)
{
    nếu (timer.checkTime())
    {
        nếu (GetAsyncKeyState(VK_LEFT))
            cout << "Bạn đã nhấn TRÁI!" << endl;
        nếu không thì (GetAsyncKeyState(VK_RIGHT))
            cout << "Bạn đã nhấn PHẢI!" << endl;
        nếu không thì (GetAsyncKeyState(VK_UP))
            cout << "Bạn đã nhấn LÊN!" << endl;
        nếu không thì (GetAsyncKeyState(VK_DOWN))
            cout << "Bạn đã nhấn DOWN!" << endl;
    }

    glutTimerFunc(1000/60, cập nhật, 0);
    glutPostRedisplay();
}

hẹn giờ.h

#pragma một lần
#include 

lớp học hẹn giờ
{
public:
    Hẹn giờ();
    bool checkTime(giới hạn kép = 0,33);
private:
    nhân đôi getElapsed();
    thời gian_t bắt đầu;
    time_t bây giờ;
    gấp đôi trôi qua;
    chạy bool;
};

hẹn giờ.cpp

#include "timer.h"

Bộ hẹn giờ::Bộ hẹn giờ()
{
    đang chạy = sai;
}

bool Hẹn giờ::checkTime (giới hạn gấp đôi)
{
    đã trôi qua = getElapsed();

    nếu (đã trôi qua < giới hạn)
    {
        trả về sai;
    }
    khác nếu (đã trôi qua >= giới hạn)
    {
        đang chạy = sai;
        trả về đúng sự thật;
    }
}

Bộ hẹn giờ kép::getElapsed()
{
    nếu (! đang chạy)
    {
        thời gian(&bắt đầu);
        đang chạy = đúng;
        trả về 0,00;
    }
    khác
    {
        thời gian(&bây giờ);
        trả về thời gian khác biệt (bây giờ, bắt đầu);
    }
}

câu trả lời hay nhất

glutTimer kích hoạt cứ sau 1000/60 mili giây, bạn kiểm tra Time::checkTime, gọi getElapsed. Tất cả các hàm thời gian của bạn được xác định gấp đôi, nhưng bạn đang sử dụng time_t, chỉ có độ phân giải 1 giây.

Vì vậy, bạn sẽ nhận được một cái gì đó trông như thế này (kỹ thuật số tương tự)

thời gian bắt đầu: 1234,5 giây
glutTimer: 1234,516 giây (getElapsed = 0) // checkTime trả về false
glutTimer: 1234,532 giây (getElapsed = 0)
...
glutTimer: 1234,596 giây (getElapsed = 0)
glutTimer: 1235.012 giây (getElapsed = 1) // điều kiện cuối cùng trả về true
...

Vì vậy, độ trễ thực tế phụ thuộc vào thời điểm bạn đặt thời gian bắt đầu so với thời gian bắt đầu thực tế là một giây kể từ kỷ nguyên được sử dụng bởi time();

Tôi nghi ngờ nếu bạn đo lường theo thống kê, thời gian trung bình sẽ gần hơn 0,5 giây.

Trả lời câu hỏi về “Giải pháp”:

Các hàm khác nhau trả về thời gian hiện tại sẽ trả về mức độ chính xác khác nhau. Ví dụ: ngay bây giờ, đồng hồ ở góc dưới bên phải màn hình của tôi ghi "12:14 PM". Chính xác là 12:14 không có giây hay là 12:14 cộng 59 giây? Tôi không thể biết vì "độ phân giải" của màn hình đồng hồ là một phút. Tương tự như vậy, tôi có thể nói bây giờ là 12 giờ 15, nhưng nếu tôi báo thời gian với độ phân giải "một phần tư giờ" thì thực tế là 14 phút trôi qua. Là con người, chúng ta luôn làm điều này mà không cần suy nghĩ. Trong phần mềm, bạn phải chú ý đến những chi tiết này khi gọi bất kỳ chức năng nào.

Nếu đang sử dụng Windows, bạn có thể nhận bộ hẹn giờ có độ phân giải cao thông qua API QueryPerformanceCounter. Trên hầu hết các nền tảng, bộ đếm hiệu suất đều dựa trên phần cứng với độ phân giải trong phạm vi micro giây.

Đây là một ví dụ về cách gọi nó:http://msdn.microsoft.com/en-us/library/windows/desktop/dn553408(v=vs.85).aspx#examples_for_acquiring_time_stamps

LARGE_INTEGER Thời gian bắt đầu, Thời gian kết thúc, Micro giây đã trôi qua;
Tần số LARGE_INTEGER;

QueryPerformanceFrequency(&Frequency); // lấy số lượng tích tắc mỗi giây
QueryPerformanceCounter(&StartingTime); // lấy số tích tắc bắt đầu

// Hoạt động được tính thời gian

QueryPerformanceCounter(&EndingTime); // lấy số lượng dấu tích kết thúc
ElapsedMicroseconds.QuadPart = Thời gian kết thúc.QuadPart - Thời gian bắt đầu.QuadPart;


//
// Bây giờ chúng ta có số lượng tích tắc đã trôi qua, cùng với
// số lượng tích tắc mỗi giây Chúng tôi sử dụng các giá trị này.
// để chuyển đổi thành số micro giây đã trôi qua.
// Để tránh mất độ chính xác, chúng tôi chuyển đổi
// đến micro giây *trước* chia cho tích tắc mỗi giây.
//

Đã trôi quaMicroseconds.QuadPart *= 1000000;
ElapsedMicroseconds.QuadPart /= Tần số.QuadPart;

Có thể có những công cụ tương tự trên Linux nhưng tôi không quen với chúng.

Hãy thử điều này:

cập nhật void(giá trị int)
{
    nếu (timer.hasTicked())
    {
        nếu (GetAsyncKeyState(VK_LEFT))
            cout << "Bạn đã nhấn TRÁI!" << endl;
        nếu không thì (GetAsyncKeyState(VK_RIGHT))
            cout << "Bạn đã nhấn PHẢI!" << endl;
        nếu không thì (GetAsyncKeyState(VK_UP))
            cout << "Bạn đã nhấn LÊN!" << endl;
        nếu không thì (GetAsyncKeyState(VK_DOWN))
            cout << "Bạn đã nhấn DOWN!" << endl;
    }
    khác nếu (!timer.isRunning())
    {
       bộ đếm thời gian.start();
    }

    glutTimerFunc(1000/60, cập nhật, 0);
    glutPostRedisplay();
}

hẹn giờ.h

// lớp này cung cấp một bộ đếm thời gian có thể được thăm dò và sẽ cho phép người dùng biết liệu một khoảng thời gian đã trôi qua hay chưa.
// lưu ý rằng bộ hẹn giờ này KHÔNG gửi bất kỳ sự kiện nào khi hết thời gian chờ.
lớpPollTimer
{
public:
    PollTimer();

    // giả sử giới hạn thời gian là một số mili giây và vừa với một số nguyên bình thường thay vì 64 bit  
    // biến thể (đó sẽ là độ trễ DÀI).
    void setTimeout(int msDelay);

    // Bộ định thời thường hiển thị tính năng bắt đầu/dừng và nói chung không nên tạo một chức năng duy nhất 
    // làm quá tải các tổ hợp hành vi phức tạp như ở đây cả hoạt động bắt đầu và hoạt động đã trôi qua.
    // thừa nhận đây là một trường hợp đơn giản, nhưng nhìn chung nó là một mẫu thiết kế tồi dẫn đến “ác”.
    bắt đầu vô hiệu();
    làm mất hiệu lực dừng();
    bool isRunning();

    // Bộ đếm thời gian đã hết hạn kể từ lần thăm dò cuối cùng chưa
    bool hasTicked();

private:
    LARGE_INTEGER Thời gian bắt đầu;
    tần số LARGE_INTEGER; // mỗi giây
    độ trễ int; // tính bằng mili giây
    chạy bool;
};

hẹn giờ.cpp

#include "timer.h"

PollTimer::PollTimer()
{
    // bỏ qua việc kiểm tra lỗi đối với phần cứng không hỗ trợ điều này.
    QueryPerformanceFrequency(& Frequency); // lấy số lượng tích tắc mỗi giây
    đang chạy = sai;
}

void PollTimer::setTimeout(int msDelay)
{
     độ trễ = msDelay;
}

void PollTimer::start()
{
    QueryPerformanceCounter(&startTime);
    đang chạy = đúng;
}

void PollTimer::stop()
{
    đang chạy = sai;
}

bool PollTimer::isRunning()
{
    chạy trở lại;
}

bool PollTimer::hasTicked()
{
    nếu (!đang chạy)
        trả về sai;

    LARGE_INTEGER bây giờ;
    QueryPerformanceCounter(&now);

    LARGE_INTEGER Đã trôi quaMili giây;
    Đã trôi quaMilli giây.QuadPart = now.QuadPart - startTime.QuadPart;

    Đã trôi quaMilli giây.QuadPart *= 1000000;
    Đã trôi quaMilliseconds.QuadPart /= tần số.QuadPart // bây giờ là micro giây;
    Đã trôi quaMilliseconds.QuadPart /= 1000; // mili giây

    bool fExpired = ( ElapsedMilliseconds.HighPart > 0 || ElapsedMilliseconds.LowPart >= delay ) ; 
    nếu(fĐã hết hạn)
    {
        // đặt lại thời gian bắt đầu
        start(); // không sao chép/dán mã bạn có thể gọi.
    }
    trả lại fĐã hết hạn;
}

Về nhân bản rắn C++: chức năng hẹn giờ bỏ qua thời gian dừng nhất định và dừng tại thời điểm cố định của chính nó, chúng tôi đã tìm thấy một câu hỏi tương tự trên Stack Overflow: https://stackoverflow.com/questions/24846663/