← Back to branch summary

~ubuntu-branches/ubuntu/trusty/plee-the-bear/trusty-proposed

« back to all changes in this revision

Viewing changes to plee-the-bear/src/ptb/layer/code/status_layer.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/layer/code/status_layer.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
29
29
#include "ptb/layer/status_layer.hpp"
30
30
 
31
31
#include "engine/game.hpp"
32
 
#include "ptb/item/timer_kill_players.hpp"
33
32
#include "visual/bitmap_writing.hpp"
34
33
#include "visual/scene_sprite.hpp"
35
34
#include "visual/scene_writing.hpp"
36
 
#include "ptb/item/plee/plee.hpp"
 
35
#include "visual/scene_line.hpp"
 
36
#include "ptb/player.hpp"
37
37
#include "ptb/level_variables.hpp"
38
 
 
39
 
/*----------------------------------------------------------------------------*/
40
 
/**
41
 
 * \brief Constructor.
42
 
 * \param glob Level globals in which we take the resources.
43
 
 * \param level_sprite The position in "gfx/tube.png" of the image to use for
44
 
 *        the main level.
45
 
 * \param loss_sprite The position in "gfx/tube.png" of the image to use for the
46
 
 *        loss level.
47
 
 * \param length The length of the bar.
48
 
 */
49
 
ptb::status_layer::horizontal_bar::horizontal_bar
50
 
( bear::engine::level_globals& glob,
51
 
  const bear::visual::rectangle_type& level_sprite,
52
 
  const bear::visual::rectangle_type& loss_sprite,
53
 
  const std::string& icon_name, unsigned int length )
54
 
  : m_level_value(length)
55
 
{
56
 
  const bear::visual::image& bar_resource = glob.get_image("gfx/tube.png");
57
 
 
58
 
  m_level = bear::visual::sprite( bar_resource, level_sprite );
59
 
  m_loss = bear::visual::sprite( bar_resource, loss_sprite );
60
 
  m_icon = glob.auto_sprite("gfx/tube-vertical.png", icon_name);
61
 
 
62
 
  m_loss.set_opacity(0);
63
 
 
64
 
  m_tube_clamp =
65
 
    bear::visual::sprite
66
 
    ( bar_resource, claw::math::rectangle<unsigned int>( 0, 0, 19, 24 ) );
67
 
 
68
 
  m_glass_tube =
69
 
    bear::visual::sprite
70
 
    ( bar_resource, claw::math::rectangle<unsigned int>( 19, 0, 1, 20 ) );
71
 
 
72
 
  m_glass_tube.set_width(length);
73
 
  m_level.set_width(length);
74
 
} // status_layer::horizontal_bar::horizontal_bar()
75
 
 
76
 
/*----------------------------------------------------------------------------*/
77
 
/**
78
 
 * \brief Set the length.
79
 
 */
80
 
void ptb::status_layer::horizontal_bar::set_length(unsigned int length)
81
 
{
82
 
  m_glass_tube.set_width(length);
83
 
} // status_layer::horizontal_bar::set_length()
84
 
 
85
 
/*----------------------------------------------------------------------------*/
86
 
/**
87
 
 * \brief Get the visual length of the bar.
88
 
 */
89
 
unsigned int ptb::status_layer::horizontal_bar::length() const
90
 
{
91
 
  return m_glass_tube.width();
92
 
} // status_layer::horizontal_bar::length()
93
 
 
94
 
/*----------------------------------------------------------------------------*/
95
 
/**
96
 
 * \brief Get the visual width of the bar.
97
 
 */
98
 
unsigned int ptb::status_layer::horizontal_bar::width() const
99
 
{
100
 
  return 2 * m_tube_clamp.width() + m_glass_tube.width();
101
 
} // status_layer::horizontal_bar::width()
102
 
 
103
 
/*----------------------------------------------------------------------------*/
104
 
/**
105
 
 * \brief Get the visual height of the bar.
106
 
 */
107
 
unsigned int ptb::status_layer::horizontal_bar::height() const
108
 
{
109
 
  return std::max
110
 
    ( m_tube_clamp.height() + m_icon.height() / 2, m_glass_tube.height() );
111
 
} // status_layer::horizontal_bar::height()
112
 
 
113
 
/*----------------------------------------------------------------------------*/
114
 
/**
115
 
 * \brief Set the level of the bar.
116
 
 * \param lev The new level.
117
 
 */
118
 
void ptb::status_layer::horizontal_bar::set_level( double lev )
119
 
{
120
 
  if ( lev != m_level_value )
121
 
    {
122
 
      if ( lev < m_level_value )
123
 
        m_loss.set_opacity(1);
124
 
      else
125
 
        m_loss.set_opacity(0);
126
 
 
127
 
      m_level_value = lev;
128
 
    }
129
 
} // status_layer::horizontal_bar::set_level()
130
 
 
131
 
/*----------------------------------------------------------------------------*/
132
 
/**
133
 
 * \brief Update the bar.
134
 
 * \param elapsed_time Elapsed time since the last call.
135
 
 */
136
 
void ptb::status_layer::horizontal_bar::progress
137
 
( bear::universe::time_type elapsed_time )
138
 
{
139
 
  if ( m_loss.get_opacity() >= 0 )
140
 
    m_loss.set_opacity
141
 
      ( std::max(0.0, m_loss.get_opacity() - elapsed_time) );
142
 
 
143
 
  m_level.set_width( (unsigned int)(m_level_value + 0.5) );
144
 
  m_loss.set_width( m_level.width() );
145
 
} // status_layer::horizontal_bar::progress()
146
 
 
147
 
/*----------------------------------------------------------------------------*/
148
 
/**
149
 
 * \brief Display the bar.
150
 
 * \param e (out) The scene elements.
151
 
 * \param pos The top-left position of the bar.
152
 
 */
153
 
void ptb::status_layer::horizontal_bar::render
154
 
( scene_element_list& e, const bear::visual::position_type& pos )
155
 
{
156
 
  bear::universe::position_type p(pos + m_icon.get_size() / 2);
157
 
  bear::visual::sprite clamp(m_tube_clamp);
158
 
  const bear::visual::coordinate_type d =
159
 
    ( clamp.height() - m_level.height() ) / 2;
160
 
 
161
 
  if (d < 0)
162
 
    p.y -= d;
163
 
 
164
 
  e.push_back( bear::visual::scene_sprite(p.x, p.y, clamp) );
165
 
  e.push_back
166
 
    ( bear::visual::scene_sprite
167
 
      (p.x - m_icon.width() / 2, p.y - m_icon.height() / 2, m_icon) );
168
 
 
169
 
  p.x += clamp.width();
170
 
  p.y += d;
171
 
  e.push_back( bear::visual::scene_sprite(p.x, p.y, m_level) );
172
 
 
173
 
  if ( m_loss.get_opacity() != 0 )
174
 
    e.push_back( bear::visual::scene_sprite(p.x, p.y, m_loss) );
175
 
 
176
 
  e.push_back( bear::visual::scene_sprite(p.x, p.y, m_glass_tube) );
177
 
 
178
 
  p.x += m_glass_tube.width();
179
 
  p.y -= d;
180
 
  clamp.mirror(true);
181
 
  e.push_back( bear::visual::scene_sprite(p.x, p.y, clamp) );
182
 
} // status_layer::horizontal_bar::render()
183
 
 
184
 
 
185
 
 
186
 
 
187
 
