File: ball.h

package info (click to toggle)
flying 6.20-6
  • links: PTS
  • area: main
  • in suites: etch, etch-m68k, lenny
  • size: 752 kB
  • ctags: 1,873
  • sloc: cpp: 10,966; makefile: 189
file content (134 lines) | stat: -rw-r--r-- 4,014 bytes parent folder | download | duplicates (3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
#ifndef _ball_h
#define _ball_h

//
// In dem Modul 'ball.h' sind alle Klassen vereint, die mit B�llen und B�gen
// zu tun haben. Dabei gelten die folgenden Ableitungen
//
//			   StaticArc			: Grundfunktionalit�t
//         /         \
//		 OuterArc	 InnerArc	: Bogen, der von au�en/innen reflektiert
//        |       \   |
//		    |       ArcWall	 	: beidseitig reflektierend (Ableitung nur symbolisch)
//		StaticBall					: 360 Grad Bogen, nicht beweglich
//        |
//		  Ball						: Kugel (gleichzeitig ein DynObj)
//
//
// Eine Besonderheit stellt der Ball dar, welcher die Funktionalit�t des
// DynObj und des Object besitzt. Au�erdem ist er ein Beispiel, wie durch
// spezielle Ausnutzung der HitFromBall-Routine die Kontrolle an ein Objekt
// gebracht werden kann. Um Schrittweise die Geschwindigkeit durch Reibung
// zu verringern, gibt er in der HitFromBall-Routine die Zeit des n�chsten
// Verlangsamungsschrittes zur�ck, wenn er nach einer Kollision mit sich
// selbst befragt wird.
//

#ifndef _arcs_h
#	include "arcs.h"			// Oberklasse StaticBall
#endif
#ifndef _dynobj_h
#	include "dynobj.h"		// zweite Oberklasse DynObj
#endif

class BallStateTop;		// forward
class PBallTop;

//
// -------------------------------------------------------------------------
//   class Ball:  Fliegende Kugeln
// -------------------------------------------------------------------------
//

class Ball : public StaticBall, public DynObj {
	public:		// private
		Vec2		v;				// Geschwindigkeits-Vektor
		char			run_flag;	// Geschwingkeit ungleich null
		const Real	a;				// Absolutwert der Negativ-Beschleunigung
#if (SIM_SLOW)
		Real			next_slowstep;		// Zeitpunkt der n�chsten Verlangsamung
		Real			last_slowstep;		// Zeitpunkt der letzten Verlangsamung
		Real			slow_granoff;		// Offset bei Start, damit Kugeln zu
												// unterschiedlicher Zeit gebremst werden.
		void			SlowStep();			// Kugel verlangsamen
#endif

		PBallTop	*pball;				// PBall, welcher den Lock hat
		int	Lock( PBallTop *pball );
		int	Unlock( PBallTop *pball );
		void	GoUnlocked();

		BallStateTop	*state;
		void SetState( BallStateTop *state_in )	{ state = state_in; }

	public:		// protected
		Real			m;			// Masse, wird vom RemotePBall veraendert !!!

#if (TIME_CACHE)
		virtual void CollisionCalc();
		virtual void HitYouAt( Object *obj, Real time );

		Object	*collision_object;
		Real		collision_time;
#endif

	public:
		Ball( double x, double y, double vx, double vy, double r, double m );
		Ball( double x, double y, double vx, double vy, double r );
		Ball( double x, double y, double vx, double vy );
		Ball( const Vec2 &v, double r, double m );
		Ball( const Vec2 &v, double r );
		~Ball();

		const Vec2 &V() const			{ return v; }
		const Real   &VX() const		{ return v.X(); }
		const Real   &VY() const		{ return v.Y(); }
//		Real   VXpix() const				{ return v.Xpix(); }
//		Real   VYpix() const				{ return v.Ypix(); }
		const	Real   &M() const			{ return m; }

		int IsRunning() const			{ return run_flag; }

		Vec2 Dir() const;
		Real Len() const					{ return V().Norm(); }

		void SetP( const Vec2 &new_p );	// Kugel auf Position setzen (mit Zeichnen)
		void SetV( const Vec2 &v_in );
		void SetPV( const Vec2 &new_p, const Vec2 &v_in=Vec2Zero )
												{ SetP( new_p ); SetV( v_in ); }
		void ChgV( const Vec2 &v_in ) {
			SetV( v_in );
#if (TIME_CACHE)
			CollisionCalc();
#endif
		}

		void TellPressed();

		Real HitFromBall( Ball *b );
		virtual Real NextCollision();
		void CollideWithBall( Ball *b );

		static Real FindClosest( const Ball *myself,  const Vec2 &pos, Ball **best );
		int FitsAt(const Vec2 &pos);
		int FitsNextTo(const Vec2 &pos, const Vec2 &delta, Vec2 *newpos);

		virtual void Move( Real t );
		virtual void Reset();
		virtual void Redraw();

		virtual void Info();
		virtual void WasHit(Object *);

		const BallStateTop *GetState()					{ return state; }

		virtual void Draw();

friend class PBallTop;
friend class LineKeeper;
friend class StackKeeper;
friend class Goal;
};


#endif