02 贪吃蛇

news2024/11/27 2:21:59

前言

呵呵 这是不知道 在哪里看到的 别人做的一个贪吃蛇 

因此 也把我 之前的 贪吃蛇 移植上来了 

当然 这个不过是为了 简单的入门了解, 呵呵 

然后 c++版本的贪吃蛇 需要先移植成 c 版本, 然后 再根据 单片机相关 设计调整

比如 led 点阵的输出, 比如 c99 语法的一些不兼容 

主控制程序

整体程序的结构如下, Test02Snake 是主控制程序, utils 是公共的东西 

snake 是贪吃蛇的相关实现 

Test02Snake.c


#include "utils.h"
#include "snake.h"


/**
 * main related
 */
long counter = 1;

u8 gled_end[8] = {0x38,0x7C,0x7E,0x3F,0x3F,0x7E,0x7C,0x38};

void main() {

    int i;
    u8 xList[8] = {1, 2, 3, 4, 6}, yList[8] = {1, 2, 3, 4, 7};
    u8 word[8];

	Snake snakeIns;

	Snake *snake = &snakeIns;
    // snake = snakeInit();

	snakeInit(snake);
    snake->init(snake);
    snake->setMap(snake);
    snake->createFood(snake);
	ledToggle(6);
			   

    while (1) {

//  		snake->print(snake);
        snake->running(snake, counter);
        if (snake->isOver(snake))
            break;

		delay_ms(5);
        counter++;

    }

    while(1) {
        lightTubeByInt(snake->grade);
        printLedWord(8, gled_end);
    }

}

utils.h

#ifndef _utils_H
#define _utils_H

#include "reg52.h"
#include "stdlib.h"


typedef unsigned int u16;
typedef unsigned char u8;
typedef unsigned long u32;

// led dot related 
sbit SHIFT_REG_INPUT = P3 ^6;
sbit STORE_REG_INPUT = P3 ^5;
sbit SERIAL_PORT_INPUT = P3 ^4;
#define LEDDZ_COL_PORT P0


// tube related 
sbit LSA=P2^2;
sbit LSB=P2^3;
sbit LSC=P2^4;
#define SMG_A_DP_PORT	P0


// keyboard matrix related
#define KEY_MATRIX_PORT	P1


/**
 * delay $delayIn10Us us
 * @param ten_us
 */
void delay_10us(u16 ten_us);

/**
 * delay $delayInMs ms
 * @param ms
 */
void delay_ms(u16 ms);

/**
 * control led[pos] on/off
 * @param pos
 * @param on
 */
void ledCtl(u8 pos, u8 on);

/**
 * toggle led[pos] on/off
 * @param pos
 * @param on
 */
void ledToggle(u8 pos);

/**
 * random number 
 * @param seed
 * @param max
 * @param min
 */
unsigned int randomInt(unsigned int seed, unsigned int max, unsigned int min);

/**
 * printLedWord
 *
 * @param wordLength
 * @param word
 */
void printLedWord(int wordLength, u8 *word);

/**
 * lightTube
 * @param word
 */
void lightTube(u8 *word);

/**
 * lightTubeByInt
 * @param word
 */
void lightTubeByInt(u16 value);

/**
 * lightTubeByIntNTimes
 * @param word
 */
void lightTubeByIntSeconds(u16 value, u16 s);

/**
 * keyboardMatrixFlipScan
 * @return
 */
u8 keyboardMatrixFlipScan(void);

#endif

utils.c



#include "utils.h"



u8 gled_col[8] = {0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0xfe};

u8 gsmg_code[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};


void hc595_write_data(u8 dat);


void delay_10us(u16 ten_us) {
    while (ten_us--);
}


void delay_ms(u16 ms) {
    u16 i, j;
    for (i = ms; i > 0; i--)
        for (j = 110; j > 0; j--);
}


void ledCtl(u8 pos, u8 on) {
    if(on == 0) {
        P2 |= (1 << pos);
        return;
    }
    P2 &= (~(1 << pos));
}


