当前位置:首页 » 编程语言 » c语言像素小人
扩展阅读
webinf下怎么引入js 2023-08-31 21:54:13
堡垒机怎么打开web 2023-08-31 21:54:11

c语言像素小人

发布时间: 2022-09-28 09:41:54

1. c语言奔跑的小人,是从左往右走的 现在要它从右面往左走,怎么修改 #include<stdio.

把初始值a = 20; while循环改成a >= 0 最后的a ++ 改成a --就好了

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
intmain(){
inta,b;a=20;//---------------------
while(a>=0){//-------------------------
system("clear");
b=1;
while(b<=a){
printf("");
b++;
}
printf("O ");
b=1;
while(b<=a){
printf("");
b++;
}
printf("<H> ");
b=1;
while(b<=a){
printf("");
b++;
}
printf("II ");
sleep(1);
a--;//--------------------------------------
}
}

2. 用c语言怎样实现像素的复制

一般要画鼠标用一个8*16的像素位置,你可以自己先定义好数组,然后步骤如下:while(1){如果不是第一次绘制鼠标,则用已保存的图像覆盖曾经鼠标位置.bios中断获取鼠标位置,如果鼠标发生移动(和以前的位置不一样),保存此位置下8*16的图像,保存鼠标位置,绘制鼠标.如果发生CLK事件,则跳出循环,处理你的程序.}

3. C语言中怎么控制小人的移动

每次循环的时候,检测按键,如果有按键按下,就改变小人的坐标,下次重绘的时候,使用新的坐标,就相当于小人运动了

4. C语言,我的小人在动的时候会闪屏,我用的是cls实现的,求知道该怎么办

利用控制光标的API头文件在windows.h(光标就是那个一闪一闪的输入提示符)
-----
HANDLE handle;
COORD coord;
handle=GetStdHandle(STD_OUTPUT_HANDLE);
coord.X=0; // 这里是光标目标位置的横坐标(此时为0,更改数值试试)
coord.Y=0; // 这里是光标目标位置的纵坐标(此时为0,更改数值试试)
SetConsoleCursorPosition(handle,coord);
-----
控制光标到想要擦出的位置进行擦除还原,再控制光标在想要画小人的地方画小人
可以将这一段编为一个函数,方便调用

5. 求一个用C语言编写的小游戏代码

#include <graphics.h>
#include <conio.h>
#include <time.h>

/////////////////////////////////////////////
// 定义常量、枚举量、结构体、全局变量
/////////////////////////////////////////////

#define WIDTH 10 // 游戏区宽度
#define HEIGHT 22 // 游戏区高度
#define SIZE 20 // 每个游戏区单位的实际像素

// 定义操作类型
enum CMD
{
CMD_ROTATE, // 方块旋转
CMD_LEFT, CMD_RIGHT, CMD_DOWN, // 方块左、右、下移动
CMD_SINK, // 方块沉底
CMD_QUIT // 退出游戏
};

// 定义绘制方块的方法
enum DRAW
{
SHOW, // 显示方块
HIDE, // 隐藏方块
FIX // 固定方块
};

// 定义七种俄罗斯方块
struct BLOCK
{
WORD dir[4]; // 方块的四个旋转状态
COLORREF color; // 方块的颜色
} g_Blocks[7] = { {0x0F00, 0x4444, 0x0F00, 0x4444, RED}, // I
{0x0660, 0x0660, 0x0660, 0x0660, BLUE}, // 口
{0x4460, 0x02E0, 0x0622, 0x0740, MAGENTA}, // L
{0x2260, 0x0E20, 0x0644, 0x0470, YELLOW}, // 反L
{0x0C60, 0x2640, 0x0C60, 0x2640, CYAN}, // Z
{0x0360, 0x4620, 0x0360, 0x4620, GREEN}, // 反Z
{0x4E00, 0x4C40, 0x0E40, 0x4640, BROWN}}; // T

// 定义当前方块、下一个方块的信息
struct BLOCKINFO
{
byte id; // 方块 ID
char x, y; // 方块在游戏区中的坐标
byte dir:2; // 方向
} g_CurBlock, g_NextBlock;

// 定义游戏区
BYTE g_World[WIDTH][HEIGHT] = {0};

/////////////////////////////////////////////
// 函数声明
/////////////////////////////////////////////

