elements.h

gehe zur Dokumentation dieser Datei

/* -*- coding: utf-8 -*- */
/***********************************************************************
 *
 * $Id: elements.h,v 1.36 2011/05/10 19:11:39 elias Exp $
 * Diese Datei gehört zur Virtuellen Zockhalle
 *
 * Virtuelle Zockhalle 
 * (c) 2010 Elias Schwerdtfeger
 * http://www.tamagothi.de/
 *
 * Dieses Programm ist freie Software, lizenziert unter den sinngemäß
 * anzuwendenden Bedingungen meiner Lizenz für freie Musik,
 * http://www.tamagothi.de/alben/lizenz.html
 *
 ***********************************************************************/


#ifndef _ELEMENTS_H
#define _ELEMENTS_H

#include "alhelper.h"
#include "dirtrect.h"

#include <time.h>

/***********************************************************************
 *
 * GLOBALE VARIABLEN
 *
 ***********************************************************************/

extern short int elements_offset_x;
extern short int elements_offset_y;
#define XOF (elements_offset_x)

#define YOF (elements_offset_y)

extern short int cheat_allowed;



/***********************************************************************
 *
 * HILFSFUNKTIONEN FÜR DAS RENDERING
 * 
 ***********************************************************************/
void draw_backdrop (BITMAP *bm);
#define clear_screen(COLOR)                     \
  drect_cls ((COLOR))

void draw_machine_front (BITMAP *bm);
/***********************************************************************
 *
 * TIMER
 *
 ***********************************************************************/

extern volatile unsigned hundreds;

#define timer_get()                             \
  (hundreds)

void timer_reset (void);
void timer_set (unsigned value);
void timer_start (void);
void timer_pause (void);
int timer_is_running (void);
#define random_future(MINTIME, MAXTIME)         \
  (timer_get () + (MINTIME) + mt_range ((MAXTIME) - (MINTIME) + 1))

#define random_time(MINTIME, MAXTIME)           \
  ((MINTIME) + mt_range ((MAXTIME) - (MINTIME) + 1))

/***********************************************************************
 *
 * VARIABLE BITMAP
 *
 ***********************************************************************/

typedef
struct variable_bitmap
{
  short int x;             
  short int y;             
  unsigned short int akt;  
  unsigned short int max;  
  unsigned short int disp; 
  BITMAP **bm;             
  short int assprite;      
} *vbitmap_t;

void vbm_set (vbitmap_t vbm, unsigned short int newval);
void vbm_sound (vbitmap_t vbm, unsigned short int newval,
                SAMPLE *smp, int vol, int pan);
#define vbm_get(VBM)                            \
  ((VBM)->akt)

#define vbm_getmax(VBM)                         \
  (assert ((VBM)), (VBM)->max)

/***********************************************************************
 *
 * ZÄHLWERK
 *
 ***********************************************************************/

struct counter 
{
  const char *uniq_id;
  int value;
  int min;
  int max;
  void (*gfx_init_cb) (remember_t rmb, struct counter *c);
  void (*render_cb) (struct counter *, int force);
  SAMPLE *smp_up;
  SAMPLE *smp_down;
  int smp_volume;
  int smp_pan;
  void *uptr1;
  void *uptr2;
  void *uprt3;
  int user_int;
  long user_long;
  int (*before_add_f) (struct counter *c, int toadd);
  int (*is_counting_f) (struct counter *c);
  void *iptr1;
  void *iptr2;
  void *iptr3;
  int impl_int;
  long impl_long;
};

void cnt_add (struct counter *c, int toadd);
int cnt_is_counting (struct counter *c);
void cnt_up_sound (struct counter *c);
void cnt_down_sound (struct counter *c);
#define cnt_get(CNTPTR)                         \
  ((CNTPTR)->value)

#define cnt_set(CNTPTR, VAL)                    \
  (cnt_add ((CNTPTR), (VAL) - cnt_get ((CNTPTR))))

#define cnt_sub(CNTPTR, TOSUB)                  \
  (cnt_add ((CNTPTR), -(TOSUB)))

#define cnt_get_max(CNTPTR)                     \
  ((CNTPTR)->max)

/***********************************************************************
 *
 * WALZE 
 *
 ***********************************************************************/

