位置: 编程技术 - 正文

Intermediate Unity 3D for iOS: Part 3/3

编辑:rootadmin

推荐整理分享Intermediate Unity 3D for iOS: Part 3/3,希望有所帮助,仅作参考,欢迎阅读内容。

文章相关热门搜索词:,内容如对您有帮助,希望把文章链接给更多的朋友!

This is a tutorial by Joshua Newnham, the founder of We Make Play, an independent studio crafting creative digital play for emerging platforms.

Welcome back to our Intermediate Unity 3D for iOS tutorial series!

In the first part of the series, you learned how to use the Unity interface to lay out a game scene, and set up physics collisions.

In the second part of the series, you learned how to script with Unity, and created most of the game logic, including shooting and scoring baskets!

In this part and final of the tutorial, you’ll be working to build a menu system for the user and interacting with it via your GameController. Let’s get started!

Testing on your Device

So far, you have been testing with the built-in Unity simulator. But now that you have your project in a functional state it’s about time to run this on an actual device for testing!

To do this, open the Build dialog via File -> Build Settings. You’ll then be presented with the following dialog:

First off, ensure you have the right platform selected (iOS should have the Unity icon next to it as shown above, if not then highlight the iOS and click on the ‘Switch Platform’).

Select “Player Settings” to bring up the build setting in the inspector panel.

There is a multitude of settings to select from, but (for now) you really only need to concern yourself with ensuring that the game is oriented correctly.

In the ‘Resolution and Presentation’ pane select Landscape-Left from the dropbox for the devices orientation and leave the rest as their defaults and move onto the next pane ‘Other Settings’.

In this section you’ll need to enter in your developer Bundle Identifier (this has the equivalent when developing in XCode) and leave the rest with their default values.

The Moment of Truth

Once you’ve set the appropriate values, go back to the Build Settings dialog and select Build.

Unity will prompt you for a destination for your project. Once you’ve selected the destination, Unity will launch XCode with your project ready to be built and run on your device.

Note: Don’t try running your game in a simulator as the Unity libraries are only for iOS devices. Running Unity projects on your device has all the usual requirements as far as certificates, App IDs and provisioning profiles go. Check out this thread on the Unity Answers site for more details.

Once you finish playing around come back and you’ll continue with building a simple menu for your game.

Keeping Score

First download the resources for this tutorial, which include some support classes that handle the persisting and retrieving of scores. Extract the zip and drag the .cs files into your Scripts folder in Unity.

The implementation of this is out of scope for this tutorial but as you will be using it you will run through a quick testable example of how it is used.

Start by creating a new empty GameObject on your scene and attach the LeaderboardController (included with this tutorials packages) script to it.

Create a new Script named LeaderboardControllerTest and attach it to a newly created GameObject. You will perform a simple test where you store a couple of scores and then retrieve them back.

To do this you need reference to the LeaderboardController so start off by adding a public LeaderboardController variable to your LeaderBoardControllerTest class, as shown below:

Note: Take note of the using System.Collections.Generic; at the top of the class, this is asking that the classes belonging to the System.Collections.Generic package are included so you can reference the Generic specific collections. Explanation of Generic can be found here.

Use the AddPlayersScore method of the LeaderboardController to add the player score (who would have thought):

This will persist the score to disk that you can retrieve even after you have closed the application. To retrieve you need to register for the LeaderboardControllers OnScoresLoaded event, along with the implemented handler method and finally request for the scores, as shown below.

By the way – the reason for the asynchronous call is to allow you to extend the LeaderboardController to handle a remote leaderboard later if you want.

The parameter List is a list of ScoreData objects, the ScoreData is a simple data object that encapsulates the details of the score (a record).

The Handle_OnScoresLoaded method will iterate through all the scores and output their points, just what you need.

That’s it! Now test it out by doing the following:

Create a new GameObject, name it LeaderboardController, and attach the LeaderboardController script to it.Select the LeaderboardControllerTest object, and attach the LeaderboardController object to the leaderboard property.Click Play, and you should see the scores log out to the console!Creating a simple menu

Now for something new and exciting – you’re going to learn how to create a menu for the game!

Here’s a screenshot of what you’re aiming to build:

There are three paths you can choose when implementing a user interface in Unity. Each has its advantages and disadvantages. The following section explains each in detail.