void Init(); // 初始化游戏
void Quit(); // 退出游戏
void NewGame(); // 开始新游戏
void GameOver(); // 结束游戏
CMD GetCmd(); // 获取控制命令
void DispatchCmd(CMD _cmd); // 分发控制命令
void NewBlock(); // 生成新的方块
bool CheckBlock(BLOCKINFO _block); // 检测指定方块是否可以放下
void DrawBlock(BLOCKINFO _block, DRAW _draw = SHOW); // 画方块
void OnRotate(); // 旋转方块
void OnLeft(); // 左移方块
void OnRight(); // 右移方块
void OnDown(); // 下移方块
void OnSink(); // 沉底方块

/////////////////////////////////////////////
// 函数定义
/////////////////////////////////////////////

// 主函数
void main()
{
Init();

CMD c;
while(true)
{
c = GetCmd();
DispatchCmd(c);

// 按退出时,显示对话框咨询用户是否退出
if (c == CMD_QUIT)
{
HWND wnd = GetHWnd();
if (MessageBox(wnd, _T("您要退出游戏吗?"), _T("提醒"), MB_OKCANCEL | MB_ICONQUESTION) == IDOK)
Quit();
}
}
}

// 初始化游戏
void Init()
{
initgraph(640, 480);
srand((unsigned)time(NULL));

// 显示操作说明
setfont(14, 0, _T("宋体"));
outtextxy(20, 330, _T("操作说明"));
outtextxy(20, 350, _T("上:旋转"));
outtextxy(20, 370, _T("左:左移"));
outtextxy(20, 390, _T("右:右移"));
outtextxy(20, 410, _T("下:下移"));
outtextxy(20, 430, _T("空格:沉底"));
outtextxy(20, 450, _T("ESC:退出"));

// 设置坐标原点
setorigin(220, 20);

// 绘制游戏区边界
rectangle(-1, -1, WIDTH * SIZE, HEIGHT * SIZE);
rectangle((WIDTH + 1) * SIZE - 1, -1, (WIDTH + 5) * SIZE, 4 * SIZE);

// 开始新游戏
NewGame();
}

// 退出游戏
void Quit()
{
closegraph();
exit(0);
}

// 开始新游戏
void NewGame()
{
// 清空游戏区
setfillstyle(BLACK);
bar(0, 0, WIDTH * SIZE - 1, HEIGHT * SIZE - 1);
ZeroMemory(g_World, WIDTH * HEIGHT);

// 生成下一个方块
g_NextBlock.id = rand() % 7;
g_NextBlock.dir = rand() % 4;
g_NextBlock.x = WIDTH + 1;
g_NextBlock.y = HEIGHT - 1;

// 获取新方块
NewBlock();
}

// 结束游戏
void GameOver()
{
HWND wnd = GetHWnd();
if (MessageBox(wnd, _T("游戏结束。\n您想重新来一局吗?"), _T("游戏结束"), MB_YESNO | MB_ICONQUESTION) == IDYES)
NewGame();
else
Quit();
}

// 获取控制命令
DWORD m_oldtime;
CMD GetCmd()
{
// 获取控制值
while(true)
{
// 如果超时,自动下落一格
DWORD newtime = GetTickCount();
if (newtime - m_oldtime >= 500)
{
m_oldtime = newtime;
return CMD_DOWN;
}

// 如果有按键,返回按键对应的功能
if (kbhit())
{
switch(getch())
{
case 'w':
case 'W': return CMD_ROTATE;
case 'a':
case 'A': return CMD_LEFT;
case 'd':
case 'D': return CMD_RIGHT;
case 's':
case 'S': return CMD_DOWN;
case 27: return CMD_QUIT;
case ' ': return CMD_SINK;
case 0:
case 0xE0:
switch(getch())
{
case 72: return CMD_ROTATE;
case 75: return CMD_LEFT;
case 77: return CMD_RIGHT;
case 80: return CMD_DOWN;
}
}
}

// 延时 (降低 CPU 占用率)
Sleep(20);
}
}

// 分发控制命令
void DispatchCmd(CMD _cmd)
{
switch(_cmd)
{
case CMD_ROTATE: OnRotate(); break;
case CMD_LEFT: OnLeft(); break;
case CMD_RIGHT: OnRight(); break;
case CMD_DOWN: OnDown(); break;
case CMD_SINK: OnSink(); break;
case CMD_QUIT: break;
}
}

// 生成新的方块
void NewBlock()
{
g_CurBlock.id = g_NextBlock.id, g_NextBlock.id = rand() % 7;
g_CurBlock.dir = g_NextBlock.dir, g_NextBlock.dir = rand() % 4;
g_CurBlock.x = (WIDTH - 4) / 2;
g_CurBlock.y = HEIGHT + 2;

// 下移新方块直到有局部显示
WORD c = g_Blocks[g_CurBlock.id].dir[g_CurBlock.dir];
while((c & 0xF) == 0)
{
g_CurBlock.y--;
c >>= 4;
}

// 绘制新方块
DrawBlock(g_CurBlock);

// 绘制下一个方块
setfillstyle(BLACK);
bar((WIDTH + 1) * SIZE, 0, (WIDTH + 5) * SIZE - 1, 4 * SIZE - 1);
DrawBlock(g_NextBlock);

// 设置计时器,用于判断自动下落
m_oldtime = GetTickCount();
}

