[Unity XLua]热更新XLua入门(二)-俄罗斯方块实例篇

最新推荐文章于 2024-04-19 22:43:00 发布
置顶 最新推荐文章于 2024-04-19 22:43:00 发布
阅读量2.1w 收藏 45
点赞数 11
分类专栏： Unity3D 文章标签： xLua Unity-xLua unity lua 热更新
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dingxiaowei2013/article/details/54664841
版权

更多精品文章

http://dingxiaowei.cn/ （手动复制到浏览器）

前言

在xLua没出来之前，开源的lua框架基本都是以界面用Lua开发为主，核心战斗用C#开发，但xLua出来之后主推C#开发，Lua用作HotFix，这里我展示的第一个例子就是基于界面的经典2D小游戏——俄罗斯方块，界面逻辑是用C#写，启动加载逻辑是用lua，后面我会继续第二个同样的Demo，但是以纯Lua为主，这个案例明天更新。

效果图

这里写图片描述
这里写图片描述
这里写图片描述
由于我不会美术，所以这里使用的开源的游戏资源，感谢此作者。

游戏启动

C#启动Lua逻辑
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using XLua;
using System;

[LuaCallCSharp]
public class LuaRunningBehaviour : MonoBehaviour
{
	public TextAsset luaScript;

	internal static LuaEnv luaEnv = new LuaEnv(); //all lua behaviour shared one luaenv only!
	internal static float lastGCTime = 0;
	internal const float GCInterval = 1;//1 second 

	private Action luaStart;
	private Action luaUpdate;
	private Action luaOnDestroy;

	private LuaTable scriptEnv;

	void Awake()
	{
		scriptEnv = luaEnv.NewTable();

		LuaTable meta = luaEnv.NewTable();
		meta.Set("__index", luaEnv.Global);
		scriptEnv.SetMetaTable(meta);
		meta.Dispose();

		scriptEnv.Set("self", this);

		luaEnv.DoString(luaScript.text, "LuaBehaviour", scriptEnv);

		Action luaAwake = scriptEnv.Get<Action>("awake");
		scriptEnv.Get("start", out luaStart);
		scriptEnv.Get("update", out luaUpdate);
		scriptEnv.Get("ondestroy", out luaOnDestroy);

		if (luaAwake != null)
		{
			luaAwake();
		}
	}

	// Use this for initialization
	void Start()
	{
		if (luaStart != null)
		{
			luaStart();
		}
	}

	// Update is called once per frame
	void Update()
	{
		if (luaUpdate != null)
		{
			luaUpdate();
		}
		if (Time.time - LuaBehaviour.lastGCTime > GCInterval)
		{
			luaEnv.Tick();
			LuaBehaviour.lastGCTime = Time.time;
		}
	}

	void OnDestroy()
	{
		if (luaOnDestroy != null)
		{
			luaOnDestroy();
		}
		luaOnDestroy = null;
		luaUpdate = null;
		luaStart = null;
		scriptEnv.Dispose();
	}
}
Lua加载游戏界面预设逻辑

local util = require 'xlua.util'

local function initGamePanel()
	local obj = CS.UnityEngine.Resources.Load("TetrisPanelOne")
	local gamePanel = CS.UnityEngine.Object.Instantiate(obj.gameObject).transform
	gamePanel.name = "GamePanel"
	gamePanel.gameObject.name = "GamePanel"
	gamePanel:SetParent(self.transform)
	gamePanel.localPosition = CS.UnityEngine.Vector3.zero
	gamePanel.localScale = CS.UnityEngine.Vector3.one
end

function start()
	print("lua start, 游戏开始...")
	initGamePanel()
end

function ondestroy()
    print("lua destroy")
end

游戏主要界面对应的Ｃ＃逻辑

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

public class MainGameCSScript : MonoBehaviour
{
	const int cRow = 16;
	const int cCol = 10;
	List<int>[] aTable = new List<int>[cRow];
	int lineCount = 0;
	public Texture[] BoxTexture = new Texture[4];
	private string[] boxColors = new string[] { "eluosi_lan", "eluosi_zi", "eluosi_lv", "eluosi_hong" };