/*----------------------------------------------------------------------------*/
188
 
/**
189
 
 * \brief Constructor.
190
 
 * \param glob Level globals in which we take the resources.
191
 
 * \param level_sprite The position in "gfx/tube-vertical.png" of the image to
192
 
 *        use for the main level.
193
 
 * \param icon_sprite The position in "gfx/tube-vertical.png" of the image to
194
 
 *        use for the icon of the bar.
195
 
 * \param length The length of the bar.
196
 
 */
197
 
ptb::status_layer::vertical_bar::vertical_bar
198
 
( bear::engine::level_globals& glob,
199
 
  const bear::visual::rectangle_type& level_sprite,
200
 
  const bear::visual::rectangle_type& icon_sprite, unsigned int length )
201
 
  : m_level_value(length)
202
 
{
203
 
  const bear::visual::image& bar_resource =
204
 
    glob.get_image("gfx/tube-vertical.png");
205
 
 
206
 
  m_level = bear::visual::sprite( bar_resource, level_sprite );
207
 
  m_icon = bear::visual::sprite( bar_resource, icon_sprite );
208
 
 
209
 
  m_tube_clamp =
210
 
    bear::visual::sprite
211
 
    ( bar_resource, claw::math::rectangle<unsigned int>( 0, 0, 24, 19 ) );
212
 
 
213
 
  m_glass_tube =
214
 
    bear::visual::sprite
215
 
    ( bar_resource, claw::math::rectangle<unsigned int>( 0, 21, 20, 1 ) );
216
 
 
217
 
  m_glass_tube.set_height(length);
218
 
  m_level.set_height(length);
219
 
} // status_layer::vertical_bar::vertical_bar()
220
 
 
221
 
/*----------------------------------------------------------------------------*/
222
 
/**
223
 
 * \brief Get the visual width of the bar.
224
 
 */
225
 
unsigned int ptb::status_layer::vertical_bar::width() const
226
 
{
227
 
  return std::max( m_tube_clamp.width() + m_icon.width() / 2,
228
 
                   m_glass_tube.width() );
229
 
} // status_layer::vertical_bar::width()
230
 
 
231
 
/*----------------------------------------------------------------------------*/
232
 
/**
233
 
 * \brief Get the visual height of the bar.
234
 
 */
235
 
unsigned int ptb::status_layer::vertical_bar::height() const
236
 
{
237
 
  return 2 * m_tube_clamp.height() + m_glass_tube.height()
238
 
    + m_icon.height() / 2;
239
 
} // status_layer::vertical_bar::height()
240
 
 
241
 
/*----------------------------------------------------------------------------*/
242
 
/**
243
 
 * \brief Set the level of the bar.
244
 
 * \param lev The new level.
245
 
 */
246
 
void ptb::status_layer::vertical_bar::set_level( double lev )
247
 
{
248
 
  m_level_value = lev;
249
 
} // status_layer::vertical_bar::set_level()
250
 
 
251
 
/*----------------------------------------------------------------------------*/
252
 
/**
253
 
 * \brief Update the bar.
254
 
 * \param elapsed_time Elapsed time since the last call.
255
 
 */
256
 
void ptb::status_layer::vertical_bar::progress
257
 
( bear::universe::time_type elapsed_time )
258
 
{
259
 
  m_level.set_height( (unsigned int)(m_level_value + 0.5) );
260
 
} // status_layer::vertical_bar::progress()
261
 
 
262
 
/*----------------------------------------------------------------------------*/
263
 
/**
264
 
 * \brief Display the bar.
265
 
 * \param e (out) The scene elements.
266
 
 * \param pos The top-left position of the bar.
267
 
 */
268
 
void ptb::status_layer::vertical_bar::render
269
 
( scene_element_list& e, const bear::visual::position_type& pos )
270
 
{
271
 
  bear::visual::position_type p(pos.x, pos.y + m_icon.height() / 2);
272
 
  bear::visual::sprite clamp(m_tube_clamp);
273
 
  const bear::visual::coordinate_type d =
274
 
    ( clamp.width() - m_level.width() ) / 2;
275
 
 
276
 
  if (d < 0)
277
 
    p.x -= d;
278
 
 
279
 
  e.push_back( bear::visual::scene_sprite(p.x, p.y, clamp) );
280
 
 
281
 
  p.x = pos.x + clamp.width() - m_icon.width() / 2;
282
 
  p.y = pos.y;
283
 
  e.push_back( bear::visual::scene_sprite(p.x, p.y, m_icon) );
284
 
 
285
 
  p.x = pos.x + d;
286
 
  p.y = pos.y + m_icon.height() / 2 + clamp.height()
287
 
    + m_glass_tube.height() - m_level.height();
288
 
  e.push_back( bear::visual::scene_sprite(p.x, p.y, m_level) );
289
 
 
290
 
  p.y = pos.y + clamp.height() + m_icon.height() / 2;
291
 
  e.push_back( bear::visual::scene_sprite(p.x, p.y, m_glass_tube) );
292
 
 
293
 
  p.x -= d;
294
 
  p.y += m_glass_tube.height();
295
 
  clamp.flip(true);
296
 
  e.push_back( bear::visual::scene_sprite(p.x, p.y, clamp) );
297
 
} // status_layer::vertical_bar::render()
298
 
 
299
 
 
300
 
 
 
38
#include "ptb/throwable_item/throwable_items_container.hpp"
 
39
#include "ptb/defines.hpp"
 
40
#include "ptb/gauge.hpp"
 
41
#include "ptb/util.hpp"
301
42
 
302
43
/*----------------------------------------------------------------------------*/
303
44
const double ptb::status_layer::player_status::s_bar_length = 100;
311
52
 */
312
53
ptb::status_layer::player_status::player_status
313
54
( bear::engine::level_globals& glob, const bear::visual::font& f,
314
 
  bear::universe::const_derived_item_handle_maker<plee>::handle_type& p )
315
 
  : energy( glob, bear::visual::rectangle_type( 22, 0, 1, 20 ),
316
 
            bear::visual::rectangle_type( 21, 0, 1, 20 ), "heart", s_bar_length ),
317
 
    oxygen( glob, bear::visual::rectangle_type( 0, 20, 20, 1 ),
318
 
            bear::visual::rectangle_type( 48, 0, 16, 16 ), s_bar_length ),
319
 
    fire_gauge( glob, bear::visual::rectangle_type( 0, 19, 20, 1 ),
320
 
            bear::visual::rectangle_type( 48, 16, 16, 16 ), s_bar_length ),
321
 
    ice_gauge( glob, bear::visual::rectangle_type( 0, 22, 20, 1 ),
322
 
            bear::visual::rectangle_type( 32, 0, 16, 16 ), s_bar_length ),
323
 
    player(p),
 
