unity_简单五子棋的实现（无AI）

最新推荐文章于 2023-10-03 12:41:07 发布
最新推荐文章于 2023-10-03 12:41:07 发布
阅读量347 收藏 4
点赞数
文章标签： 游戏 ui
原文链接：http://www.cnblogs.com/fomando/p/9548751.html
版权

首先在网上找一张棋盘的图片（16x16），导入unity，图片类型设置为Sprite（2D and UI），作为背景；

 

 

新建 2D 物体  sprite   在Sprite Render 内的Sprite 中指定之前导入的图片。

通过Scale调整背景的大小  使得边界落子位置能够处在一个较为工整的坐标位置。

创建空物体 GameManager  用于挂载 GameManager。

创建空物体Gird 用于存放棋子。（坐标重置）

 

 

创建关于棋子的类 PointItem.cs

棋子类型分为空类型，白，黑。通过调节 color的rgba值来实现，游戏开始所有的棋子都为无色。

该类挂载在棋子预支体上

 1 using System;
 2 using System.Collections;
 3 using System.Collections.Generic;
 4 using UnityEngine;
 5 public enum PointType
 6 {
 7     Empty,
 8     White,
 9     Black
10 }
11 
12 public class PointItem :MonoBehaviour
13 {
14     PointType pointType;
15     SpriteRenderer sr;
16     public int X, Y;
17 
18     void Start()
19     {
20         sr = this.gameObject.GetComponent<SpriteRenderer>();
21     }
22 
23     public PointType PointType
24     {
25         get { return pointType; }
26         set 
27         { 
28             pointType = value;
29             if (pointType == PointType.White)
30                 sr.color = new Color(1, 1, 1, 1);
31             if (pointType == PointType.Black)
32                 sr.color = new Color(0, 0, 0, 1);  
33         }
34     }
35 
36     public PointItem(int x,int y)
37     {
38         this.X = x;
39         this.Y = y;
40         this.pointType = PointType.Empty;
41     }
42 }

预制体的创建只需要用基本图形创建圆形的2d sprite就可以了（初始设置为全透明）   设置好 tag  和  layer  即可

GameManager.cs如下    算法很烂  但是感觉思路应该问题不大 

每次落子的时候（先进行横向匹配），先向左遍历，如果左边第一子与落子颜色相同，继续向左遍历，如果左边第二子颜色不同或为空，

则直接判断右边三子（3个）的颜色是否与落子相同，如果相同则落子胜  否则为不胜。

可以理解为左一同，则右三同可胜

                  左二同，则右二同可胜

                   。。。