	public int LineCount
	{
		get { return lineCount; }
		set
		{
			lineCount = value;
			this.onLineCountChange();
		}
	}
	int score = 0;

	public int Score
	{
		get { return score; }
		set
		{
			score = value;
			this.onScoreChange();
		}
	}
	int nextCellID = 0;
	int curCellID = 0;

	float curSpeed = 1;
	float fCurSpeed = 1;
	float fDeltaTime = 0;
	bool bPause = false;

	bool bStart = false;
	bool bGameOver = false;

	public bool BGameOver
	{
		get { return bGameOver; }
		set
		{
			bGameOver = value;
			this.onGameOverChange(bGameOver);
		}
	}

	System.Random rdm = new System.Random();

	const int boxTop = 16;
	const int boxLeft = 290;
	/// <summary>
	/// 彩色砖块的宽度
	/// </summary>
	const int boxSize = 38;

	int[][] nextCell = null;
	int[][] curCell = null;
	int curCellCol = 0;
	int curCellRow = 0;

	public GameObject BtnUp, BtnDown, BtnLeft, BtnRight, BtnIsPause;
	public UILabel TimeLabel, ScoreLabel, LineCountLabel;

	private Action onScoreChange = null;
	private Action onLineCountChange = null;
	private Action<bool> onGameOverChange = null;
	public GameObject EndPanel, BtnRestart;
	public UISprite[] BoxSprites = null;

	void Start()
	{
		BoxSprites = new UISprite[4];
		for (int i = 0; i < 4; i++)
		{
			BoxTexture[i] = Resources.Load<Texture>(boxColors[i]);
		}
		this.onScoreChange = this.ScoreChange;
		this.onLineCountChange = this.LineCountChange;
		this.onGameOverChange = this.GameOverChange;
		TimeLabel = transform.Find("LeftNode/CutDownBG/CountLabel").GetComponent<UILabel>();
		LineCountLabel = transform.Find("ScoreNode/LineCount").GetComponent<UILabel>();
		ScoreLabel = transform.Find("ScoreNode/Score").GetComponent<UILabel>();
		BtnLeft = transform.Find("InputNode/Left").gameObject;
		BtnRight = transform.Find("InputNode/Right").gameObject;
		BtnUp = transform.Find("InputNode/Up").gameObject;
		BtnDown = transform.Find("InputNode/Down").gameObject;
		BtnIsPause = transform.Find("LeftNode/RestartBtn").gameObject;
		EndPanel = transform.Find("EndPanel").gameObject;
		BtnRestart = transform.Find("EndPanel/ReplayBtn").gameObject;

		for (int i = 1; i <= 4; i++)
		{
			var obj = transform.Find(string.Format("BlcokTop/Blocks/block{0}", i)).gameObject;
			var sprite = obj.GetComponent<UISprite>();
			BoxSprites[i - 1] = sprite;
		}

		UIEventListener.Get(BtnRestart).onClick = go =>
		{
			EndPanel.gameObject.SetActive(false);
			Debug.Log("重新开始");
			DoStart();
		};

		UIEventListener.Get(BtnIsPause).onClick = go =>
		{
			Debug.Log("开始/暂停");
			bPause = !bPause;
		};

		UIEventListener.Get(BtnUp).onClick = go =>
		{
			Debug.Log("上翻");
			DoTransform();
		};

		UIEventListener.Get(BtnDown).onPress = (go, state) =>
		{
			Debug.Log("下按");
			//state  true:按下   false:松开
			if (state)
				DoSpeedUp();
			else
				DoSpeedRestore();
		};

		UIEventListener.Get(BtnLeft).onClick = go =>
		{
			Debug.Log("左移");
			DoLeft();
		};

		UIEventListener.Get(BtnRight).onClick = go =>
		{
			Debug.Log("右移");
			DoRight();
		};

		this.DoStart();
	}