55
  bear::universe::const_derived_item_handle_maker<player>::handle_type& p )
 
56
  : energy( glob, s_bar_length, "bar (green)", "bar (red)", "heart", true ),
 
57
    oxygen( glob, s_bar_length, "bar (blue)", "bubble" ),
 
58
    fire_gauge( glob, s_bar_length, "bar (yellow)", "sun" ),
 
59
    ice_gauge( glob, s_bar_length, "bar (white)", "snowflake" ),
 
60
    m_player(p),
324
61
    oxygen_active(false), oxygen_offset_x(oxygen.width() + 5),
325
62
    fire_gauge_active(false), fire_gauge_offset_x(fire_gauge.width() + 5),
326
63
    ice_gauge_active(false), ice_gauge_offset_x(ice_gauge.width() + 5)
327
64
{
328
65
  score.create(f, "0pt");
329
 
  stones.create(f, "0");
 
66
  throwable_items.create(f, "0");
330
67
 
331
68
  m_air_power = false;
332
69
  m_fire_power = false;
333
70
  m_water_power = false;
334
71
 
335
 
  m_last_tries = game_variables::get_lives_count(player->get_index());
 
72
  m_last_tries = game_variables::get_lives_count(m_player->get_index());
336
73
  m_tries_time = 0;
337
 
  
338
 
  if ( p.get() ) 
339
 
    update_stone_animation(glob,p->get_index());
 
74
 
 
75
  if ( p.get() )
 
76
    update_throwable_item_animation();
340
77
} // status_layer::player_status::player_status()
341
78
 
342
79
/*----------------------------------------------------------------------------*/
352
89
  oxygen.progress(elapsed_time);
353
90
  fire_gauge.progress(elapsed_time);
354
91
  ice_gauge.progress(elapsed_time);
355
 
 
356
 
  if (player.get())
 
92
 
 
93
  if (m_player.get())
357
94
    {
358
 
      energy.set_length(game_variables::get_max_energy(player->get_index()));
359
 
      energy.set_level
360
 
        ( energy.length() * player->get_energy() / 
361
 
          game_variables::get_max_energy(player->get_index()) );
362
 
      
363
 
      progress_gauge
364
 
        (oxygen, player->get_gauge(plee::oxygen_gauge)->is_activated(),
365
 
         player->get_gauge(plee::oxygen_gauge)->get_value(),
366
 
         plee::s_max_oxygen, oxygen_active, oxygen_offset_x);
367
 
      
368
 
      progress_gauge
369
 
        (fire_gauge, player->get_gauge(plee::fire_gauge)->is_activated(),
370
 
         player->get_gauge(plee::fire_gauge)->get_value(),
371
 
         plee::s_max_fire_gauge, fire_gauge_active, fire_gauge_offset_x);
372
 
      
373
 
      progress_gauge
374
 
        (ice_gauge, player->get_gauge(plee::ice_gauge)->is_activated(),
375
 
         player->get_gauge(plee::ice_gauge)->get_value(),
376
 
         plee::s_max_ice_gauge, ice_gauge_active, ice_gauge_offset_x);
377
 
      
 
95
      energy.set_length
 
96
        (game_variables::get_max_energy(m_player->get_index()));
 
97
      energy.set_max_level
 
98
        (game_variables::get_max_energy(m_player->get_index()));
 
99
      energy.set_level( m_player->get_energy() );
 
100
 
 
101
      progress_gauge
 
102
        (oxygen, m_player->get_gauge(player::oxygen_gauge)->is_activated(),
 
103
         m_player->get_gauge(player::oxygen_gauge)->get_value(),
 
104
         player::s_max_oxygen, oxygen_active, oxygen_offset_x);
 
105
 
 
106
      progress_gauge
 
107
        (fire_gauge, m_player->get_gauge(player::fire_gauge)->is_activated(),
 
108
         m_player->get_gauge(player::fire_gauge)->get_value(),
 
109
         player::s_max_fire_gauge, fire_gauge_active, fire_gauge_offset_x);
 
110
 
 
111
      progress_gauge
 
112
        (ice_gauge, m_player->get_gauge(player::ice_gauge)->is_activated(),
 
113
         m_player->get_gauge(player::ice_gauge)->get_value(),
 
114
         player::s_max_ice_gauge, ice_gauge_active, ice_gauge_offset_x);
 
115
 
378
116
      bear::visual::font f = glob.get_font("font/bouncy.fnt");
379
117
 
380
118
      std::ostringstream oss1;
381
 
      oss1 << game_variables::get_score(player->get_index());
382
 
      if ( game_variables::get_score(player->get_index()) > 0 ) 
383
 
        oss1 << "pts";
384
 
      else
385
 
        oss1 << "pt";
386
 
      score.create(f, oss1.str());  
 
119
      oss1 << game_variables::get_score(m_player->get_index());
 
120
      score.create(f, oss1.str());
387
121
      score->set_intensity(1, 0.8, 0);
388
 
      
 
122
 
389
123
      std::ostringstream oss2;
390
 
      oss2 << game_variables::get_stones_count(player->get_index());
391
 
      stones.create(f, oss2.str());
392
 
      stones->set_intensity(1, 0.8, 0);
393
 
      
394
 
      update_tries(glob, elapsed_time, player->get_index());
395
 
      
396
 
      if ( update_powers(player->get_index()) ) 
397
 
        update_stone_animation(glob,player->get_index());
398
 
      
399
 
      stone_animation.next(elapsed_time);
 
124
      oss2 << m_player->get_throwable_items()->get_current_throwable_item
 
125
        ()->get_stock();
 
126
      throwable_items.create(f, oss2.str());
 
127
      throwable_items->set_intensity(1, 0.8, 0);
 
128
 
 
129
      update_tries(glob, elapsed_time, m_player->get_index());
 
130
 
 
131
      if ( update_throwable_item(m_player->get_index()) )
 
132
        update_throwable_item_animation();
 
133
 
 
134
      throwable_item_animation.next(elapsed_time);
400
135
    }
401
136
} // status_layer::player_status::progress()
402
137
 
403
138
/*----------------------------------------------------------------------------*/
404
139
/**
405
 
 * \brief Update the powers.
 
140
 * \brief Update the throwable_item.
406
141
 * Return true if the powers have changed.
407
142
 * \param index The index of the player.
408
143
 */
409
 
bool ptb::status_layer::player_status::update_powers( unsigned int index )
 
144
bool ptb::status_layer::player_status::update_throwable_item
 