1) GUI

Unity provides a set of pre-defined user interface controls that can be implemented using the GUI Component via the MonoBehaviour hook method OnGUI. Unity also supports the ability to customize the appearance of the menu using Skins.

For scenes that aren’t performance-critical, this is an ideal solution as it provides the richest set of premade controls. However, as it has performance concerns, it should not be used during game play!

2) GUITexture and GUIText

Two components Unity provides are the GUITexture and GUIText. These components allow you to present flat (2D) images and text on the screen. You can easily extend these to create your user interface with a reduced hit on performance compared to using the GUI Component controls.

3) 3D Planes / Texture Altas

If you’re creating a heads up display (HUD i.e. a menu shown during game-play) then this is the preferred option; even though it requires the most effort! :] But once you have built the supporting classes for your heads up display, you can port them to every new project.

3D planes refers to implementing the HUD using a combination of flat 3D planes associated with a texture atlas, a texture atlas being a collection of many discrete images that has been saved as one large image. It’s similar in concept to a sprite sheet for all you Cocos2D users! :]

Since the Material (which references the texture) is shared across all of your HUD elements, usually only one call is required to render the HUD to the screen. In most cases, you would use a dedicated Camera for the HUD as its likely you’ll be rendering them in orthographic projection rather than perspective (which is a mode of the camera).

The option you will use in this tutorial is #1 – Unity’s GUI. Despite the above recommendations to avoid using it, it does have a host of pre-built controls which will keep this tutorial manageable! :]

You will start by creating the Skins for the main menu. Then you’ll work through the code which renders the main menu, and finally tie it all together by linking it with the GameController.

Sound good? Time to get started with skinning! :]

Skins

Unity provides a way to dress up the GUI elements using something called a Skin. This can be thought of as a simple stylesheet used in conjunction with HTML elements.

I created two skin files for you (which you already imported into your project way back in the first part of this tutorial), one for × displays, and the other for the × Retina display. The following is a screenshot of the properties of the × skin:

The Skin property file exposes a lot of attributes that allow you to create unique styles for your project. For this project, you only need to be concerned with the font.

So open the GameMenuSmall skin and drag the scoreboard font onto the Font property and set the Font size to . Then open the GameMenuNormal and drag the scoreboard font onto the Font property and set the Font size to .

Next up is implementing the actual main menu!

Main Menu

This section presents the code for the GameMenuController which is responsible for rendering the main menu and interpreting user input. You’ll work quickly through the important parts of the code, and then finally hook it up to your game!

Create a new script named GameMenuController and add the following variables as shown below:

First, there is a set of publicly accessible variables, which are assigned within the editor that gives theGameMenuController access to elements used to render the main menu. Next you have variables to reference the two skins you created in the previous section.

Following that you have variables that you’ll use to fade in and out the main menu.

We also include references of the GameController and LeaderboardController with reference to the scores you retrieve back from your LeaderboardController.

Intermediate Unity 3D for iOS: Part 3/3

Following this you have a set of constants and variables which are used to determine the scale of the user interface elements i.e. to manage the different screen resolutions of the, for example, iPhone 3GS (×) and iPhone 4 (×).

And finally you have some variables you use to manage the state of the GameMenuController Component.

Next add the Awake() and Start() methods, as shown below:

During Start(), the scores are requested from the LeaderboardController. As well, some graphics ratios are calculated so that the GUI can be adjusted accordingly (as mentioned above).

The scale offsets in the code above are used to ensure the GUI elements are scaled appropriately. For instance, if the menu is designed for ×, and the current device resolution is ×, then you need to scale these down by %; your scaleOffset will be 0.5. This works fairly well if you’re using simple graphics without the need of duplication, and will become more relevant when you start porting to devices with multiple resolutions.

Once the scores are loaded, cache the scores locally (this should look familiar to you as we’ve just implemented something very similar in the above section), which will be used when rendering the GUI:

Time to test

Lets take a little break and test what you have so far.

Add the following code to your GameMenuController:

The above snippet of code shows the OnGUI method. This method is called in a manner similar to Update(), and provides access to the GUI Component. The GUI Component provides a suite of static methods exposing standard user interface controls, click here to learn more about the OnGUI and GUI class from the official Unity site.

