EX31: Developing Multiplayer Games with Microsoft ... - MSDN

prettybadelyngeΛογισμικό & κατασκευή λογ/κού

18 Νοε 2013 (πριν από 3 χρόνια και 11 μήνες)

85 εμφανίσεις

Hello!

Switcheroo.


(session based on new project) + (bureaucracy) = trouble

with Grant
Skinner

building multiplayer games

with Grant Skinner

b
uilding games in
silverlight

about this talk


m
icrosoft

platform


market
opportunities


skills required


technology


challenges


Q&A / discussion

Market Opportunities

65%

3
5%

MALE

FEMALE

20% AGR & accelerating

Online Casual Games

$600M

$2.1B

2007

2008

Downloadable Casual Games (PC)

$490M

$835M

2008

2009

Social Games

FarmVille

by
Zynga


Primarily played
through Facebook


5 weeks to develop


1M users in first 4 days


82M
users in 9 months


Est.
$200M
+ revenues
from micropayments,
ads, &
offers in just 2
years

FarmVille


Direct sales to consumer


Sale / licensing to
distributor


Advertising (in
-
game &
banner)


Premium subscriptions


Micro transactions
(fastest growing
segment)


Indirect: marketing,
services, component
sales

Revenue Breakdown 2010*

Monetization


dedicated game
development companies,
including mainstream
game companies (ex. EA)


marketing agencies &
interactive shops building
branded properties


casual developers working
for fun / free. There is a
move towards “publishers”
funding games.

Who builds these games?


Currently owns social
games market (MySpace
distant #2)


70% games played
outside US


FB Connect biggest driver


FB Credits coming soon


Average player is 35+


Currently growing at 10%

Facebook

Game developer qualifications

Game development is one of the best ways to expand your
abilities as a developer, but it requires a special type of
developer.

Multiplayer Game Development

Game Development

Application Development

Game development

Optimization

Holistic optimization of performance and memory.
Encompassing code, graphics, architecture, and
algorithms.

Code optimization

Syntactical and structural optimizations start with a good
understanding of the compiler, runtime, timing model, and
GC.


Profiling tools for Silverlight include XPerf, Silverlight Spy,
Eqatec Profiler.

Graphics optimization

Game developers need to look beyond code, and
understand the performance implications of graphics and
animation.


For example, the relative impact of vector vs. bitmap vs.
cached art, understanding GPU acceleration, and the cost
of shaders and 2.5D effects.

Creative architecture

Due to the performance critical nature of game logic, you
often must make practical trade
-
offs between architecture
and performance.


Abstraction and low coupling often come at the cost of
some performance overhead.

Algorithms

Games frequently rely on performance critical algorithms
for tasks like path finding, proximity detection, spacial
division, data manipulation, and physics simulation.


An understanding of algorithm growth rates, and the ability
to utilize / analyze / adapt existing algorithms is critical.

Math

At a bare minimum, you will require basic knowledge of
elementary math, spatial math, bitwise operations, and
trigonometry. Advanced trig and some calculus or physics
can pay off as well.


Things get vastly more complicated when you move into
3D. Hello quaternions!

Game experience

In game development the user experience is more tightly
bound to development than in RIA development. This
means the developer must have a genuine interest and
aptitude in creating quality gameplay.

Graphics & sound integration


Graphics and audio are much more closely tied to
development in games than in most applications. It also
tends to be a much tighter iteration process
.


You will want to be very familiar with the import tools in
Blend. Knowing a bit about the tools your designers are
working with is also helpful for quick tweaks.

Interaction & display


Games tend to require more granular control of
interactions (mouse & keyboard), and the display.


For example, limitations with mouse leave, tracking key
down state (ex.
KeyHandler
), handling key repeat, etc.



Spiking

The process of creating small, isolated tests is broadly
useful in development, but is especially applicable to game
development.


Silverlight / VS is not particularly suited to spiking, but
we’ve found some approaches that work ok.

Spiking: Approach 1

1.
Create
solution in VS for your spikes & add any shared class
libraries

2.
Create
a web project, and set its start action to “current page”

3.
Create
new spikes as new projects in the solution.


Launching
the project will display the project directory in IE, allowing you to select a
spike quickly.

Spiking: Approach 2

1.
Create a new project for your spikes.

2.
Create each new spike as a
UserControl
.

3.
Switch the
RootVisual

for your application either in code.


Similarly to this, you can simply load in your spike as the primary
child of a simple harness app, and change it at runtime.

Programmatic motion

There are a lot of ways to move elements around on
screen. Understanding the pros and cons of each, and
being able to implement them is a must.


Ex. programmatic eases, linear, simple, acceleratory,
cartesian, vector / angular.

Collision Detection

Most game types require collision detection. There are
multiple approaches:

rectangular, point to shape
(VisualTreeHelper.FindElementsInHostCoordinates),
mathematical, & shape to shape (w/custom shader).

Multiplayer game development

Models


Server as host: The server manages game state and
handles all significant logic. Clients act as views
.


Client as host: One client is promoted to host / super
client, and owns the definitive game state.

Turn
-
based
asynchronous / social

Interactions between players are asynchronous or have
minimal intersection. The game continues across multiple
sessions. It may have alternating or adhoc “turns”.


Generally more traditional networking approach (http,
request based). Requires separate messaging. Game state
lives on the server and must be maintained for the life of
the game.

Turn
-
based
synchronous

Players alternate turns in a single gaming session.


Can use either http requests & polling or socket
connections. Latency has little impact. State can live on the
client or on the server.

Real time

All players are active simultaneously, and can interact with each
other in real time.


Clients communicate through a socket server. Latency
management is critical. Game state can live on the client or
server.


Be very careful with random and time based logic.

Real time messaging

Typically broken into 3 message types: interactions, game
events, and state updates.



Interactions
-

disseminate user interactions to server /
clients


Game events
-

notifications of significant game events


State updates
-

full or partial state information

Handling latency

Latency will generally range from 60
-
300ms (client to server to client).
Better connected and more localized servers will reduce this. Server
based game logic also greatly reduces the impact of latency.


Dealing with latency involves strategies like delaying user inputs to
account for latency, interpolating values based on known / estimated
latency, and making interactions “fuzzy” to reduce obvious
discrepancies.

Minimizing cheating

Gamers will spend an unbelievable amount of energy
hacking popular games. Packet sniffing / injection,
decompiling / modifying / redistributing your game client,
etc.


This can be minimized by keeping more logic on server,
random checks, client “honesty” heuristics, and
obfuscation.

Technology

Java is (surprisingly) still in use, but is rapidly losing
ground to Flash, the market leader. Silverlight is the
new kid on the block.


Lack of tooling / support for animation & interactive design


Higher barrier to entry for users & developers


Larger file size & slower initialization


Version fragmentation, complicated runtime distribution


Security considerations

Java’s downfall

Flash’s strengths



Ubiquity



Very low barrier to entry for developers & users



Strong toolset for animation, interactive design, & development



Simple run
-
time updating



Robust, approachable language



Good code performance, reasonable graphics performance



Very strong & vibrant community, lots of OSS code incl. game
frameworks



Portability to AIR, mobile, devices

Strengths: Development


Robust
language & excellent developer / debugging
tools


Server
-
side
integration


Access
to mature game libraries & commercial
components


Some
XNA libraries can be used via
Silversprite

(and
similar projects)

Strengths: Performance



Code execution



Multi
-
threading



GPU support (limited)

Strengths: Portability



Portability to Windows Phone 7, XBLA, WPF



Very simple out of browser experience



Easy to move to native desktop application

Thank you!

@
gskinner

gskinner.com/blog/

Questions?