145
( unsigned int index )
410
146
{
411
147
  bool result = false;
412
148
 
413
 
  if ( m_air_power != game_variables::get_air_power(index) ) 
 
149
  if ( m_air_power != game_variables::get_air_power(index) )
414
150
    {
415
151
      m_air_power = game_variables::get_air_power(index);
416
152
      result = true;
417
153
    }
418
154
 
419
 
  if ( m_fire_power != game_variables::get_fire_power(index) ) 
 
155
  if ( m_fire_power != game_variables::get_fire_power(index) )
420
156
    {
421
157
      m_fire_power = game_variables::get_fire_power(index);
422
158
      result = true;
423
159
    }
424
160
 
425
 
  if ( m_water_power != game_variables::get_water_power(index) ) 
 
161
  if ( m_water_power != game_variables::get_water_power(index) )
426
162
    {
427
163
      m_water_power = game_variables::get_water_power(index);
428
164
      result = true;
429
165
    }
430
166
 
 
167
  if ( m_last_throwable_item !=
 
168
       m_player->get_throwable_items()->get_current_throwable_item() )
 
169
    {
 
170
      m_last_throwable_item =
 
171
        m_player->get_throwable_items()->get_current_throwable_item();
 
172
      result = true;
 
173
    }
 
174
 
 
175
  if ( m_last_throw_status !=
 
176
       m_player->get_throwable_items()->get_current_throwable_item
 
177
       ()->can_throw() )
 
178
    {
 
179
      m_last_throw_status =
 
180
        m_player->get_throwable_items()->get_current_throwable_item
 
181
        ()->can_throw();
 
182
      result = true;
 
183
    }
 
184
 
431
185
  return result;
432
186
} // player_status::update_powers
433
187
 
436
190
 * \brief Update the tries count.
437
191
 * \param glob The level globals in which we load the media.
438
192
 * \param index The index of the player.
 
193
 * \param elapsed_time Elapsed time since the last call.
439
194
 */
440
195
void ptb::status_layer::player_status::update_tries
441
 
( bear::engine::level_globals& glob, bear::universe::time_type elapsed_time, 
 
196
( bear::engine::level_globals& glob, bear::universe::time_type elapsed_time,
442
197
  unsigned int index )
443
198
{
444
 
  unsigned int nb = game_variables::get_lives_count(player->get_index());
 
199
  unsigned int nb = game_variables::get_lives_count(m_player->get_index());
445
200
 
446
 
  if ( nb > m_last_tries ) 
 
201
  if ( nb > m_last_tries )
447
202
    {
448
203
      m_last_tries = nb;
449
204
      m_tries_time = elapsed_time;
452
207
    {
453
208
      m_tries_time += elapsed_time;
454
209
      if ( m_tries_time > 1 )
455
 
        m_tries_time = 0;
 
210
        m_tries_time = 0;
456
211
    }
457
 
  
 
212
  else
 
213
    m_last_tries = nb;
 
214
 
458
215
  std::ostringstream oss;
459
216
  oss << nb;
460
217
  bear::visual::font f = glob.get_font("font/bouncy.fnt");
461
218
  tries.create(f, oss.str());
462
 
  
 
219
 
463
220
  double red = 1;
464
221
  double green = 0.8;
465
 
      
466
 
  if ( m_tries_time != 0 ) 
 
222
 
 
223
  if ( m_tries_time != 0 )
467
224
    {
468
225
      if ( m_tries_time > 0.5 )
469
 
        {
470
 
          red = m_tries_time;
471
 
          green = 2*(m_tries_time-0.5); 
472
 
        }
473
 
      else if ( m_tries_time > 0 ) 
474
 
        {
475
 
          red = 1 - m_tries_time;
476
 
          green = 0.8 - 1.6*m_tries_time;
477
 
        }
 
226
        {
 
227
          red = m_tries_time;
 
228
          green = 2*(m_tries_time-0.5);
 
229
        }
 
230
      else if ( m_tries_time > 0 )
 
231
        {
 
232
          red = 1 - m_tries_time;
 
233
          green = 0.8 - 1.6*m_tries_time;
 
234
        }
478
235
    }
479
236
  tries->set_intensity(red, green, 0);
480
237
} // player_status::update_tries()
481
238
 
482
239
/*----------------------------------------------------------------------------*/
483
240
/**
484
 
 * \brief Update the stone animation.
 
241
 * \brief Update the throwable_item animation.
485
242
 * \param glob The level globals in which we load the media.
486
243
 * \param index The index of the player.
487
244
 */
488
 
void ptb::status_layer::player_status::update_stone_animation
489
 
( bear::engine::level_globals& glob, unsigned int index ) 
 
245
void ptb::status_layer::player_status::update_throwable_item_animation()
490
246
{
491
 
  if ( game_variables::get_air_power(index) )
492
 
    if ( game_variables::get_fire_power(index) )
493
 
      if ( game_variables::get_water_power(index) )
494
 
        stone_animation = glob.get_animation
495
 
          ("animation/stones/air_fire_water_stone.canim");
496
 
      else
497
 
        stone_animation = glob.get_animation
498
 
          ("animation/stones/air_fire_stone.canim");
499
 
    else
500
 
      if ( game_variables::get_water_power(index) )
501
 
        stone_animation = glob.get_animation
502
 
          ("animation/stones/air_water_stone.canim");
503
 
      else
504
 
        stone_animation = glob.get_animation
505
 
          ("animation/stones/air_stone.canim");
506
 
  else
507
 
    if ( game_variables::get_fire_power(index) )
508
 
      if ( game_variables::get_water_power(index) )
509
 
        stone_animation = glob.get_animation
510
 
          ("animation/stones/water_fire_stone.canim");
511
 
      else
512
 
        stone_animation = glob.get_animation
513
 
          ("animation/stones/fire_stone.canim");
514
 
    else
515
 
      if ( game_variables::get_water_power(index) )
516
 
        stone_animation = glob.get_animation
517
 
          ("animation/stones/water_stone.canim");
518
 
      else
519
 
        stone_animation = glob.get_animation
520
 
          ("animation/stones/stone.canim");
 
247
  throwable_item_animation =
 
248
    m_player->get_throwable_items()
 
249
    ->get_current_throwable_item()->get_animation();
521
250
} // player_status::update_stone_animation()
522
251
 
523
252
/*----------------------------------------------------------------------------*/
531
260
 * \param offset_x (out) The offset of the gauge in x axis.
532
261
 */
533
262
void ptb::status_layer::player_status::progress_gauge
534
 
( vertical_bar& gauge, bool is_active, double value, double max_value,
 
263
( vertical_gauge& gauge, bool is_active, double value, double max_value,
535
264
  bool& new_active, bear::visual::coordinate_type& offset_x)
536
265
{
537
266
  gauge.set_level( s_bar_length * value / max_value );
553
282
} // status_layer::player_status::progress_gauge()
554
283
 
555
284
 
 
285
 
 
286
 
556
287
/*----------------------------------------------------------------------------*/
557
288
const unsigned int ptb::status_layer::s_margin = 10;
558
289
 
561
292
 * \brief Constructor
562
293
 */
563
294
ptb::status_layer::status_layer()
564
 
  : m_data_1(NULL), m_data_2(NULL), 
565
 
    m_first_player(NULL), m_second_player(NULL), m_corrupting_bonus(NULL)
 
295
  : m_data_1(NULL), m_data_2(NULL), m_first_player(NULL), m_second_player(NULL),
 
296
    m_timer(NULL), m_corrupting_bonus(NULL)
566
297
{
567
298
 
568
299
} // status_layer::status_layer()
575
306
{
576
307
  delete m_data_1;
577
308
  delete m_data_2;
578
 
 
579
 
  if ( m_corrupting_bonus )
580
 
    delete m_corrupting_bonus;
 
309
  delete m_corrupting_bonus;
581
310
} // status_layer::~status_layer()
582
311
 
583
312
/*----------------------------------------------------------------------------*/
592
321
 
593
322
  m_text_time.create(f, "00:00");
594
323
  m_time_on = true;
595
 
  
596
 
  m_small_plee = 
 
324
 
 
325
  m_small_player =
597
326
    bear::visual::sprite( glob.auto_sprite("gfx/status.png", "plee"));
598
 
  
 
327
 
 
328
  m_last_corrupting_bonus = game_variables::get_corrupting_bonus_count();
 
329
  m_corrupting_bonus_time = 0;
599
330
  m_text_corrupting_bonus.create(f, "0");
600
 
  
601
 
  m_azelnut = new bear::visual::animation
602
 
    (glob.get_animation("animation/owl/azelnut.canim"));
 
331
 
 
332
  m_hazelnut = new bear::visual::animation
 
333
    (glob.get_animation("animation/owl/hazelnut.canim"));
603
334
 
604
335
  m_honeypot = glob.auto_sprite("gfx/status.png", "shiny jar");
605
336
} // status_layer::build()
614
345
 
615
346
  progress_time(elapsed_time);
616
347
  progress_corrupting_bonus(elapsed_time);
617
 
  
 
348
 
618
349
  if ( m_data_1 != NULL )
619
350
    m_data_1->progress(get_level_globals(),elapsed_time);
620
 
  
 
351
 
621
352
  if ( m_data_2 != NULL )
622
353
    m_data_2->progress(get_level_globals(),elapsed_time);
623
354
} // status_layer::progress()
637
368
  if (m_data_2 != NULL)
638
369
    render_player2( e );
639
370
 
640
 
  if ( m_time_on ) 
 
371
  if ( m_time_on )
641
372
    e.push_back
642
373
      ( bear::visual::scene_writing
643
 
        ( (get_size().x - m_text_time.get_width()) / 2, 
644
 
          s_margin, m_text_time ) );
645
 
  
 
374
        ( (get_size().x - m_text_time.get_width()) / 2,
 
375
          get_size().y - s_margin - m_text_time.get_height(), m_text_time ) );
 