Within the OnGUI method you are asking a texture to be drawn across the whole screen with the following code:

Next you wrap the GUI.Button method with a conditional statement, the GUI.Button method renders a button at the specified location (using the offsets you calculated before to handle differing screen resolutions). This method also returns a boolean whether the user has clicked on it or not i.e. will return true if the user has clicked on it otherwise false.

In this case if it has been clicked then it will output “Click” to the console.

To test, attach your GameMenuController script to the GameObject your GameController is attached to, and then set attach all the public properties to the appropriate objects, as shown below:

Now try it out! Click play and you’ll see a button appear. Click on it and you’ll see a message in the console!

Not bad, eh? The first small step of your menu is underway! :]

Using your skins

Now that you’ve confirmed you’re heading in the right direction, let’s continue by assigning the appropriate skin depending on the screen size.

Replace the body of your OnGUI method with the following code:

The skins will ensure that you use the correct font size (based on the screensize); you determine what skin to use based on the _scale you calculated previously. If it is less than 1.0 then you will use the small skin otherwise revert to the normal skin.

Showing and hiding

Rather than abruptly popping up the GUI when requested, you will gradually fade in. To do this you will manipulate the GUI’s static contentColor variable (this affects all subsequent drawing done by the GUI class).

To manage the fading in you will granularly increase your _globalTintAlpha variable from 0 to 1 and assign this to your GUI.contentColor variable.

Add the following code to your OnGUI method:

You also need a way to initiate the showing and hiding of your menu, so create two publicly accessible method called Show and Hide (as shown below):

Nothing fancy going on here! You request a new batch of scores in case the user has added a new score. Then you adjust the global tint alpha to 0 and enable/disable this Component to start/stop the OnGUI call (i.e. if this Component is disabled then all update methods e.g. Update, FixedUpdate, OnGUI wont be called).

What your menu displays will depend on what state the game is in e.g. Pause will render differently to GameOver.

Add the following code to your OnGUI method:

This should look fairly familiar to you; all you are doing is rendering textures and buttons depending on what state the GameController is in.

When paused you render two buttons to allow the user to resume or restart:

Note: Wondering how I got those position and size numbers? I painfully copied them across from GIMP, which I used to create the interface.

The other state it could be in is GameOver, which is when you render the play button.

Note: You may have noticed the two variables _showInstructions and _gamesPlayedThisSession. The _gamesPlayedThisSession is used to determine how many games you have played for this session, if it is the first game then you flag _showInstructions to true before playing the game. This allows use to display a set of instructions (shown next) before the user plays their first game of Nothing But Net.

Time to test

Before you finish off the GameMenuController, lets make sure everything is working at expected. Everything should be setup from your previous test so you should be able to press the play button and see something similar to the following:

Finishing off the GameMenuController

The final pieces left is the title, instructions, and score.

Drawing the title or instruction is dependent on the instruction flag (as described above); add the following code to the bottom of your OnGUI method:

That take care of that; the final piece is the scoreboard. OnGUI provides groups, groups allow you to group things together in a specified layout (horizontal or vertical). The following code draws the leaderboard and some dummy buttons for Facebook / Twitter and then iterates through all the scores adding them individually. Add the following code to the bottom of your OnGUI method:

And that’s that for your GameMenuController; to finish off lets hook up your GameMenuController to your GameController class (which tells it to show and hide as required), open up the GameController and lets make your way through it.

So open up GameController and declare the following variables at the top:

Now get reference to them in the Awake method;

The most significant change is within your State property; replace your UpdateStatePlay with the following and afterwards we’ll summarize the changes:

The code should hopefully be pretty self-explanatory; when the state is updated to Menu or Pause you ask your GameMenuController to show itself using the Show method you implemented. If the state is set to Play then you ask the GameMenuController to hide itself using the Hide method. And finally when the state is changed to GameOver you add the players score to your leaderboard (just how you did it when you created your example).

Finally, notice that this code depends on an Alerter object. So to make this work, create a new empty object, assign it the Alerter script, then drag that object onto the Alerter property on the Game Controller.

Build and Run

As you did before, open the Build dialog via File -> Build Settings, and click on the build button to test your finished game!