	void ScoreChange()
	{
		ScoreLabel.text = "获得积分:" + this.Score.ToString();
	}

	void LineCountChange()
	{
		LineCountLabel.text = "消灭行数:" + this.LineCount.ToString();
	}

	void GameOverChange(bool state)
	{
		if (state)
			EndPanel.SetActive(true);
	}

	/// <summary>
	/// 初始化10*16的格子
	/// </summary>
	void DoInit()
	{
		this.LineCount = 0;
		this.Score = 0;
		curSpeed = 1;

		for (int i = 0; i < aTable.Length; i++)
		{
			aTable[i] = new List<int>();
			for (int j = 0; j < cCol; j++)
				aTable[i].Add(0);
		}
	}

	void OnGUI()
	{
		if (!bStart)
			return;

		if (BGameOver)
		{
			return;
		}

		if (bPause)
		{
			return;
		}

		for (int i = 0; i < curCell.Length; i++)
		{
			for (int j = 0; j < curCell[i].Length; j++)
			{
				if (curCell[i][j] == 0)
				{
					continue;
				}
				if (i + curCellRow < 0)
				{
					continue;
				}
				GUI.DrawTexture(new Rect(boxLeft + boxSize * j + curCellCol * boxSize, boxTop + boxSize * i + curCellRow * boxSize, boxSize, boxSize), BoxTexture[0]);
			}
		}


		//背景图
		for (int i = 0; i < aTable.Length; i++)
		{
			for (int j = 0; j < cCol; j++)
			{
				if (aTable[i][j] == 0)
				{
					continue;
				}
				GUI.DrawTexture(new Rect(boxLeft + boxSize * j, boxTop + boxSize * i, boxSize, boxSize), BoxTexture[aTable[i][j] - 1]);
			}
		}
	}

	string GetContent(int cellContent)
	{
		switch (cellContent)
		{
			case 0:
				return "";
			default:
				return cellContent.ToString();
		}
	}

	void DoStart()
	{
		DoInit();
		DoNextCell();

		bStart = true;
		BGameOver = false;
	}

	void DrawNextBox()
	{
		//绘制下一个图
		int boxIndex = 0;
		for (int i = 0; i < nextCell.Length; i++)
		{
			for (int j = 0; j < nextCell[i].Length; j++)
			{
				if (nextCell[i][j] == 0)
				{
					continue;
				}
				BoxSprites[boxIndex++].transform.localPosition = new Vector3(j * 35, i * (-35), 0);
			}
		}
	}

	/// <summary>
	/// 随机生成下面一个模型
	/// </summary>
	void DoNextCell()
	{
		if (nextCell == null)
		{
			nextCellID = rdm.Next(aCells.Length);
			nextCell = aCells[nextCellID];
		}
		curCellCol = cCol / 2 - 2;
		curCellRow = -4;
		curCell = nextCell;
		curCellID = nextCellID;
		nextCellID = rdm.Next(aCells.Length);
		nextCell = aCells[nextCellID];

		DrawNextBox();

		DetectIsFail();
	}

	/// <summary>
	/// 放置当前的模型
	/// </summary>
	private void DoSetCurCellDown()
	{
		for (int i = 0; i < curCell.Length; i++)
		{
			for (int j = 0; j < curCell[i].Length; j++)
			{
				if (curCell[i][j] == 0)
				{
					continue;
				}
				if (curCellRow + i < 0)
				{
					BGameOver = true;
					return;
				}
				aTable[curCellRow + i][curCellCol + j] = curCell[i][j];
			}
		}
		//速度重置
		DoSpeedRestore();
		//消除一行
		DoLine();
		//生成下一个模型
		DoNextCell();
	}