// 画方块
void DrawBlock(BLOCKINFO _block, DRAW _draw)
{
WORD b = g_Blocks[_block.id].dir[_block.dir];
int x, y;

int color = BLACK;
switch(_draw)
{
case SHOW: color = g_Blocks[_block.id].color; break;
case HIDE: color = BLACK; break;
case FIX: color = g_Blocks[_block.id].color / 3; break;
}
setfillstyle(color);

for(int i=0; i<16; i++)
{
if (b & 0x8000)
{
x = _block.x + i % 4;
y = _block.y - i / 4;
if (y < HEIGHT)
{
if (_draw != HIDE)
bar3d(x * SIZE + 2, (HEIGHT - y - 1) * SIZE + 2, (x + 1) * SIZE - 4, (HEIGHT - y) * SIZE - 4, 3, true);
else
bar(x * SIZE, (HEIGHT - y - 1) * SIZE, (x + 1) * SIZE - 1, (HEIGHT - y) * SIZE - 1);
}
}
b <<= 1;
}
}

// 检测指定方块是否可以放下
bool CheckBlock(BLOCKINFO _block)
{
WORD b = g_Blocks[_block.id].dir[_block.dir];
int x, y;

for(int i=0; i<16; i++)
{
if (b & 0x8000)
{
x = _block.x + i % 4;
y = _block.y - i / 4;
if ((x < 0) || (x >= WIDTH) || (y < 0))
return false;

if ((y < HEIGHT) && (g_World[x][y]))
return false;
}
b <<= 1;
}

return true;
}

// 旋转方块
void OnRotate()
{
// 获取可以旋转的 x 偏移量
int dx;
BLOCKINFO tmp = g_CurBlock;
tmp.dir++; if (CheckBlock(tmp)) { dx = 0; goto rotate; }
tmp.x = g_CurBlock.x - 1; if (CheckBlock(tmp)) { dx = -1; goto rotate; }
tmp.x = g_CurBlock.x + 1; if (CheckBlock(tmp)) { dx = 1; goto rotate; }
tmp.x = g_CurBlock.x - 2; if (CheckBlock(tmp)) { dx = -2; goto rotate; }
tmp.x = g_CurBlock.x + 2; if (CheckBlock(tmp)) { dx = 2; goto rotate; }
return;

rotate:
// 旋转
DrawBlock(g_CurBlock, HIDE);
g_CurBlock.dir++;
g_CurBlock.x += dx;
DrawBlock(g_CurBlock);
}

// 左移方块
void OnLeft()
{
BLOCKINFO tmp = g_CurBlock;
tmp.x--;
if (CheckBlock(tmp))
{
DrawBlock(g_CurBlock, HIDE);
g_CurBlock.x--;
DrawBlock(g_CurBlock);
}
}

// 右移方块
void OnRight()
{
BLOCKINFO tmp = g_CurBlock;
tmp.x++;
if (CheckBlock(tmp))
{
DrawBlock(g_CurBlock, HIDE);
g_CurBlock.x++;
DrawBlock(g_CurBlock);
}
}

// 下移方块
void OnDown()
{
BLOCKINFO tmp = g_CurBlock;
tmp.y--;
if (CheckBlock(tmp))
{
DrawBlock(g_CurBlock, HIDE);
g_CurBlock.y--;
DrawBlock(g_CurBlock);
}
else
OnSink(); // 不可下移时,执行“沉底方块”操作
}