376
 
646
377
  render_corrupting_bonus( e );
647
 
  render_azelnut( e );
 
378
  render_hazelnut( e );
648
379
  render_honeypots( e );
649
380
} // status_layer::render()
650
381
 
651
382
/*----------------------------------------------------------------------------*/
652
383
/**
 
384
 * \brief Set the timer to use for the time.
 
385
 */
 
386
void ptb::status_layer::set_timer( const timer_handle& t )
 
387
{
 
388
  m_timer = t;
 
389
} // status_layer::set_timer()
 
390
 
 
391
/*----------------------------------------------------------------------------*/
 
392
/**
653
393
 * \brief Update the time text.
654
394
 */
655
395
void ptb::status_layer::progress_time( bear::universe::time_type elapsed_time )
656
396
{
657
 
  timer_kill_players::msg_get_value msg;
658
 
  bear::engine::level_globals& glob = get_level_globals();
659
 
 
660
 
  if ( glob.send_message( "level_timer", msg ) )
 
397
  if ( m_timer != (bear::timer*)NULL )
661
398
    {
662
399
      m_time_on = true;
663
400
 
664
 
      bear::universe::time_type time = msg.value;
665
 
      unsigned int sec = (unsigned int)time % 60;
666
 
      unsigned int min = (unsigned int)time / 60;
667
 
 
668
 
      std::ostringstream oss_time;
669
 
      if ( min < 10 )
670
 
        oss_time << " ";
671
 
      oss_time << min;
672
 
 
673
 
      oss_time << ":";
674
 
 
675
 
      if ( sec < 10 )
676
 
        oss_time << "0";
677
 
      oss_time << sec;
678
 
 
679
 
      if ( msg.countdown && ( min == 0 ) && ( sec <= 30 ) &&
680
 
           ( (unsigned int)((time - 60*min - sec )*4)%2 == 1) )
 
401
      const bear::universe::time_type time = m_timer->get_time();
 
402
      const std::string t
 
403
        ( bear::systime::format_time_s( time,  gettext("%M:%S") ) );
 
404
 
 
405
      if ( m_timer->is_countdown() && (time <= 30) &&
 
406
           ((time - (int)time) < 0.5) )
681
407
        m_text_time->set_intensity(1, 0, 0);
682
408
      else
683
409
        m_text_time->set_intensity(1, 0.8, 0);
684
410
 
685
 
      m_text_time.create
686
 
        ( get_level_globals().get_font("font/bouncy.fnt"), oss_time.str() );
 
411
      m_text_time.create( get_level_globals().get_font("font/bouncy.fnt"), t );
687
412
    }
688
413
  else
689
 
     m_time_on = false;
 
414
    m_time_on = false;
690
415
} // status_layer::progress_time()
691
416
 
692
417
/*----------------------------------------------------------------------------*/
696
421
void ptb::status_layer::progress_corrupting_bonus
697
422
( bear::universe::time_type elapsed_time )
698
423
{
699
 
  if ( ! m_corrupting_bonus ) 
 
424
  if ( !m_corrupting_bonus )
700
425
    {
701
426
      const std::string name
702
 
        (game_variables::get_corrupting_bonus_animation_name());
703
 
      if ( ! name.empty() ) 
704
 
        m_corrupting_bonus = new bear::visual::animation
705
 
          ( get_level_globals().get_animation(name));
 
427
        ( game_variables::get_corrupting_bonus_animation_name() );
 
428
      if ( !name.empty() )
 
429
        {
 
430
          m_corrupting_bonus =
 
431
            new bear::visual::animation
 
432
            ( get_level_globals().get_animation(name));
 
433
 
 
434
          m_corrupting_bonus->set_size( m_corrupting_bonus->get_size() / 2 );
 
435
        }
706
436
    }
707
 
  
708
 
  if ( m_corrupting_bonus )   
 
437
 
 
438
  if ( m_corrupting_bonus )
709
439
    {
 
440
      bear::engine::level_globals& glob = get_level_globals();
 
441
      unsigned int nb = game_variables::get_corrupting_bonus_count();
 
442
 
 
443
      if ( nb < m_last_corrupting_bonus )
 
444
        {
 
445
          m_last_corrupting_bonus = nb;
 
446
          m_corrupting_bonus_time = elapsed_time;
 
447
        }
 
448
      else if ( m_corrupting_bonus_time != 0 )
 
449
        {
 
450
          m_corrupting_bonus_time += elapsed_time;
 
451
          if ( m_corrupting_bonus_time > 1 )
 
452
            m_corrupting_bonus_time = 0;
 
453
        }
 
454
      else
 
455
        m_last_corrupting_bonus = nb;
 
456
 
710
457
      std::ostringstream oss;
711
 
      oss << game_variables::get_corrupting_bonus_count();
712
 
      m_text_corrupting_bonus.create
713
 
        ( get_level_globals().get_font("font/bouncy.fnt"), oss.str() );
714
 
      
715
 
      m_text_corrupting_bonus->set_intensity(1, 0.8, 0);
 
458
      oss << nb;
 
459
      bear::visual::font f = glob.get_font("font/bouncy.fnt");
 
460
      m_text_corrupting_bonus.create(f, oss.str());
 
461
 
 
462
      double red = 1;
 
463
      double green = 0.8;
 
464
 
 
465
      if ( m_corrupting_bonus_time != 0 )
 
466
        {
 
467
          if ( m_corrupting_bonus_time > 0.5 )
 
468
            {
 
469
              red = m_corrupting_bonus_time;
 
470
              green = 2*(m_corrupting_bonus_time-0.5);
 
471
            }
 
472
          else if ( m_corrupting_bonus_time > 0 )
 
473
            {
 
474
              red = 1 - m_corrupting_bonus_time;
 
475
              green = 0.8 - 1.6*m_corrupting_bonus_time;
 
476
            }
 
477
        }
 
478
      m_text_corrupting_bonus->set_intensity(red, green, 0);
716
479
    }
717
480
} // status_layer::progress_corrupting_bonus()
718
481
 
