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

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, bool pointToPoint = false);
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__
BurningBuildingFrames
std::vector< BurningBuildingFrame * > BurningBuildingFrames
Definition: missile.cpp:73
MissilePointToPointWithHit::Action
virtual void Action()
Definition: missile_pointotpointwithhit.cpp:44
MissileLandMine
Definition: missile.h:520
MissileClassNone
@ MissileClassNone
Definition: missile.h:322
Missile::Delay
int Delay
delay between frames
Definition: missile.h:442
MissileStay
Definition: missile.h:495
MissileType
Base structure of missile-types.
Definition: missile.h:343
MissileType::DrawMissileType
void DrawMissileType(int frame, const PixelPos &pos) const
Definition: missile.cpp:495
MissileTypeByIdent
MissileType * MissileTypeByIdent(const std::string &ident)
Get missile-type by ident.
Definition: missile.cpp:118
ViewPointDistanceToMissile
int ViewPointDistanceToMissile(const Missile &missile)
distance from view point to missile
Definition: missile.cpp:1215
FreeBurningBuildingFrames
void FreeBurningBuildingFrames()
Definition: missile.cpp:1404
Missile::SpriteFrame
int SpriteFrame
missile-type pointer
Definition: missile.h:438
BurningBuildingFrame::BurningBuildingFrame
BurningBuildingFrame()
Definition: missile.h:569
MissileType::Speed
int Speed
missile sleep
Definition: missile.h:388
MissileType::IgnoreWalls
bool IgnoreWalls
pierce every target only once
Definition: missile.h:380
Missile::MissileHit
void MissileHit(CUnit *unit=NULL)
Definition: missile.cpp:914
MissileWhirlwind::Action
virtual void Action()
Definition: missile_whirlwind.cpp:47
MissileClassPointToPoint
@ MissileClassPointToPoint
Missile does nothing.
Definition: missile.h:323
MissileType::SmokeParticle
LuaCallback * SmokeParticle
impact particle
Definition: missile.h:401
MissileCclRegister
void MissileCclRegister()
Burning building frames.
Definition: script_missile.cpp:428
Missile::Slot
unsigned int Slot
missile is a local missile
Definition: missile.h:460
MissileClassParabolic
@ MissileClassParabolic
Missile shows the hit points.
Definition: missile.h:331
MissileType::DrawLevel
int DrawLevel
missile size in pixels
Definition: missile.h:363
MissileType::NumDirections
int NumDirections
number of sprite frames in graphic
Definition: missile.h:365
MissilePointToPointCycleOnce::Action
virtual void Action()
Definition: missile_pointtopointcycleonce.cpp:43
CUnitPtr
Definition: unitptr.h:41
Missile::source
PixelPos source
Definition: missile.h:434
Missile::Wait
int Wait
Animation wait.
Definition: missile.h:441
MissileType::Pierce
bool Pierce
missile will always fire (even if target is dead)
Definition: missile.h:378
MissileClassPointToPointCycleOnce
@ MissileClassPointToPointCycleOnce
Missile flies from x,y to x1,y1 than shows hit animation.
Definition: missile.h:325
Missile::Hidden
int Hidden
time to live (ticks) used for spells
Definition: missile.h:452
Missile::NextMissileFrame
bool NextMissileFrame(char sign, char longAnimation)
Definition: missile.cpp:1086
MissileType::Height
int Height() const
Definition: missile.h:357
MissileNone::Action
virtual void Action()
Definition: missile_none.cpp:43
Missile::TotalStep
int TotalStep
Current step (0 <= x < TotalStep).
Definition: missile.h:457
MissileType::~MissileType
~MissileType()
Definition: missile.cpp:1351
MissileClassWhirlwind
@ MissileClassWhirlwind
Missile wait on x,y until a non-air unit comes by, the explodes.
Definition: missile.h:333
MissileTracer::Action
virtual void Action()
Definition: missile_tracer.cpp:121
MissileType::AlwaysFire
bool AlwaysFire
missile can't hit own units
Definition: missile.h:377
MissileStraightFly::Action
virtual void Action()
Definition: missile_straightfly.cpp:45
MissileType::MissileStopFlags
int MissileStopFlags
How frequently the smoke missile will generate itself.
Definition: missile.h:393
MissileType::CanHitOwner
bool CanHitOwner
flip image when facing left
Definition: missile.h:375
MissileFire::Action
virtual void Action()
Definition: missile_fire.cpp:46
Missile::destination
PixelPos destination
missile pixel position
Definition: missile.h:436
Missile::State
int State
sprite frame counter
Definition: missile.h:439
MissileType::KillFirstUnit
bool KillFirstUnit
missile ignores Wall units on it's way
Definition: missile.h:381
vec2i.h
MissileCycleOnce::Action
virtual void Action()
Definition: missile_cycleonce.cpp:44
MissileClassLandMine
@ MissileClassLandMine
Missile flies from x,y to x1,y1 using a parabolic path.
Definition: missile.h:332
FindAndSortMissiles
void FindAndSortMissiles(const CViewport &vp, std::vector< Missile * > &table)
Definition: missile.cpp:577
MissileType::Impact
std::vector< MissileConfig * > Impact
missile splash divisor
Definition: missile.h:398
Missile::TTL
int TTL
direct damage that missile applies
Definition: missile.h:451
MissileType::Init
void Init()
Definition: missile.cpp:1307
Vec2T::y
T y
Definition: vec2i.h:43
MissileType::ChangeAmount
int ChangeAmount
variable to change
Definition: missile.h:367
MissileHandleBlocking
bool MissileHandleBlocking(Missile &missile, const PixelPos &position)
Definition: missile.cpp:684
CleanMissiles
void CleanMissiles()
Clean missiles.
Definition: missile.cpp:1390
MissileType::ImpactParticle
LuaCallback * ImpactParticle
trailing missile
Definition: missile.h:400
MakeLocalMissile
Missile * MakeLocalMissile(const MissileType &mtype, const PixelPos &startPos, const PixelPos &destPos)
create a local missile
Definition: missile.cpp:274
SoundConfig
Definition: unitsound.h:54
MissileLandMine::Action
virtual void Action()
Definition: missile_landmine.cpp:66
CleanMissileTypes
void CleanMissileTypes()
Clean missile-types.
Definition: missile.cpp:1364
MissileType::OnImpact
LuaCallback * OnImpact
smoke particle
Definition: missile.h:402
MissileType::Flip
bool Flip
restricts the radius damage depending on land, air, naval
Definition: missile.h:374
MissileType::ChangeVariable
int ChangeVariable
number of directions missile can face
Definition: missile.h:366
CViewport
Definition: viewport.h:63
PointToPointMissile
bool PointToPointMissile(Missile &missile)
Definition: missile.cpp:748
BurningBuildingFrame
Definition: missile.h:566
FireMissile
void FireMissile(CUnit &unit, CUnit *goal, const Vec2i &goalPos)
fire a missile
Definition: missile.cpp:348
Missile::AnimWait
int AnimWait
state
Definition: missile.h:440
MissileTracer
Definition: missile.h:541
MissileType::SplashFactor
int SplashFactor
missile damage range
Definition: missile.h:397
BurningBuildingFrame::Percent
int Percent
Definition: missile.h:569
MissileWhirlwind
Definition: missile.h:525
Vec2T< int >
Missile::Count
static unsigned int Count
unique number for draw level.
Definition: missile.h:462
MissileType::ChangeMax
bool ChangeMax
how many to change
Definition: missile.h:368
MissileActions
void MissileActions()
handle all missiles
Definition: missile.cpp:1202
Missile::CurrentStep
int CurrentStep
this tells missile-class-straight-fly, that it's time to die
Definition: missile.h:456
MissileConfig
Definition: missileconfig.h:44
MissileType::ReduceFactor
int ReduceFactor
missile time-to-live
Definition: missile.h:391
MissileContinious::Action
virtual void Action()
Definition: missile_continuous.cpp:43
Missile::TargetUnit
CUnitPtr TargetUnit
unit that fires (could be killed)
Definition: missile.h:445
MissileType::FiredSound
SoundConfig FiredSound
modify the max, if value will exceed it
Definition: missile.h:370
MissileHit
Definition: missile.h:510
MissileHit::Action
virtual void Action()
Definition: missile_hit.cpp:43
MissileClassFlameShield
@ MissileClassFlameShield
Missile appears at x,y, is whirlwind.
Definition: missile.h:334
MissileType::Transparency
int Transparency
missile name
Definition: missile.h:361
Missile::position
PixelPos position
Missile source position.
Definition: missile.h:435
MissileCycleOnce
Definition: missile.h:500
MissileType::Class
int Class
missile kills first unit blocking it's way
Definition: missile.h:383
unitptr.h
MissileType::Damage
NumberDesc * Damage
On which terrain types missile won't fly.
Definition: missile.h:394
MissileType::SmokePrecision
int SmokePrecision
Multiplier for reduce or increase damage dealt to the next unit.
Definition: missile.h:392
InitMissiles
void InitMissiles()
Initialize missiles.
Definition: missile.cpp:1375
MissileFire
Definition: missile.h:505
MissileClipToTarget
Definition: missile.h:547
MissileHandlePierce
void MissileHandlePierce(Missile &missile, const Vec2i &pos)
Definition: missile.cpp:667
MissileType::TTL
int TTL
speed for blizzard shards
Definition: missile.h:390
MissileClassPointToPointWithHit
@ MissileClassPointToPointWithHit
Missile flies from x,y to x1,y1.
Definition: missile.h:324
Missile::Missile
Missile()
Definition: missile.cpp:148
NumberDesc
Definition: script.h:206
MakeMissile
Missile * MakeMissile(const MissileType &mtype, const PixelPos &startPos, const PixelPos &destPos)
create a missile
Definition: missile.cpp:257
MissileInitMove
bool MissileInitMove(Missile &missile, bool pointToPoint=false)
Definition: missile.cpp:641
MissileParabolic
Definition: missile.h:515
MissileClassTracer
@ MissileClassTracer
Missile is death coil.
Definition: missile.h:336
MissilePointToPointBounce::Action
virtual void Action()
Definition: missile_pointtopointbounce.cpp:45
MissileType::FriendlyFire
bool FriendlyFire
missile can hit the owner
Definition: missile.h:376
MissileType::Smoke
MissileConfig Smoke
missile produces an impact
Definition: missile.h:399
MissileType::Sleep
int Sleep
missile start delay
Definition: missile.h:387
MissileParabolic::Action
virtual void Action()
Definition: missile_parabolic.cpp:120
InitMissileTypes
void InitMissileTypes()
Initialize missile-types.
Definition: missile.cpp:1323
Missile::SaveMissile
void SaveMissile(CFile &file) const
Definition: missile.cpp:1255
MissileClassCycleOnce
@ MissileClassCycleOnce
Missile appears at x,y, does it's anim and vanishes.
Definition: missile.h:328
Missile::~Missile
virtual ~Missile()
Definition: missile.cpp:1382
MissileClassClipToTarget
@ MissileClassClipToTarget
Missile seeks towards to target unit.
Definition: missile.h:337
Missile::Action
virtual void Action()=0
NewMissileTypeSlot
MissileType * NewMissileTypeSlot(const std::string &ident)
allocate an empty missile-type slot
Definition: missile.cpp:137
MissileStraightFly
Definition: missile.h:559
Missile::Damage
int Damage
Units which are already pierced by this missile.
Definition: missile.h:449
MissileType::Ident
std::string Ident
Definition: missile.h:360
missileconfig.h
Missile::MissileNewHeadingFromXY
void MissileNewHeadingFromXY(const PixelPos &delta)
Definition: missile.cpp:611
MissilePointToPointCycleOnce
Definition: missile.h:485
MissileType::NumBounces
int NumBounces
missile class
Definition: missile.h:384
MissileType::CorrectSphashDamage
bool CorrectSphashDamage
impact sound for this missile-type
Definition: missile.h:373
CalculateDamage
int CalculateDamage(const CUnit &attacker, const CUnit &goal, const NumberDesc *formula)
Calculates damage done to goal by attacker using formula.
Definition: missile.cpp:325
MissileType::ParabolCoefficient
int ParabolCoefficient
number of bounces
Definition: missile.h:385
LoadMissileSprites
void LoadMissileSprites()
load all missile sprites
Definition: missile.cpp:103
MissileClassStay
@ MissileClassStay
Missile flies from x,y to x1,y1 than bounces three times.
Definition: missile.h:327
MissileClassPointToPointBounce
@ MissileClassPointToPointBounce
Missile flies from x,y to x1,y1 and animates ONCE from start to finish and back.
Definition: missile.h:326
MissileClassDeathCoil
@ MissileClassDeathCoil
Missile surround x,y.
Definition: missile.h:335
Missile::PiercedUnits
std::vector< CUnit * > PiercedUnits
target unit, used for spells
Definition: missile.h:447
MissileNone
Definition: missile.h:470
SaveMissiles
void SaveMissiles(CFile &file)
Save missiles.
Definition: missile.cpp:1289
LuaCallback
Definition: luacallback.h:41
MissileType::MissileType
MissileType(const std::string &ident)
Definition: missile.cpp:1333
MissileClassContinious
@ MissileClassContinious
Missile remains clipped to target's current goal and plays his animation once.
Definition: missile.h:338
MissileDeathCoil
Definition: missile.h:535
MissileType::Load
void Load(lua_State *l)
Definition: script_missile.cpp:80
Missile::Init
static Missile * Init(const MissileType &mtype, const PixelPos &startPos, const PixelPos &destPos)
Definition: missile.cpp:173
MissileFlameShield::Action
virtual void Action()
Definition: missile_flameshield.cpp:47
unitsound.h
Missile::SourceUnit
CUnitPtr SourceUnit
delay to show up
Definition: missile.h:444
MissileClassFire
@ MissileClassFire
Missile appears at x,y, then cycle through the frames once.
Definition: missile.h:329
MissileType::G
CGraphic * G
called when
Definition: missile.h:405
BurningBuildingFrame::Missile
MissileType * Missile
HP percent.
Definition: missile.h:572
MissileType::Width
int Width() const
Definition: missile.h:356
MissileType::Range
int Range
missile damage (used for non-direct missiles, e.g. impacts)
Definition: missile.h:396
MissilePointToPoint::Action
virtual void Action()
Definition: missile_pointtopoint.cpp:43
MissilePointToPointBounce
Definition: missile.h:490
MissilePointToPointWithHit
Definition: missile.h:480
Missile::Type
const MissileType * Type
missile pixel destination
Definition: missile.h:437
MissileType::size
PixelSize size
missile transparency
Definition: missile.h:362
Missile::DestroyMissile
int DestroyMissile
If this is 1 then the missile is invisible.
Definition: missile.h:453
script.h
MissileType::SpriteFrames
int SpriteFrames
Level to draw missile at.
Definition: missile.h:364
MissileClassHit
@ MissileClassHit
Missile doesn't move, than checks the source unit for HP.
Definition: missile.h:330
Vec2T::x
T x
Definition: vec2i.h:42
MissileType::BlizzardSpeed
int BlizzardSpeed
missile speed
Definition: missile.h:389
MissileFlameShield
Definition: missile.h:530
MissileType::StartDelay
int StartDelay
parabol coefficient in parabolic missile
Definition: missile.h:386
MissileType::ImpactSound
SoundConfig ImpactSound
fired sound
Definition: missile.h:371
Missile::NextMissileFrameCycle
void NextMissileFrameCycle()
Definition: missile.cpp:1132
MissileType::LoadMissileSprite
void LoadMissileSprite()
load the graphics for a missile type
Definition: missile.cpp:84
MissileType::PierceOnce
bool PierceOnce
missile will hit every unit on his way
Definition: missile.h:379
MissileStay::Action
virtual void Action()
Definition: missile_stay.cpp:43
MissileDeathCoil::Action
virtual void Action()
Definition: missile_deathcoil.cpp:50
MissileContinious
Definition: missile.h:553
MissileClassStraightFly
@ MissileClassStraightFly
Missile stays and plays it's animation several times.
Definition: missile.h:339
MissileBurningBuilding
MissileType * MissileBurningBuilding(int percent)
Get the burning building missile based on hp percent.
Definition: missile.cpp:1230
MissileClipToTarget::Action
virtual void Action()
Definition: missile_cliptotarget.cpp:46
Missile::DrawMissile
void DrawMissile(const CViewport &vp) const
Definition: missile.cpp:536
CFile
Definition: iolib.h:102
CUnit
The big unit structure.
Definition: unit.h:135
Missile
Missile on the map.
Definition: missile.h:413
Missile::Local
unsigned Local
Total step.
Definition: missile.h:459
MissilePointToPoint
Definition: missile.h:475
CGraphic
Definition: video.h:91
(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.