// 沉底方块
void OnSink()
{
int i, x, y;

// 连续下移方块
DrawBlock(g_CurBlock, HIDE);
BLOCKINFO tmp = g_CurBlock;
tmp.y--;
while (CheckBlock(tmp))
{
g_CurBlock.y--;
tmp.y--;
}
DrawBlock(g_CurBlock, FIX);

// 固定方块在游戏区
WORD b = g_Blocks[g_CurBlock.id].dir[g_CurBlock.dir];
for(i = 0; i < 16; i++)
{
if (b & 0x8000)
{
if (g_CurBlock.y - i / 4 >= HEIGHT)
{ // 如果方块的固定位置超出高度,结束游戏
GameOver();
return;
}
else
g_World[g_CurBlock.x + i % 4][g_CurBlock.y - i / 4] = 1;
}

b <<= 1;
}

// 检查是否需要消掉行,并标记
int row[4] = {0};
bool bRow = false;
for(y = g_CurBlock.y; y >= max(g_CurBlock.y - 3, 0); y--)
{
i = 0;
for(x = 0; x < WIDTH; x++)
if (g_World[x][y] == 1)
i++;
if (i == WIDTH)
{
bRow = true;
row[g_CurBlock.y - y] = 1;
setfillstyle(WHITE, DIAGCROSS2_FILL);
bar(0, (HEIGHT - y - 1) * SIZE + SIZE / 2 - 2, WIDTH * SIZE - 1, (HEIGHT - y - 1) * SIZE + SIZE / 2 + 2);
}
}

if (bRow)
{
// 延时 200 毫秒
Sleep(200);

// 擦掉刚才标记的行
IMAGE img;
for(i = 0; i < 4; i++)
{
if (row[i])
{
for(y = g_CurBlock.y - i + 1; y < HEIGHT; y++)
for(x = 0; x < WIDTH; x++)
{
g_World[x][y - 1] = g_World[x][y];
g_World[x][y] = 0;
}

getimage(&img, 0, 0, WIDTH * SIZE, (HEIGHT - (g_CurBlock.y - i + 1)) * SIZE);
putimage(0, SIZE, &img);
}
}
}

// 产生新方块
NewBlock();
}

6. C语言小题,这个图片里面的小人是输出,怎么用C语言让这个小人从右往左移动呢

其实就是输出4行数据。

前面有若干个空格。所以要想让它移动的话,执行两步
清屏
重新输出4行数据,每行前面空格减少一位。

这样就向左移动了一位了。
循环执行 就是不停向左,类似的 还可以上下右移动。

7. 用C语言画简单的小人

TC2.0里有一个bgidemo.c的图形编程示例程序。
其中有一个演示屏幕贴图的子程序,一个外星人的飞船在屏幕上飞来飞去。
这个程序可以简单地修改一下就可以用于你的需求了。
程序不难看懂。

这个代码我找到了。大概说一下。LZ需要自己去找一下完整的代码研究,这里我只贴出相关的一段。

void PutImageDemo(void)
{
static int r = 20;
static int StartX = 100;
static int StartY = 50;

struct viewporttype vp;
int PauseTime, x, y, ulx, uly, lrx, lry, size, i, width, height, step;
void *Saucer;

MainWindow("GetImage / PutImage Demonstration");
getviewsettings( &vp );

/* Draw Saucer */ 下面是用绘画的方式画了一个简单的飞碟。这个飞碟图用于之前复制到内存里备用。
setfillstyle( SOLID_FILL, getmaxcolor() );
fillellipse(StartX, StartY, r, (r/3)+2);
ellipse(StartX, StartY-4, 190, 357, r, r/3);

line(StartX+7, StartY-6, StartX+10, StartY-12);
circle(StartX+10, StartY-12, 2);
line(StartX-7, StartY-6, StartX-10, StartY-12);
circle(StartX-10, StartY-12, 2);

/* Read saucer image */ 这里开始把那个飞碟的小图图复制到一个内存缓冲区里。先计算大小,需要的内存大小。
ulx = StartX-(r+1);
uly = StartY-14;
lrx = StartX+(r+1);
lry = StartY+(r/3)+3;
width = lrx - ulx + 1;
height = lry - uly + 1;
size = imagesize(ulx, uly, lrx, lry);

Saucer = malloc( size ); // 分配内存
getimage(ulx, uly, lrx, lry, Saucer); // 搞到了。
putimage(ulx, uly, Saucer, XOR_PUT); // 这就在原位置上,以异或的方式画一下。用异或的方式绘图,两次绘制后,图像正好就会消失为原来的背景。
但是,LZ的可能这样不行,那就需要复杂一些的绘制了,用人物的黑轮廓图或上背景,得到镂空,然后再把黑背景的角色用or方式绘上。

下面就是随机地绘制了。
/* Plot some "stars" */
for ( i=0 ; i<1000; ++i )
putpixel(random(MaxX), random(MaxY), random( MaxColors-1 )+1);
x = MaxX / 2;
y = MaxY / 2;
PauseTime = 70;

/* until a key is hit */
while ( !kbhit() ) {

/* Draw the Saucer */
putimage(x, y, Saucer, XOR_PUT); /* draw image */
delay(PauseTime);
putimage(x, y, Saucer, XOR_PUT); /* erase image */
上面的还是两次 xor,显示图片,消除图片。
/* Move Saucer */

step = random( 2*r );
if ((step/2) % 2 != 0 )
step = -1 * step;
x = x + step;
step = random( r );
if ((step/2) % 2 != 0 )
step = -1 * step;
y = y + step;

if (vp.left + x + width - 1 > vp.right)
x = vp.right-vp.left-width + 1;
else
if (x < 0)
x = 0;
if (vp.top + y + height - 1 > vp.bottom)
y = vp.bottom-vp.top-height + 1;
else
if (y < 0)
y = 0;
}
free( Saucer );
Pause();
}
另外,团IDC网上有许多产品团购,便宜有口碑