	void Update()
	{
		if (!bStart)
		{
			return;
		}

		if (BGameOver)
		{
			return;
		}

		if (bPause)
		{
			return;
		}

		//自动下滑
		fDeltaTime += Time.deltaTime;
		if (fDeltaTime > fCurSpeed)
		{
			fDeltaTime -= fCurSpeed;
			if (CanMoveTo(curCellCol, curCellRow + 1))
			{
				curCellRow++;
			}
			else
			{
				DoSetCurCellDown();
				return;
			}
		}

		if (BGameOver)
		{
			return;
		}

		if (Input.GetKeyDown(KeyCode.A) || Input.GetKeyDown(KeyCode.LeftArrow))  //左移
		{
			DoLeft();
		}
		if (Input.GetKeyDown(KeyCode.D) || Input.GetKeyDown(KeyCode.RightArrow)) //右移
		{
			DoRight();
		}
		if (Input.GetKeyDown(KeyCode.W) || Input.GetKeyDown(KeyCode.UpArrow))  //上翻
		{
			DoTransform();
		}
		if (Input.GetKeyDown(KeyCode.S) || Input.GetKeyDown(KeyCode.DownArrow))  //按下快速下移
		{
			DoSpeedUp();
		}
		if (Input.GetKeyUp(KeyCode.S) || Input.GetKeyUp(KeyCode.DownArrow))  //按键取消 取消快速下移
		{
			DoSpeedRestore();
		}
	}

	/// <summary>
	/// 检测游戏是否结束
	/// </summary>
	private void DetectIsFail()
	{
		if (CanMoveTo(curCellCol, curCellRow))
		{
			return;
		}
		BGameOver = true;
	}

	/// <summary>
	/// 判断模型移动
	/// </summary>
	/// <param name="x"></param>
	/// <param name="y"></param>
	/// <param name="cell"></param>
	/// <returns></returns>
	bool CanMoveTo(int x, int y, int[][] cell = null) // 3, -4
	{
		if (cell == null)
		{
			cell = curCell;
		}
		for (int i = 0; i < cell.Length; i++)
		{
			for (int j = 0; j < cell[i].Length; j++)
			{
				if (cell[i][j] == 0)
				{
					continue;
				}
				if (x + j < 0 || x + j >= cCol)
				{
					return false;
				}
				if (y + i >= cRow) //到顶了
				{
					return false;
				}
				if (y + i < 0)
				{
					continue;
				}
				if (aTable[i + y][j + x] != 0)
				{
					return false;
				}
			}
		}
		return true;
	}

	private void DoSpeedRestore()
	{
		fCurSpeed = curSpeed;
	}

	//下移加速
	private void DoSpeedUp()
	{
		fCurSpeed = curSpeed / 8;
		fDeltaTime = fCurSpeed;
	}

	//右移
	private void DoRight()
	{
		if (CanMoveTo(curCellCol + 1, curCellRow))
		{
			curCellCol++;
		}
	}

	//左移
	private void DoLeft()
	{
		if (CanMoveTo(curCellCol - 1, curCellRow))
		{
			curCellCol--;
		}
	}

	//上翻
	private void DoTransform()
	{
		int transformedCellID = curCellID / 4 * 4 + (curCellID % 4 + 1) % 4;
		if (CanMoveTo(curCellCol, curCellRow, aCells[transformedCellID]))
		{
			curCellID = transformedCellID;
			curCell = aCells[transformedCellID];
		}
	}

	/// <summary>
	/// 消除一行
	/// </summary>
	private void DoLine()
	{
		List<int> fulledLines = new List<int>();
		for (int i = curCellRow; i < curCellRow + 4; i++)
		{
			if (i >= cRow)
			{
				continue;
			}
			if (i < 0)
			{
				BGameOver = true;
				return;
			}
			for (int j = 0; j < cCol; j++)
			{
				if (aTable[i][j] == 0)
				{
					break;
				}
				if (j == cCol - 1)
				{
					fulledLines.Add(i);
				}
			}
		}

		if (fulledLines.Count == 0)
		{
			return;
		}

		for (int i = 0; i < fulledLines.Count; i++)
		{
			for (int j = 0; j < cCol; j++)
			{
				aTable[fulledLines[i]][j] = 0;
			}
		}

		int ilastEmptyRow = fulledLines[fulledLines.Count - 1];
		int ilastNotEmptyRow = ilastEmptyRow - 1;
		while (true)
		{
			if (ilastNotEmptyRow < 0)
			{
				break;
			}

			if (!IsRowEmpty(ilastNotEmptyRow))
			{
				for (int j = 0; j < cCol; j++)
				{
					aTable[ilastEmptyRow][j] = aTable[ilastNotEmptyRow][j];
					aTable[ilastNotEmptyRow][j] = 0;
				}
				ilastEmptyRow--;
			}
			ilastNotEmptyRow--;
		}

		for (int i = 0; i < fulledLines.Count; i++)
		{
			for (int j = 0; j < cCol; j++)
			{
				aTable[i][j] = 0;
			}
		}
		//消除的行数
		LineCount += fulledLines.Count;
		//分数加成
		Score += fulledLines.Count * fulledLines.Count;

		curSpeed *= 0.99f;
	}