void ledToggle(u8 pos) {
    P2 ^= (1 << pos);
}


unsigned int randomInt(unsigned int seed, unsigned int min, unsigned int max) {

    return rand() % (max + 1 - min) + min;
}

void printLedWord(int wordLength, u8 *word) {
    u8 i;
    for (i = 0; i < wordLength; i++) {
        LEDDZ_COL_PORT = gled_col[i];
        hc595_write_data(word[i]);
        delay_10us(10);
        hc595_write_data(0x00);
    }
}

void hc595_write_data(u8 dat) {
    u8 i = 0;

    for (i = 0; i < 8; i++) {
        SERIAL_PORT_INPUT = dat >> 7;
        dat <<= 1;
        SHIFT_REG_INPUT = 0;
        delay_10us(1);
        SHIFT_REG_INPUT = 1;
        delay_10us(1);
    }
    STORE_REG_INPUT = 1;
    delay_10us(1);
    STORE_REG_INPUT = 0;
}


void lightTube(u8 *word) {
    u8 i=0;
    for(i=0;i<8;i++) {
        switch(i) {
            case 0: LSC=1;LSB=1;LSA=1;break;
            case 1: LSC=1;LSB=1;LSA=0;break;
            case 2: LSC=1;LSB=0;LSA=1;break;
            case 3: LSC=1;LSB=0;LSA=0;break;
            case 4: LSC=0;LSB=1;LSA=1;break;
            case 5: LSC=0;LSB=1;LSA=0;break;
            case 6: LSC=0;LSB=0;LSA=1;break;
            case 7: LSC=0;LSB=0;LSA=0;break;
        }
        SMG_A_DP_PORT = gsmg_code[word[i]];
        delay_10us(10);
        SMG_A_DP_PORT=0x00;
    }
}


void lightTubeByInt(u16 value) {
	u16 i;
	u8 idx = 7;
	u8 word[8];

	for(i=0; i<8; i++) {
	    word[i] = 0;
	}
    i = value;
	while(i > 0) {
	    word[idx --] = i % 10;
	    i = i / 10;
	}
    lightTube(word);
}

void lightTubeByIntSeconds(u16 value, u16 s) {
    u16 i, j;
    for (i = s * 8; i > 0; i--)
        for (j = 110; j > 0; j--)
        	lightTubeByInt(value);
}

u8 keyboardMatrixFlipScan(void) {
    static u8 result = 0;

    KEY_MATRIX_PORT=0x0f;
    if(KEY_MATRIX_PORT!=0x0f) {
        delay_10us(1000);
        if(KEY_MATRIX_PORT!=0x0f) {
            KEY_MATRIX_PORT=0x0f;
            switch(KEY_MATRIX_PORT) {
                case 0x07: result=1;break;
                case 0x0b: result=2;break;
                case 0x0d: result=3;break;
                case 0x0e: result=4;break;
            }

            KEY_MATRIX_PORT=0xf0;
            switch(KEY_MATRIX_PORT) {
                case 0x70: result=result;break;
                case 0xb0: result=result+4;break;
                case 0xd0: result=result+8;break;
                case 0xe0: result=result+12;break;
            }
            while(KEY_MATRIX_PORT!=0xf0);
        }
    }
    else
        result=0;

    return result;
}

贪吃蛇的实现

snake.h 

#ifndef _snake_H
#define _snake_H


#include "utils.h"

typedef struct Node {
    int x;
    int y;
} Node;


typedef struct Snake {
    struct Node *head;        
    struct Node *food;        
    int flag;        
    int grade;        
    int level;        
    int direction;

    void (*setMap)(struct Snake *snake);          
    int (*isOver)(struct Snake *snake);            
    void (*go)(struct Snake *snake);                
    void (*running)(struct Snake *snake, int counter);
    void (*isKeyPressed)(struct Snake *snake);
    void (*init)(struct Snake *snake);
    void (*addNode)(struct Snake *snake, int x, int y);            
	void (*moveTo)(struct Snake *snake, int direction);            
    void (*createFood)(struct Snake *snake);        
    int (*getFood)(struct Snake *snake);            
    int (*isFoodCover)(struct Snake *snake);        
    int (*isSuccess)(struct Snake *snake);        
    void (*print)(struct Snake *snake);            
} Snake;