8. C语言运动的小人

多了一个最后的大括号}。
编写程序请养成缩格书写的习惯!

9. 如何利用c语言实现像素图形的输出

1、可以变成灰度图也可以不变。这里假设你的图像都是IPL_DEPTH_8U类型。

2、如果变成灰度图,就是单通道图像,获取的就是每一个像素点的灰度值。
IplImage* img = cvLoadImage("test.bmp", 0);
for (int i = 0; i < img->height; i++)
{
for (int j = 0; j < img->width; j++)
{
//方法一:使用cvGet2D()函数间接访问
CvScalar s = cvGet2D(img, i, j); //其中i代表y轴(第i行),即height;j代表x轴(第j列),即width。
printf("gray value=%f\n",s.val[0]);

//方法二:使用直接访问
uchar val = ((uchar *)(img->imageData + i*img->widthStep))[j]; //i和j的意义同上
printf("gray value=%d\n",val);
}
}

3、如果不变成灰度图,就是3通道图像,获取的就是每一个像素点的BGR值,然后分别获取B值,G值和R值。
IplImage* img = cvLoadImage("test.bmp", 1);
for (int i = 0; i < img->height; i++)
{
for (int j = 0; j < img->width; j++)
{
//方法一:使用cvGet2D()函数间接访问
CvScalar s=cvGet2D(img,i,j); //其中i代表y轴(第i行),即height;j代表x轴(第j列),即width。
printf("B=%f, G=%f, R=%f\n",s.val[0],s.val[1],s.val[2]); //注意是BGR顺序

//方法二:使用直接访问
int bVal = ((uchar *)(img->imageData + i*img->widthStep))[j*img->nChannels + 0]; // B
int gVal = ((uchar *)(img->imageData + i*img->widthStep))[j*img->nChannels + 1]; // G
int rVal = ((uchar *)(img->imageData + i*img->widthStep))[j*img->nChannels + 2]; // R
printf("B=%d, G=%d, R=%d\n",bVal,gVal,rVal); //注意是BGR顺序
}
}

10. 哪位大神有c语言做的小人的代码,什么小人都可以,什么叮当猫hellokitty

#include<stdio.h>

intmain(){
char*s[]={"______________$$$$$$$",
"_____________$$$$$$$$$",
"____________$$$$$$$$$$$",
"____________$$$$$$$$$$$",
"____________$$$$$$$$$$$",
"_____________$$$$$$$$$",
"_____$$$$$$_____$$$$$$$$$$",
"____$$$$$$$$__$$$$$$_____$$$",
"___$$$$$$$$$$$$$$$$_________$",
"___$$$$$$$$$$$$$$$$______$__$",
"___$$$$$$$$$$$$$$$$_____$$$_$",
"___$$$$$$$$$$$__________$$$_$_____$$",
"____$$$$$$$$$____________$$_$$$$_$$$$",
"______$$$__$$__$$$______________$$$$",
"___________$$____$_______________$",
"____________$$____$______________$",
"_____________$$___$$$__________$$",
"_______________$$$_$$$$$$_$$$$$",
"________________$$____$$_$$$$$",
"_______________$$$$$___$$$$$$$$$$",
"_______________$$$$$$$$$$$$$$$$$$$$",
"_______________$$_$$$$$$$$$$$$$$__$$",
"_______________$$__$$$$$$$$$$$___$_$",
"______________$$$__$___$$$______$$$$",
"______________$$$_$__________$$_$$$$",
"______________$$$$$_________$$$$_$_$",
"_______________$$$$__________$$$__$$",
"_____$$$$_________$________________$",
"___$$$___$$______$$$_____________$$",
"__$___$$__$$_____$__$$$_____$$__$$",
"_$$____$___$_______$$$$$$$$$$$$$",
"_$_____$____$_____$$$$$$__$$$$$$$$"};

intLENGTH=32;
inti=0;
for(i=0;i<LENGTH;i++){
printf("%s ",s[i]);
}
}