Build and run the Xcode project, and you should see a beautiful working menu on your device!

wt you’ve got a complete simple Unity 3D game! :]

Optimizations

A book could be written about optimizing your app! Even if you think the performance is acceptable, consider that there are a LOT of old iPod touches and iPhone 3G models out there. You’ve worked hard to make a game, and you don’t people with older devices to think your games are laggy!

Here’s a list of items to keep in mind when developing:

Keep draw calls to a minimum — You should aim to keep your draw calls as minimal as possible. To achieve this, share textures and materials, and avoid using transparent shaders — use mobile shaders instead. Limit the number of lights you use, and always use a texture atlas for your HUD.Keep an eye on the complexity of your scene — Use optimized models, meaning models with minimal geometry. Instead of using geometry for the details, you can usually achieve the same effect by baking the details into the textures, similar to how you would bake in lighting. Remember that the user is only staring at a small screen, so a lot of detail won’t be picked up.Fake the shadows with the model — Dynamic shadows are not available in iOS, but projectors can be used to mimic shadows. The only issue is that projectors drive up your draw calls, so if possible, use a flat plane with a shadow texture that uses a a particle Shader to mimic the shadow.Be wary of anything you place in your Update/FixedUpdate methods — Ideally the Update() and FixedUpdate() calls run to times per second. Because of this, ensure that you calculate or reference everything possible before these are called. Also be wary of any logic you add to these modules, especially if they are physics related!Turn off anything you’re not using — If you don’t need a script to run, then disable it. It doesn’t matter how simple it appears to be – everything in your app consumes processor time!Use the simplest component possible — If you don’t require most of the functionality of a component, then write the parts you need yourself and avoid using the component altogether. As an example, CharacterController is a greedy component, so it’s best to roll your own solution using Rigidbody.Test on the device throughout development — When running your game, turn on the console debug log so you can see what may be eating up processor cycles. To do this, locate and open the iPhone_Profiler.h file in XCode and set ENABLE_INTERNAL_PROFILER to 1. This gives you a high-level view of how well your app is performing. If you have Unity 3D Advance, then you can take advantage of the profiler which will allow you to drill down into your scripts to find how much time each method is consuming. The output of the internal profiler looks something like the following:frametime gives you an indication of how fast your game loop is; by default this is set to either or . Your average should be hitting somewhere near this value.draw-call gives you the number of draw calls for the current render call – as mentioned before, keep this as low as possible by sharing textures and materials.verts gives you an snapshot of how many vertices are currently being renderedplayer-detail gives you a nice overview of how much time each component of your game engine is consumingWhere To Go From Here?

Here is a sample project with the complete finished game from this tutorial series. To open it in Unity, go to FileOpen Project, click Open Other, and browse to the folder. Note that the scene won’t load by default – to open it, select ScenesGameScene.

You’ve done well to get this far, but the journey doesn’t stop here! :] Hopefully you will keep up the momentum and become a Unity ninja; there is definitely a lot of demand for these types of skills at the moment!

Here are a few suggestions of how you can extend your game:

Add sound. Sound is extremely important for any interactive content, so spend some time looking into sound and music and add it to the game.Hook up Facebook so users can compete with friends.Add multiplayer mode, which will allow users to play against each other on the same device, where each player takes turns throwing.Add new characters to allow the user to personalize the game.Extend the user input to allow different gestures, and then use these gestures to implement different types of throws.Add bonus balls, with each ball having different physical attributes, such as increased gravity.Add new levels, with each level being ever more challenging!

That should be enough to keep you busy! :]

I hope you enjoyed this tutorial series and learned a bit about Unity. I hope to see some of you create some Unity apps in the future!

If you have any comments or questions on this tutorial or Unity in general, please join the forum discussion below!

This is a tutorial by Joshua Newnham, the founder of We Make Play, an independent studio crafting creative digital play for emerging platforms.

From:

Unity导出的Android项目按钮无法点击问题 Unity导出的Android项目,有时会出现按钮不能点击的问题,可以在AndroidManifest.xml的主Activity入口处添加如下meta-data试试。meta-dataandroid:name=unityplayer.ForwardNat