void snakeInit(struct Snake *snake);


#endif

snake.c 

如下 就是 贪吃蛇的初始化, 生成食物, 运行, 等等 相关 


#include "snake.h"


void position(int, int);

struct Node *nodeInit(int, int y);

void snakeInit(Snake *snake);

void setMap(struct Snake *snake);

int isOver(struct Snake *snake);

void go(struct Snake *snake);

void running(struct Snake *snake, int counter);

void isKeyPressed(struct Snake *snake);

void init(struct Snake *snake);

void addNode(struct Snake *snake, int x, int y);
   
void moveTo(struct Snake *snake, int direction);

void createFood(struct Snake *snake);

int getFood(struct Snake *snake);

int isFoodCover(struct Snake *snake);

int isSuccess(struct Snake *snake);

void print(struct Snake *snake);

int snakeHeadInitX = 2;
int snakeHeadInitY = 2;
int gameRangeXMax = 8;
int gameRangeYMax = 8;
int snakeNodeXOffset = 1;
int snakeNodeYOffset = 1;

Node nodeList[100];
Node foodNodeIns;
Node *foodNode = &foodNodeIns;


void snakeInit(struct Snake *snake) {
    // struct Snake *result = malloc(sizeof(struct Snake));
//    snake->head = nodeInit(snakeHeadInitX, snakeHeadInitY);
    snake->head = &nodeList[0];
    snake->level = 0;
    addNode(snake, snakeHeadInitX, snakeHeadInitY);


    snake->flag = 0;
    snake->direction = 2;
    snake->grade = 0;

    snake->setMap = setMap;
    snake->isOver = isOver;
    snake->go = go;
    snake->running = running;
    snake->isKeyPressed = isKeyPressed;
    snake->init = init;
    snake->addNode = addNode;
	snake->moveTo = moveTo;
    snake->createFood = createFood;
    snake->getFood = getFood;
    snake->isFoodCover = isFoodCover;
    snake->isSuccess = isSuccess;
    snake->print = print;
}


void setMap(struct Snake *snake) {

}


void init(struct Snake *snake) {
	int i;
    struct Node *p = snake->head;
    for (i = 1; i <= 2; i++) {
        addNode(snake, p->x - (i * snakeNodeXOffset), p->y);
    }
}

void addNode(struct Snake *snake, int x, int y) {
    nodeList[snake->level].x = x;
    nodeList[snake->level].y = y;
    snake->level ++;
    snake->grade = snake->grade + 5 * (snake->level + 1);
}

void moveTo(struct Snake *snake, int direction) {
    u8 i;
    for(i = snake->level - 1; i > 0; i--) {
        nodeList[i].x = nodeList[i-1].x;
        nodeList[i].y = nodeList[i-1].y;
    }

	snake->direction = direction;
    if ((snake->direction + 2) % 2 == 1) {
        snake->head->y -= snake->direction;
    } else {
        snake->head->x += (snake->direction / 2);
    }
}

int isOver(struct Snake *snake) {
    struct Node *head = snake->head;
    struct Node *p;
	u8 i;
    if (head->x >= (gameRangeXMax * snakeNodeXOffset) || head->x < 0
        || head->y >= (gameRangeYMax * snakeNodeYOffset) || head->y < 0)
        return 1;
    for(i=2; i<snake->level; i++) {
        p = &nodeList[i];
        if (head->x == p->x && head->y == p->y) return 1;
    }
    if (snake->level >= 10) return 1;
    return 0;
}


void createFood(struct Snake *snake) {
    do {
        foodNode->x = randomInt(0, 0, (gameRangeXMax-1) * snakeNodeXOffset);
        foodNode->y = randomInt(0, 0, (gameRangeYMax-1) * snakeNodeYOffset);
    } while (snake->isFoodCover(snake));
}