723
486
void ptb::status_layer::render_corrupting_bonus
724
487
( scene_element_list& e) const
725
488
{
726
 
  if ( m_corrupting_bonus )   
 
489
  if ( m_corrupting_bonus )
727
490
    {
728
 
      bear::universe::coordinate_type width = 
729
 
        m_corrupting_bonus->width() +  
 
491
      double scale = 1;
 
492
      if ( m_corrupting_bonus_time > 0.5 )
 
493
        scale = 2 - m_corrupting_bonus_time;
 
494
      else if ( m_corrupting_bonus_time > 0 )
 
495
        scale = 1 + m_corrupting_bonus_time;
 
496
 
 
497
      bear::universe::coordinate_type width =
 
498
        m_corrupting_bonus->width() +
730
499
        m_text_corrupting_bonus.get_width() + s_margin;
731
 
      
 
500
 
732
501
      bear::universe::position_type pos
733
 
        ( get_size().x/2 - width/2, 
734
 
          get_size().y - m_corrupting_bonus->height() - 
735
 
          m_honeypot.height() - 2*s_margin);
736
 
      
737
 
      e.push_back
738
 
        ( bear::visual::scene_sprite
739
 
          (pos.x, pos.y, m_corrupting_bonus->get_sprite()) );
740
 
      
741
 
      e.push_back
742
 
        ( bear::visual::scene_writing
743
 
          ( get_size().x/2  + width/2 - m_text_corrupting_bonus.get_width(),  
744
 
            get_size().y - 2*s_margin -  m_honeypot.height() -
745
 
            m_corrupting_bonus->height()/2 - 
746
 
            m_text_corrupting_bonus.get_width()/4,
747
 
            m_text_corrupting_bonus ) );
 
502
        ( get_size().x/2 - width/2, m_honeypot.height() + 2*s_margin);
 
503
 
 
504
      if (m_corrupting_bonus->height() > m_text_corrupting_bonus.get_height())
 
505
        {
 
506
          bear::visual::scene_sprite
 
507
            sp( pos.x, pos.y, m_corrupting_bonus->get_sprite() );
 
508
 
 
509
          sp.set_scale_factor(scale,scale);
 
510
          e.push_back( sp );
 
511
 
 
512
          pos.x += m_corrupting_bonus->width() + s_margin;
 
513
          pos.y +=
 
514
            (m_corrupting_bonus->height()
 
515
             - m_text_corrupting_bonus.get_height()) / 2;
 
516
        }
 
517
      else
 
518
        {
 
519
          bear::visual::scene_sprite
 
520
            sp(pos.x,
 
521
               pos.y + (m_text_corrupting_bonus.get_height()
 
522
                        - m_corrupting_bonus->height()) / 2,
 
523
               m_corrupting_bonus->get_sprite() );
 
524
 
 
525
          sp.set_scale_factor(scale,scale);
 
526
          e.push_back( sp );
 
527
 
 
528
          pos.x += m_corrupting_bonus->width() + s_margin;
 
529
        }
 
530
 
 
531
      bear::visual::scene_writing s( pos.x, pos.y, m_text_corrupting_bonus );
 
532
      s.set_scale_factor(scale,scale);
 
533
      e.push_back( s );
748
534
    }
749
535
} // status_layer::render_corrupting_bonus()
750
536
 
751
537
/*----------------------------------------------------------------------------*/
752
538
/**
753
 
 * \brief Render the azelnut.
 
539
 * \brief Render the hazelnut.
754
540
 */
755
 
void ptb::status_layer::render_azelnut
 
541
void ptb::status_layer::render_hazelnut
756
542
( scene_element_list& e) const
757
543
{
758
 
  if ( level_variables::get_azelnut(get_level()) )   
 
544
  if ( level_variables::get_hazelnut(get_level()) )
759
545
    {
760
546
      e.push_back
761
547
        ( bear::visual::scene_sprite
762
 
          ( (get_size().x-m_azelnut->width())/2, 
763
 
            2*s_margin + m_text_time.get_height(), 
764
 
            m_azelnut->get_sprite()) );
 
548
          ( (get_size().x-m_hazelnut->width())/2,
 
549
            get_size().y - 2*s_margin - m_text_time.get_height()
 
550
            - m_hazelnut->get_sprite().height(),
 
551
            m_hazelnut->get_sprite()) );
765
552
    }
766
 
} // status_layer::render_azelnut()
 
553
} // status_layer::render_hazelnut()
767
554
 
768
555
/*----------------------------------------------------------------------------*/
769
556
/**
773
560
( scene_element_list& e) const
774
561
{
775
562
  unsigned int nb = level_variables::get_honeypots_found(get_level());
776
 
  bear::universe::coordinate_type width = 
 
563
  bear::universe::coordinate_type width =
777
564
    nb * m_honeypot.width() + (nb-1)*s_margin;
778
565
 
779
566
  if ( nb > 0 )
780
567
    for ( unsigned int i = 0; i != nb; ++i )
781
568
      e.push_back
782
569
        ( bear::visual::scene_sprite
783
 
          ( ( get_size().x - width )/ 2 + 
 
570
          ( ( get_size().x - width )/ 2 +
784
571
            i * (s_margin + m_honeypot.width()),
785
 
            get_size().y - m_honeypot.height() - s_margin, 
 
572
            s_margin,
786
573
            m_honeypot) );
787
574
} // status_layer::render_honeypots()
788
575
 
793
580
 */