同理可以做出纵向匹配和斜向匹配。（注意好索引溢出的问题就好了）

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class GameManager : MonoBehaviour {
    
    PointItem[,] points;

    public GameObject go;

    GameObject gird;

    private PointType State = PointType.White;

	void Start () {
        points = new PointItem[16,16];

        gird = GameObject.FindGameObjectWithTag("Gird");
        for (int i = 0; i < 16; i++)
        {
            for (int j = 0; j < 16; j++)
            {
                Vector3 position = new Vector3(-7.5f + Mathf.Floor(j), 7.5f - Mathf.Floor(i), 0f);
                GameObject goo = Instantiate(go,position,Quaternion.identity);
                goo.transform.SetParent(gird.transform);
                PointItem p = goo.transform.GetComponent<PointItem>();
                p.X = j;
                p.Y = i;
                points[j,i] = p;
            }
        }
	}
    void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            //Debug.Log("点击了");
            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            RaycastHit hit;
            PointItem p;
            if(Physics.Raycast(ray,out hit))
            {
                if (hit.transform.gameObject.tag == "trigger")
                {
                    p = hit.transform.GetComponent<PointItem>();
                    Choose(p.X,p.Y);
                   // Debug.Log(new Vector2(p.X, p.Y));
                }
            }
        }
    }


    public void Choose(int x,int y)
    {
        if (points[x,y].PointType != PointType.Empty)
            return;

        points[x,y].PointType = State;
        Comfirm(x, y, State);
        if (State == PointType.White)
            State = PointType.Black;
        else
            State = PointType.White;
    }

    public void Comfirm(int x, int y, PointType p)
    {

        //横向匹配
        if (x - 1 > -1 && points[x - 1, y].PointType == p)
        {
            if (x - 2 > -1 && points[x - 2, y].PointType == p)
            {
                if (x - 3 > -1 && points[x - 3, y].PointType == p)
                {
                    if (x - 4 > -1 && points[x - 4, y].PointType == p)
                    {
                        Debug.Log(p + "赢了");
                    }
                    else if (x + 1 < 16)
                    {
                        if (points[x + 1, y].PointType == p)
                            Debug.Log(p + "赢了");
 
                    }
                }
                else if (x + 2 < 16)
                {
                    if (points[x + 1, y].PointType == p &&
                        points[x + 2, y].PointType == p)
                        Debug.Log(p + "赢了");

                }
            }
            else if (x + 3 < 16)
            {
                if (points[x + 1, y].PointType == p &&
                    points[x + 2, y].PointType == p &&
                    points[x + 3, y].PointType == p)
                    Debug.Log(p + "赢了");

            }
        }
        else if (x + 4 < 16)
        {
            if (points[x + 1, y].PointType == p &&
                points[x + 2, y].PointType == p &&
                points[x + 3, y].PointType == p &&
                points[x + 4, y].PointType == p)
                Debug.Log(p + "赢了");

        }

        //纵向匹配
        if (y - 1 > -1 && points[x, y - 1].PointType == p)
        {
            if (y - 2 > -1 && points[x, y - 2].PointType == p)
            {
                if (y - 3 > -1 && points[x, y - 3].PointType == p)
                {
                    if (y - 4 > -1 && points[x, y - 4].PointType == p)
                    {
                        Debug.Log(p + "赢了");

                    }
                    else if (y + 1 < 16)
                    {
                        if (points[x, y + 1].PointType == p)
                            Debug.Log(p + "赢了");

                    }
                }
                else if (y + 2 < 16)
                {
                    if (points[x, y + 1].PointType == p &&
                        points[x, y + 2].PointType == p)
                        Debug.Log(p + "赢了");

                }
            }
            else if (y + 3 < 16)
            {
                if (points[x, y + 1].PointType == p &&
                    points[x, y + 2].PointType == p &&
                    points[x, y + 3].PointType == p)
                    Debug.Log(p + "赢了");

            }
        }
        else if (y + 4 < 16)
        {
            if (points[x, y + 1].PointType == p &&
                points[x, y + 2].PointType == p &&
                points[x, y + 3].PointType == p &&
                points[x, y + 4].PointType == p)
                Debug.Log(p + "赢了");

        }

        //左上右下匹配
        if (y - 1 > -1 && x - 1 > -1 && points[x - 1, y - 1].PointType == p)
        {
            if (y - 2 > -1 && x - 2 > -1 && points[x - 2, y - 2].PointType == p)
            {
                if (y - 3 > -1 && x - 3 > -1 && points[x - 3, y - 3].PointType == p)
                {
                    if (y - 4 > -1 && x - 4 > -1 && points[x - 4, y - 4].PointType == p)
                    {
                        Debug.Log(p + "赢了");

                    }
                    else if (y + 1 < 16 && x + 1 < 16)
                    {
                        if (points[x + 1, y + 1].PointType == p)
                            Debug.Log(p + "赢了");

                    }
                }
                else if (y + 2 < 16 && x + 2 < 16)
                {
                    if (points[x + 1, y + 1].PointType == p &&
                        points[x + 2, y + 2].PointType == p)
                        Debug.Log(p + "赢了");

                }
            }
            else if (y + 3 < 16 && x + 3 < 16)
            {
                if (points[x + 1, y + 1].PointType == p &&
                    points[x + 2, y + 2].PointType == p &&
                    points[x + 3, y + 3].PointType == p)
                    Debug.Log(p + "赢了");

            }
        }
        else if (y + 4 < 16 && x + 4 < 16)
        {
            if (points[x + 1, y + 1].PointType == p &&
                points[x + 2, y + 2].PointType == p &&
                points[x + 3, y + 3].PointType == p &&
                points[x + 4, y + 4].PointType == p)
                Debug.Log(p + "赢了");

        }

        //右上左下匹配
        if (y - 1 > -1 && x + 1 < 16 && points[x + 1, y - 1].PointType == p)
        {
            if (y - 2 > -1 && x + 2 < 16 && points[x + 2, y - 2].PointType == p)
            {
                if (y - 3 > -1 && x + 3 < 16 && points[x + 3, y - 3].PointType == p)
                {
                    if (y - 4 > -1 && x + 4 < 16 && points[x + 4, y - 4].PointType == p)
                    {
                        Debug.Log(p + "赢了");

                    }
                    else if (y + 1 < 16 && x - 1 > -1)
                    {
                        if (points[x - 1, y + 1].PointType == p)
                            Debug.Log(p + "赢了");

                    }
                }
                else if (y + 2 < 16 && x - 2 > -1)
                {
                    if (points[x - 1, y + 1].PointType == p &&
                        points[x - 2, y + 2].PointType == p)
                        Debug.Log(p + "赢了");

                }
            }
            else if (y + 3 < 16 && x - 3 > -1)
            {
                if (points[x - 1, y + 1].PointType == p &&
                    points[x - 2, y + 2].PointType == p &&
                    points[x - 3, y + 3].PointType == p)
                    Debug.Log(p + "赢了");

            }
        }
        else if (y + 4 < 16 && x - 4 > -1)
        {
            if (points[x - 1, y + 1].PointType == p &&
                points[x - 2, y + 2].PointType == p &&
                points[x - 3, y + 3].PointType == p &&
                points[x - 4, y + 4].PointType == p)
                Debug.Log(p + "赢了");

        }
    }

}

 算法感觉很笨拙  而且即使前面胜利   后面的if语句还是会执行。

 我的解决思路是将这4个匹配做成4个方法里  返回bool值

 再通过或运算来得到结果。

 不知道还有没有什么更好的办法。

 感觉应该有更省事的写法，不知道有没有大神指点一下。

 