enum
  {
    REELF_WEIGHTED = (1UL << 0),
    REELF_OWNRAND = (1UL << 1),
    REELF_INITED = (1UL << 7),  
    REELF_IMPL = (1UL << 8),
    REELF_USER = (1UL << 16)
  };

enum 
  {
    REEL_STOPPED = 0,    
    REEL_STARTING = 1,   
    REEL_RUNNING = 2,    
    REEL_STOPPING = 3,   
    REEL_HOLDED = 4,
    REEL_SPECIAL = 5, 
    REEL_IMPL = 16,
    REEL_USER = 256
  };

struct reel
{
  const char *uniq_id;
  unsigned pos;
  unsigned size;
  unsigned long flags;
  void (*gfx_init_cb) (remember_t rmb, struct reel *r);
  void (*render_cb) (struct reel *r, int force);
  SAMPLE *smp_start;
  SAMPLE *smp_running;
  SAMPLE *smp_stop;
  int smp_volume;
  int smp_pan;
  void (*reelstart_cb) (struct reel *r);
  void (*reelstop_cb) (struct reel *r);
  void *uptr1;
  void *uptr2;
  void *uptr3;
  int user_int;
  long user_long;
  unsigned short *weights;
  void (*reelinit_cb) (struct reel *r);
  int state;
  unsigned (*randompos_cb) (struct reel *r);
  unsigned long weight_sum;
  void *iptr1;
  void *iptr2;
  void *iptr3;
  int impl_int;
  long impl_long;
};

void reel_set_random (struct reel *r);
void reel_start (struct reel *r);
void reel_stop_ex (struct reel *r, int force);
unsigned reel_pos (const struct reel *r);
void reel_start_sound (struct reel *r);
void reel_stop_sound (struct reel *r);
void reel_stop (struct reel *r);
void reel_invisible_render_cb (struct reel *r, int force);
/***********************************************************************
 * 
 * PERSISTENZEN
 *
 ***********************************************************************/

struct invisible_persistent
{
  const char *uniq_id;
  int *value;
};

/***********************************************************************
 * 
 * STATISTIK
 * 
 ***********************************************************************/

#define BIGWIN_BUFSZ (40)

#define BIGWIN_STORE (40)

struct stat_bigwin
{
  time_t when;
  char text[BIGWIN_BUFSZ];
};

struct stat_part
{
  int games;
  int games_won;
  int bet;
  int won;
};

struct machine_stat
{
  struct stat_part overall;
  struct stat_part session;
  int played;
  struct stat_bigwin bigwin[BIGWIN_STORE];
};

void register_bigwin (const char *fmt, ...);

/***********************************************************************
 *
 * SIMULATION
 *
 ***********************************************************************/

typedef struct machine *machine_t;

struct simstrat
{
  const char *name;
  const char *description;
  int (*bet_f) (machine_t md);
  void (*before_start_f) (machine_t md, int *hold_reel_flags);
  void (*after_stop_f) (machine_t md, int *start_again_flags); 
};

extern struct simstrat default_sim;

/***********************************************************************
 *
 * SPIELGERÄT
 *
 ***********************************************************************/

enum
  {
    MFL_PLAYABLE = (1UL << 0),
    MFL_DEBUG = (1UL << 1),
    MFL_WANTPAYOUT = (1UL << 2),
    MFL_WANTQUIT = (1UL << 3),
    MFL_DONE = (1UL << 4),
    MFL_SIMULATED = (1UL << 5),
    MFL_CHEATED = (1UL << 6),
    MFL_FILEMISS = (1UL << 7),
    MFL_INITCHECK = (1UL << 8),
    MFL_USER = (1UL << 12)
  };

enum 
  {
    A_001 = (1UL << 1),  
    A_002 = (1UL << 2),  
    A_005 = (1UL << 3),  
    A_010 = (1UL << 4),  
    A_020 = (1UL << 5),  
    A_050 = (1UL << 6),  
    A_100 = (1UL << 7),  
    A_200 = (1UL << 8),  
    A_500 = (1UL << 9),  
    A_EURO = (A_010 | A_020 | A_050 | A_100 | A_200),
    A_DEM = (A_010 | A_050 | A_100 | A_200 | A_500),
    A_NULL = 0
  };

enum 
  {
    PREVIEW_W = 210, 
    PREVIEW_H = 300  
  };

