/****************************************************************************
Fill the area covered by the sprite with the given color.
****************************************************************************/
void canvas_fog_sprite_area(struct canvas *pcanvas, struct sprite *psprite,
int canvas_x, int canvas_y)
{
cairo_t *cr;
int width, height;
canvas_fill_sprite_area(pcanvas, psprite,
get_color(tileset, COLOR_MAPVIEW_UNKNOWN),
canvas_x, canvas_y);
get_sprite_dimensions(psprite, &width, &height);
if (!pcanvas->drawable) {
cr = cairo_create(pcanvas->surface);
} else {
cr = pcanvas->drawable;
}
if (pcanvas->drawable) {
cairo_save(cr);
}
cairo_rectangle(cr, canvas_x * pcanvas->zoom, canvas_y * pcanvas->zoom,
width, height);
cairo_set_operator(cr, CAIRO_OPERATOR_HSL_COLOR);
cairo_scale(cr, pcanvas->zoom, pcanvas->zoom);
cairo_set_source_rgb(cr, 0.65, 0.65, 0.65);
cairo_fill(cr);
if (!pcanvas->drawable) {
cairo_destroy(cr);
} else {
cairo_restore(cr);
}
}
/****************************************************************************
Draw some or all of a sprite onto the mapview or citydialog canvas.
****************************************************************************/
void canvas_put_sprite(struct canvas *pcanvas,
int canvas_x, int canvas_y,
struct sprite *sprite,
int offset_x, int offset_y, int width, int height)
{
int sswidth, ssheight;
cairo_t *cr;
get_sprite_dimensions(sprite, &sswidth, &ssheight);
if (!pcanvas->drawable) {
cr = cairo_create(pcanvas->surface);
} else {
cr = pcanvas->drawable;
}
if (pcanvas->drawable) {
cairo_save(cr);
}
cairo_rectangle(cr, offset_x + canvas_x, offset_y + canvas_y,
MIN(width, MAX(0, sswidth - offset_x)),
MIN(height, MAX(0, ssheight - offset_y)));
cairo_clip(cr);
cairo_set_source_surface(cr, sprite->surface, canvas_x, canvas_y);
cairo_paint(cr);
if (!pcanvas->drawable) {
cairo_destroy(cr);
} else {
cairo_restore(cr);
}
}
/****************************************************************************
Fill the area covered by the sprite with the given color.
****************************************************************************/
void canvas_fill_sprite_area(struct canvas *pcanvas,
struct sprite *psprite,
struct color *pcolor,
int canvas_x, int canvas_y)
{
int width, height;
get_sprite_dimensions(psprite, &width, &height);
canvas_put_rectangle(pcanvas, pcolor, canvas_x, canvas_y, width, height);
}
/****************************************************************************
Draw a full sprite onto the mapview or citydialog canvas.
****************************************************************************/
void canvas_put_sprite_full(struct canvas *pcanvas,
int canvas_x, int canvas_y,
struct sprite *sprite)
{
int width, height;
get_sprite_dimensions(sprite, &width, &height);
canvas_put_sprite(pcanvas, canvas_x, canvas_y, sprite,
0, 0, width, height);
}
/**************************************************************************
Loads the sprite. If the sprite is already loaded a reference
counter is increased. Can return NULL if the sprite couldn't be
loaded.
**************************************************************************/
static struct sprite *load_sprite(struct theme *t, const char *tag_name)
{
/* Lookup information about where the sprite is found. */
struct small_sprite *ss;
log_debug("load_sprite(tag='%s')", tag_name);
if (!small_sprite_hash_lookup(t->sprite_hash, tag_name, &ss)) {
return NULL;
}
fc_assert_ret_val(ss->ref_count >= 0, NULL);
if (!ss->sprite) {
/* If the sprite hasn't been loaded already, then load it. */
fc_assert_ret_val(ss->ref_count == 0, NULL);
if (ss->file) {
ss->sprite = load_gfx_file(ss->file);
if (!ss->sprite) {
log_fatal("Couldn't load gfx file \"%s\" for sprite '%s'.",
ss->file, tag_name);
exit(EXIT_FAILURE);
}
} else {
int sf_w, sf_h;
ensure_big_sprite(ss->sf);
get_sprite_dimensions(ss->sf->big_sprite, &sf_w, &sf_h);
if (ss->x < 0 || ss->x + ss->width > sf_w
|| ss->y < 0 || ss->y + ss->height > sf_h) {
log_error("Sprite '%s' in file \"%s\" isn't within the image!",
tag_name, ss->sf->file_name);
return NULL;
}
ss->sprite =
crop_sprite(ss->sf->big_sprite, ss->x, ss->y, ss->width, ss->height,
NULL, -1, -1);
}
}
/* Track the reference count so we know when to free the sprite. */
ss->ref_count++;
return ss->sprite;
}
/**************************************************************************
Only used for isometric view.
**************************************************************************/
void pixmap_put_overlay_tile_draw(struct canvas *pcanvas,
int canvas_x, int canvas_y,
struct sprite *ssprite,
bool fog)
{
cairo_t *cr;
int sswidth, ssheight;
if (!ssprite) {
return;
}
get_sprite_dimensions(ssprite, &sswidth, &ssheight);
canvas_put_sprite(pcanvas, canvas_x, canvas_y,
ssprite, 0, 0, sswidth, ssheight);
if (fog) {
if (!pcanvas->drawable) {
cr = cairo_create(pcanvas->surface);
} else {
cr = pcanvas->drawable;
}
if (pcanvas->drawable) {
cairo_save(cr);
}
cairo_set_operator(cr, CAIRO_OPERATOR_HSL_COLOR);
cairo_scale(cr, pcanvas->zoom, pcanvas->zoom);
cairo_set_source_rgb(cr, 0.65, 0.65, 0.65);
cairo_fill(cr);
if (!pcanvas->drawable) {
cairo_destroy(cr);
} else {
cairo_restore(cr);
}
}
}
/* ----------------------------------------------------------------------------
* Draws a resource.
*/
void resource::draw_mob(bitmap_effect_manager* effect_manager) {
sprite* s_ptr = anim.get_cur_sprite();
if(!s_ptr) return;
point draw_pos = get_sprite_center(s_ptr);
point draw_size = get_sprite_dimensions(s_ptr);
bitmap_effect_manager effects;
add_sector_brightness_bitmap_effect(&effects);
if(fsm.cur_state->id == RESOURCE_STATE_BEING_DELIVERED) {
add_delivery_bitmap_effect(
&effects, script_timer.get_ratio_left(),
carrying_color_move
);
}
draw_bitmap_with_effects(
s_ptr->bitmap,
draw_pos, draw_size,
angle + s_ptr->angle, &effects
);
}
/* ----------------------------------------------------------------------------
* Draws a treasure.
*/
void treasure::draw() {
sprite* s_ptr = anim.get_cur_sprite();
if(!s_ptr) return;
float draw_x, draw_y;
float draw_w, draw_h, scale;
get_sprite_center(this, s_ptr, &draw_x, &draw_y);
get_sprite_dimensions(this, s_ptr, &draw_w, &draw_h, &scale);
float radius = type->radius * scale;
bool being_delivered = false;
ALLEGRO_COLOR extra_color;
if(fsm.cur_state->id == TREASURE_STATE_BEING_DELIVERED) {
//If it's being delivered, do some changes to the scale and coloring.
being_delivered = true;
if(script_timer.get_ratio_left() >= 0.5) {
//First half of the sucking in process = interpolated coloring.
extra_color = interpolate_color(
script_timer.get_ratio_left(),
0.5, 1.0,
carrying_color_move,
al_map_rgb(0, 0, 0)
);
} else {
//Second half of the sucking in process = interpolated scaling.
extra_color = carrying_color_move;
radius *= (script_timer.get_ratio_left() * 2.0);
}
}
draw_sprite(
s_ptr->bitmap,
draw_x,
draw_y,
radius * 2.0, -1,
angle,
map_gray(get_sprite_brightness(this))
);
if(being_delivered) {
int old_op, old_src, old_dst, old_aop, old_asrc, old_adst;
al_get_separate_blender(
&old_op, &old_src, &old_dst, &old_aop, &old_asrc, &old_adst
);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ONE);
draw_sprite(
s_ptr->bitmap,
draw_x,
draw_y,
radius * 2.0, -1,
angle,
extra_color
);
al_set_separate_blender(
old_op, old_src, old_dst, old_aop, old_asrc, old_adst
);
}
}
/* ----------------------------------------------------------------------------
* Draws a Pikmin, including its leaf/bud/flower, idle glow, etc.
*/
void pikmin::draw_mob(bitmap_effect_manager* effect_manager) {
sprite* s_ptr = anim.get_cur_sprite();
if(!s_ptr) return;
point draw_pos = get_sprite_center(s_ptr);
point draw_size = get_sprite_dimensions(s_ptr);
bool is_idle =
fsm.cur_state->id == PIKMIN_STATE_IDLING ||
fsm.cur_state->id == PIKMIN_STATE_IDLING_H ||
fsm.cur_state->id == PIKMIN_STATE_SPROUT;
bitmap_effect_manager effects;
add_sector_brightness_bitmap_effect(&effects);
add_status_bitmap_effects(&effects);
if(is_idle) {
bitmap_effect idle_effect;
bitmap_effect_props idle_effect_props;
idle_effect_props.glow_color = al_map_rgb(255, 255, 255);
idle_effect.add_keyframe(0, idle_effect_props);
effects.add_effect(idle_effect);
}
draw_bitmap_with_effects(
s_ptr->bitmap,
draw_pos, draw_size,
angle + s_ptr->angle, &effects
);
if(s_ptr->top_visible) {
point top_pos;
top_pos = rotate_point(s_ptr->top_pos, angle);
draw_bitmap_with_effects(
pik_type->bmp_top[maturity],
pos + top_pos,
s_ptr->top_size,
angle + s_ptr->top_angle,
&effects
);
}
if(is_idle) {
draw_bitmap(
bmp_idle_glow,
pos,
point(standard_pikmin_radius * 8, standard_pikmin_radius * 8),
area_time_passed * IDLE_GLOW_SPIN_SPEED,
type->main_color
);
}
float status_bmp_scale;
ALLEGRO_BITMAP* status_bmp = get_status_bitmap(&status_bmp_scale);
if(status_bmp) {
draw_bitmap(
status_bmp, pos,
point(type->radius * 2 * status_bmp_scale, -1)
);
}
}