int getFood(struct Snake *snake) {
    struct Node *head = snake->head;
    struct Node *p;

    if (head->x == foodNode->x && head->y == foodNode->y) {
        p = &nodeList[snake->level-1];
        addNode(snake, p->x, p->y);
        return 1;
    }
    return 0;
}


int isFoodCover(struct Snake *snake) {
	u8 i;
    struct Node *p = snake->head;
    struct Node *food = foodNode;
    for(i=0; i<snake->level; i++) {
        p = &nodeList[i];
        if (food->x == p->x && food->y == p->y) return 1;
    }
    return 0;
}


void go(struct Snake *snake) {
    struct Node *head = snake->head;
    struct Node *p;

    snake->moveTo(snake, snake->direction);
    snake->print(snake);
}


long snakeTurnNextThreshold = 1;
int snakeMaxRowCount = 50;
int snakeCurrentRowIdx = 1;


void running(struct Snake *snake, int counter) {
    struct Node *p;
    if (counter % snakeTurnNextThreshold == 0) {
        snakeCurrentRowIdx = (snakeCurrentRowIdx + 1) % snakeMaxRowCount;
    }

	snake->isKeyPressed(snake);
    if(snakeCurrentRowIdx > 0) {
        snake->print(snake);
        return ;
    }

    snake->print(snake);
    snake->go(snake);
    if (snake->getFood(snake)) {
        snake->createFood(snake);
    }

}

void isKeyPressed(struct Snake *snake) {
	u8 keyPressed = 0;
    keyPressed = keyboardMatrixFlipScan();
    // UP
    if (keyPressed == 2 && snake->direction != 1) snake->direction = -1;
        // LEFT
    else if (keyPressed == 5 && snake->direction != 2) snake->direction = -2;
        // DOWN
    else if (keyPressed == 6 && snake->direction != -1) snake->direction = 1;
        // RIGHT
    else if (keyPressed == 7 && snake->direction != -2) snake->direction = 2;
    if (keyPressed == 16) {
        while (1) {
            keyPressed = keyboardMatrixFlipScan();
            snake->print(snake);
            if (keyPressed == 16) break;
        }
    }
}

int isSuccess(struct Snake *snake) {
    if (snake->level >= 10) return 1;
    return 0;
}


void print(struct Snake *snake) {
    struct Node *p;
    u8 word[8];
    u8 i;

    for(i=0; i<8; i++) {
        word[i] = 0;
    }
    for(i=0; i<snake->level; i++) {
        p = &nodeList[i];
        word[p->x] |= (1 << p->y);
    }
    p = foodNode;
    word[p->x] |= (1 << p->y);

    printLedWord(8, word);
}

实际效果如下图 

游戏结束效果如下

完

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1625696.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

分布式密钥生成

分布式密钥生成

可验证且无经销商 分布式密钥生成 (DKG) 是一种加密协议&#xff0c;使多方能够协作生成共享密钥&#xff0c;而无需任何一方完全了解密钥。 它通过在多个参与者之间分配信任来增强各种应用程序的安全性&#xff0c;从而降低密钥泄露的风险。 我们引入了一种可验证且无经销商的…
阅读更多...
C语言中整型与浮点型在内存中的存储

C语言中整型与浮点型在内存中的存储

今天让我们来看看整型的数据和浮点型的数据在内存中是怎么存储的呢 整型数据在内存中的存储 整型数据在内存中存储的是二进制的补码 正数的话也没什么可说的&#xff0c;原码反码补码都相同 我们来看看负数&#xff1a; 以-5为例 原码&#xff1a;10000000 00000000 00000000 0…
阅读更多...
集控中心的调度桌成就事业的重要工具

集控中心的调度桌成就事业的重要工具

在集控中心的调度室内&#xff0c;一排排整齐的调度桌构成了一道独特的风景线。其中最引人注目的便是那一张张配备现代化设备&#xff0c;宽敞而舒适的调度桌。就我们嘉德立来说这些调度桌不仅见证了调度员们严谨、细致的工作态度&#xff0c;也是他们成就事业的重要工具。 集控…
阅读更多...
C++初阶之入门