struct machine
{
  const char *uniq_id;
  const char *name;
  const char *desc;
  const char *version;
  const char *version_id;
  void (*format_money_f) (unsigned bufsz, char *buf, int value);
  unsigned bet;
  unsigned default_bet;
  BITMAP *preview_image; 
  unsigned long flags;
  unsigned long coinaccept;
  int n_files;
  char **filenames;
  unsigned n_vbms;
  struct variable_bitmap *v_vbms;
  unsigned n_counters;
  struct counter *v_counters;
  unsigned n_reels;
  struct reel *v_reels;
  unsigned n_strategies;
  struct simstrat *v_strategies;
  int (*initcheck_f) (void);
  int (*wincheck_f) (machine_t md);
  void (*init_f) (machine_t md, remember_t rmb);
  void (*startaction_f) (machine_t md);
  void (*endaction_f) (machine_t md);
  void (*graphic_init_f) (machine_t md, remember_t rmb);
  void (*cleanup_f) (machine_t md, remember_t rmb);
  void (*before_render_f) (machine_t md);
  void (*after_render_f) (machine_t md);
  void (*timer_f) (machine_t md, unsigned timer);
  void (*key_f) (machine_t md, int keycode, int scancode);
  void (*wantquit_f) (machine_t md);
  void (*winhandler_f) (machine_t md, int win);
  struct counter *credit_counter;
  unsigned n_invisibles;
  struct invisible_persistent *v_invisibles;
};

#define machine_is_debug(MD)                    \
  (((MD)->flags & MFL_DEBUG) != 0)

#define machine_is_simulated(MD)                \
  (((MD)->flags & MFL_SIMULATED) != 0)

#define machine_plays_for_real(MD)              \
  (((MD)->flags & MFL_SIMULATED) == 0)

#define machine_is_cheated(MD)                  \
  (((MD)->flags & MFL_CHEATED) != 0)

#define machine_want_payout(MD)                 \
  (((MD)->flags & MFL_WANTPAYOUT) != 0)

void machine_precheck (machine_t md);
struct machine_stat *machine_play (machine_t md);
struct stat_part *machine_simulate (machine_t md, 
                                    struct simstrat *strat,
                                    unsigned n,
                                    int (*sim_cb) (unsigned n, int win));
void machine_bet (machine_t md, unsigned bet);
void machine_wincheck (machine_t md);
void machine_quit_check (machine_t md);
#define machine_is_quitting(MD)         \
  (((MD)->flags & (MFL_WANTQUIT | MFL_DONE)) != 0)

void machine_start_action (machine_t md);
void machine_end_action (machine_t md);
#define machine_credit_add(M, ADD)              \
  (cnt_add ((M)->credit_counter, (ADD)))

#define machine_credit_sub(M, SUB)              \
  (machine_credit_add ((M), -(SUB)))

#define machine_coinin(M, CIN)                  \
  (cnt_add ((M)->credit_counter, (CIN)))

#define machine_credit(M)                       \
  ((M)->credit_counter->value)

void machine_payout_ex (machine_t md, int amount);
#define machine_payout(M)                       \
  (machine_payout_ex ((M), machine_credit (M)))

#define machine_payout_remain(M, REMAIN)                \
  do {                                                  \
    int amount = machine_credit ((M)) - (REMAIN);       \
    if (amount > 0)                                     \
      machine_payout_ex ((M), amount);                  \
  } while (0);

int m_all_files_exist (unsigned n, char **filenames);
DATAFILE * _internal_load_datafile (const char *filename);
DATAFILE *m_load_datafile (remember_t rmb, const char *filename);
struct stat_bigwin *m_bigwin_stats (const char *uniq_id);
struct stat_part *m_overall_stats (const char *uniq_id);
int m_machine_started (const char *uniq_id);
void m_cb_wantquit_setflag (machine_t md);
void m_cb_format_dem (unsigned bufsz, char *buf, int value);
void m_cb_format_eur (unsigned bufsz, char *buf, int value);
void m_cb_format_generic (unsigned bufsz, char *buf, int value);
void m_reel_positions (machine_t md, ...);

#define m_saverect(BM, X, Y)                    \
  drect_saverect ((BM), (X) + XOF, (Y) + YOF)

#define m_blitfull(BM, X, Y)                    \
  drect_blitfull ((BM), (X) + XOF, (Y) + YOF)