794
581
void ptb::status_layer::render_player1( scene_element_list& e ) const
795
582
{
796
 
  bear::visual::position_type pos(s_margin, s_margin);
 
583
  bear::visual::position_type pos
 
584
    ( s_margin, get_size().y - s_margin - m_data_1->energy.height() );
797
585
 
798
586
  m_data_1->energy.render(e, pos);
799
587
 
800
 
  pos.set( s_margin , 2 * s_margin + m_data_1->energy.height() );
 
588
  pos.y -= s_margin + m_data_1->score.get_height();
801
589
  bear::visual::scene_writing s1( pos.x, pos.y, m_data_1->score );
802
590
  e.push_back( s1 );
803
591
 
804
 
  pos.set( s_margin,
805
 
           3*s_margin + m_data_1->energy.height() +
806
 
           m_data_1->score.get_height());
807
 
  e.push_back
808
 
    ( bear::visual::scene_sprite
809
 
      (pos.x, pos.y, m_data_1->stone_animation.get_sprite()) );
810
 
  
811
 
  pos.set( 2*s_margin + m_data_1->stone_animation.width(),
812
 
           3*s_margin + m_data_1->energy.height() + 
813
 
           m_data_1->score.get_height());
814
 
  if ( m_data_1->stone_animation.height() > m_data_1->stones.get_height() )
815
 
    pos.y += ( m_data_1->stone_animation.height() - 
816
 
               m_data_1->stones.get_height() ) / 2;
817
 
  bear::visual::scene_writing s2( pos.x, pos.y, m_data_1->stones );
 
592
  bear::visual::coordinate_type y_saved(pos.y);
 
593
  pos.y -= s_margin + m_data_1->throwable_item_animation.get_sprite().height();
 
594
  bear::visual::scene_sprite s_item
 
595
    (pos.x, pos.y, m_data_1->throwable_item_animation.get_sprite());
 
596
 
 
597
  pos.x += m_data_1->throwable_item_animation.get_sprite().width() + s_margin;
 
598
  pos.y +=
 
599
    ( m_data_1->throwable_item_animation.get_sprite().height()
 
600
      - m_data_1->throwable_items.get_height() ) / 2;
 
601
 
 
602
  bear::visual::scene_writing s2( pos.x, pos.y, m_data_1->throwable_items );
 
603
 
 
604
  if ( !m_first_player->get_throwable_items()->get_current_throwable_item
 
605
       ()->can_throw() )
 
606
    {
 
607
      s_item.get_rendering_attributes().set_opacity(0.5);
 
608
      s2.get_rendering_attributes().set_opacity(0.5);
 
609
      s2.get_rendering_attributes().set_intensity(1,0.4,0.4);
 
610
    }
 
611
 
 
612
  e.push_back( s_item );
818
613
  e.push_back( s2 );
819
 
  
820
 
  pos.y += m_data_1->stone_animation.height() + s_margin;
 
614
 
 
615
  pos.x = s_margin;
 
616
  pos.y = std::min(pos.y, y_saved) - s_margin - m_data_1->oxygen.height();
821
617
 
822
618
  if ( m_data_1->oxygen_active )
823
619
    {
824
620
      pos.x -= m_data_1->oxygen_offset_x;
825
621
      m_data_1->oxygen.render(e, pos);
826
622
    }
827
 
  pos.set( s_margin, pos.y + m_data_1->oxygen.height() + s_margin );
 
623
  pos.set( s_margin, pos.y - m_data_1->fire_gauge.height() - s_margin );
828
624
 
829
625
  if ( m_data_1->fire_gauge_active )
830
626
    {
831
627
      pos.x -= m_data_1->fire_gauge_offset_x;
832
628
      m_data_1->fire_gauge.render(e, pos);
833
629
    }
834
 
  pos.set( s_margin, pos.y + m_data_1->fire_gauge.height() + s_margin );
 
630
  pos.set( s_margin, pos.y - m_data_1->ice_gauge.height() - s_margin );
835
631
 
836
632
  if ( m_data_1->ice_gauge_active )
837
633
    {
838
634
      pos.x -= m_data_1->ice_gauge_offset_x;
839
635
      m_data_1->ice_gauge.render(e, pos);
840
636
    }
841
 
  pos.set( s_margin, pos.y + m_data_1->ice_gauge.height() + s_margin );
 
637
  pos.set( s_margin, pos.y - s_margin );
842
638
 
843
639
  // lifes
844
 
  pos.set( s_margin, get_size().y - s_margin - m_small_plee.height() );
845
 
  e.push_back( bear::visual::scene_sprite(pos.x, pos.y, m_small_plee) );
 
640
  pos.set( s_margin, s_margin );
 
641
  e.push_back( bear::visual::scene_sprite(pos.x, pos.y, m_small_player) );
846
642
 
847
643
  double scale = 1;
848
644
  if ( m_data_1->m_tries_time > 0.5 )
849
645
    scale = 2 - m_data_1->m_tries_time;
850
 
  else if ( m_data_1->m_tries_time > 0 ) 
 
646
  else if ( m_data_1->m_tries_time > 0 )
851
647
    scale = 1 + m_data_1->m_tries_time;
852
648
 
853
 
  pos.set( m_small_plee.width() + 2*s_margin, 
854
 
           get_size().y - s_margin - 
855
 
           ( m_small_plee.height() + m_data_1->tries.get_height()*scale)/2 );
856
 
  
 
649
  pos.x += m_small_player.width() + s_margin;
 
650
  pos.y =
 
651
    s_margin
 
652
    + (m_small_player.height() - m_data_1->tries.get_height() * scale) / 2;
 
653
 
857
654
  bear::visual::scene_writing s3( pos.x, pos.y, m_data_1->tries );
858
 
  s3.set_scale_factor(scale,scale);  
 
655
  s3.set_scale_factor(scale,scale);
859
656
  e.push_back( s3 );
860
657
} // status_layer::render_player1()
861
658
 
867
664
void ptb::status_layer::render_player2( scene_element_list& e ) const
868
665
{
869
666
  bear::visual::position_type pos
870
 
    (get_size().x - m_data_2->energy.width() - s_margin, s_margin);
 
667
    ( get_size().x - m_data_2->energy.width() - s_margin,
 
668
      get_size().y - s_margin - m_data_2->energy.height() );
871
669
 
872
 
  m_data_2->energy.render(e, pos);  
 
670
  m_data_2->energy.render(e, pos);
873
671
 
874
672
  pos.set( get_size().x - s_margin - m_data_2->score.get_size().x,
875
 
           2*s_margin + m_data_2->energy.height());
 
673
           pos.y - s_margin - m_data_2->score.get_height() );
876
674
  bear::visual::scene_writing s1( pos.x, pos.y, m_data_2->score );
877
675
  e.push_back( s1 );
878
676
 
879
 
  pos.set( get_size().x - s_margin - m_data_2->stone_animation.width(), 
880
 
           3*s_margin + m_data_2->energy.height() + 
881
 
           m_data_2->score.get_height());
882
 
  
883
 
  e.push_back
884
 
    ( bear::visual::scene_sprite
885
 
      (pos.x, pos.y, m_data_2->stone_animation.get_sprite()) );  
886
 
 
887
 
  pos.set( get_size().x - 2 * s_margin - m_data_2->stone_animation.width()
888
 
               - m_data_2->stones.get_size().x, 3*s_margin + 
889
 
               m_data_2->energy.height() + m_data_2->score.get_height());
890
 
 
891
 
  if ( m_data_2->stone_animation.height() > m_data_2->stones.get_height() )
