Jypeli 10
The simple game programming library
Camera.cs
Siirry tämän tiedoston dokumentaatioon.
1#region MIT License
2/*
3 * Copyright (c) 2009 University of Jyväskylä, Department of Mathematical
4 * Information Technology.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24#endregion
25
26/*
27 * Authors: Tero Jäntti, Tomi Karppinen, Janne Nikkanen.
28 */
29
30using System;
31using System.Collections.Generic;
32
33namespace Jypeli
34{
38 [Save]
39 public class Camera : PositionalRW
40 {
41 // Huom. tätä käytetään vain jos seurataan useita olioita kerralla
42 private List<GameObject> followedObjects = null;
44
45 [Save] internal bool _stayInLevel = false;
46 [Save] internal double _zoomFactor = 1.0;
47
51 [Save]
53 {
54 get { return _pos; }
55 set { _pos = value; }
56 }
57
61 [Save]
62 public Vector Velocity { get; set; }
63
67 public double X
68 {
69 get
70 {
71 return _pos.X;
72 }
73 set
74 {
75 _pos.X = value;
76 }
77 }
78
82 public double Y
83 {
84 get
85 {
86 return _pos.Y;
87 }
88 set
89 {
90 _pos.Y = value;
91 }
92 }
93
98 public double ZoomFactor
99 {
100 get { return _zoomFactor; }
101 set { _zoomFactor = value; }
102 }
103
107 public bool StayInLevel
108 {
109 get { return _stayInLevel; }
110 set { _stayInLevel = value; }
111 }
112
116 public GameObject FollowedObject { get; set; }
117
121 public bool FollowsX { get; set; }
122
126 public bool FollowsY { get; set; }
127
140 [Save] public Vector FollowOffset { get; set; }
141
146 public double FollowXMargin { get; set; }
147
152 public double FollowYMargin { get; set; }
153
157 internal Camera()
158 {
159 FollowsX = true;
160 FollowsY = true;
162 }
163
168 {
169 return Position + (1 / ZoomFactor) * point;
170 }
171
176 {
177 return (point - Position) * ZoomFactor;
178 }
179
184 public Vector ScreenToWorld( Vector point, Layer layer )
185 {
186 if ( layer == null )
187 return ScreenToWorld( point );
188 if ( layer.IgnoresZoom )
189 return Vector.ComponentProduct( Position, layer.RelativeTransition ) + point;
190
191 return Vector.ComponentProduct( Position, layer.RelativeTransition ) + ( 1 / ZoomFactor ) * point;
192 }
193
198 public Vector WorldToScreen( Vector point, Layer layer )
199 {
200 if ( layer == null )
201 return WorldToScreen( point );
202 if ( layer.IgnoresZoom )
203 return point - Vector.ComponentProduct( Position, layer.RelativeTransition );
204
205 return ( point - Vector.ComponentProduct( Position, layer.RelativeTransition ) ) * ZoomFactor;
206 }
207
212 public void Move( Vector v )
213 {
214 Position += new Vector( v.X / ZoomFactor, v.Y / ZoomFactor );
215 }
216
224 public void Zoom( double zoom )
225 {
226 ZoomFactor *= zoom;
227 }
228
232 public void Reset()
233 {
236 ZoomFactor = 1.0f;
238 }
239
244 public void Follow( params GameObject[] gameobjects )
245 {
246 FollowsX = true;
247 FollowsY = true;
248
249 if ( gameobjects.Length == 0 ) return;
250 if ( gameobjects.Length == 1 )
251 {
252 FollowedObject = gameobjects[0];
253 return;
254 }
255
256 FollowedObject = new GameObject( 1.0, 1.0 );
257 followedObjects = new List<GameObject>( gameobjects );
259 }
260
265 public void FollowX( params GameObject[] gameobjects )
266 {
267 Follow( gameobjects );
268 FollowsX = true;
269 FollowsY = false;
270 }
271
276 public void FollowY( params GameObject[] gameobjects )
277 {
278 Follow( gameobjects );
279 FollowsX = false;
280 FollowsY = true;
281 }
282
286 public void StopFollowing()
287 {
288 if ( followedObjects != null )
289 {
290 followedObjects = null;
292 }
293
294 FollowedObject = null;
295 }
296
297 private void updateAvgPoint()
298 {
299 FollowedObject.Position = followedObjects.ConvertAll<GameObject, Vector>( ( GameObject o ) => { return o.Position; } ).Average();
300
301 double maxDx = followedObjects.ConvertAll<GameObject, double>( ( GameObject o ) => { return Math.Abs( o.X - FollowedObject.X ); } ).Max();
302 double maxDy = followedObjects.ConvertAll<GameObject, double>( ( GameObject o ) => { return Math.Abs( o.Y - FollowedObject.Y ); } ).Max();
303
304 double zoomX = Game.Screen.Width / ( 2 * maxDx + FollowXMargin );
305 double zoomY = Game.Screen.Height / ( 2 * maxDy + FollowYMargin );
306
307 ZoomFactor = Math.Min( zoomX, zoomY );
308 }
309
315 public void ZoomTo( Vector bottomLeft, Vector topRight )
316 {
317 ZoomTo( bottomLeft.X, bottomLeft.Y, topRight.X, topRight.Y );
318 }
319
324 public void ZoomTo( BoundingRectangle rectangle )
325 {
326 ZoomTo( rectangle.Left, rectangle.Bottom, rectangle.Right, rectangle.Top );
327 }
328
335 public void ZoomTo( BoundingRectangle rectangle, double borderSize )
336 {
337 ZoomTo( rectangle.Left, rectangle.Bottom, rectangle.Right, rectangle.Top, borderSize );
338 }
339
343 public void ZoomToAllObjects()
344 {
345 ZoomToAllObjects( 0 );
346 }
347
352 public void ZoomToAllObjects( double borderSize )
353 {
354 // Do the real zoom next update so all objects waiting to be added are added before that
355 Game.DoNextUpdate( doZoomToAllObjects, borderSize );
356 }
357
358 private void doZoomToAllObjects( double borderSize )
359 {
360 if ( Game.Instance.ObjectCount > 0 )
361 ZoomTo( Game.Instance.Level.FindObjectLimits(), borderSize );
362 }
363
371 public void ZoomTo( double left, double bottom, double right, double top )
372 {
373 ZoomTo( left, bottom, right, top, 0 );
374 }
375
376 internal void ZoomTo( double left, double bottom, double right, double top, double borderSize )
377 {
378 double screenWidth = (double)Game.Screen.Width;
379 double screenHeight = (double)Game.Screen.Height;
380 double width = right - left;
381 double height = top - bottom;
382
383 Position = new Vector( left + width / 2, bottom + height / 2 );
384
385 if ( ( width / height ) >= ( screenWidth / screenHeight ) )
386 this.ZoomFactor = screenWidth / ( width + borderSize );
387 else
388 this.ZoomFactor = screenHeight / ( height + borderSize );
389 }
390
394 public void ZoomToLevel()
395 {
396 ZoomToLevel( 0 );
397 }
398
403 public void ZoomToLevel( double borderSize )
404 {
405 FollowedObject = null;
406 Level level = Game.Instance.Level;
407 ZoomTo( level.Left, level.Bottom, level.Right, level.Top, borderSize );
408 }
409
414 internal void Update( Time time )
415 {
416 Position += Velocity * time.SinceLastUpdate.TotalSeconds;
417
418 if ( FollowedObject != null )
419 {
420 Vector center = ScreenToWorld( Vector.Zero );
421 Vector worldOffset = ScreenToWorld( FollowOffset );
422
423 // Update the average point if following multiple objects
424 if ( followedObjects != null ) updateAvgPoint();
425
426 if ( FollowsX && FollowsY )
427 Position = FollowedObject.Position + ( worldOffset - center );
428 else if ( FollowsX )
429 X = FollowedObject.X + ( worldOffset.X - center.X );
430 else if ( FollowsY )
431 Y = FollowedObject.Y + ( worldOffset.Y - center.Y );
432 }
433
434 if ( StayInLevel )
435 {
436 double screenWidth = (double)Game.Screen.Width;
437 double screenHeight = (double)Game.Screen.Height;
438 Level level = Game.Instance.Level;
439
440 double screenAspectRatio = screenWidth / screenHeight;
441 double levelAspectRatio = level.Width / level.Height;
442
443 double zoomedWidth = level.Width * ZoomFactor;
444 double zoomedHeight = level.Height * ZoomFactor;
445
446 double viewAreaWidth = screenWidth / ZoomFactor;
447 double viewAreaHeight = screenHeight / ZoomFactor;
448
449 if ( zoomedWidth < screenWidth || zoomedHeight < screenHeight )
450 {
451 ZoomFactor = Math.Max( screenWidth / level.Width, screenHeight / level.Height );
452 }
453
454 if ( ( Position.X - ( viewAreaWidth / 2 ) ) < level.Left )
455 {
456 _pos.X = level.Left + ( viewAreaWidth / 2 );
457 }
458 else if ( Position.X + ( viewAreaWidth / 2 ) > level.Right )
459 {
460 _pos.X = level.Right - ( viewAreaWidth / 2 );
461 }
462
463 if ( Position.Y - ( viewAreaHeight / 2 ) < level.Bottom )
464 {
465 _pos.Y = level.Bottom + ( viewAreaHeight / 2 );
466 }
467 else if ( Position.Y + ( viewAreaHeight / 2 ) > level.Top )
468 {
469 _pos.Y = level.Top - ( viewAreaHeight / 2 );
470 }
471 }
472 }
473 }
474}
Kamera. Määrittää mikä osa pelitasosta on kerralla näkyvissä.
Definition: Camera.cs:40
Camera()
Luo uuden kameran.
Definition: Camera.cs:157
bool FollowsY
Seurataanko oliota (FollowedObject) y- eli pystysuunnassa.
Definition: Camera.cs:126
double X
Kameran paikan X-koordinaatti.
Definition: Camera.cs:68
Vector _pos
Definition: Camera.cs:43
Vector Position
Kameran sijainti.
Definition: Camera.cs:53
double Y
Kameran paikan Y-koordinaatti.
Definition: Camera.cs:83
void ZoomTo(BoundingRectangle rectangle)
Sijoittelee kameran annettuun suorakulmioon
Definition: Camera.cs:324
void doZoomToAllObjects(double borderSize)
Definition: Camera.cs:358
void FollowX(params GameObject[] gameobjects)
Seuraa jotakin peliobjektia X- eli vaakasuunnassa.
Definition: Camera.cs:265
void ZoomTo(double left, double bottom, double right, double top, double borderSize)
Definition: Camera.cs:376
double ZoomFactor
Kameran zoomauskerroin. Oletuksena 1.0. Mitä suurempi zoomauskerroin, sitä lähempänä kamera on (esim ...
Definition: Camera.cs:99
Vector FollowOffset
Jos kamera seuraa oliota, tällä voi säätää missä kohtaa ruutua pelaaja näkyy. Toisin sanoen ruutukoor...
Definition: Camera.cs:140
void ZoomToLevel()
Zoomaa ja keskittää kameran siten, että koko kenttä on näkyvissä kerralla.
Definition: Camera.cs:394
void ZoomTo(BoundingRectangle rectangle, double borderSize)
Sijoittelee kameran annettuun suorakulmioon annetulla marginaalilla
Definition: Camera.cs:335
Vector WorldToScreen(Vector point)
Muuntaa annetun pisteen maailmankoordinaateista ruutukoordinaatteihin.
Definition: Camera.cs:175
void Update(Time time)
Ajetaan kun pelitilannetta päivitetään.
Definition: Camera.cs:414
Vector ScreenToWorld(Vector point, Layer layer)
Muuntaa annetun pisteen ruutukoordinaateista maailmankoordinaatteihin ottaen huomioon oliokerroksen s...
Definition: Camera.cs:184
Vector Velocity
Kameran liikkumisnopeus.
Definition: Camera.cs:62
void ZoomToAllObjects()
Keskittää ja zoomaa kameran niin, että kaikki objektit näkyvät ruudulla.
Definition: Camera.cs:343
double _zoomFactor
Definition: Camera.cs:46
void Reset()
Resetoi kameran (keskittää, laittaa zoomin oletusarvoon ja lopettaa seuraamisen).
Definition: Camera.cs:232
double FollowYMargin
Jos kamera seuraa useita olioita, tällä voi säätää kuinka paljon ylä- ja alareunaan jätetään tyhjää t...
Definition: Camera.cs:152
void Follow(params GameObject[] gameobjects)
Seuraa yhtä tai useampaa peliobjektia.
Definition: Camera.cs:244
void Move(Vector v)
Liikuttaa kameraa.
Definition: Camera.cs:212
Vector ScreenToWorld(Vector point)
Muuntaa annetun pisteen ruutukoordinaateista maailmankoordinaatteihin.
Definition: Camera.cs:167
void StopFollowing()
Lopettaa olio(iden) seuraamisen.
Definition: Camera.cs:286
void ZoomToAllObjects(double borderSize)
Zoomaa ja sijoittaa kameran siten, että kaikki pelioliot ovat yhtäaikaa näkyvissä.
Definition: Camera.cs:352
Vector WorldToScreen(Vector point, Layer layer)
Muuntaa annetun pisteen maailmankoordinaateista ruutukoordinaatteihin ottaen huomioon oliokerroksen s...
Definition: Camera.cs:198
List< GameObject > followedObjects
Definition: Camera.cs:42
GameObject FollowedObject
Olio, jota kamera seuraa. Jos null, mitään oliota ei seurata.
Definition: Camera.cs:116
double FollowXMargin
Jos kamera seuraa useita olioita, tällä voi säätää kuinka paljon vasempaan ja oikeaan reunaan jätetää...
Definition: Camera.cs:146
void updateAvgPoint()
Definition: Camera.cs:297
bool _stayInLevel
Definition: Camera.cs:45
void ZoomTo(Vector bottomLeft, Vector topRight)
Zoomaa ja sijoittaa kameran niin, että parametreina annettua alue näkyy kokonaan ruudulla.
Definition: Camera.cs:315
void ZoomTo(double left, double bottom, double right, double top)
Zoomaa ja sijoittaa kameran niin, että parametreina annettua alue näkyy kokonaan ruudulla.
Definition: Camera.cs:371
void ZoomToLevel(double borderSize)
Zoomaa ja keskittää kameran siten, että koko kenttä on näkyvissä kerralla. Tällöin kamera ei seuraa m...
Definition: Camera.cs:403
bool StayInLevel
Jos tosi, kamera ei mene koskaan kentän ulkopuolelle.
Definition: Camera.cs:108
bool FollowsX
Seurataanko oliota (FollowedObject) x- eli vaakasuunnassa.
Definition: Camera.cs:121
void Zoom(double zoom)
Zoomaa.
Definition: Camera.cs:224
void FollowY(params GameObject[] gameobjects)
Seuraa jotakin peliobjektia Y- eli pystysuunnassa.
Definition: Camera.cs:276
Level Level
Aktiivinen kenttä.
Definition: Game.cs:145
static void DoNextUpdate(Action action)
Suorittaa aliohjelman seuraavalla päivityksellä.
int ObjectCount
Kuinka monta pelioliota pelissä on
Definition: Layers.cs:71
static Game Instance
Käynnissä olevan pelin pääolio.
Definition: Game.cs:96
static ScreenView Screen
Näytön dimensiot, eli koko ja reunat.
Definition: Graphics.cs:90
Pelialueella liikkuva olio. Käytä fysiikkapeleissä PhysicsObject-olioita.
Definition: Appearance.cs:34
override Vector?? Position
Definition: Dimensions.cs:72
override void Destroy()
Tuhoaa olion. Tuhottu olio poistuu pelistä.
Definition: GameObject.cs:55
double X
Olion paikan X-koordinaatti.
double Y
Olion paikan Y-koordinaatti.
Kerros. Vastaa olioiden piirtämisestä.
Definition: Layer.cs:32
bool IgnoresZoom
Jättää kameran zoomin huomiotta jos asetettu.
Definition: Layer.cs:119
Vector RelativeTransition
Kuinka paljon tämän kerroksen olioiden paikka muuttuu kameran siirtyessä suhteessa muihin kerroksiin....
Definition: Layer.cs:111
Pelikenttä, johon voi lisätä olioita. Kentällä voi myös olla reunat ja taustaväri tai taustakuva.
Definition: Borders.cs:6
double Top
Kentän yläreunan y-koordinaatti.
Definition: Level.cs:152
double Left
Kentän vasemman reunan x-koordinaatti.
Definition: Level.cs:136
double Right
Kentän oikean reunan x-koordinaatti.
Definition: Level.cs:144
double Width
Kentän leveys.
Definition: Level.cs:109
double Bottom
Kentän alareunan y-koordinaatti.
Definition: Level.cs:160
double Height
Kentän korkeus.
Definition: Level.cs:118
BoundingRectangle FindObjectLimits()
Laskee pienimmän alueen, jonka sisälle kaikki kentän oliot mahtuvat.
Definition: Level.cs:190
double Width
Näytön leveys x-suunnassa.
Definition: View.cs:222
double Height
Näytön korkeus y-suunnassa.
Definition: View.cs:235
Olio jolla on paikka jota voi muuttaa.
Definition: Positional.cs:28
double Top
Suorakaiteen yläreunan Y
double Right
Suorakaiteen oikean reunan X
double Left
Suorakaiteen vasemman reunan X
double Bottom
Suorakaiteen alareunen Y
Sisältää tiedon ajasta, joka on kulunut pelin alusta ja viime päivityksestä.
Definition: Time.cs:14
TimeSpan SinceLastUpdate
Aika joka on kulunut viime päivityksestä.
Definition: Time.cs:27
2D-vektori.
Definition: Vector.cs:67
double Y
Vektorin Y-komponentti
Definition: Vector.cs:339
static readonly Vector Zero
Nollavektori.
Definition: Vector.cs:71
double X
Vektorin X-komponentti.
Definition: Vector.cs:334
static Vector ComponentProduct(Vector a, Vector b)
Kertoo kaksi vektoria komponenteittain.
Definition: Vector.cs:179