#define m_blit(BM, SX, SY, DX, DY, W, H)        \
  drect_blit ((BM), (SX), (SY), (DX) + XOF, (DY) + YOF, (W), (H))

#define m_sprite(BM, X, Y)                      \
  drect_sprite ((BM), (X) + XOF, (Y) + YOF)

#define m_stretch_sprite(BM, X, Y, W, H)        \
  drect_sprite ((BM), (X) + XOF, (Y) + YOF, (W), (H))

#define m_rle_sprite(RLE, X, Y)                 \
  drect_rle_sprite ((RLE), (X) + XOF, (Y) + YOF)

#define m_trans_rle_sprite(RLE, X, Y)           \
  drect_trans_rle_sprite ((RLE), (X) + XOF, (Y) + YOF)

#define m_text(FNT, STR, X, Y, FG, BG)          \
  drect_text ((FNT), (STR), (X) + XOF, (Y) + YOF, FG, BG)

#define m_ctext(FNT, STR, X, Y, FG, BG)         \
  drect_ctext ((FNT), (STR), (X) + XOF, (Y) + YOF, FG, BG)

#define m_rtext(FNT, STR, X, Y, FG, BG)         \
  drect_rtext ((FNT), (STR), (X) + XOF, (Y) + YOF, FG, BG)

#define m_drawbox(X, Y, W, H, C)                \
  drect_drawbox ((X) + XOF, (Y) + YOF, W, H, C)

#define m_fillbox(X, Y, W, H, C)                \
  drect_fillbox ((X) + XOF, (Y) + YOF, W, H, C)

/***********************************************************************
 *
 * SAMPLE-LOOP
 *
 ***********************************************************************/

struct sample_loop
{
  SAMPLE *smp;
  int vol;
  int pan;
  int freq;
  int playing;
};

void smploop_start (struct sample_loop *sl);
void smploop_stop (struct sample_loop *sl);


/***********************************************************************
 *
 * PROGRAMMSTEUERUNG
 *
 ***********************************************************************/

typedef void (*prg_p0cb_t) (void);
typedef void (*prg_p1cb_t) (void *p1);
typedef void (*prg_p2cb_t) (void *p1, void *p2);
typedef void (*prg_picb_t) (void *ptr, int i);
void prg_clear (void);
void prg_add (unsigned time_when, prg_p0cb_t cb);
void prg_add_1param (unsigned time_when, prg_p1cb_t cb, void *p1);
void prg_add_2param (unsigned time_when, prg_p2cb_t cb, void *p1, void *p2);
void prg_add_piparam (unsigned time_when, prg_picb_t cb, void *ptr, int i);
#define prg_reset_timer(WHEN)                   \
  prg_add ((WHEN), reset_timer)

#define prg_start_reel(WHEN, REEL)                              \
  prg_add_1param ((WHEN), (prg_p1cb_t) reel_start, (REEL))

#define prg_stop_reel(WHEN, REEL)                                       \
  prg_add_1param ((WHEN), (prg_p1cb_t) reel_stop, (REEL))

#define prg_vbm_set(WHEN, VBM, NEWVAL)                                  \
  prg_add_piparam ((WHEN), (prg_picb_t) vbm_set, (VBM), (NEWVAL))

#define prg_smploop_start(WHEN, SMPLOOP)                                \
  prg_add_1param ((WHEN), (prg_p1cb_t) smploop_start, (SMPLOOP))

#define prg_smploop_stop(WHEN, SMPLOOP)                         \
  prg_add_1param ((WHEN), (prg_p1cb_t) smploop_stop, (SMPLOOP))

void prg_endgame_action (unsigned when, machine_t md);
void prg_default_bet (unsigned when, machine_t md);
void prg_bet (unsigned when, machine_t md, int amount);
void prg_startgame_action (unsigned when, machine_t md);
#define prg_startgame_loop(WHEN, MD)            \
  do {                                          \
    timer_reset ();                             \
    prg_startgame_action ((WHEN), (MD));        \
  } while (0)                                   \

#define prg_quitcheck(WHEN, MD)                                 \
  prg_add_1param ((WHEN), (prg_p1cb_t) machine_quitcheck, (MD))

#define prg_wincheck(WHEN, MD)                                  \
  prg_add_1param ((WHEN), (prg_p1cb_t) machine_wincheck, (MD))

#endif /* _ELEMENTS_H */