	bool IsRowEmpty(int irow)
	{
		for (int j = 0; j < cCol; j++)
		{
			if (aTable[irow][j] != 0)
			{
				return false;
			}
		}
		return true;
	}

	/// <summary>
	/// 各种形态的砖块  28个
	/// </summary>
	private int[][][] aCells = new int[][][]
        {
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,1,1,0},
                        new int[]{0,1,1,0},
                        new int[]{0,0,0,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,1,1,0},
                        new int[]{0,1,1,0},
                        new int[]{0,0,0,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,1,1,0},
                        new int[]{0,1,1,0},
                        new int[]{0,0,0,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,1,1,0},
                        new int[]{0,1,1,0},
                        new int[]{0,0,0,0},
                },
 
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,0,1,1},
                        new int[]{0,1,1,0},
                        new int[]{0,0,0,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,1,0,0},
                        new int[]{0,1,1,0},
                        new int[]{0,0,1,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,0,1,1},
                        new int[]{0,1,1,0},
                        new int[]{0,0,0,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,1,0,0},
                        new int[]{0,1,1,0},
                        new int[]{0,0,1,0},
                },
 
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{1,1,0,0},
                        new int[]{0,1,1,0},
                        new int[]{0,0,0,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,0,1,0},
                        new int[]{0,1,1,0},
                        new int[]{0,1,0,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{1,1,0,0},
                        new int[]{0,1,1,0},
                        new int[]{0,0,0,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,0,1,0},
                        new int[]{0,1,1,0},
                        new int[]{0,1,0,0},
                },
 
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{1,1,1,1},
                        new int[]{0,0,0,0},
                        new int[]{0,0,0,0},
                },
                new int[][]
                {
                        new int[]{0,0,1,0},
                        new int[]{0,0,1,0},
                        new int[]{0,0,1,0},
                        new int[]{0,0,1,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{1,1,1,1},
                        new int[]{0,0,0,0},
                        new int[]{0,0,0,0},
                },
                new int[][]
                {
                        new int[]{0,0,1,0},
                        new int[]{0,0,1,0},
                        new int[]{0,0,1,0},
                        new int[]{0,0,1,0},
                },
 
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,1,0,0},
                        new int[]{1,1,1,0},
                        new int[]{0,0,0,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,1,0,0},
                        new int[]{0,1,1,0},
                        new int[]{0,1,0,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,0,0,0},
                        new int[]{1,1,1,0},
                        new int[]{0,1,0,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,1,0,0},
                        new int[]{1,1,0,0},
                        new int[]{0,1,0,0},
                },
 
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,1,1,0},
                        new int[]{0,0,1,0},
                        new int[]{0,0,1,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,0,1,0},
                        new int[]{1,1,1,0},
                        new int[]{0,0,0,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,1,0,0},
                        new int[]{0,1,0,0},
                        new int[]{0,1,1,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{1,1,1,0},
                        new int[]{1,0,0,0},
                        new int[]{0,0,0,0},
                },
 
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,1,1,0},
                        new int[]{0,1,0,0},
                        new int[]{0,1,0,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{1,1,1,0},
                        new int[]{0,0,1,0},
                        new int[]{0,0,0,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{0,0,1,0},
                        new int[]{0,0,1,0},
                        new int[]{0,1,1,0},
                },
                new int[][]
                {
                        new int[]{0,0,0,0},
                        new int[]{1,0,0,0},
                        new int[]{1,1,1,0},
                        new int[]{0,0,0,0},
                },
        };
}