C++初阶之入门

零、什么是C C是基于C语言而产生的&#xff0c;它既可以进行C语言的过程化程序设计&#xff0c;又可以进行以抽象数据类型为特点的基于对象的程序设计&#xff0c;还可以进行面向对象的程序设计。 C缺点之一&#xff0c;是相对许多语言复杂&#xff0c;而且难学难精。许多人说学…
阅读更多...
13 c++版本的五子棋

13 c++版本的五子棋

前言 呵呵 这大概是 大学里面的 c 五子棋了吧 有一些 面向对象的理解, 但是不多 这里 具体的实现 就不赘述, 仅仅是 发一下代码 以及 具体的使用 然后 貌似 放在 win10 上面执行 还有一些问题, 渲染的, 应该很好调整 五子棋 #include<Windows.h> #include<io…
阅读更多...
ChatGPT全方位指导：学术论文写作从零开始，轻松搞定高质量论文！

ChatGPT全方位指导：学术论文写作从零开始，轻松搞定高质量论文！

目录 文末福利 一、论文选题的深度探讨 二、撰写摘要的艺术 三、关键词的精选 四、引言的构建 五、正文的结构设计 六、撰写结论的策略 七、致谢的编写 八、附录的有效利用 九、参考文献的整理 文末有福利哦 撰写一篇高质量的学术论文是一项既复杂又耗时的任务。这个…
阅读更多...
c++中的指针

c++中的指针

一、指针的基本概念 指针的作用&#xff1a;可以通过指针间接访问内存 内存编号是从0开始记录的&#xff0c;一般采用16进制数字表示。可以利用指针变量保存地址。 二、指针变量的定义和使用 指针变量定义语法&#xff1a; 数据类型 * 变量名 #include<iostream> u…
阅读更多...
JAVA实现easyExcel模版导出

JAVA实现easyExcel模版导出

easyExcel文档 模板注意&#xff1a; 用 {} 来表示你要用的变量 &#xff0c;如果本来就有"{“,”}" &#xff0c;特殊字符用"{“,”}"代替{} 代表普通变量{.}代表是list的变量 添加pom依赖 <dependency><groupId>com.alibaba</groupId&g…
阅读更多...
模块三：二分——LCR. 173.点名

模块三：二分——LCR. 173.点名

文章目录 题目描述算法原理暴力查找二分查找 代码实现暴力查找二分&#xff1a;CJava 题目描述 题目链接&#xff1a;LCR. 173.点名 关于这道题中&#xff0c;时间复杂度为 O(N) 的解法有很多种&#xff0c;⽽且也是⽐较好想的&#xff0c;这⾥就不再赘述。本题只讲解⼀个最优…
阅读更多...
超实用的电脑桌面便签+待办清单app

超实用的电脑桌面便签+待办清单app

对于上班族来说&#xff0c;桌面便签加待办清单软件是提升工作效率的得力助手。想象一下&#xff0c;在繁忙的工作中&#xff0c;你能够快速记录重要事项&#xff0c;设置待办任务提醒&#xff0c;一切都能有条不紊地进行。这种便捷性&#xff0c;尤其在处理多项任务和紧急事务…
阅读更多...
Unity读书系列《Unity3D游戏开发》——脚本（一）

Unity读书系列《Unity3D游戏开发》——脚本（一）

文章目录 前言一、脚本模版及其拓展1、脚本模版2、拓展脚本模版 二、脚本的生命周期三、脚本的执行顺序四、脚本序列化1、序列化数据2、serializedObject3、监听部分元素修改事件 五、定时器与间隔定时器六、工作线程&#xff08;多线程&#xff09;总结 前言 脚本在Unity的重…
阅读更多...
中颖51芯片学习9. PWM（12bit脉冲宽度调制）

中颖51芯片学习9. PWM（12bit脉冲宽度调制）