转载于:https://www.cnblogs.com/fomando/p/9548751.html

叛逆的鲁鲁修love CC
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Unity开发的五子棋游戏
04-27
自己用UNITY开发的五子棋程序，支持悔棋。
Unity五子棋（三种难度人机）
08-10
自己的毕业设计，有源码、成品、答辩ppt和视频演示。 游戏有三种不同难度的人机，初级和中级人机使用贪心算法，中级人机扩充了棋谱，高级人机使用了博弈树理论、极大极小值算法、Alpha-Beta剪枝、深度优先遍历和广度优先遍历，由于时间有限，最高等级的人机完成度并不高，有能力的人可以自行改进。此外，也可以进行局域网对战，测试时可以一台电脑打开两个游戏成品进行对战。 论文相关的其他材料没有打包进来。
简单的unity小游戏--五子棋
weixin_70964175的博客
10-03 1327
该小游戏的代码分为三个部分，分别是模型部分（model）、视图部分（view）和控制部分（controller）。使用训练数据-控制分离的编程思维，其中模型部分只包含游戏对象数据，视图部分只使用IMGUI构建UI，控制部分控制模型对象（数据）的基本操作逻辑，而整个系统指在游戏循环驱动下，运用部件完成游戏逻辑。首先是模型部分，模型部分包含了五子棋游戏所需要的游戏对象，分别是玩家编号（两名玩家），落子的个数（用于判断棋盘是否下满），胜利者的编号（用于保存胜利玩家编号），棋盘的大小（设置为一个10×10的矩阵）
unity3D网络五子棋
12-31
使用unity3D开发的游戏，界面用NGUI开发，能够单机 对战 网络对玩等功能的实现 很好的资源 供初学者学习
Unity3D实现简易五子棋
08-25
主要为大家详细介绍了Unity3D实现简易五子棋源码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
五子棋.rar_unity_unity五子棋_untiy 五子棋_untiy五子棋_五子棋
07-14
Unity开发的五子棋功能，AI系统，有需要的可以进行下载
AlphaZero-In-Unity_alphazero_五子棋AI_AlphaZero-In-Unity_missingopg
10-04
在Unity中实现AlphaZero框架，可以让开发者创建出智能的棋类游戏AI。Unity是一款强大的跨平台游戏引擎，支持各种游戏开发，包括2D、3D、VR和AR。在这个项目中，“AlphaZero-In-Unity”提供了四子棋、翻转棋和五子棋...
unity开发五子棋游戏
最新发布
05-10
Unity开发五子棋游戏是一个基于Unity引擎的项目，主要用于创建一个简单的二人对弈的五子棋游戏。Unity是一个跨平台的游戏开发工具，以其强大的3D和2D图形渲染能力、直观的可视化编程环境以及广泛支持多平台发布而受...
Unity3d五子棋项目源码.7z
03-12
在这个"Unity3d五子棋项目源码"中，开发者通过300多行代码实现了仅17KB大小的五子棋游戏，展示了Unity3d在轻量化游戏开发方面的潜力。 一、Unity3d基础知识 Unity3d的核心是C#脚本，它允许开发者通过编写代码来控制...
Unity4.7.2五子棋
11-15
项目是用Unity4.7.2做的，运行没有问题，下载用来学习绝对没有问题！
Unity 五子棋
08-11
Unity 五子棋 源代码
Unity开发—五子棋小程序
09-30
Unity开发 —五子棋小程序，下载几个运行，可多平台运行。
Unity3D开发实战之五子棋游戏
08-25
主要为大家详细介绍了Unity3D开发实战之五子棋游戏，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
unity—五子棋源码
10-14
局域网对战，双人对战，AI对战三种玩法（悔棋、更换先手） 1.本机对战 2.人机对战 （1）、入门 （2）、进阶 （3）、高手 3.联网 1.局域网 2.因特网 多人匹配系统 3.游戏大厅 规则编辑 (1)对局双方各执一色棋子。 (2)空棋盘开局。 (3)黑先、白后，交替下子，每次只能下一子。 (4)棋子下在棋盘的空白点上，棋子下定后，不得向其它点移动，不得从棋盘上拿掉或拿起另落别处。 (5)黑方的第一枚棋子可下在棋盘任意交叉点上。 (6)轮流下子是双方的权利，但允许任何一方放弃下子权
三个AI小游戏（unity）-五子棋、扫雷、Wumpus怪物世界
12-27
三个基于Unity实现的小游戏，五子棋可实现人机对战（α-β剪枝）、扫雷可AI自动扫雷、Wumpus可AI自动进行游戏
Unity 五子棋游戏设计和简单AI(3)
makise2333的博客
08-02 1246
在把五子棋基本胜利逻辑完成之后，我们这次就着手开始AI的设计。主要的思路是使用贪心算法，评估函数来进行一个五子棋AI的设计。
unity2018.4.3f1实现五子棋游戏（八）
在Redhat7.2环境下用C语言写小游戏
12-13 420
电脑AI自动下棋（字典）一、AI原理二、评分表三、AI难度选择1、决定因素2、简单模式评分表：扫棋方法3、困难模式评分表：扫棋方法4、炼狱模式 一、AI原理 当我们人在下棋的时候，我们根据当前棋局的变化，做出防守和攻击的策略。如果不用堵对手的棋子，我们都想下在那个能我方快速连成5子的地方。我们肉眼看见，三子连珠我们肯定会去防，看见两子连珠却无动于衷，那是因为我们脑海里面装了评分表，不同棋型对应不同的分数，取最大的分数。人类有时会失误，因为不是所有人都有比较强的抽象能力，下棋可以看很多步的。 那我们就是要用代
Unity 五子棋游戏设计和简单AI（2）
makise2333的博客
07-31 1695
Unity 五子棋胜负条件判断
unity期末大作业-五子棋游戏
weixin_43474701的博客
07-17 516
unity做的五子棋游戏，比较简单，人与电脑对弈，AI算法基于蒙特卡洛树搜索（Monte Carlo Tree Search）实现，适合初学者学习使用，如下图所示:（资源链接在文末） 资源下载链接：https://download.csdn.net/download/weixin_43474701/20348526 ...
UNITY_TRANSFER_FOG
04-09
UNITY_TRANSFER_FOG是Unity引擎中的一个预定义宏，用于在Shader中实现雾效。雾效是一种常用的图形效果，可以增加场景的深度感和氛围。UNITY_TRANSFER_FOG宏可以将Unity中设置的全局雾参数传递给Shader，以便在渲染...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值