#include <graphics
.h>
#include <conio
.h>
#include <vector>
#include <ctime>
#include <string>
#include <sstream>
#include <windows
.h>
#include <algorithm>
#include <atomic>
#include <thread>
#include <mmsystem
.h>
#pragma comment
(lib, "winmm
.lib"
)
using namespace std;
const int ROW = 8;
const int COL = 10;
const int BLOCK_SIZE = 80;
const int WINDOW_WIDTH = COL * BLOCK_SIZE;
const int WINDOW_HEIGHT = ROW * BLOCK_SIZE + 150;
const int COLORS[] = {RED, GREEN, BLUE, YELLOW, MAGENTA, CYAN, BROWN, LIGHTBLUE};
const int NUM_COLORS = sizeof
(COLORS
) / sizeof
(COLORS[0]
);
vector<vector<int>> grid
(ROW, vector<int>
(COL
));
atomic<int> score
(0
);
atomic<bool> exitFlag
(false
);
bool gameOver = false;
int selectedX = -1, selectedY = -1;
long long lastClickTime = 0;
const int MIN_CLICK_INTERVAL = 50;
bool isAnimating = false;
enum GameState { READY, PLAYING, TIME_UP };
GameState gameState = READY;
const int GAME_DURATION = 60;
int remainingTime = GAME_DURATION;
long long gameStartTime = 0;
int finalScore = 0;
bool isMusicPlaying = false;
const char* MUSIC_FILE = "C:\\Users\\27287\\Desktop\\devc\\ma+7\\music
.mp3"; // 使用普通字符串路径
class HighResTimer {
public:
void start
() {
QueryPerformanceCounter
(&startTime
);
}
double elapsed
() const {
LARGE_INTEGER endTime, frequency;
QueryPerformanceCounter
(&endTime
);
QueryPerformanceFrequency
(&frequency
);
return static_cast<double>
(endTime
.QuadPart - startTime
.QuadPart
) / frequency
.QuadPart;
}
private:
LARGE_INTEGER startTime;
};
void playBackgroundMusic
() {
string openCmd = "open \"" + string
(MUSIC_FILE
) + "\" type mpegvideo alias bgmusic";
mciSendString
(openCmd
.c_str
(), NULL, 0, NULL
);
mciSendString
("setaudio bgmusic volume to 500", NULL, 0, NULL
);
mciSendString
("play bgmusic repeat", NULL, 0, NULL
);
isMusicPlaying = true;
}
void stopBackgroundMusic
() {
if
(isMusicPlaying
) {
mciSendString
("stop bgmusic", NULL, 0, NULL
);
mciSendString
("close bgmusic", NULL, 0, NULL
);
isMusicPlaying = false;
}
}
string intToString
(int value
) {
stringstream ss;
ss << value;
return ss
.str
();
}
void initGrid
() {
srand
(static_cast<unsigned>
(time
(0
)));
bool hasMatches = true;
while
(hasMatches
) {
hasMatches = false;
for
(int i = 0; i < ROW; ++i
) {
for
(int j = 0; j < COL; ++j
) {
grid[i][j] = rand
() % NUM_COLORS;
}
}
for
(int i = 0; i < ROW; ++i
) {
for
(int j = 0; j < COL - 2; ++j
) {
if
(grid[i][j] == grid[i][j+1] && grid[i][j] == grid[i][j+2]
) {
hasMatches = true;
break;
}
}
if
(hasMatches
) break;
}
if
(!hasMatches
) {
for
(int j = 0; j < COL; ++j
) {
for
(int i = 0; i < ROW - 2; ++i
) {
if
(grid[i][j] == grid[i+1][j] && grid[i][j] == grid[i+2][j]
) {
hasMatches = true;
break;
}
}
if
(hasMatches
) break;
}
}
}
}
void resetGame
() {
score = 0;
remainingTime = GAME_DURATION;
gameOver = false;
selectedX = -1;
selectedY = -1;
isAnimating = false;
gameState = PLAYING;
// 使用QueryPerformanceCounter获取高精度时间
LARGE_INTEGER li;
QueryPerformanceCounter
(&li
);
gameStartTime = li
.QuadPart;
initGrid
();
if
(!isMusicPlaying
) {
playBackgroundMusic
();
}
}
void drawGridPartial
(int highlightX, int highlightY
) {
if
(highlightX >= 0 && highlightY >= 0
) {
int x = highlightX, y = highlightY;
setfillcolor
(BLACK
);
solidrectangle
(x * BLOCK_SIZE, y * BLOCK_SIZE,
(x + 1
) * BLOCK_SIZE,
(y + 1
) * BLOCK_SIZE
);
if
(grid[y][x] != -1
) {
setfillcolor
(COLORS[grid[y][x]]
);
solidrectangle
(x * BLOCK_SIZE, y * BLOCK_SIZE,
(x + 1
) * BLOCK_SIZE,
(y + 1
) * BLOCK_SIZE
);
setlinecolor
(BLACK
);
rectangle
(x * BLOCK_SIZE, y * BLOCK_SIZE,
(x + 1
) * BLOCK_SIZE,
(y + 1
) * BLOCK_SIZE
);
}
if
(x == selectedX && y == selectedY
) {
setlinecolor
(WHITE
);
setlinestyle(PS_SOLID, 3
);
rectangle
(x * BLOCK_SIZE + 2, y * BLOCK_SIZE + 2,
(x + 1
) * BLOCK_SIZE - 2,
(y + 1
) * BLOCK_SIZE - 2
);
setlinestyle(PS_SOLID, 1
);
}
return;
}
cleardevice
();
settextstyle
(24, 0, "Arial"
);
if
(gameState == READY
) {
settextcolor
(WHITE
);
settextstyle
(36, 0, "Arial"
);
outtextxy
(WINDOW_WIDTH/2 - 150, WINDOW_HEIGHT/2 - 60, "Block Game"
);
settextstyle
(24, 0, "Arial"
);
outtextxy
(WINDOW_WIDTH/2 - 100, WINDOW_HEIGHT/2, "Click to Start"
);
outtextxy
(20, WINDOW_HEIGHT - 80, "Rules:"
);
outtextxy
(20, WINDOW_HEIGHT - 50, "1
. Swap adjacent blocks"
);
outtextxy
(20, WINDOW_HEIGHT - 20, "2
. Match 3+ to eliminate"
);
setfillcolor
(isMusicPlaying ? GREEN : RED
);
solidrectangle
(WINDOW_WIDTH - 120, 20, WINDOW_WIDTH - 20, 60
);
setlinecolor
(WHITE
);
rectangle
(WINDOW_WIDTH - 120, 20, WINDOW_WIDTH - 20, 60
);
settextcolor
(WHITE
);
outtextxy
(WINDOW_WIDTH - 110, 30, isMusicPlaying ? "Music:ON" : "Music:OFF"
);
return;
}
for
(int i = 0; i < ROW; ++i
) {
for
(int j = 0; j < COL; ++j
) {
if
(grid[i][j] != -1
) {
setfillcolor
(COLORS[grid[i][j]]
);
solidrectangle
(j * BLOCK_SIZE, i * BLOCK_SIZE,
(j + 1
) * BLOCK_SIZE,
(i + 1
) * BLOCK_SIZE
);
setlinecolor
(BLACK
);
rectangle
(j * BLOCK_SIZE, i * BLOCK_SIZE,
(j + 1
) * BLOCK_SIZE,
(i + 1
) * BLOCK_SIZE
);
if
(i == selectedY && j == selectedX
) {
setlinecolor
(WHITE
);
setlinestyle(PS_SOLID, 3
);
rectangle
(j * BLOCK_SIZE + 2, i * BLOCK_SIZE + 2,
(j + 1
) * BLOCK_SIZE - 2,
(i + 1
) * BLOCK_SIZE - 2
);
setlinestyle(PS_SOLID, 1
);
}
} else {
setfillcolor
(BLACK
);
setlinecolor
(DARKGRAY
);
rectangle
(j * BLOCK_SIZE, i * BLOCK_SIZE,
(j + 1
) * BLOCK_SIZE,
(i + 1
) * BLOCK_SIZE
);
}
}
}
setfillcolor
(DARKGRAY
);
solidrectangle
(0, ROW * BLOCK_SIZE, WINDOW_WIDTH, WINDOW_HEIGHT
);
settextcolor
(WHITE
);
string scoreStr = "Score: " + intToString
(score
);
outtextxy
(20, ROW * BLOCK_SIZE + 20, scoreStr
.c_str
());
string timeStr = "Time: " + intToString
(remainingTime
) + "s";
outtextxy
(WINDOW_WIDTH/2 - 80, ROW * BLOCK_SIZE + 20, timeStr
.c_str
());
setfillcolor
(isMusicPlaying ? GREEN : RED
);
solidrectangle
(20, ROW * BLOCK_SIZE + 10, 120, ROW * BLOCK_SIZE + 40
);
setlinecolor
(WHITE
);
rectangle
(20, ROW * BLOCK_SIZE + 10, 120, ROW * BLOCK_SIZE + 40
);
settextcolor
(WHITE
);
outtextxy
(30, ROW * BLOCK_SIZE + 15, isMusicPlaying ? "Music:ON" : "Music:OFF"
);
setfillcolor
(LIGHTGRAY
);
solidrectangle
(WINDOW_WIDTH - 120, ROW * BLOCK_SIZE + 10, WINDOW_WIDTH - 20, ROW * BLOCK_SIZE + 40
);
setlinecolor
(WHITE
);
rectangle
(WINDOW_WIDTH - 120, ROW * BLOCK_SIZE + 10, WINDOW_WIDTH - 20, ROW * BLOCK_SIZE + 40
);
settextcolor
(BLACK
);
outtextxy
(WINDOW_WIDTH - 110, ROW * BLOCK_SIZE + 15, "Main Menu"
);
if
(gameOver
) {
settextcolor
(RED
);
settextstyle
(36, 0, "Arial"
);
outtextxy
(WINDOW_WIDTH/2 - 120, WINDOW_HEIGHT/2 - 30, "Game Over!"
);
settextstyle
(24, 0, "Arial"
);
string finalScoreStr = "Final: " + intToString
(finalScore
);
outtextxy
(WINDOW_WIDTH/2 - 100, WINDOW_HEIGHT/2 + 20, finalScoreStr
.c_str
());
}
if
(gameState == TIME_UP
) {
setfillcolor
(0x7F000000
);
solidrectangle
(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT
);
settextcolor
(WHITE
);
settextstyle
(36, 0, "Arial"
);
outtextxy
(WINDOW_WIDTH/2 - 120, WINDOW_HEIGHT/2 - 60, "Time Up!"
);
settextstyle
(24, 0, "Arial"
);
string finalScoreStr = "Score: " + intToString
(finalScore
);
outtextxy
(WINDOW_WIDTH/2 - 80, WINDOW_HEIGHT/2, finalScoreStr
.c_str
());
setfillcolor
(GREEN
);
solidrectangle
(WINDOW_WIDTH/2 - 100, WINDOW_HEIGHT/2 + 50,
WINDOW_WIDTH/2 + 100, WINDOW_HEIGHT/2 + 100
);
setlinecolor
(WHITE
);
rectangle
(WINDOW_WIDTH/2 - 100, WINDOW_HEIGHT/2 + 50,
WINDOW_WIDTH/2 + 100, WINDOW_HEIGHT/2 + 100
);
settextcolor
(WHITE
);
outtextxy
(WINDOW_WIDTH/2 - 40, WINDOW_HEIGHT/2 + 65, "Restart"
);
}
}
bool hasPossibleMoves
() {
for
(int i = 0; i < ROW; ++i
) {
for
(int j = 0; j < COL - 1; ++j
) {
swap
(grid[i][j], grid[i][j+1]
);
bool matchFound = false;
for
(int r = max
(0, i-1
); r <= min
(ROW-1, i+1
); ++r
) {
for
(int c = max
(0, j-2
); c <= min
(COL-3, j+2
); ++c
) {
if
(c < 0 || c+2 >= COL
) continue;
if
(grid[r][c] != -1 &&
grid[r][c] == grid[r][c+1] &&
grid[r][c] == grid[r][c+2]
) {
matchFound = true;
break;
}
}
if
(matchFound
) break;
}
if
(!matchFound
) {
for
(int c = max
(0, j-1
); c <= min
(COL-1, j+1
); ++c
) {
for
(int r = max
(0, i-2
); r <= min
(ROW-3, i+2
); ++r
) {
if
(r < 0 || r+2 >= ROW
) continue;
if
(grid[r][c] != -1 &&
grid[r][c] == grid[r+1][c] &&
grid[r][c] == grid[r+2][c]
) {
matchFound = true;
break;
}
}
if
(matchFound
) break;
}
}
swap
(grid[i][j], grid[i][j+1]
);
if
(matchFound
) return true;
}
}
for
(int j = 0; j < COL; ++j
) {
for
(int i = 0; i < ROW - 1; ++i
) {
swap
(grid[i][j], grid[i+1][j]
);
bool matchFound = false;
for
(int r = max
(0, i-1
); r <= min
(ROW-1, i+1
); ++r
) {
for
(int c = max
(0, j-2
); c <= min
(COL-3, j+2
); ++c
) {
if
(c < 0 || c+2 >= COL
) continue;
if
(grid[r][c] != -1 &&
grid[r][c] == grid[r][c+1] &&
grid[r][c] == grid[r][c+2]
) {
matchFound = true;
break;
}
}
if
(matchFound
) break;
}
if
(!matchFound
) {
for
(int c = max
(0, j-1
); c <= min
(COL-1, j+1
); ++c
) {
for
(int r = max
(0, i-2
); r <= min
(ROW-3, i+2
); ++r
) {
if
(r < 0 || r+2 >= ROW
) continue;
if
(grid[r][c] != -1 &&
grid[r][c] == grid[r+1][c] &&
grid[r][c] == grid[r+2][c]
) {
matchFound = true;
break;
}
}
if
(matchFound
) break;
}
}
swap
(grid[i][j], grid[i+1][j]
);
if
(matchFound
) return true;
}
}
return false;
}
int processMatches
() {
vector<vector<bool>> toRemove
(ROW, vector<bool>
(COL, false
));
int matchCount = 0;
for
(int i = 0; i < ROW; ++i
) {
for
(int j = 0; j < COL - 2;
) {
if
(grid[i][j] != -1 &&
grid[i][j] == grid[i][j + 1] &&
grid[i][j] == grid[i][j + 2]
) {
int k = j + 2;
while
(k < COL && grid[i][j] == grid[i][k]
) {
k++;
}
for
(int pos = j; pos < k; ++pos
) {
toRemove[i][pos] = true;
matchCount++;
}
j = k;
} else {
j++;
}
}
}
for
(int j = 0; j < COL; ++j
) {
for
(int i = 0; i < ROW - 2;
) {
if
(grid[i][j] != -1 &&
grid[i][j] == grid[i + 1][j] &&
grid[i][j] == grid[i + 2][j]
) {
int k = i + 2;
while
(k < ROW && grid[i][j] == grid[k][j]
) {
k++;
}
for
(int pos = i; pos < k; ++pos
) {
toRemove[pos][j] = true;
matchCount++;
}
i = k;
} else {
i++;
}
}
}
if
(matchCount > 0
) {
static int comboCount = 0;
comboCount++;
int comboBonus = max
(0, comboCount - 1
) * 5;
score += matchCount * 10 + comboBonus;
} else {
static int comboCount = 0;
comboCount = 0;
}
for
(int i = 0; i < ROW; ++i
) {
for
(int j = 0; j < COL; ++j
) {
if
(toRemove[i][j]
) {
grid[i][j] = -1;
}
}
}
return matchCount;
}
void dropBlocksAnimated
() {
HighResTimer timer;
timer
.start
();
vector<vector<int>> newPositions
(COL
);
vector<vector<int>> temp
(COL
);
for
(int j = 0; j < COL; ++j
) {
for
(int i = ROW - 1; i >= 0; --i
) {
if
(grid[i][j] != -1
) {
temp[j]
.push_back
(grid[i][j]
);
}
}
int newBlocks = ROW - temp[j]
.size
();
for
(int i = 0; i < newBlocks; ++i
) {
temp[j]
.push_back
(rand
() % NUM_COLORS
);
}
for
(int i = 0; i < ROW; ++i
) {
newPositions[j]
.push_back
(temp[j][ROW - 1 - i]
);
}
}
const double animationDuration = 0
.3;
vector<vector<int>> originalGrid = grid;
while
(true
) {
double elapsed = timer
.elapsed
();
if
(elapsed >= animationDuration
) break;
double progress = min
(1
.0, elapsed / animationDuration
);
for
(int j = 0; j < COL; ++j
) {
for
(int i = 0; i < ROW; ++i
) {
if
(originalGrid[i][j] != -1 && newPositions[j][i] != originalGrid[i][j]
) {
int targetY = i;
while
(targetY < ROW && grid[targetY][j] != newPositions[j][i]
) {
targetY++;
}
if
(targetY < ROW
) {
double currentY = i +
(targetY - i
) * progress;
setfillcolor
(COLORS[originalGrid[i][j]]
);
solidrectangle
(j * BLOCK_SIZE, static_cast<int>
(currentY * BLOCK_SIZE
),
(j + 1
) * BLOCK_SIZE, static_cast<int>
((currentY + 1
) * BLOCK_SIZE
));
setlinecolor
(BLACK
);
rectangle
(j * BLOCK_SIZE, static_cast<int>
(currentY * BLOCK_SIZE
),
(j + 1
) * BLOCK_SIZE, static_cast<int>
((currentY + 1
) * BLOCK_SIZE
));
}
}
}
}
FlushBatchDraw
();
Sleep
(10
);
}
for
(int j = 0; j < COL; ++j
) {
for
(int i = 0; i < ROW; ++i
) {
grid[i][j] = newPositions[j][i];
}
}
}
void handleMouseClick
() {
if
(isAnimating
) return;
if
(MouseHit
()) {
MOUSEMSG msg = GetMouseMsg
();
// 使用GetTickCount
()代替chrono
long long now = GetTickCount
();
if
(now - lastClickTime < MIN_CLICK_INTERVAL
) {
return;
}
lastClickTime = now;
if
(gameState == READY && msg
.uMsg == WM_LBUTTONDOWN
) {
resetGame
();
return;
}
if
(gameState == TIME_UP && msg
.uMsg == WM_LBUTTONDOWN
) {
int x = msg
.x;
int y = msg
.y;
if
(x >= WINDOW_WIDTH/2 - 100 && x <= WINDOW_WIDTH/2 + 100 &&
y >= WINDOW_HEIGHT/2 + 50 && y <= WINDOW_HEIGHT/2 + 100
) {
resetGame
();
return;
}
}
if
(msg
.uMsg == WM_LBUTTONDOWN
) {
int x = msg
.x;
int y = msg
.y;
if
(x >= 20 && x <= 120 &&
y >= ROW * BLOCK_SIZE + 10 && y <= ROW * BLOCK_SIZE + 40
) {
if
(isMusicPlaying
) {
stopBackgroundMusic
();
} else {
playBackgroundMusic
();
}
drawGridPartial
(-1, -1
);
FlushBatchDraw
();
return;
}
if
(x >= WINDOW_WIDTH - 120 && x <= WINDOW_WIDTH - 20 &&
y >= ROW * BLOCK_SIZE + 10 && y <= ROW * BLOCK_SIZE + 40
) {
gameState = READY;
selectedX = -1;
selectedY = -1;
gameOver = false;
drawGridPartial
(-1, -1
);
FlushBatchDraw
();
return;
}
}
if
(msg
.uMsg == WM_LBUTTONDOWN
) {
int x = msg
.x / BLOCK_SIZE;
int y = msg
.y / BLOCK_SIZE;
if
(x >= 0 && x < COL && y >= 0 && y < ROW && grid[y][x] != -1 && gameState == PLAYING
) {
if
(selectedX == -1
) {
selectedX = x;
selectedY = y;
drawGridPartial
(x, y
);
FlushBatchDraw
();
}
else if
(selectedX == x && selectedY == y
) {
selectedX = -1;
selectedY = -1;
drawGridPartial
(x, y
);
FlushBatchDraw
();
}
else if
((abs
(selectedX - x
) == 1 && selectedY == y
) ||
(abs
(selectedY - y
) == 1 && selectedX == x
)) {
isAnimating = true;
int prevX = selectedX, prevY = selectedY;
HighResTimer swapTimer;
swapTimer
.start
();
const double swapDuration = 0
.2;
while
(true
) {
double elapsed = swapTimer
.elapsed
();
if
(elapsed >= swapDuration
) break;
double progress = min
(1
.0, elapsed / swapDuration
);
int offsetX = static_cast<int>
((x - prevX
) * progress * BLOCK_SIZE
);
int offsetY = static_cast<int>
((y - prevY
) * progress * BLOCK_SIZE
);
setfillcolor
(BLACK
);
solidrectangle
(prevX * BLOCK_SIZE, prevY * BLOCK_SIZE,
(prevX + 1
) * BLOCK_SIZE,
(prevY + 1
) * BLOCK_SIZE
);
solidrectangle
(x * BLOCK_SIZE, y * BLOCK_SIZE,
(x + 1
) * BLOCK_SIZE,
(y + 1
) * BLOCK_SIZE
);
setfillcolor
(COLORS[grid[prevY][prevX]]
);
solidrectangle
(prevX * BLOCK_SIZE + offsetX, prevY * BLOCK_SIZE + offsetY,
(prevX + 1
) * BLOCK_SIZE + offsetX,
(prevY + 1
) * BLOCK_SIZE + offsetY
);
setfillcolor
(COLORS[grid[y][x]]
);
solidrectangle
(x * BLOCK_SIZE - offsetX, y * BLOCK_SIZE - offsetY,
(x + 1
) * BLOCK_SIZE - offsetX,
(y + 1
) * BLOCK_SIZE - offsetY
);
FlushBatchDraw
();
Sleep
(10
);
}
swap
(grid[prevY][prevX], grid[y][x]
);
bool matched = false;
if
(processMatches
() > 0
) {
matched = true;
}
if
(!matched
) {
swap
(grid[prevY][prevX], grid[y][x]
);
drawGridPartial
(prevX, prevY
);
drawGridPartial
(x, y
);
FlushBatchDraw
();
} else {
while
(true
) {
dropBlocksAnimated
();
if
(processMatches
() == 0
) break;
}
gameOver = !hasPossibleMoves
();
}
selectedX = selectedY = -1;
isAnimating = false;
}
else {
int oldX = selectedX, oldY = selectedY;
selectedX = x;
selectedY = y;
if
(oldX >= 0 && oldY >= 0
) {
drawGridPartial
(oldX, oldY
);
}
drawGridPartial
(x, y
);
FlushBatchDraw
();
}
}
else if
(selectedX >= 0 || selectedY >= 0
) {
int oldX = selectedX, oldY = selectedY;
selectedX = selectedY = -1;
if
(oldX >= 0 && oldY >= 0
) {
drawGridPartial
(oldX, oldY
);
}
FlushBatchDraw
();
}
}
}
}
void keyListenerThread
() {
while
(!exitFlag
) {
if
(_kbhit
()) {
char ch = _getch
();
if
(ch == 27
) {
exitFlag = true;
break;
}
}
Sleep
(50
);
}
}
int main
() {
initgraph
(WINDOW_WIDTH, WINDOW_HEIGHT
);
initGrid
();
playBackgroundMusic
();
BeginBatchDraw
();
thread keyThread
(keyListenerThread
);
HighResTimer frameTimer;
const double targetFPS = 120
.0;
const double frameTime = 1
.0 / targetFPS;
while
(!exitFlag
) {
frameTimer
.start
();
if
(gameState == PLAYING
) {
// 使用QueryPerformanceCounter计算剩余时间
LARGE_INTEGER now, frequency;
QueryPerformanceCounter
(&now
);
QueryPerformanceFrequency
(&frequency
);
double elapsedSeconds = static_cast<double>
(now
.QuadPart - gameStartTime
) / frequency
.QuadPart;
remainingTime = max
(0, GAME_DURATION - static_cast<int>
(elapsedSeconds
));
if
(remainingTime == 0
) {
gameState = TIME_UP;
finalScore = score;
}
if
(gameOver
) {
finalScore = score;
}
}
drawGridPartial
(-1, -1
);
handleMouseClick
();
FlushBatchDraw
();
double elapsed = frameTimer
.elapsed
();
if
(elapsed < frameTime
) {
int sleepTime = static_cast<int>
((frameTime - elapsed
) * 1000
);
if
(sleepTime > 0
) {
Sleep
(sleepTime
);
}
}
}
exitFlag = true;
if
(keyThread
.joinable
()) {
keyThread
.join
();
}
stopBackgroundMusic
();
EndBatchDraw
();
closegraph
();
return 0;
}把页面所展示的英文转换为中文，便于理解
本文通过C语言示例代码展示了如何使用graphics.h库初始化绘图环境，并设置不同的线条样式来绘制水平线，以此演示基本的图形输出功能。
扫一扫
1285
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
