← Back to branch summary

~ubuntu-branches/ubuntu/vivid/plee-the-bear/vivid

« back to all changes in this revision

Viewing changes to plee-the-bear/src/ptb/code/monster.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Julien Jorge, Julien Jorge
  • Date: 2010-11-17 20:13:34 UTC
  • mfrom: (6.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20101117201334-o4dp7uq437to7oxb
Tags: 0.5.1-1
http://bugs.debian.org/565062
http://bugs.debian.org/546514
http://bugs.debian.org/604689
[ Julien Jorge ]
* New upstream release (Closes: #565062, #546514).
* Add armhf architecture (Closes: #604689).
* Remove patches integrated upstream: rpath-editors.diff, rpath-game.diff,
  editors-menu-section.diff.
* Bump the Standard-Version, no changes.
* Update my email address.
* Set build dependency of libclaw to 1.6.0.
* Add the missing ${misc:Depends} in debian/control.
* List gettext translations in bear-factory.install and plee-the-bear.install.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plee-the-bear/src/ptb/code/monster.cpp
1
1
/*
2
2
  Plee the Bear
3
3
 
4
 
  Copyright (C) 2005-2009 Julien Jorge, Sebastien Angibaud
 
4
  Copyright (C) 2005-2010 Julien Jorge, Sebastien Angibaud
5
5
 
6
6
  This program is free software; you can redistribute it and/or modify it
7
7
  under the terms of the GNU General Public License as published by the
27
27
 * \author Sebastien Angibaud
28
28
 */
29
29
#include "ptb/monster.hpp"
 
30
#include "ptb/game_variables.hpp"
 
31
#include "ptb/level_variables.hpp"
 
32
#include "engine/base_item.hpp"
 
33
#include "engine/variable/variable.hpp"
30
34
 
31
35
#include <iostream>
32
36
#include <sstream>
40
44
 * \brief Constructor.
41
45
 */
42
46
ptb::monster::monster()
43
 
  : m_offensive_force(0), m_energy(0), m_offensive_phase(true),
 
47
  : m_offensive_force(0), m_energy(0), m_initial_energy(0),
 
48
    m_offensive_phase(true),
44
49
    m_defensive_powers(s_attack_count+1, false),
45
50
    m_offensive_coefficients(s_attack_count+1, 0), m_invincible(false),
46
51
    m_is_injured(false)
68
73
( monster& attacker, const bear::universe::collision_info& info)
69
74
{
70
75
  bool result = false;
71
 
 
72
 
  if( (!m_invincible) && (!m_is_injured) ) 
 
76
 
 
77
  if( (!m_invincible) && (!m_is_injured) )
73
78
    {
74
 
      if ( attacker.is_invincible() ) 
 
79
      if ( attacker.is_invincible() &&
 
80
           ( attacker.get_monster_type() != stone_1_monster ) &&
 
81
           ( attacker.get_monster_type() != stone_2_monster ) &&
 
82
           ( attacker.get_monster_type() != stone_3_monster ) )
75
83
        {
76
84
          if ( ( m_energy > 0 ) && is_vulnerable( attacker,info ) )
77
85
            {
78
86
              result = true;
79
87
              injure(attacker,info);
80
88
              remove_energy(attacker,m_energy);
81
 
              attacker.has_attacked();
 
89
              attacker.has_attacked(*this);
82
90
            }
83
91
        }
84
92
      else if( is_vulnerable( attacker,info )  )
85
93
        {
86
94
          double energy = 0;
87
 
          
 
95
 
88
96
          for( unsigned int i=0; i!=m_defensive_powers.size(); ++i )
89
97
            if ( !get_defensive_power(i,attacker,info) )
90
98
              energy += attacker.get_offensive_coefficient(i,*this,info);
91
 
          
 
99
 
92
100
          energy *= attacker.m_offensive_force;
93
 
          
 
101
 
94
102
          if ( energy > 0 )
95
103
            {
96
104
              result = true;
97
105
              injure(attacker,info);
98
106
              remove_energy(attacker,energy);
99
 
              attacker.has_attacked();
 
107
              attacker.has_attacked(*this);
100
108
            }
101
109
        }
102
110
    }
107
115
/*----------------------------------------------------------------------------*/
108
116
/**
109
117
 * \brief The item has attacked.
 
118
 * \param other The monster that is attacked.
110
119
 */
111
 
void ptb::monster::has_attacked()
 
120
void ptb::monster::has_attacked(const monster& other)
112
121
{
113
122
 
114
123
} // monster::has_attacked()
187
196
    oss << "player_1";
188
197
  else if ( m_monster_type == player_2_monster )
189
198
    oss << "player_2";
 
199
  else if ( m_monster_type == player_3_monster )
 
200
    oss << "player_3";
190
201
  else if ( m_monster_type == enemy_monster )
191
202
    oss << "enemy";
192
203
  else if ( m_monster_type == stone_1_monster )
244
255
{
245
256
  bool result = false;
246
257
 
 
258
  bool friendly(game_variables::get_friendly_fire());
 
259
  bear::engine::variable<bool> var("friendly_fire");
 
260
  bear::engine::level& lvl =
 
261
    dynamic_cast<const bear::engine::base_item*>(this)->get_level();
 
262
 
 
263
  if ( lvl.level_variable_exists(var) )
 
264
    friendly = level_variables::get_friendly_fire(lvl);
 
265
 
247
266
  switch( m_monster_type )
248
267
    {
249
 
    case nature_monster: result = false; break;
 
268
    case nature_monster:
 
269
      result = false;
 
270
      break;
250
271
 
251
272
    case player_1_monster:
252
 
      result = ( attacker.get_monster_type() != stone_1_monster );
 
273
      if ( ( attacker.get_monster_type() == stone_2_monster ) ||
 
274
           ( attacker.get_monster_type() == player_2_monster ) )
 
275
        result = friendly;
 
276
      else
 
277
        result = ( attacker.get_monster_type() != stone_1_monster );
253
278
      break;
254
279
 
255
280
    case player_2_monster:
256
 
      result = ( attacker.get_monster_type() != stone_2_monster );
257
 
      break;
258
 
 
259
 
    case enemy_monster: result =
260
 
        ( attacker.get_monster_type() != enemy_monster ); break;
 
281
      if ( ( attacker.get_monster_type() == stone_1_monster ) ||
 
282
           ( attacker.get_monster_type() == player_1_monster ) )
 
283
        result = friendly;
 
284
      else
 
285
        result = ( attacker.get_monster_type() != stone_2_monster );
 
286
      break;
 
287
 
 
288
    case player_3_monster:
 
289
      result = ( attacker.get_monster_type() != stone_3_monster );
 
290
      break;
 
291
 
 
292
    case enemy_monster:
 
293
      result = ( attacker.get_monster_type() != enemy_monster );
261
294
      break;
262
295
 
263
296
    case stone_1_monster:
264
 
      result = ( ( attacker.get_monster_type() != player_1_monster ) &&
265
 
                 ( attacker.get_monster_type() != stone_1_monster ) );
 
297
       if ( ( attacker.get_monster_type() == stone_2_monster ) ||
 
298
           ( attacker.get_monster_type() == player_2_monster ) )
 
299
        result = friendly;
 
300
      else
 
301
        result = ( ( attacker.get_monster_type() != player_1_monster ) &&
 
302
                   ( attacker.get_monster_type() != stone_1_monster ) );
266
303
      break;
267
304
 
268
305
    case stone_2_monster:
269
 
      result = ( ( attacker.get_monster_type() != player_2_monster ) &&
 
306
       if ( ( attacker.get_monster_type() == stone_1_monster ) ||
 
307
           ( attacker.get_monster_type() == player_1_monster ) )
 
308
        result = friendly;
 
309
       else
 
310
         result = ( ( attacker.get_monster_type() != player_2_monster ) &&
270
311
                 ( attacker.get_monster_type() != stone_2_monster ) );
271
312
      break;
 
313
 
 
314
    case stone_3_monster:
 
315
       if ( ( attacker.get_monster_type() == stone_3_monster ) ||
 
316
           ( attacker.get_monster_type() == player_3_monster ) )
 
317
        result = friendly;
 
318
       else
 
319
         result = ( ( attacker.get_monster_type() != player_3_monster ) &&
 
320
                 ( attacker.get_monster_type() != stone_3_monster ) );
 
321
      break;
 
322
 
 
323
    default:
 
324
      break;
 
325
 
272
326
    }
273
327
 
 
328
 
274
329
  return result;
275
330
} // monster::is_vulnerable()
276
331
 
326
381
 
327
382
/*----------------------------------------------------------------------------*/
328
383
/**
 
384
 * \brief Get a given defensive power status.
 
385
 * \param index Type of the considered attack.
 
386
 */
 
387
bool
 
388
ptb::monster::get_defensive_power(const attack_type index) const
 
389
{
 
390
  return m_defensive_powers[index];
 
391
} // ptb::monster::get_defensive_power()
 
392
 
 
393
/*----------------------------------------------------------------------------*/
 
394
/**
329
395
 * \brief Set an offensive coefficient.
330
396
 * \param index Type of the considered attack.
331
397
 * \param coef The new offensive coefficient.
358
424
 
359
425
/*----------------------------------------------------------------------------*/
360
426
/**
 
427
 * \brief Return the initial energy of the monster.
 
428
 */
 
429
double ptb::monster::get_initial_energy() const
 
430
{
 
431
  return m_initial_energy;
 
432
} // monster::get_initial_energy()
 
433
 
 
434
 
 
435
/*----------------------------------------------------------------------------*/
 
436
/**
 
437
 * \brief Return if te monster is injured.
 
438
 */
 
439
bool ptb::monster::is_injured() const
 
440
{
 
441
  return m_is_injured;
 
442
} // monster::is_injured()
 
443
 
 
444
/*----------------------------------------------------------------------------*/
 
445
/**
361
446
 * \brief Indicates if the monster is in a offensive phase.
362
447
 */
363
448
bool ptb::monster::is_in_offensive_phase() const