Android开发之Volley网络通信框架 今天用了一下Volley网络通信框架,感觉挺好用的,写个博客记录一下使用方法,方便以后VC。Volley(Google提供的网络通信库,能使网络通信更快,更简单

安卓工程如何正确导入第三方jar (2) ---解决问题【intellij+gradle+android-support-multidex.jar】 参考资料androidstudio更新Gradle错误解决方法IntellijIdeaimportgradleprojecterror-Cause:unexpectedendofblockdata收集整理Android开发所需的AndroidSDK、开发中用到的工具1、int

标签: Intermediate Unity 3D for iOS: Part 3/3

本文链接地址:https://www.jiuchutong.com/biancheng/379615.html 转载请保留说明!

上一篇:Android屏幕适配-android学习之旅(五十九)(android屏幕尺寸适配)

下一篇:Unity导出的Android项目按钮无法点击问题(Unity导出的webgl能做AR吗)

  • 个人所得税可以退吗
  • 延期缴纳税款是纳税争议吗
  • 建筑业增值税税额怎么算
  • 生产成本怎么计算
  • 工会经费的会计核算方法
  • 未开发票如何确认收入并进行申报
  • 公司申请破产后股东需要还债吗
  • 出库入库结存表
  • 酒店物料消耗包括哪些
  • 小规模纳税人开了3%的专票还能享受1%
  • 货架折旧年限
  • 税率开错情况说明
  • 经营活动现金净流量公式
  • 所得税纳税申报表在哪里打印
  • 纳税人经营所得预缴申报表怎么填
  • 结转当月材料采购成本的会计分录怎么做?
  • 冲销去年暂估费用
  • 以旧换新会计处理金银首饰
  • 代办会议费是否允许差额纳税
  • 企业车辆保险费要按什么交印花税的
  • 结转出租包装物的成本
  • 研发费用领用材料
  • 疫情期间企业应该承担哪些责任
  • 机器设备计提折旧年限是多少
  • 年度中间符合小数怎么算
  • 餐饮业管理费用明细表
  • 苹果14promax电池掉电很快
  • 主板故障开机断电
  • 存贷款利率计算器
  • vscode国内镜像
  • 0x80070035无法访问
  • php怎么创建数据表
  • koeids.dll
  • php preg_grep
  • 公益性捐赠增值税税率
  • iis防盗链
  • 财务人员应计入什么科目
  • 详解九章算法
  • 汇算清缴补交的所得税怎么记帐
  • 一般纳税人企业所得税如何计算
  • 差旅费住宿费专票抵扣联贴在哪里
  • 【超直白讲解opencv RGB与BGR】RGB模式与BGR模式有什么不同,如何相互转换?
  • node express安装
  • 已申报未导入是什么情况
  • js reverse
  • 进项未认证但已开票怎么办
  • php屏蔽ip
  • 深入解读何暮楚
  • 生产设备的折旧分录
  • 主营业务收入在哪个报表里面
  • SQL server配置管理器打开TCP/IP后重启不了
  • 水电费的会计分录
  • 材料已入库后收回怎么办
  • 劳务费个人所得税核定征收
  • 写字楼里的公司怎么赚钱
  • 刻章费用怎么说
  • 社保补差什么流程
  • 酒店会计做账流程
  • 个人如何成立公司
  • mysql 5.6 从陌生到熟练之_数据库备份恢复的实现方法
  • mysql中count(), group by, order by使用详解
  • bios单词
  • 2021图解
  • 苹果15手机价格和图片颜色
  • win8.1连接wifi
  • xp开机chkdsk
  • pcards
  • python 进程间通讯
  • jsp中onload事件
  • linux启动过程流程图
  • 使用脚本什么意思
  • 无法加载odbc驱动程序
  • 启动游戏使用的文件夹什么意思
  • javascript基础书
  • 国家河南税务局
  • 出口退税的汇率按什么时候的汇率
  • 企业年度总收入指的是什么意思
  • 苏州社保一卡通要充值吗
  • 中国税务报订阅电话
  • 税票电话号码变更影响抵扣吗
  • 免责声明:网站部分图片文字素材来源于网络,如有侵权,请及时告知,我们会第一时间删除,谢谢! 邮箱:opceo@qq.com

    鄂ICP备2023003026号

    网站地图: 企业信息 工商信息 财税知识 网络常识 编程技术

    友情链接: 武汉网站建设