中颖51芯片学习9. PWM&#xff08;12bit脉冲宽度调制&#xff09; 一、资源简介二、PWM工作流程三、寄存器介绍1. PWMx控制寄存器PWMxCON2. PWM0周期寄存器PWM0PH/L3. PWM1周期寄存器PWM1PH/L4. PWM0占空比控制寄存器PWM0DH/L5. PWM1占空比控制寄存器 PWM1DH/L6. 占空比寄存器与…
阅读更多...
临床常用的8个护理评估量表分享，医护必备！

临床常用的8个护理评估量表分享，医护必备！

常笑医学整理了8个常用的护理评估量表&#xff0c;包括Morse跌倒量表、Braden压疮评分、格拉斯哥昏迷评分GCS、深静脉血栓评分DVT、Brathel日常生活活动能力量表等&#xff0c;这些量表在常笑医学网上均支持在线使用和下载&#xff0c;供医护人员学习与使用。 Morse跌倒危险因素…
阅读更多...
【北京迅为】《iTOP龙芯2K1000开发指南》-第三部分 迅为龙芯开发板快速体验

【北京迅为】《iTOP龙芯2K1000开发指南》-第三部分 迅为龙芯开发板快速体验

龙芯2K1000处理器集成2个64位GS264处理器核&#xff0c;主频1GHz&#xff0c;以及各种系统IO接口&#xff0c;集高性能与高配置于一身。支持4G模块、GPS模块、千兆以太网、16GB固态硬盘、双路UART、四路USB、WIFI蓝牙二合一模块、MiniPCIE等接口、双路CAN总线、RS485总线&#…
阅读更多...
webpack热更新原理详解

webpack热更新原理详解

文章目录 前言基础配置创建项目HMR配置 HMR交互概览HMR流程概述HMR实现细节初始化注册监听编译完成事件启动服务监听文件代码变化服务端发送消息客户端收到消息热更新文件请求热更新代码替换 问题思考 前言 刷新分为两种&#xff1a;一种是页面刷新&#xff0c;不保留页面状态…
阅读更多...
LANGUAGE-DRIVEN SEMANTIC SEGMENTATION

LANGUAGE-DRIVEN SEMANTIC SEGMENTATION

环境不易满足&#xff0c;不建议复现
阅读更多...
CentOS7利用宝塔面板安装zabbix6.0.x详细安装教程（手把手图文详解版）

CentOS7利用宝塔面板安装zabbix6.0.x详细安装教程（手把手图文详解版）

最近学习CentOS7安装zabbix6.0.x的版本&#xff0c;尝试了很多教程&#xff0c;很多都比较麻烦且容易出错&#xff0c;最后发现使用宝塔面板最为简单&#xff0c;将具体过程记录下来&#xff0c;一来分享给有需要的人&#xff0c;二来自己也当记录笔记&#xff0c;以免以后遗忘…
阅读更多...
Hive中几个非常重要的问题

Hive中几个非常重要的问题

1、Hive 有哪些方式保存元数据&#xff0c;各有哪些优缺点 (1).DerBy数据库&#xff1a;默认自带 优点&#xff1a;使用简单&#xff0c;不需要额外的配置。 缺点&#xff1a;只有一个客户端&#xff0c;多个客户访问会报错。 (2).使用MySql数据库存储 优点&#xff1a;单独的…
阅读更多...
OSPF的LSA详解

OSPF的LSA详解

一、什么是LSA&#xff1f;LSA作用&#xff1f; 在OSPF协议中&#xff0c;LSA全称链路状态通告&#xff0c;主要由LSA头部信息&#xff08;LSA摘要&#xff09;和链路状态组成。部分LSA只有LSA头部信息&#xff0c;无链路状态信息。使用LSA来传递路由信息和拓扑信息&#xff0c…
阅读更多...
linux系统安全

linux系统安全

一、账号安全基本措施 1.1 系统账号清理 1.1.1 将用户设置为无法登录-- 改登录shell 登录shell是用户与计算机系统直接交互的接口&#xff0c;使用户能够通过命令行方式进行各种操作和管理。 所以让用户无法登录&#xff0c;其实就是将登录shell改为 /sbin/nologin,可以用us…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023