892
 
    pos.y += ( m_data_2->stone_animation.height() - 
893
 
               m_data_2->stones.get_height() ) / 2;
894
 
  
895
 
  bear::visual::scene_writing s2( pos.x, pos.y, m_data_2->stones );
 
677
  bear::visual::coordinate_type y_saved(pos.y);
 
678
  pos.set( get_size().x - s_margin -
 
679
           m_data_2->throwable_item_animation.width(),
 
680
           pos.y - s_margin -
 
681
           m_data_2->throwable_item_animation.get_sprite().height() );
 
682
  bear::visual::scene_sprite s_item
 
683
    (pos.x, pos.y, m_data_2->throwable_item_animation.get_sprite());
 
684
 
 
685
  pos.set( get_size().x - 2 * s_margin -
 
686
           m_data_2->throwable_item_animation.width()
 
687
           - m_data_2->throwable_items.get_size().x,
 
688
           pos.y
 
689
           + ( m_data_2->throwable_item_animation.get_sprite().height()
 
690
               - m_data_2->throwable_items.get_height() ) / 2 );
 
691
 
 
692
  bear::visual::scene_writing s2( pos.x, pos.y, m_data_2->throwable_items );
 
693
 
 
694
  if ( !m_second_player->get_throwable_items()->get_current_throwable_item
 
695
       ()->can_throw() )
 
696
    {
 
697
      s_item.get_rendering_attributes().set_opacity(0.5);
 
698
      s2.get_rendering_attributes().set_opacity(0.5);
 
699
      s2.get_rendering_attributes().set_intensity(1,0.4,0.4);
 
700
    }
 
701
 
 
702
  e.push_back( s_item );
896
703
  e.push_back( s2 );
897
704
 
898
 
  pos.y += m_data_2->stone_animation.height() + s_margin;
 
705
  pos.x = get_size().x - s_margin;
 
706
  pos.y = std::min(pos.y, y_saved) - s_margin - m_data_2->oxygen.height();
899
707
 
900
708
  if ( m_data_2->oxygen_active )
901
709
    {
904
712
      m_data_2->oxygen.render(e, pos);
905
713
    }
906
714
  pos.set( get_size().x - s_margin,
907
 
           pos.y + m_data_2->oxygen.height() + s_margin );
 
715
           pos.y - m_data_2->fire_gauge.height() - s_margin );
908
716
 
909
717
  if ( m_data_2->fire_gauge_active )
910
718
    {
913
721
      m_data_2->fire_gauge.render(e, pos);
914
722
    }
915
723
  pos.set( get_size().x - s_margin,
916
 
           pos.y + m_data_2->fire_gauge.height() + s_margin );
 
724
           pos.y - m_data_2->ice_gauge.height() - s_margin );
917
725
 
918
726
  if ( m_data_2->ice_gauge_active )
919
727
    {
921
729
        + m_data_2->ice_gauge_offset_x;
922
730
      m_data_2->ice_gauge.render(e, pos);
923
731
    }
924
 
  pos.set( get_size().x - s_margin,
925
 
           pos.y + m_data_2->ice_gauge.height() + s_margin );
 
732
  pos.set( get_size().x - s_margin, pos.y - s_margin );
926
733
 
927
734
  // lifes
928
 
  pos.set( get_size().x - s_margin - m_small_plee.width(),
929
 
           get_size().y - s_margin - m_small_plee.height() );
930
 
  e.push_back( bear::visual::scene_sprite(pos.x, pos.y, m_small_plee) );
931
 
  
 
735
  pos.set( get_size().x - s_margin - m_small_player.width(), s_margin );
 
736
  e.push_back( bear::visual::scene_sprite(pos.x, pos.y, m_small_player) );
 
737
 
932
738
  double scale = 1;
933
739
  if ( m_data_2->m_tries_time > 0.5 )
934
740
    scale = 2 - m_data_2->m_tries_time;
935
 
  else if ( m_data_2->m_tries_time > 0 ) 
 
741
  else if ( m_data_2->m_tries_time > 0 )
936
742
    scale = 1 + m_data_2->m_tries_time;
937
743
 
938
 
  pos.set( get_size().x - 2*s_margin - m_small_plee.width()
939
 
           - m_data_2->tries.get_width()*scale,
940
 
           get_size().y - s_margin - 
941
 
           ( m_data_2->tries.get_height()*scale + m_small_plee.height())/2 );
 
744
  pos.set( get_size().x - 2*s_margin - m_small_player.width()
 
745
           - m_data_2->tries.get_width()*scale,
 
746
           s_margin
 
747
           + ( m_small_player.height()
 
748
               - m_data_2->tries.get_height() * scale ) / 2 );
942
749
 
943
750
  bear::visual::scene_writing s3( pos.x, pos.y, m_data_2->tries );
944
751
  s3.set_scale_factor(scale,scale);
945
 
 
946
752
  e.push_back( s3 );
947
753
} // status_layer::render_player2()
948
754
 
949
 
 
950
755
/*----------------------------------------------------------------------------*/
951
756
/**
952
757
 * \brief Search players.
953
758
 */
954
759
void ptb::status_layer::search_players( )
955
760
{
956
 
  if ( m_first_player.get() == NULL )
 
761
  if ( m_first_player == (player*)NULL )
957
762
    {
958
 
      plee::get_instance_message msg;
959
 
      bear::engine::level_globals& glob = get_level_globals();
960
 
      bear::visual::font f = glob.get_font("font/bouncy.fnt");
961
 
      glob.send_message(plee::player_name(1),msg);
962
 
      m_first_player = msg.get_instance();
 
763
      m_first_player = util::find_player( get_level_globals(), 1 );
963
764
 
964
 
      if ( m_first_player.get() != NULL )
965
 
        m_data_1 = new player_status( glob, f, m_first_player );
 
765
      if ( m_first_player != (player*)NULL )
 
766
        m_data_1 = new player_status
 
767
          ( get_level_globals(),
 
768
            get_level_globals().get_font("font/bouncy.fnt"), m_first_player );
966
769
    }
967
770
 
968
771
  if ( game_variables::get_players_count() == 2 )
969
 
    {
970
 
      if ( m_second_player.get() == NULL )
971
 
        {
972
 
           plee::get_instance_message msg2;
973
 
           bear::engine::level_globals& glob = get_level_globals();
974
 
           bear::visual::font f = glob.get_font("font/bouncy.fnt");
975
 
           
976
 
           glob.send_message(plee::player_name(2),msg2);
977
 
           m_second_player = msg2.get_instance();
978
 
           
979
 
           if ( m_second_player.get() != NULL )
980
 
             m_data_2 = new player_status( glob, f, m_second_player );
981
 
        }
982
 
    }
 
772
    if ( m_second_player == (player*)NULL )
 
773
      {
 
774
        m_second_player = util::find_player( get_level_globals(), 2 );
 
775
 
 
776
        if ( m_second_player != (player*)NULL )
 
777
          m_data_2 = new player_status
 
778
            ( get_level_globals(),
 
779
              get_level_globals().get_font("font/bouncy.fnt"),
 
780
              m_second_player );
 
781
      }
983
782
} // status_layer::search_players( )