精华内容
下载资源
问答
  • 记忆翻牌小游戏

    2019-11-03 19:23:58
    记忆翻牌小游戏
  • 一款原生js开发的记忆翻牌匹配小游戏代码,有多种难度模式可以选择。游戏规则:翻开两个格子,如果图案一致则配对,将其挑出,如果图案不一致则盖回去,直到所有格子都配对完成,游戏结束。
  • 主要功能实现翻开的2张牌如果配对就会消除,否则2张牌都会返回背面,下面为大家介绍一下需求分析及示例代码,感兴趣的朋友可以学习下
  • 记忆翻牌游戏,一开始所有牌都为盖着,点击以后,点击牌会翻过来,如果第二张点击的牌与第一张匹配,两张牌则都显示,否则会翻转到背面。
  • 本项目是一个基于安卓的翻牌游戏项目源码。12张中6对相同牌,用户可以设置几秒后翻面和游戏时间限制。并且有消除特效,背景音乐以及音效。 第一次运行将有引导页,平时启动有欢迎页。算是一个完整的游戏项目。
  • cocos creator写的记忆翻牌大师,基本功能都有实现,类似微信小游戏《记忆翻牌大师》。第一张与第二张相同的话两张都会翻到正面,否则都会返回到背面
  • 鼠标点击牌进行翻牌配对,按Esc退出。 Unity版本:2019.4.18f1c1
  • 记忆翻牌游戏.rar

    2020-09-15 10:40:27
    结合JavaScript、HTML、CSS开发的网页版小游戏(记忆翻牌),是一个初级的小项目,适合初学者进行练习
  • 这个是用C#编写的小游戏源程序,记忆翻牌-也叫图片配对,是学习C#练手用的,百分百自己原创,小游戏包含了美女、动物、水果、卡通等小图片,可以一类也可以任意随机组合,打开游戏音效,则玩游戏时会有十分震憾的...
  • 共16张图片背面向上,每次翻开一张图片,如果和上一次翻开的是相同的图片则加1分,知道得8分
  • Android 记忆翻牌游戏简单地匹配两张牌。
  • js记忆翻牌连连看游戏代码是一款原生js网格翻牌小游戏代码。
  • 原生JS记忆翻牌小游戏游戏截图游戏逻辑代码详解htmlcssjavascript 游戏截图 游戏逻辑 游戏规则:在被分成16个方格的小方块下面有被随机打乱分配的8对图片,使用鼠标点击方格将图片翻转,若连续两次翻转的图片相同,...

    游戏截图

    在这里插入图片描述

    游戏逻辑

    游戏规则:在被分成16个方格的小方块下面有被随机打乱分配的8对图片,使用鼠标点击方格将图片翻转,若连续两次翻转的图片相同,则该组图片翻转成功,若连续两次翻转的图片不一样,则两张图片会在0.3秒后自动翻转回方格,当8对图片全部被翻转成功则游戏胜利。
    主要逻辑

    1. 定义一个数组,将其用Array.sort()方法进行乱序处理
    2. 根据得到的乱序数组将图片进行洗牌,分配到不同的方块下隐藏
    3. 根据以上得到的图片排列逻辑,将图片元素渲染进页面
    4. 监听鼠标点击事件,并通过事件委托判断鼠标点击的单位是否为已经反转过得单位
    5. 根据两张连续被翻转牌的id判断是否相同,从而判断是否反转成功,若id相同则成功,若id不相同则不成功
    6. 当被成功反转牌的个数等于方块的总个数时,游戏成功

    自定义更改:想要更改游戏规格时,可以在对象初始化时将level参数调大,我准备的最大规格为level=3,想要更大规格同时也要准备同样多的图片,否则游戏中会出现多组相同的图片

    代码详解

    html页面结构

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>原生JS翻牌小游戏复刻1</title>
        <link rel="stylesheet" href="style.css">
    </head>
    <body>
        <div id="game">
    
        </div>
        <script src="index.js"></script>
    </body>
    </html>
    

    css外部样式

    * {
        margin: 0;
        padding: 0;
    }
    
    #game {
        width: 600px;
        height: 600px;
        margin: 60px auto;
    }
    
    .block {
        float: left;
        box-sizing: border-box;
        width: 25%;
        height: 25%;
        border: 2px solid #ddd;
        background-color: #f0f0f0;
    }
    
    .block:hover {
        background-color: #2b84d0;
    }
    
    .pic {
        width: 100%;
        height: 100%;
        background-repeat: no-repeat;
        background-position: center center;
        transform: scaleX(0);
        transition: transform .2s;
    }
    
    .block.on .pic {
        transform: scaleX(1);
    }
    

    javascript页面行为

    var game = {
        el: '',//父元素
        level: 0,//当前游戏级别
        blocks: 0,//“牌”的总数
        gameWidth: 600,//游戏区域宽度,单位px
        gameHeight: 600,//游戏区域的高度,单位px
        dataArr: [],//数据数组,存放牌的信息
        judgeArr: [],//判断数组,存放被翻转牌的信息
        turnNum: 0,//翻转牌的总数
        picNum: 20,//牌的总数
        maxLevel: 3,//最高游戏级别
        init: function(options) {
            this.initData(options);
            this.render();
            this.handle();
        },
        initData: function(options) {
            this.options = options;
            this.el = options.el;
            this.level = options.level > this.maxLevel ? this.maxLevel : options.level;
            this.blocks = (this.level * 2) * (this.level * 2);
            this.getdataArr();
        },
        getdataArr: function() {
            /**
             * 获取数据数组
             */
            //1,利用Array.sort乱序
            var randomArr = this.randomArr();//得到随机数组
            var halfBlocks = this.blocks / 2;//得到排数的一半
            var dataArr = [];
    
            for(var i = 0; i < halfBlocks; i ++) {
                var num = randomArr[i];
                var info = {
                    url: './images/' + num + '.png',
                    id: num
                }
                dataArr.push(info,info);
            }
            this.dataArr = this.shuffle(dataArr);
        },
        randomArr: function() {
            /**
             * 回去数字数组
             * 数组中的每一项为0到count数字
             */
            var picNum = this.picNum;
            var arr = [];
            for(var i = 0; i < picNum; i ++) {
                arr.push(i + 1);
            }
            return this.shuffle(arr);
        },
        shuffle: function(arr) {
            /**
             * 洗牌,数组乱序方法
             */
            //1,利用Array.sort方法进行数组乱序
            return arr.sort(function() {
                return 0.5 - Math.random();
            })
        },
        render: function() {
            /**
             * 渲染元素
             */
            //var template = '';
            var blocks = this.blocks;
            var gameWidth = this.gameWidth;
            var gameHeight = this.gameHeight;
            var level = this.level;
            var blockWidth = gameWidth / (level * 2);
            var blockHeight = gameHeight / (level * 2);
            var dataArr = this.dataArr;
    
            for(var i = 0; i < blocks; i ++) {
                var info = dataArr[i];
                var oBlock = document.createElement('div');
                var oPic = document.createElement('div');
                oPic.style.backgroundImage = 'url(' + info.url + ')';
                oBlock.style.width = blockWidth + 'px';
                oBlock.style.height = blockHeight + 'px';
                oBlock.picid = info.id;
                oPic.setAttribute('class','pic');
                oBlock.setAttribute('class','block');
                oBlock.appendChild(oPic);
                this.el.appendChild(oBlock);
            }
        },
        handle: function() {
            /**
             * 监听父元素的点击事件
             * 通过事件委托判断点击的元素是否为未翻转的牌
             */
            var self = this;
            this.el.onclick = function(e) {
                var dom = e.target;
                var isBlock = dom.classList.contains('block');
                if(isBlock) {
                    self.handleBlock(dom);
                }
            }
        },
        handleBlock: function(dom) {
            /**
             * 点击未翻转成功的牌时
             * 如果点击了两张牌,咋判断是否为同一张牌
             */
            var picId = dom.picid;
            var judgeArr = this.judgeArr;
            var judgeLength = judgeArr.push({
                id: picId,
                dom: dom
            });
            dom.classList.add('on');
    
            if(judgeLength === 2) {this.judgePic();}
            this.judgeWin();
        },
        judgePic: function() {
            /**
             * 判断被翻转牌的图片是否相同
             * 若两个元素的id相同,则翻转成功
             * 若不同,则不成功,将牌再次翻转
             */
            var judgeArr = this.judgeArr;
            var isSamePic = judgeArr[0].id === judgeArr[1].id;
    
            if(isSamePic) {
                this.turnNum += 2;
            } else {
                var picDom1 = judgeArr[0].dom;
                var picDom2 = judgeArr[1].dom;
                setTimeout(function() {
                    picDom1.classList.remove('on');
                    picDom2.classList.remove('on');
                },800)
            }
            judgeArr.length = 0;
        },
        judgeWin: function() {
            /**
             * 判断游戏是否胜利
             * 如果翻转成功牌的个数等于牌的总个数,则胜利
             */
    
             if(this.turnNum === this.blocks) {
                 setTimeout(function() {
                     alert('胜利');
                 },300)
             }
        }
    }
    
    game.init({
        el: document.getElementById('game'),
        level: 2
    })
    
    展开全文
  • 记忆翻牌游戏单机版

    2012-04-23 20:45:08
    记忆翻牌游戏,基于VC++6.0的MFC技术实现,此单机版!后续本人将发布网络对战版...
  • 主要为大家详细介绍了原生JS实现记忆翻牌游戏,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • C#小游戏-记忆翻牌

    2021-09-19 03:01:12
    记忆翻牌是一个记忆游戏,翻开一张牌,再翻开另一张牌,如果两张牌一样,那么就成显示状态,否则两张牌都重新盖回去。并不是最简洁的,只是功能的实现。
  • js记忆翻牌连连看游戏代码是一款原生js网格翻牌小游戏代码。
  • 这是动态编程语言(python)大作业-记忆翻牌游戏的代码,实现了记忆翻牌游戏的功能,相关介绍可以去看:https://mp.csdn.net/postedit。
  • 基于Linux系统的SDL图形库记忆翻牌小游戏 图片
  • 记忆翻牌游戏的源代码

    热门讨论 2010-08-28 09:49:28
    课题项目~俺和俺的搭档一起做的(数组代码是参考部分资料的) 只带源代码供参考
  • 接上回,对于上篇中的翻牌效果,虽然实现了鼠标点击翻牌,但是可以发现,已经翻开的扑克牌,依然被放置在牌桌上,没有被移除。 此篇就来实现移除效果。 先来看看最终效果。 上篇我们已经可以通过鼠标点击翻牌,要想...

    前两篇的文章
    记忆翻牌游戏(一)
    记忆翻牌游戏(二)


    接上回,对于上篇中的翻牌效果,虽然实现了鼠标点击翻牌,但是可以发现,已经翻开的扑克牌,依然被放置在牌桌上,没有被移除。
    此篇就来实现移除效果。

    先来看看最终效果。

    在这里插入图片描述
    上篇我们已经可以通过鼠标点击翻牌,要想实现移除效果,则需要对扑克牌进行配对检查。
    基本思路如下:

    • 遍历扑克牌集合中的每一张扑克牌,如果牌是第一张被翻开的,记录下此时牌的点数,若是第二张被翻开的,也记录下牌的点数;
    • 将第一张牌的点数与第二张牌的点数进行比较,若点数相同,则移除这两张牌,若不同,则将两张牌恢复为初始状态(即背面朝上)。

    在Table类的act()方法中添加以下配对检查的代码

    • 首先定义所需要的变量
    Card card1 = null, card2 = null;  //用来保存两张牌的对象
    int count = 0;                    //表示牌桌上被翻开的是第几张牌
    int card1Value = 0,card2Vlaue = 0;//记录两张牌的点数
    
    • 接下来循环遍历扑克牌集合
      整体框架
    for (int i=0; i< cards.size(); i++) {	//用for循环遍历集合cards中的所有牌
                if (cards.get(i).getFaceup() == true) {	//如果遍历到的这张牌是翻开的
                    count++;		//用count将牌桌上翻开的牌数累加
                    if (count == 1) {			//如果是第一张翻开的牌
                    
                    }
                    if (count == 2) {			//如果是第二张翻开的牌
                    
                   }    
                }
            }
    

    通过count的值来确定当前被翻开的牌是第几张,为1则表示为第一张,只需保存其点数。

     if (count == 1) {			//如果是第一张翻开的牌
     	card1 = cards.get(i);	
        card1Value = card1.getValue();	//变量card1Value记录第一张翻开牌的点数
                    }
    

    保存点数后继续遍历集合,若还有被点击翻开的扑克牌,则count值加为2,并且比较桌上被翻开的两张牌的点数是否相同。

     if (count == 2) {			//如果是第二张翻开的牌
     	card2 = cards.get(i);
        card2Value = card2.getValue();	//变量card2Value记录第二张翻开牌的点数
        if (card1Value == card2Value) {   // 如果翻开的两张牌的点数是一样的 
        	Greenfoot.playSound("WaterDrop.wav");
            Greenfoot.delay(10);	//延迟10毫秒,游戏效果更好
            
            //移除翻开的两张同样的牌
            removeObject(card1);
            removeObject(card2);
            cards.remove(card1);
            cards.remove(card2);
        } else {	
        	//如果翻开的两张牌不同
            reenfoot.delay(15);
            
            // 将两张牌面朝下背朝上
            card1.turnFaceDown();
            card2.turnFaceDown();
        }
        break;	//剩下的牌不再遍历,结束for循环
    }        
    

    通过比较card1Value和card2Value的值是否相同来判断两张牌是否相同,相同则调用removeObject()方法将其从牌桌移除,同时也需要调用remove()方法将其从整个扑克牌集合中移除。

    完整代码如下:

    import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
    import java.util.ArrayList;
    import java.util.Collections;
    
    /**
     * 牌桌类,提供游戏的运行场景
     */
    public class Table extends World{
        ArrayList<Card> cards = new ArrayList<Card>();  //声明一个保存扑克牌对象的集合cards 
        //Table类的构造方法
        public Table() {   
            super(600, 400, 1);
            for (int i=1; i<=5; i++) {      //向集合cards中添加两组共10张5点以下的牌
                cards.add(new Card(i));
                cards.add(new Card(i));
            }
            Collections.shuffle(cards); //集合类Collections的混排算法,用于打乱集合cards中牌的顺序
            int x=100, y=100;   //牌桌上摆放牌的起点坐标
            for (int i=0; i<5; i++) {   //用for循环依次在牌桌上摆放每排5张,共两排的扑克牌
                addObject(cards.get(i) , x, y);
                addObject(cards.get(i+5) , x, y + cards.get(i).getImage().getHeight() + 20);
                x += cards.get(i).getImage().getWidth()+20;
            }
        }
        
        //act()方法是游戏单步执行的动作
        public void act() {     
            int count = 0, card1Value=0, card2Value=0;	//count表示牌桌上被翻开的第几张牌
            Card card1=null, card2=null;
            for (int i=0; i< cards.size(); i++) {	//用for循环遍历集合cards中的所有牌
                if (cards.get(i).getFaceup() == true) {	//如果遍历到的这张牌是翻开的
                    count++;		//用count将牌桌上翻开的牌数累加
                    if (count == 1) {			//如果是第一张翻开的牌
                        card1 = cards.get(i);	
                        card1Value = card1.getValue();	//变量card1Value记录第一张翻开牌的点数
                    }
                    if (count == 2) {			//如果是第二张翻开的牌
                        card2 = cards.get(i);
                        card2Value = card2.getValue();	//变量card2Value记录第二张翻开牌的点数
                        if (card1Value == card2Value) {   // 如果翻开的两张牌的点数是一样的 
                            Greenfoot.playSound("WaterDrop.wav");
                            Greenfoot.delay(10);	//延迟10毫秒,游戏效果更好
                            //移除翻开的两张同样的牌
                            removeObject(card1);
                            removeObject(card2);
                            cards.remove(card1);
                            cards.remove(card2);
                        }
                        else {	//如果翻开的两张牌不同
                            Greenfoot.delay(15);
                            // 将两张牌面朝下背朝上
                            card1.turnFaceDown();
                            card2.turnFaceDown();
                        }
                        break;	//两张牌如相同,则移除,如不同,则翻回来。剩下的牌不再遍历,结束for循环
                    }
                }
            }
        }
    }
    
    

    至此,鼠标点击翻牌,并且相同点数的牌从牌桌上移除的效果已实现。

    展开全文
  • 记忆翻牌游戏(一) 记忆翻牌游戏(二) 记忆翻牌游戏(三) 在上一篇中我们已经实现了记忆翻牌游戏的大部分功能,游戏也能正常运行。那我们怎样才能知道游戏已经结束了呢?还是需要给用户一点提示。 今天就来实现...

    前几篇文章在这里
    记忆翻牌游戏(一)
    记忆翻牌游戏(二)
    记忆翻牌游戏(三)


    在上一篇中我们已经实现了记忆翻牌游戏的大部分功能,游戏也能正常运行。那我们怎样才能知道游戏已经结束了呢?还是需要给用户一点提示。
    今天就来实现最后一点游戏结束功能

    最终效果
    在这里插入图片描述
    当牌桌上所有的扑克牌都被消除时,给用户一个游戏结束的信息。

    需要做的就是,在每一轮比较之后,检查桌面上是否还残存有扑克牌,若有,则游戏继续,若没有,则游戏结束。

    if (cards.size() == 0) {            //配对的牌全部找到,游戏结束
    	showText("Game Over!",300,200);
    	Greenfoot.stop();
    }
    

    显示画面如下:

    在这里插入图片描述
    完整代码如下:

    import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
    import java.util.ArrayList;
    import java.util.Collections;
    
    /**
     * 牌桌类,提供游戏的运行场景
     */
    public class Table extends World{
        ArrayList<Card> cards = new ArrayList<Card>();  //声明一个保存扑克牌对象的集合cards 
        //Table类的构造方法
        public Table() {   
            super(600, 400, 1);
            for (int i=1; i<=5; i++) {      //向集合cards中添加两组共10张5点以下的牌
                cards.add(new Card(i));
                cards.add(new Card(i));
            }
            Collections.shuffle(cards); //集合类Collections的混排算法,用于打乱集合cards中牌的顺序
            int x=100, y=100;   //牌桌上摆放牌的起点坐标
            for (int i=0; i<5; i++) {   //用for循环依次在牌桌上摆放每排5张,共两排的扑克牌
                addObject(cards.get(i) , x, y);
                addObject(cards.get(i+5) , x, y + cards.get(i).getImage().getHeight() + 20);
                x += cards.get(i).getImage().getWidth()+20;
            }
        }
        
        //act()方法是游戏单步执行的动作
        public void act() {     
            int count = 0, card1Value=0, card2Value=0;	//count表示牌桌上被翻开的第几张牌
            Card card1=null, card2=null;
            for (int i=0; i< cards.size(); i++) {	//用for循环遍历集合cards中的所有牌
                if (cards.get(i).getFaceup() == true) {	//如果遍历到的这张牌是翻开的
                    count++;		//用count将牌桌上翻开的牌数累加
                    if (count == 1) {			//如果是第一张翻开的牌
                        card1 = cards.get(i);	
                        card1Value = card1.getValue();	//变量card1Value记录第一张翻开牌的点数
                    }
                    if (count == 2) {			//如果是第二张翻开的牌
                        card2 = cards.get(i);
                        card2Value = card2.getValue();	//变量card2Value记录第二张翻开牌的点数
                        if (card1Value == card2Value) {   // 如果翻开的两张牌的点数是一样的 
                            Greenfoot.playSound("WaterDrop.wav");
                            Greenfoot.delay(10);	//延迟10毫秒,游戏效果更好
                            //移除翻开的两张同样的牌
                            removeObject(card1);
                            removeObject(card2);
                            cards.remove(card1);
                            cards.remove(card2);
    						if (cards.size() == 0) {    //配对的牌全部找到,游戏结束
                                showText("Game Over! ",  300, 200);
                                Greenfoot.stop();
                            }
                        }
                        else {	//如果翻开的两张牌不同
                            Greenfoot.delay(15);
                            // 将两张牌面朝下背朝上
                            card1.turnFaceDown();
                            card2.turnFaceDown();
                        }
                        break;	//两张牌如相同,则移除,如不同,则翻回来。剩下的牌不再遍历,结束for循环
                    }
                }
            }
        }
    }
    
    

    至此,记忆翻牌游戏已全部完成,但只是实现了最基本的功能,还有改进和完善的地方。

    • 加入更多的扑克牌
    • 添加计数器和计时器,记录玩家翻牌的次数以及整个游戏用时
    • 添加更多的文字提示
    • 使用其他图像
    展开全文
  • 这是动态编程语言(python)大作业-记忆翻牌游戏的代码,实现了记忆翻牌游戏的功能。 代码(如需素材及完整项目可以:): import pygame import time from random import shuffle pygame.init() display_...

    这是动态编程语言(python)大作业-记忆翻牌游戏的代码,实现了记忆翻牌游戏的功能。

    代码(如需素材及完整项目可以:):

    import pygame
    import time
    from random import shuffle
    
    pygame.init()
    
    display_width = 900
    display_height = 600
    image_width = 150
    image_height = 150
    level = 1
    
    start_time = time.time()
    flag = 1
    
    black = (0, 0, 0)
    white = (255, 255, 255)
    red = (255, 0, 0)
    green = (0, 200, 0)
    bright_red = (255, 0, 0)
    bright_green = (0, 255, 0)
    mmm_orange = (255, 136, 17)
    mmm_orange_lite = (255, 157, 60)
    mmm_yellow = (244, 208, 111)
    mmm_blue = (157, 217, 210)
    mmm_cream = (255, 248, 240)
    mmm_purple = (57, 47, 90)
    mmm_purple_lite = (93, 84, 120)
    
    gameDisplay = pygame.display.set_mode((display_width, display_height))
    pygame.display.set_caption('记忆翻牌')
    clock = pygame.time.Clock()
    
    win = False
    run = True
    original = []
    cnt = 0
    usertime = 0
    start_time = 0
    # 初始化所有隐藏图像的位置 
    for i in range(12):
        original.append(i)
        original.append(i)
    
    shuffle(original)
    
    concealed = list(original)
    flipped = []
    found = []
    missed = 0
    first_card = []
    has_first = False
    has_second = False
    second_card = []
    first_flip_time = 0
    second_flip_time = 0
    show_time = 1
    game_start_time = 0
    start_screen = True
    
    
    def initialize():
        print("重新开始}}}}}}}}}}}}}}}}}}")
        # 删除全局变量
        global win, run, original, concealed, flipped, found, missed, first_card, has_first, has_second, second_card
        global first_flip_time, second_flip_time, show_time, game_start_time, start_screen
        win = False
        run = True
        original = []
    
        for i in range(12):
            original.append(i)
            original.append(i)
    
        shuffle(original)
    
        concealed = list(original)
        flipped = []
        found = []
        missed = 0
        first_card = []
        has_first = False
        has_second = False
        second_card = []
        first_flip_time = 0
        second_flip_time = 0
        show_time = 1
        game_start_time = 0
        start_screen = True
    
    def text_objects(text, font, colour):
        text_surface = font.render(text, True, colour)
        return text_surface, text_surface.get_rect()
    
    
    def draw_start_screen(mouse):
        gameDisplay.fill(mmm_purple)
        draw_text(mmm_cream, "fonts/ARCADE.TTF", 200, "WECHAT", (display_width / 2), 120)
        draw_text(mmm_cream, "fonts/ARCADE.TTF", 58, "MEMORY-MATCH", (display_width / 2), 165)
        draw_text(mmm_cream, "fonts/ARCADE.TTF", 35, "Medium", (display_width / 2) + 26, 300)
        draw_text(mmm_cream, "fonts/ARCADE.TTF", 35, "Level feature coming soon", (display_width / 2) + 26, 370)
        start = draw_interactive_button(mouse, 300, 50, 485, mmm_orange, mmm_orange_lite, "START", False)
        pygame.draw.circle(gameDisplay, mmm_cream, (int(display_width / 2) - 56, 295), 9, 3)
        select_level()
        return start
    
    
    def select_level():
        h = 295
        pygame.draw.circle(gameDisplay, mmm_cream, (int(display_width / 2) - 56, h), 2)
    
    
    def draw_win_screen(mouse):
        global win
        win = False
        gameDisplay.fill(mmm_purple)
        draw_text(mmm_yellow, "fonts/ARCADE.TTF", 150, "Congrats!", (display_width / 2), 200)
        draw_text(mmm_yellow, "fonts/ARCADE.TTF", 58, "You found all the pieces", (display_width / 2), 270)
        draw_text(mmm_yellow, "fonts/ARCADE.TTF", 58, "Your time is : %ds" % int(usertime) , (display_width / 2), 270  + 100)
        restart = draw_interactive_button(mouse, 300, 50, 485, mmm_orange, mmm_orange_lite, "PLAY AGAIN", True)
        return restart
    
    
    def draw_text(colour, font, size, content, center_x, center_y):
        text = pygame.font.Font(font, size)
        text_surf, text_rect = text_objects(content, text, colour)
        text_rect.center = (center_x, center_y)
        gameDisplay.blit(text_surf, text_rect)
    
    
    def draw_interactive_button(mouse, w, h, y, colour, secondary_colour, text, restart):
        stay_on_start_screen = True
        x = display_width / 2 - w / 2
        click = pygame.mouse.get_pressed()
        if x + w > mouse[0] > x and y + h > mouse[1] > y:
            pygame.draw.rect(gameDisplay, secondary_colour, (x, y, w, h))
            if click[0] == 1:
                print("重新开始-----139")
                flag = 1
                stay_on_start_screen = False
                if restart:
                    global  start_time
                    start_time = time.time()
                    initialize()
        else:
            pygame.draw.rect(gameDisplay, colour, (x, y, w, h))
    
        draw_text(mmm_cream, "fonts/ARCADE.TTF", 50, text, display_width / 2, y + 32)
        return stay_on_start_screen
    
    
    def load_card_face(image_id):
        card = "./bundle2/img%s.JPG" % image_id
        img = pygame.image.load(card)
        return img
    
    
    def load_card_back():
        card = "./cardback/card_back2.JPG"
        img = pygame.image.load(card)
        return img
    
    def calculate_coord(index):
        y = int(index / 6)
        x = index - y * 6
        return [x, y]
    
    
    def load_images():
        for n, j in enumerate(concealed):
            card_coord = calculate_coord(n)
            if (j == 's') or (j == 'f'):
                img = load_card_face(original[n])
            else:
                img = load_card_back()
            gameDisplay.blit(img, (card_coord[0] * image_width, card_coord[1] * image_height))
    
    
    def identify_card(position_pressed):
        x_coord = int(position_pressed[0] / image_width)
        y_coord = int(position_pressed[1] / image_height)
        card = [x_coord, y_coord]
        return card
    
    
    def calculate_index(card_pos):
        return card_pos[1] * 6 + card_pos[0]
    
    
    def show_card(card_pos):
        if card_pos:
            concealed[calculate_index(card_pos)] = 's'
    
    
    def flip_card(card_pos):
        if card_pos:
            concealed[calculate_index(card_pos)] = 'f'
    
    
    def hide_card(card_pos):
        if card_pos:
            ind = calculate_index(card_pos)
            if concealed[ind] == 's':
                concealed[ind] = original[ind]
    
    
    def check_same(card1, card2):
        if card1 and card2:
            return original[calculate_index(card1)] == original[calculate_index(card2)]
    
    
    def check_win():
        is_win = True
        for item in concealed:
            if isinstance(item, int):
                is_win = False
        return is_win
    
    
    
    # 用一整个循环运行游戏
    while run:
        ev = pygame.event.get()
        key = pygame.key.get_pressed()
        for event in ev:
            if event.type == pygame.QUIT:
                run = False
            elif event.type == pygame.KEYDOWN:
                if start_screen:
                    if event.key == pygame.K_RETURN:
                        start_screen = False
                        # start_time = time.time()
                        # flag = 1
                        print("开始------")
                    elif event.key == pygame.K_ESCAPE:
                        run = False
            elif event.type == pygame.MOUSEBUTTONDOWN:
                cnt = cnt + 1
                card_flipped = identify_card(pygame.mouse.get_pos())
                card_index = calculate_index(card_flipped)
                if concealed[card_index] != 's' and concealed[card_index] != 'f' and not start_screen:
                    if not has_first:
                        first_flip_time = time.time()
                        first_card = card_flipped
                        show_card(card_flipped)
                        is_first_flip = False
                        has_first = True
                    elif not has_second:
                        second_flip_time = time.time()
                        second_card = card_flipped
                        show_card(card_flipped)
                        has_second = True
    
        if has_first and has_second and check_same(first_card, second_card):
            flip_card(first_card)
            flip_card(second_card)
        if has_second and (time.time() - second_flip_time > show_time):
            hide_card(second_card)
            hide_card(first_card)
            has_first = has_second = False
    
        win = check_win()
    
        # if cnt > 2 and cnt < 4:
        #     win = True
        mouse = pygame.mouse.get_pos()
        if start_screen:
            # print("游戏开始!")
            flag = 1
            start_time = time.time()
            start_screen = draw_start_screen(mouse)
        elif not win:
            load_images()
        else:
            # print("win")
            if flag == 1:
                # print("sta: ", start_time)
                usertime = time.time() - start_time   #计算用时
                print("win: ", win, start_time)
                flag = 0
            restart = draw_win_screen(mouse)
    
        pygame.display.update()
        clock.tick(60)
    
    pygame.quit()
    quit()
    

     

    展开全文
  • 今天来学习怎样用Greenfoot制作一款记忆翻盘游戏。 游戏规则如下:首先在牌桌上摆放一系列的扑克牌,游戏开始时牌的背面朝上,玩家无法看到牌的...四、 记忆翻牌游戏 一、Greenfoot概述 Greenfoot是由英国肯特大学的M
  • 原生JS实现记忆翻牌小游戏

    千次阅读 2020-05-03 19:51:53
    html代码 <div id="game"> <!-- div.block*16>div.pic --> </div> css代码 * { padding: 0; margin: 0; } #game { width: 600px; height: 600px; margin: 0 auto;... ...
  • 自己做的一个记忆翻牌小游戏,做的不是很好,开放源代码
  • css3 ,js,记忆翻牌

    2013-05-24 11:37:14
    用html写的页面结构,使用CSS3动画效果,js控制事件。

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 371
精华内容 148
关键字:

记忆翻牌