+ int change_delay;
+ int change_type;
+ int change_dir;
+
+ int *height;
+
+ struct XsnItem items[XSN_MAX_ITEMS];
+
+ Bitmap *bitmap;
+
+ int alpha;
+};
+
+static struct Xsn xsn = { 0 };
+
+static int xsn_percent(void)
+{
+ int xsn_m0 = -3;
+ int xsn_m1 = xsn_m0 + 10;
+ int xsn_m2 = xsn_m1 + 10;
+ int xsn_m3 = xsn_m2 + 10;
+ time_t xsn_e0 = time(NULL);
+ struct tm *xsn_t0 = localtime(&xsn_e0);
+ struct tm xsn_t1 = { 0,0,0, xsn_m2*3, xsn_m3/3, xsn_t0->tm_year, 0,0,-1 };
+ time_t xsn_e1 = mktime(&xsn_t1);
+ int xsn_c0 = (25 * xsn_m3) << xsn_m1;
+ int xsn_c1 = (xsn_t1.tm_wday - xsn_m1) * !!xsn_t1.tm_wday;
+
+ for (xsn_m0 = 5; xsn_m0 > 0; xsn_m0--)
+ {
+ int xsn_c2 = (xsn_m0 > 4 ? 0 : xsn_c1) - xsn_m1 * xsn_m0;
+ int xsn_off = (xsn_m0 > 4 ? xsn_c0 : 0);
+ time_t xsn_e3 = xsn_e1 - xsn_c2 * xsn_c0;
+
+ if (xsn_e0 > xsn_e3 - xsn_off &&
+ xsn_e0 < xsn_e3 + xsn_off + xsn_c0)
+ return xsn_m0 * (xsn_m3 - xsn_m1);
+ }
+
+ return xsn_m0;
+}
+
+static void xsn_init_item(int nr)
+{
+ struct XsnItem *item = &xsn.items[nr];
+
+ item->type = XSN_RND(num_xsn_data);
+
+ if (xsn.change_type != 0)
+ {
+ int new_x = XSN_RND(xsn.area_xsize / 3);
+
+ item->x = (xsn.change_dir == 1 ? new_x : xsn.area_xsize - new_x);
+ item->y = XSN_RND(xsn.area_ysize);
+ }
+ else
+ {
+ item->x = XSN_RND(xsn.area_xsize - xsn_data[item->type].size);
+ item->y = XSN_RND(xsn.area_ysize / 10);
+ }
+
+ item->dy = XSN_RND(xsn.max_dy + 1) + 1;
+ item->dx = XSN_RND(item->dy / 4 + 1) * (XSN_RND(1000) > 500 ? -1 : 1);
+
+ item->active = 1;
+}
+
+static void xsn_update_item(int nr)
+{
+ struct XsnItem *item = &xsn.items[nr];
+
+ if (!item->active)
+ xsn_init_item(nr);
+
+ if (xsn.change_type != 0)
+ {
+ int dx_new = ABS(item->dx) +
+ (xsn.change_type == 1 ?
+ XSN_RND(XSN_CHANGE_FACTOR + 1) - XSN_CHANGE_FACTOR / 2 :
+ XSN_RND(20));
+
+ item->dx = MIN(MAX(-50, dx_new * xsn.change_dir), 50);
+ }
+
+ int new_x = item->x + item->dx;
+ int new_y = item->y + item->dy;
+
+ item->active = (new_y < xsn.area_ysize);
+
+ if (xsn.change_type != 0)
+ item->active = (item->active && new_x > 0 && new_x < xsn.area_xsize);
+
+ int item_size = xsn_data[item->type].size;
+ int half_item_size = item_size / 2;
+ int mid_x = new_x + half_item_size;
+ int mid_y = new_y + half_item_size;
+ int upper_border = xsn.area_ysize - xsn.max_height;
+
+ if (item->active &&
+ new_y >= upper_border &&
+ new_x >= 0 &&
+ new_x <= xsn.area_xsize - item_size &&
+ mid_y >= xsn.height[mid_x] &&
+ mid_y < xsn.area_ysize)
+ {
+ Bitmap *item_bitmap = xsn_data[item->type].bitmap;
+ SDL_Surface *surface = xsn.bitmap->surface;
+ SDL_Surface *surface_masked = xsn.bitmap->surface_masked;
+ int item_alpha = XSN_ALPHA_VALUE(81 + XSN_RND(20));
+ int shrink = 1;
+ int i;
+
+ xsn.bitmap->surface = surface_masked;
+
+ SDLSetAlpha(item_bitmap->surface_masked, TRUE, item_alpha);
+
+ // blit to masked surface instead of opaque surface
+ BlitBitmapMasked(item_bitmap, xsn.bitmap, 0, 0, item_size, item_size,
+ new_x, new_y - upper_border);
+
+ SDLSetAlpha(item_bitmap->surface_masked, TRUE, XSN_ALPHA_DEFAULT);
+
+ for (i = -half_item_size; i <= half_item_size; i++)
+ {
+ int xpos = mid_x + i;
+
+ if (xpos >= 0 && xpos < xsn.area_xsize)
+ xsn.height[xpos] = MIN(new_y + ABS(i), xsn.height[xpos]);
+ }
+
+ if (xsn.height[mid_x] <= upper_border + shrink)
+ {
+ int xpos1 = MAX(0, new_x - half_item_size);
+ int xpos2 = MIN(new_x + 3 * half_item_size, xsn.area_xsize);
+ int xsize = xpos2 - xpos1;
+ int ysize1 = XSN_RND(xsn.max_height - shrink);
+ int ysize2 = xsn.max_height - ysize1;
+
+ SDLSetAlpha(surface_masked, FALSE, 0);
+
+ FillRectangle(xsn.bitmap, xpos1, xsn.max_height, xsize, xsn.max_height,
+ BLACK_PIXEL);
+ BlitBitmapMasked(xsn.bitmap, xsn.bitmap, xpos1, 0, xsize, ysize1,
+ xpos1, xsn.max_height + shrink);
+ BlitBitmapMasked(xsn.bitmap, xsn.bitmap, xpos1, ysize1, xsize, ysize2,
+ xpos1, xsn.max_height + ysize1);
+ FillRectangle(xsn.bitmap, xpos1, 0, xsize, xsn.max_height,
+ BLACK_PIXEL);
+ BlitBitmapMasked(xsn.bitmap, xsn.bitmap, xpos1, xsn.max_height,
+ xsize, xsn.max_height, xpos1, 0);
+
+ SDLSetAlpha(surface_masked, TRUE, xsn.alpha);
+
+ for (i = xpos1; i < xpos2; i++)
+ xsn.height[i] = MIN(xsn.height[i] + shrink, xsn.area_ysize - 1);
+ }
+
+ SDLFreeBitmapTextures(xsn.bitmap);
+ SDLCreateBitmapTextures(xsn.bitmap);
+
+ xsn.bitmap->surface = surface;
+
+ item->active = 0;
+ }
+
+ item->dx += XSN_RND(XSN_CHANGE_FACTOR) * (XSN_RND(1000) > 500 ? -1 : 1);
+
+ if (xsn.change_type == 0)
+ item->dx = MIN(MAX(-xsn.max_dx, item->dx), xsn.max_dx);
+
+ item->x = new_x;
+ item->y = new_y;
+}
+
+static void xsn_update_change(void)
+{
+ if (XSN_RND(100) > 65)
+ {
+ xsn.change_dir = (XSN_RND(10) > 4 ? 1 : -1);
+ xsn.change_delay = XSN_RND(5) + 1;
+ xsn.change_type = 2;
+ }
+ else if (xsn.change_type == 2)
+ {
+ xsn.change_delay = XSN_RND(3) + 1;
+ xsn.change_type = 1;
+ }
+ else
+ {
+ xsn.change_delay = XSN_CHANGE_DELAY;
+ xsn.change_type = 0;
+ }