_________ __                 __
        /   _____//  |_____________ _/  |______     ____  __ __  ______
        \_____  \\   __\_  __ \__  \\   __\__  \   / ___\|  |  \/  ___/
        /        \|  |  |  | \// __ \|  |  / __ \_/ /_/  >  |  /\___ \
       /_______  /|__|  |__|  (____  /__| (____  /\___  /|____//____  >
               \/                  \/          \//_____/            \/
    ______________________                           ______________________
                          T H E   W A R   B E G I N S
                   Stratagus - A free fantasy real time strategy game engine

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
missile.h
Go to the documentation of this file.
1 // _________ __ __
2 // / _____// |_____________ _/ |______ ____ __ __ ______
3 // \_____ \\ __\_ __ \__ \\ __\__ \ / ___\| | \/ ___/
4 // / \| | | | \// __ \| | / __ \_/ /_/ > | /\___ |
5 // /_______ /|__| |__| (____ /__| (____ /\___ /|____//____ >
6 // \/ \/ \//_____/ \/
7 // ______________________ ______________________
8 // T H E W A R B E G I N S
9 // Stratagus - A free fantasy real time strategy game engine
10 //
12 //
13 // (c) Copyright 1998-2005 by Lutz Sammer
14 //
15 // This program is free software; you can redistribute it and/or modify
16 // it under the terms of the GNU General Public License as published by
17 // the Free Software Foundation; only version 2 of the License.
18 //
19 // This program is distributed in the hope that it will be useful,
20 // but WITHOUT ANY WARRANTY; without even the implied warranty of
21 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 // GNU General Public License for more details.
23 //
24 // You should have received a copy of the GNU General Public License
25 // along with this program; if not, write to the Free Software
26 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
27 // 02111-1307, USA.
28 //
29 
30 #ifndef __MISSILE_H__
31 #define __MISSILE_H__
32 
34 
35 /*----------------------------------------------------------------------------
36 -- Documentation
37 ----------------------------------------------------------------------------*/
38 
294 /*----------------------------------------------------------------------------
295 -- Includes
296 ----------------------------------------------------------------------------*/
297 
298 #include "missileconfig.h"
299 #include "script.h"
300 #include "unitptr.h"
301 #include "unitsound.h"
302 #include "vec2i.h"
303 
304 /*----------------------------------------------------------------------------
305 -- Declarations
306 ----------------------------------------------------------------------------*/
307 
308 class CGraphic;
309 class CUnit;
310 class CViewport;
311 class CFile;
312 class LuaCallback;
313 
314 /*----------------------------------------------------------------------------
315 -- Missile-type
316 ----------------------------------------------------------------------------*/
317 
321 enum {
340 };
341 
344 {
345 public:
346  explicit MissileType(const std::string &ident);
347  ~MissileType();
348 
350  void LoadMissileSprite();
351  void Init();
352  void DrawMissileType(int frame, const PixelPos &pos) const;
353 
354  void Load(lua_State *l);
355 
356  int Width() const { return size.x; }
357  int Height() const { return size.y; }
358 
359  //private:
360  std::string Ident;
363  int DrawLevel;
368  bool ChangeMax;
369 
372 
374  bool Flip;
375  bool CanHitOwner;
377  bool AlwaysFire;
378  bool Pierce;
379  bool PierceOnce;
380  bool IgnoreWalls;
382 
383  int Class;
387  int Sleep;
388  int Speed;
390  int TTL;
395 
396  int Range;
398  std::vector <MissileConfig *> Impact;
403 
404  // --- FILLED UP ---
406 };
407 
408 /*----------------------------------------------------------------------------
409 -- Missile
410 ----------------------------------------------------------------------------*/
411 
413 class Missile
414 {
415 protected:
416  Missile();
417 
418 public:
419  virtual ~Missile();
420 
421  static Missile *Init(const MissileType &mtype, const PixelPos &startPos, const PixelPos &destPos);
422 
423  virtual void Action() = 0;
424 
425  void DrawMissile(const CViewport &vp) const;
426  void SaveMissile(CFile &file) const;
427  void MissileHit(CUnit *unit = NULL);
428  bool NextMissileFrame(char sign, char longAnimation);
429  void NextMissileFrameCycle();
430  void MissileNewHeadingFromXY(const PixelPos &delta);
431 
432 
433  //private:
437  const MissileType *Type;
439  int State;
440  int AnimWait;
441  int Wait;
442  int Delay;
443 
446 
447  std::vector<CUnit *> PiercedUnits;
448 
449  int Damage;
450 
451  int TTL;
452  int Hidden;
454 
455  // Internal use:
457  int TotalStep;
458 
459  unsigned Local: 1;
460  unsigned int Slot;
461 
462  static unsigned int Count;
463 };
464 
465 extern bool MissileInitMove(Missile &missile);
466 extern bool PointToPointMissile(Missile &missile);
467 extern void MissileHandlePierce(Missile &missile, const Vec2i &pos);
468 extern bool MissileHandleBlocking(Missile &missile, const PixelPos &position);
469 
470 class MissileNone : public Missile
471 {
472 public:
473  virtual void Action();
474 };
476 {
477 public:
478  virtual void Action();
479 };
481 {
482 public:
483  virtual void Action();
484 };
486 {
487 public:
488  virtual void Action();
489 };
491 {
492 public:
493  virtual void Action();
494 };
495 class MissileStay : public Missile
496 {
497 public:
498  virtual void Action();
499 };
500 class MissileCycleOnce : public Missile
501 {
502 public:
503  virtual void Action();
504 };
505 class MissileFire : public Missile
506 {
507 public:
508  virtual void Action();
509 };
510 class MissileHit : public Missile
511 {
512 public:
513  virtual void Action();
514 };
515 class MissileParabolic : public Missile
516 {
517 public:
518  virtual void Action();
519 };
520 class MissileLandMine : public Missile
521 {
522 public:
523  virtual void Action();
524 };
525 class MissileWhirlwind : public Missile
526 {
527 public:
528  virtual void Action();
529 };
531 {
532 public:
533  virtual void Action();
534 };
535 class MissileDeathCoil : public Missile
536 {
537 public:
538  virtual void Action();
539 };
540 
541 class MissileTracer : public Missile
542 {
543 public:
544  virtual void Action();
545 };
546 
548 {
549 public:
550  virtual void Action();
551 };
552 
554 {
555 public:
556  virtual void Action();
557 };
558 
560 {
561 public:
562  virtual void Action();
563 };
564 
565 
567 {
568 public:
570 
571  int Percent;
573 } ;
574 
575 /*----------------------------------------------------------------------------
576 -- Variables
577 ----------------------------------------------------------------------------*/
578 
579 extern std::vector<BurningBuildingFrame *> BurningBuildingFrames;
580 
581 /*----------------------------------------------------------------------------
582 -- Functions
583 ----------------------------------------------------------------------------*/
584 
585 // In ccl_missile.c
586 
588 extern void MissileCclRegister();
589 
590 // In missile.c
591 
593 extern void LoadMissileSprites();
595 extern MissileType *NewMissileTypeSlot(const std::string &ident);
597 extern MissileType *MissileTypeByIdent(const std::string &ident);
599 extern Missile *MakeMissile(const MissileType &mtype, const PixelPos &startPos, const PixelPos &destPos);
601 extern Missile *MakeLocalMissile(const MissileType &mtype, const PixelPos &startPos, const PixelPos &destPos);
602 
604 extern int CalculateDamage(const CUnit &attacker, const CUnit &goal, const NumberDesc *formula);
606 extern void FireMissile(CUnit &unit, CUnit *goal, const Vec2i &goalPos);
607 
608 extern void FindAndSortMissiles(const CViewport &vp, std::vector<Missile *> &table);
609 
611 extern void MissileActions();
613 extern int ViewPointDistanceToMissile(const Missile &missile);
614 
616 extern MissileType *MissileBurningBuilding(int percent);
617 
619 extern void SaveMissiles(CFile &file);
620 
622 extern void InitMissileTypes();
624 extern void CleanMissileTypes();
626 extern void InitMissiles();
628 extern void CleanMissiles();
629 
630 extern void FreeBurningBuildingFrames();
631 
633 
634 #endif // !__MISSILE_H__
Missile stays and plays it's animation several times.
Definition: missile.h:339
~MissileType()
Definition: missile.cpp:1344
bool MissileHandleBlocking(Missile &missile, const PixelPos &position)
Definition: missile.cpp:677
void SaveMissiles(CFile &file)
Save missiles.
Definition: missile.cpp:1282
LuaCallback * OnImpact
smoke particle
Definition: missile.h:402
MissileType * MissileBurningBuilding(int percent)
Get the burning building missile based on hp percent.
Definition: missile.cpp:1223
void InitMissileTypes()
Initialize missile-types.
Definition: missile.cpp:1316
int State
sprite frame counter
Definition: missile.h:439
SoundConfig ImpactSound
fired sound
Definition: missile.h:371
int Range
missile damage (used for non-direct missiles, e.g. impacts)
Definition: missile.h:396
const MissileType * Type
missile pixel destination
Definition: missile.h:437
int Damage
Units which are already pierced by this missile.
Definition: missile.h:449
static unsigned int Count
unique number for draw level.
Definition: missile.h:462
Definition: missile.h:490
virtual void Action()
Definition: missile_straightfly.cpp:45
MissileType * NewMissileTypeSlot(const std::string &ident)
allocate an empty missile-type slot
Definition: missile.cpp:136
PixelPos position
Missile source position.
Definition: missile.h:435
Missile wait on x,y until a non-air unit comes by, the explodes.
Definition: missile.h:333
virtual void Action()
Definition: missile_parabolic.cpp:120
Missile on the map.
Definition: missile.h:413
bool MissileInitMove(Missile &missile)
Definition: missile.cpp:635
CUnitPtr SourceUnit
delay to show up
Definition: missile.h:444
MissileType * Missile
HP percent.
Definition: missile.h:572
virtual void Action()
Definition: missile_tracer.cpp:121
bool Flip
restricts the radius damage depending on land, air, naval
Definition: missile.h:374
int Percent
Definition: missile.h:569
Definition: missile.h:566
virtual void Action()=0
Missile()
Definition: missile.cpp:147
PixelPos source
Definition: missile.h:434
int DestroyMissile
If this is 1 then the missile is invisible.
Definition: missile.h:453
void CleanMissiles()
Clean missiles.
Definition: missile.cpp:1383
Missile * MakeMissile(const MissileType &mtype, const PixelPos &startPos, const PixelPos &destPos)
create a missile
Definition: missile.cpp:256
Definition: missile.h:535
T y
Definition: vec2i.h:43
Missile surround x,y.
Definition: missile.h:335
PixelPos destination
missile pixel position
Definition: missile.h:436
virtual void Action()
Definition: missile_pointotpointwithhit.cpp:44
NumberDesc * Damage
On which terrain types missile won't fly.
Definition: missile.h:394
int SmokePrecision
Multiplier for reduce or increase damage dealt to the next unit.
Definition: missile.h:392
Definition: missile.h:530
virtual void Action()
Definition: missile_deathcoil.cpp:50
Missile appears at x,y, is whirlwind.
Definition: missile.h:334
bool NextMissileFrame(char sign, char longAnimation)
Definition: missile.cpp:1079
void MissileHandlePierce(Missile &missile, const Vec2i &pos)
Definition: missile.cpp:660
void NextMissileFrameCycle()
Definition: missile.cpp:1125
int SpriteFrame
missile-type pointer
Definition: missile.h:438
Definition: missileconfig.h:44
SoundConfig FiredSound
modify the max, if value will exceed it
Definition: missile.h:370
The big unit structure.
Definition: unit.h:119
Definition: script.h:205
Definition: missile.h:480
Missile does nothing.
Definition: missile.h:323
MissileConfig Smoke
missile produces an impact
Definition: missile.h:399
void MissileNewHeadingFromXY(const PixelPos &delta)
Definition: missile.cpp:605
bool Pierce
missile will always fire (even if target is dead)
Definition: missile.h:378
unsigned int Slot
missile is a local missile
Definition: missile.h:460
int Transparency
missile name
Definition: missile.h:361
void FindAndSortMissiles(const CViewport &vp, std::vector< Missile * > &table)
Definition: missile.cpp:571
int Class
missile kills first unit blocking it's way
Definition: missile.h:383
Definition: missile.h:510
int Speed
missile sleep
Definition: missile.h:388
CUnitPtr TargetUnit
unit that fires (could be killed)
Definition: missile.h:445
virtual void Action()
Definition: missile_none.cpp:43
static Missile * Init(const MissileType &mtype, const PixelPos &startPos, const PixelPos &destPos)
Definition: missile.cpp:172
unsigned Local
Total step.
Definition: missile.h:459
Missile * MakeLocalMissile(const MissileType &mtype, const PixelPos &startPos, const PixelPos &destPos)
create a local missile
Definition: missile.cpp:273
bool KillFirstUnit
missile ignores Wall units on it's way
Definition: missile.h:381
int ParabolCoefficient
number of bounces
Definition: missile.h:385
Missile flies from x,y to x1,y1 than shows hit animation.
Definition: missile.h:325
Definition: unitsound.h:54
std::vector< MissileConfig * > Impact
missile splash divisor
Definition: missile.h:398
bool PointToPointMissile(Missile &missile)
Definition: missile.cpp:741
int NumDirections
number of sprite frames in graphic
Definition: missile.h:365
Definition: missile.h:541
int ChangeAmount
variable to change
Definition: missile.h:367
Missile seeks towards to target unit.
Definition: missile.h:337
Missile remains clipped to target's current goal and plays his animation once.
Definition: missile.h:338
virtual void Action()
Definition: missile_pointtopointbounce.cpp:45
LuaCallback * ImpactParticle
trailing missile
Definition: missile.h:400
std::string Ident
Definition: missile.h:360
Missile flies from x,y to x1,y1 using a parabolic path.
Definition: missile.h:332
bool AlwaysFire
missile can't hit own units
Definition: missile.h:377
Definition: video.h:64
Definition: viewport.h:63
virtual void Action()
Definition: missile_landmine.cpp:66
int MissileStopFlags
How frequently the smoke missile will generate itself.
Definition: missile.h:393
Definition: iolib.h:101
bool CanHitOwner
flip image when facing left
Definition: missile.h:375
int NumBounces
missile class
Definition: missile.h:384
virtual void Action()
Definition: missile_continuous.cpp:43
int SplashFactor
missile damage range
Definition: missile.h:397
int Width() const
Definition: missile.h:356
virtual void Action()
Definition: missile_pointtopointcycleonce.cpp:43
int AnimWait
state
Definition: missile.h:440
bool ChangeMax
how many to change
Definition: missile.h:368
void LoadMissileSprites()
load all missile sprites
Definition: missile.cpp:102
int ChangeVariable
number of directions missile can face
Definition: missile.h:366
virtual void Action()
Definition: missile_flameshield.cpp:47
int Wait
Animation wait.
Definition: missile.h:441
Definition: missile.h:547
int Delay
delay between frames
Definition: missile.h:442
void MissileCclRegister()
Burning building frames.
Definition: script_missile.cpp:423
void FireMissile(CUnit &unit, CUnit *goal, const Vec2i &goalPos)
fire a missile
Definition: missile.cpp:347
void FreeBurningBuildingFrames()
Definition: missile.cpp:1397
int Hidden
time to live (ticks) used for spells
Definition: missile.h:452
bool PierceOnce
missile will hit every unit on his way
Definition: missile.h:379
int TTL
speed for blizzard shards
Definition: missile.h:390
void MissileHit(CUnit *unit=NULL)
Definition: missile.cpp:907
int ViewPointDistanceToMissile(const Missile &missile)
distance from view point to missile
Definition: missile.cpp:1208
int ReduceFactor
missile time-to-live
Definition: missile.h:391
void SaveMissile(CFile &file) const
Definition: missile.cpp:1248
void DrawMissile(const CViewport &vp) const
Definition: missile.cpp:530
virtual void Action()
Definition: missile_cycleonce.cpp:44
Definition: unitptr.h:41
bool FriendlyFire
missile can hit the owner
Definition: missile.h:376
int SpriteFrames
Level to draw missile at.
Definition: missile.h:364
int Sleep
missile start delay
Definition: missile.h:387
std::vector< CUnit * > PiercedUnits
target unit, used for spells
Definition: missile.h:447
T x
Definition: vec2i.h:42
void MissileActions()
handle all missiles
Definition: missile.cpp:1195
void InitMissiles()
Initialize missiles.
Definition: missile.cpp:1368
int CurrentStep
this tells missile-class-straight-fly, that it's time to die
Definition: missile.h:456
int StartDelay
parabol coefficient in parabolic missile
Definition: missile.h:386
virtual void Action()
Definition: missile_whirlwind.cpp:47
void LoadMissileSprite()
load the graphics for a missile type
Definition: missile.cpp:84
virtual void Action()
Definition: missile_stay.cpp:43
BurningBuildingFrame()
Definition: missile.h:569
Definition: missile.h:495
Definition: missile.h:505
Base structure of missile-types.
Definition: missile.h:343
Missile is death coil.
Definition: missile.h:336
Missile shows the hit points.
Definition: missile.h:331
Missile appears at x,y, then cycle through the frames once.
Definition: missile.h:329
Definition: missile.h:559
int TTL
direct damage that missile applies
Definition: missile.h:451
Definition: luacallback.h:38
Definition: missile.h:322
void CleanMissileTypes()
Clean missile-types.
Definition: missile.cpp:1357
Definition: missile.h:553
std::vector< BurningBuildingFrame * > BurningBuildingFrames
Definition: missile.cpp:73
virtual void Action()
Definition: missile_cliptotarget.cpp:46
LuaCallback * SmokeParticle
impact particle
Definition: missile.h:401
Missile flies from x,y to x1,y1 and animates ONCE from start to finish and back.
Definition: missile.h:326
virtual ~Missile()
Definition: missile.cpp:1375
Definition: missile.h:520
bool CorrectSphashDamage
impact sound for this missile-type
Definition: missile.h:373
int Height() const
Definition: missile.h:357
bool IgnoreWalls
pierce every target only once
Definition: missile.h:380
virtual void Action()
Definition: missile_pointtopoint.cpp:43
CGraphic * G
called when
Definition: missile.h:405
Missile doesn't move, than checks the source unit for HP.
Definition: missile.h:330
Definition: missile.h:475
Definition: missile.h:500
Missile appears at x,y, does it's anim and vanishes.
Definition: missile.h:328
Definition: missile.h:470
MissileType(const std::string &ident)
Definition: missile.cpp:1326
virtual void Action()
Definition: missile_fire.cpp:46
Definition: missile.h:515
MissileType * MissileTypeByIdent(const std::string &ident)
Get missile-type by ident.
Definition: missile.cpp:117
Missile flies from x,y to x1,y1.
Definition: missile.h:324
void Load(lua_State *l)
Definition: script_missile.cpp:80
int CalculateDamage(const CUnit &attacker, const CUnit &goal, const NumberDesc *formula)
Calculates damage done to goal by attacker using formula.
Definition: missile.cpp:324
Missile flies from x,y to x1,y1 than bounces three times.
Definition: missile.h:327
int TotalStep
Current step (0 <= x < TotalStep).
Definition: missile.h:457
Definition: missile.h:485
Definition: missile.h:525
int DrawLevel
missile size in pixels
Definition: missile.h:363
PixelSize size
missile transparency
Definition: missile.h:362
void DrawMissileType(int frame, const PixelPos &pos) const
Definition: missile.cpp:489
void Init()
Definition: missile.cpp:1300
virtual void Action()
Definition: missile_hit.cpp:43
int BlizzardSpeed
missile speed
Definition: missile.h:389
(C) Copyright 1998-2012 by The Stratagus Project under the GNU General Public License.
All trademarks and copyrights on this page are owned by their respective owners.