位置: 编程技术 - 正文

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吗)

  • 施工合同的印花税需要合同双方都缴纳吗?
  • 期末留抵税额怎么算开票金额
  • 加了油的电子发票怎么导出来
  • 手写报销单据格式图片
  • 收了押金不退
  • 非营利组织免税资格怎么认定
  • 利息收入需要交印花税吗
  • 企业所得税汇算清缴退税分录
  • 承租人与出租人签订了一份租赁合同,该设备
  • 有限合伙企业经营期限多久
  • 企业变更地址需要哪些资料
  • 增值税和实际缴税不符
  • 民办非企业收入会计分录
  • 项目部管理人员及作业人员的
  • 货物运输企业纳税多少
  • 税款负担方式是什么
  • 差额纳税计算方法
  • 月末主营业务收入结转会计分录
  • 什么企业不可以开通信保订单服务
  • 当月认证失控发票怎么做账处理?
  • 个人收回转让的股权个税应如何处理?
  • 盈余积累转增资本的条件
  • 0x8000005解决方案
  • 常见转移支付事项有哪些情况
  • microsoft word安装
  • php jquery教程
  • 内置管理员无法激活此应用
  • windows设备超时是什么意思
  • 电脑dwm.exe是什么
  • 如何修复win10开机转圈五分钟
  • 采购原材料合理化建议
  • 员工冲借款应该怎么做账
  • 未分配利润转增股本交印花税
  • 如何查询税务完税证明
  • php数组的类型有哪些
  • syms命令
  • php如何使用
  • nginx连接超时时间设置多少
  • php屏蔽错误
  • 深度学习数据集—水果数据集大合集
  • 如何验证工具坐标系
  • php页面跳转可以用header
  • 研发人员餐费
  • 预收账款包括哪些内容具体明细
  • 跨年的发票可以退税吗
  • sql server数据库正在恢复
  • phpcms api
  • 织梦如何使用
  • 代销费是谁给谁
  • 租单位的房子怎么办营业执照
  • 发生的计提费用没有发生怎么办
  • 暂估成本发票最晚什么时候补齐
  • 以前年度的银行流水可以补进来做账嘛
  • 车辆使用费怎么算
  • 固定资产报废怎么开票
  • 公司的房租发票怎么开
  • 营改增后税额计算公式
  • 以物易物有什么好处
  • 一般纳税人月销售额10万以下
  • 原材料暂估入库成本结转处理
  • 公司员工还款会计分录
  • 职工教育经费可以结转几年继续抵扣吗
  • 会计凭证中转是什么
  • 免于填报什么意思
  • ubuntu 12.04使用QQ截图安装教程
  • centos部署tomcat配置
  • win7怎么退出域环境
  • win8.1 蓝屏
  • linux CentOS/redhat 6.5 LVM分区使用详解
  • mac安装win10系统后怎么关掉f1快捷键
  • centos为什么没有桌面
  • linux运行级别有几种
  • linux中vi命令是什么意思
  • 基于python的聊天软件
  • jq写css样式
  • androidのLinearLayout中组件右对齐
  • 安徽地税局电话号码
  • 普惠性和非普惠的区别
  • 国税湖南电子税务局官网
  • 交17000办的保险是什么保险
  • 免责声明:网站部分图片文字素材来源于网络,如有侵权,请及时告知,我们会第一时间删除,谢谢! 邮箱:opceo@qq.com

    鄂ICP备2023003026号

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

    友情链接: 武汉网站建设