欢迎加群交流

1.unity游戏开发群
QQ群
unity3d unity 游戏开发

2.专门探讨XLua的程序群：437645698

下载地址

https://git.oschina.net/dingxiaowei/Aladdin_XLua.git
Github同步：https://github.com/dingxiaowei/Aladdin_XLua
关注后续更新请点start或者fork，感谢！

丁小未
关注
  • 11
    点赞
  • 踩
  • 45
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
单机捕鱼-creator.zip源码cocos creator项目源码下载
03-17
单机捕鱼-creator.zip源码cocos creator项目源码下载单机捕鱼-creator.zip源码cocos creator项目源码下载 1.适合个人学习技术做项目参考 2.开发脚本为javsScropt或者typeScript 3.适合小公司开发游戏项目参考
介绍一个非常好用的C++开源框架:openFrameworks
weixin_33978016的博客
01-22 402
2019独角兽企业重金招聘Python工程师标准>>> ...
Unity3D学习之Lua热更新解决方案（一）AB包和LUA语法
Lmz_0314的博客
02-22 1379
-面向对象实现--万物之父 所有对象的基类 Object--封装--实例化方法--给空对象设置元表 以及 __indexreturn objend--继承--根据名字生成一张表 就是一个类--设置自己的“父类”--给子类设置元表 以及 __indexend--申明一个新的类--成员变量--成员方法end--实例化对象使用obj:Move()--申明一个新的类 Player 继承 GameObject--多态 重写了 GameObject的Move方法。
Unity小游戏算法分析与实现（Unity+XR+游戏开发+算法+MVC+斗地主+耳轮跳+见缝插针+王者荣耀+绝地求生+立钻哥哥+==）
VRunSoftYanlz的博客
06-13 6216
《Unity小游戏算法分析与实现》 《Unity小游戏算法分析与实现》 版本 作者 参与者 完成日期 备注 Unity2017_GameDemo_V01_1.0 严立钻 2019.02.24 ...
JAVA游戏编程之三----j2me 手机游戏入门开发--俄罗斯方块_5_使用LUA脚本写游戏
07-09 287
该程序是基于07年底写的一个J2ME小游戏 俄罗斯方块，将全部逻辑绘制都放到LUA脚本里来做，J2ME方面仅作一个绘制库来使用！ 建立J2ME程序这里就不说了， 详见我的BLOG http://blog.csdn.net/kome2000/article/details/4183199 http://kome2000.blog.51cto.com/969562/578555   由于J
游戏UI设计师的基本工作流程与技能需求
wangchewen的博客
10-21 620
当下正是游戏产业蓬勃发展的时期，相较于端游、页游只能在PC上操作的固定模式，手机游戏已经无处不在，成为了一种生活必需品。随着手游市场的扩大，手机游戏的需求更是日益添增，大量的研发团队与美术外包占领了业界的主导，而大批量的游戏生产 ，也同时促就了【游戏UI设计师】这个新兴量产的职业，成为游戏市场的最大需求端。最近很多朋友常会讨论，个人的审美不同，如何才能评定一款游戏的UI是否优秀，而标准又是什么？其实这个题目太大，能讲的理论太多，为此，本人在写这篇文章时，特地请教了数位UI同仁，并做了大量考察，得出的结论却大
xLua学习笔记（三） Lua调用C#代码
kuangben2000的博客
07-28 1685
xLua学习笔记（三） Lua调用C#代码 https://www.cnblogs.com/herenzhiming/articles/8460856.html 将下列代码挂载到任何一个GameObject上，这样就能在Unity中加载并执行Resources/Lua文件夹下的csharp_call.lua.txt文件中Lua代码了 public class CSharpRun : MonoBehaviour { private LuaEnv luaenv; void S.
Xlua 学习笔记（一） ByString 和 ByFile 两种方式运行Lua
_Afra 的博客
05-15 592
ByString： 新建一个 Xlua_Start.cs 脚本，挂载到场景中 using System.Collections; using System.Collections.Generic; using UnityEngine; using XLua; public class Xlua_Start : MonoBehaviour { // 全局唯一的 LuaEnv 虚拟机;...
xlua官方Examples例子学习
玖歌的博客
03-22 4231
文章目录一 Hello World例子 执行字符串二 执行lua文件，C#与lua交互 一 Hello World例子 执行字符串 namespace XLuaTest { public class Helloworld : MonoBehaviour { void Start() { LuaEnv luaenv = new LuaEnv(); luaenv.DoString("CS.UnityEngine.De
XLUA学习笔记之C#和Lua之间的相互调用
kuangben2000的博客
01-24 969
XLUA学习笔记之C#和Lua之间的相互调用 https://blog.csdn.net/xmx5166/article/details/90712888 感觉学习的笔记还是放在网上查询的时候比较方便，文章初看会感觉很难理清，需要耐心去看，对不起自己对不起翻到我文章的同学，不废话直接上代码。 1.C#调用Lua （耐心！耐心！耐心！） using System; using System....
xlua-Lua代码访问C#
成长ing中的w的专栏
05-06 385
lua代码如何访问C#代码的变量方法呢？本篇文章做了比较详细的介绍 C#代码部分如下 using System; using System.Collections; using System.Collections.Generic; using UnityEngine; using XLua; namespace Framework { [LuaCallCSharp] public enum ChannelType { None, QQ, WeChat, WeiBo, }
用Lua语言写的俄罗斯方块游戏源代码
04-23
学习嵌入式脚本语言Lua时写的俄罗斯方块程序。编写这种代码感觉挺有意思，这么微小的语言照样能完成复杂的界面功能。 因为是在图形界面下运行，需要lua语言的wxWidget库，可以先安装luaforwindows环境。
Unity3d 基于xlua热更新实现系列二：Xlua脚本动态加载（半热更新）源码
03-21
Unity3d 基于xlua热更新实现系列二：Xlua脚本动态加载（半热更新）源码 建议先看说明：https://blog.csdn.net/qq_33789001/article/details/123637629
Unity游戏热更新实战案例（基于xLua）+高清视频指导+源代码工程
01-01
Unity游戏热更新实战案例（基于xLua）+高清视频指导+源代码工程
unity2017热更新xLua 教程
03-06
unity2017热更新xLua 教程，有案例有教程，资源齐全仅供学习使用
Unity3d 基于xlua热更新实现系列一：熟悉lua重写C#
03-18
以lua编写C#的登录功能源码。 建议先看说明：https://blog.csdn.net/qq_33789001/article/details/123580137
xlua 热更新 教程
01-21
xlua 教程 !!!! 你想要的,分享给大家!欢迎大家下载. 自己找了好久才找到的. 非常给力!!!
Redis中的Lua脚本(五)
最新发布
Cover_sky的博客
04-19 316
EVALSHA命令式所有与Lua脚本有关的命令中，复制操作最复杂的一个，因为主服务器与从服务器载入Lua脚本的情况可能有所不同，所以主服务器不能像复制EVAL命令、SCRIPT LOAD命令或者SCRIPT FLUSH命令那样，直接将EVALSHA命令传播给从服务器，对于一个在主服务器被成功执行的EVALSHA命令来说，相同的EVALSHA命令在从服务器执行时可能会出现脚本未找到(not found)错误。举个例子。
Lua语法(六)——面相对象编程
记录知识点的博客
04-12 760
Lua中没有类这个类型，所以只有用表来模拟类。
unity xlua异常捕获
05-25
在 Unity 中使用 XLua，可以通过 try-catch 语句捕获异常。以下是一个简单的示例： ```csharp using XLua; public class LuaExceptionTest : MonoBehaviour { public string luaScript; private LuaEnv luaEnv;...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值