source: abuse/trunk/src/scene.cpp @ 541 Tweet

/*
 *  Abuse - dark 2D side-scrolling platform game
 *  Copyright (c) 1995 Crack dot Com
 *  Copyright (c) 2005-2011 Sam Hocevar <sam@hocevar.net>
 *
 *  This software was released into the Public Domain. As with most public
 *  domain software, no warranty is made or implied by Crack dot Com or
 *  Jonathan Clark.
 */

#include "config.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <fcntl.h>

#include "specs.h"
#include "jwindow.h"
#include "fonts.h"
#include "timing.h"
#include "scene.h"
#include "game.h"
#include "parse.h"
#include "cache.h"


class string_node
{
  string_node *l,*r;
  char *n;
public :
  string_node(char *Name, string_node *Left=NULL, string_node *Right=NULL)
  { l = Left;
    r = Right;
    n = strdup(Name);
  }
  ~string_node() { free(n); }
  char *name() { return n; }
  string_node *left() { return l; }
  string_node *right() { return r; }
} ;


/*class string_tree
{
  string_node *root;
public :
  string_tree() { root=NULL; }
  void insert(char *name);

} ; */



char scene_filename[100];

class scene_frame
{
public :
  int picture;
  long time,xc,yc;

  scene_frame *next;
  scene_frame(char *&s);
  ~scene_frame() { cache.unreg(picture); }
} ;


scene_frame::scene_frame(char *&s)
{
  char tmp_name[50];
  expect(get_token(s,tmp_name),sWORD,s);

  picture=cache.reg(scene_filename,tmp_name);
  if (picture<0)
  {
    printf("Frame image not found (%s)\n",tmp_name);
    exit(0);
  }


  xc=yc=0;
  time=-1;
  if (token_type(s)==sLEFT_PAREN)  // is a descriptor included?
  {
    next_token(s);

    xc=get_number(s);
    if (token_type(s)!=sRIGHT_PAREN)
    {
      yc=get_number(s);
      if (token_type(s)!=sRIGHT_PAREN)
        time=get_number(s);
    }
    expect(get_token(s,tmp_name),sRIGHT_PAREN,s);
  }

  next=NULL;
}



class scene_sequence : public linked_node
{
public :
  char *n;
  scene_frame *first;
  scene_sequence *next;
  scene_sequence(char *&s);
  ~scene_sequence();
} ;



scene_sequence::~scene_sequence()
{ free(n);
  while (first)
  { scene_frame *p=first;
    first=first->next;
    delete p;
  }
}


scene_sequence::scene_sequence(char *&s)
{
  scene_frame *cur;
  char tmp_name[50];
  expect(token_type(s),sLEFT_PAREN,s);
  next_token(s);

  expect(get_token(s,tmp_name),sWORD,s);
  n = strdup(tmp_name);
  cur = first=new scene_frame(s);

  while (token_type(s)!=sRIGHT_PAREN)
  {
    cur->next=new scene_frame(s);
    cur=cur->next;

    next=NULL;
  }
  next_token(s);
  next=NULL;
}


class scene_sequence_list
{
public :
  scene_sequence *first;
  scene_sequence_list(char *&s);
  scene_sequence *get_seq(char *seq_name);
  ~scene_sequence_list();
} ;

scene_sequence_list::~scene_sequence_list()
{
  scene_sequence *p;
  while (first)
  {
    p=first;
    first=first->next;
    delete p;
  }
}

scene_sequence_list::scene_sequence_list(char *&s)
{
  scene_sequence *cur;
  expect(token_type(s),sLEFT_PAREN,s);
  next_token(s);

  cur=first=new scene_sequence(s);
  while (token_type(s)!=sRIGHT_PAREN)
  {
    cur->next=new scene_sequence(s);
    cur=cur->next;
  }
  next_token(s);
}

scene_sequence *scene_sequence_list::get_seq(char *seq_name)
{
  scene_sequence *s=first;
  while (s && strcmp(s->n,seq_name)) s=s->next;
  if (!s)
  {
    printf("No sequence named %s\n",seq_name);
    exit(1);
  }
  return s;
}


class scene_character
{
  scene_sequence_list *seq_list;

  game_object *me;

public :
  char *n;
  scene_character *next;
  scene_sequence *current_seq;
  scene_frame *current_frame;

  time_marker *last_frame;
  void draw();
  void area(int &x1, int &y1, int &x2, int &y2);
  scene_character(char *&s);
  void set_seq(char *seq_name)
  { current_seq=seq_list->get_seq(seq_name); }
  int x() { return the_game->screenx(me->x)-cache.fig(current_frame->picture)->xcfg; }
  int y() { return the_game->screeny(me->y)-cache.fig(current_frame->picture)->forward->height(); }
  int next_frame();  // true if sequence is done
  ~scene_character() { free(n); delete seq_list; if (last_frame) delete last_frame; }
} ;


int scene_character::next_frame()
{
  me->x+=current_frame->xc;
  me->y+=current_frame->yc;

  current_frame=current_frame->next;        // advance the picture

  if (last_frame)                           // save the time stamp, delete old one
    delete last_frame;
  last_frame=new time_marker;

  if (!current_frame)                      // end of sequence?
  {
    current_frame=current_seq->first;       // reset and return 1
    return 1;
  }
  else return 0;
}


void scene_character::area(int &x1, int &y1, int &x2, int &y2)
{

  x1=x();
  y1=y();
  y2=x2=0;

  scene_frame *p=current_seq->first;
  while (p)
  {
    if (x()+cache.fig(p->picture)->width()-1>x2)
      x2=x()+cache.fig(p->picture)->width()-1;
    if (y()+cache.fig(p->picture)->height()-1>y2)
      y2=y()+cache.fig(p->picture)->height()-1;
    p=p->next;
  }
}


void scene_character::draw()
{
  cache.fig(current_frame->picture)->forward->put_image(screen,x(),y());

}


scene_character::scene_character(char *&s)
{
  char tmp[100];
  expect(get_token(s,tmp),sLEFT_PAREN,s);
  expect(get_token(s,tmp),sWORD,s);
  n = strdup(tmp);
  expect(get_token(s,tmp),sNUMBER,s);

/*  if (atoi(tmp)==0) */

  me=current_level->main_character();


  seq_list=new scene_sequence_list(s);
  current_seq=seq_list->first;
  current_frame=current_seq->first;
  expect(get_token(s,tmp),sRIGHT_PAREN,s);

  last_frame=NULL;
  next=NULL;
}


class scene_character_list
{
public :
  scene_character *first;
  scene_character_list(char *&s);
  void inital_states(char *&s);
  scene_character *get(char *name);
 ~scene_character_list();
} ;

scene_character  *scene_character_list::get(char *name)
{
  scene_character *s=first;
  while (s)
  {
    if (!strcmp(s->n,name)) return s;
    s=s->next;
  }
  printf("Character %s not found!\n",name);
  exit(1);
}


scene_character_list::~scene_character_list()
{
  scene_character *p;
  while (first)
  {
    p=first;
    first=first->next;
    delete p;
  }
}

scene_character_list::scene_character_list(char *&s)
{
  scene_character *cur;
  expect(token_type(s),sLEFT_PAREN,s);
  next_token(s);

  cur=first=new scene_character(s);

  while (token_type(s)!=sRIGHT_PAREN)
  {
    cur->next=new scene_character(s);
    cur=cur->next;
  }
  next_token(s);
}


void scene_character_list::inital_states(char *&s)
{
  char ch[50],seq[50];

  do
  {
    expect(get_token(s,ch),sLEFT_PAREN,s);
    expect(get_token(s,ch),sWORD,s);
    expect(get_token(s,seq),sWORD,s);
    scene_character *c=first;
    while (c && strcmp(c->n,ch)) c=c->next;
    if (!c)
    {
      printf("No character named %s, at %s\n",ch,s);
      exit(0);
    } else c->set_seq(seq);
    expect(get_token(s,ch),sRIGHT_PAREN,s);
  } while (token_type(s)!=sRIGHT_PAREN);
}

class text_blocker
{
public :
  int x1,y1,x2,y2;
  text_blocker *next;
  text_blocker(int X1, int Y1, int X2, int Y2, text_blocker *Next)
  { x1=X1;
    y1=Y1;
    x2=X2;
    y2=Y2;
    next=Next;
  }
} ;


int text_draw(int y, int x1, int y1, int x2, int y2, char const *buf,
          text_blocker *first, JCFont *font)
{
  int cx1, cy1, cx2, cy2, word_size, word_len;
  screen->GetClip(cx1, cy1, cx2, cy2);
  screen->InClip(x1,y1,x2+1,y2+1);
  int h=font->height()+2,w=font->width(),x=x1,dist;
  y+=y1;
  char const *word_start;

  while (*buf)
  {
    do
    {
      if (*buf=='\\' && buf[1]=='n')
      {
    x=x1;
    y+=h*2;
    buf+=2;
      }

      // skip space
      if (*buf==' ' || *buf=='\r' || *buf=='\n' || *buf=='\t')
      {
    x+=w;
    while (*buf==' ' || *buf=='\r' || *buf=='\n' || *buf=='\t')   // skip space until next word
          buf++;
      }

      word_start=buf;
      for (word_len=0,word_start=buf,word_size=0; *buf && *buf!=' ' && *buf!='\r' && *buf!='\n' &&
       *buf!='\t' && (*buf!='\\' || buf[1]!='n'); buf++,word_size+=w,word_len++);

      if (word_size<x2-x1) // make sure the word can fit on the screen
      {
    if (word_size+x>x2)    // does word not fit on line?
    {
      y+=h;                // go to next line
      x=x1;
    }
      }


      if (y+h<y1)         // word on screen yet?
    x+=word_size;

    } while (y+h<y1);     // if not on screen yet, fetch next word

/*    dist=100;
    for (n=first; n; n=n->next)
    {
      if (x<n->x1)
        minx=(n->x1-x);
      else if (x>n->x2)
        minx=(x-n->x2);
      else minx=0;

      if (y<n->y1)
        miny=(n->y1-y);
      else if (y>n->y2)
        miny=(y-n->y2);
      else miny=0;

      dist=min(dist,max(minx,miny));
    }


    if (dist<=8) dist=8;
    else if (dist>31) dist=31;      */

    dist=31;
    if (y-y1<dist)
      if (y-y1<8) dist=8;
      else dist=y-y1;
    if (y2-y<dist)
      if (y2-y<8) dist=8;
      else dist=y2-y;

    if (y>y2) return 0;

    while (word_len--)
    {
      font->put_char(screen,x+1,y+1,*word_start,0);
      font->put_char(screen,x,y,*word_start,32-dist);
      word_start++;
      x+=w;
    }

  }

  screen->SetClip(cx1, cy1, cx2, cy2);
  return (y<=y1);
}


struct scene_data_struct       // define a name for the structure so that we can inspect in gdb
{
  int x1,y1,x2,y2,
      pan_vx,pan_yv,pan_steps,
      frame_speed,scroll_speed,pan_speed;
} scene_data;





void play_scene(char *script, char *filename, JCFont *font)
{
  char *s=script;
  char token[90];
  text_blocker *text_blockers=NULL;

  char *strng=(char *)malloc(MAX_SCROLL_DATA);
  strcpy(scene_filename,filename);

  int x1,y1,x2,y2,done,pan_xv=0,pan_yv=0,pan_steps=0,
      text_loaded=0,frame_speed=100,scroll_speed=50,pan_speed=60,abort=0,text_step=-2;

  int cx1, cy1, cx2, cy2;

  the_game->draw(1);

  screen->GetClip(cx1, cy1, cx2, cy2);
  screen->SetClip(the_game->viewx1, the_game->viewy1,
                   the_game->viewx2 + 1, the_game->viewy2 + 1);




  expect(get_token(s,token),sLEFT_PAREN,s);
  scene_character_list cl(s);
  int y;

  do
  {
    expect(get_token(s,token),sLEFT_PAREN,s);   // list of transitions start
    // ACTIONS
    time_marker *last_text_time=NULL;
    time_marker *last_pan_time=NULL;
    do
    {
      expect(get_token(s,token),sLEFT_PAREN,s);
      expect(get_token(s,token),sWORD,s);

      if (!strcmp(token,"pan"))
      {
    pan_xv=get_number(s);
    pan_yv=get_number(s);
        pan_steps=get_number(s);
      }
      else if (!strcmp(token,"states"))
        cl.inital_states(s);
      else if (!strcmp(token,"scroll_speed"))
        scroll_speed=get_number(s);
      else if (!strcmp(token,"pan_speed"))
        pan_speed=get_number(s);
      else if (!strcmp(token,"frame_speed"))
        frame_speed=get_number(s);
      else if (!strcmp(token,"text_region"))
      {
    x1=the_game->viewx1+get_number(s);
    y1=the_game->viewy1+get_number(s);
    x2=the_game->viewx1+get_number(s);
    y2=the_game->viewy1+get_number(s);
    y=y2-y1;
      } else if (!strcmp(token,"text_block"))
      {
    int sx1=get_number(s)+the_game->viewx1;
    int sy1=get_number(s)+the_game->viewy1;
    int sx2=get_number(s)+the_game->viewx1;
    int sy2=get_number(s)+the_game->viewy1;
    text_blockers=new text_blocker(sx1,sy1,sx2,sy2,text_blockers);
      } else if (!strcmp(token,"block"))
      {
    int sx1,sy1,sx2,sy2;
    expect(get_token(s,token),sWORD,s);
    cl.get(token)->area(sx1,sy1,sx2,sy2);
    text_blockers=new text_blocker(sx1,sy1,sx2,sy2,text_blockers);
      }
      else if (!strcmp(token,"scroll"))
      {
    expect(get_token(s,strng),sSTRING,s);
    text_loaded=1;
    y=y2-y1;
      } else if (!strcmp(token,"wait"))
      {
    expect(get_token(s,token),sWORD,s);
    printf("waiting for %s\n",token);
    done=0;




    int old_dev=dev;
    dev=dev&(0xffff-DRAW_PEOPLE_LAYER);


    do
    {
      the_game->draw_map();

      time_marker cur_time;
      if (pan_steps)
      {
        if (last_pan_time)
        {
          if ((int)(cur_time.diff_time(last_pan_time)*1000)>pan_speed)
          {
        the_game->pan(pan_xv,pan_yv);
        pan_steps--;
        delete last_pan_time;
        if (pan_steps)
           last_pan_time=new time_marker;
        else last_pan_time=NULL;
          }
        } else last_pan_time=new time_marker;
      }

      scene_character *first=cl.first;
      while (first)
      {
        first->draw();

        if (!first->last_frame)
          first->last_frame=new time_marker;
        else
        {
          int time=first->current_frame->time,advance=0;
          if (time>=0)
          {
             if ((int)(cur_time.diff_time(first->last_frame)*1000)>time)
          advance=1;
          }
          else
          {
        if ((int)(cur_time.diff_time(first->last_frame)*1000)>frame_speed)
          advance=1;
          }

          if (advance)
          {
            if (!strcmp(token,first->n))      // is this the character we are waiting on?
        {
              if (first->next_frame())
            done=1;
        } else first->next_frame();
          }
        }
        first=first->next;
      }
      if (text_loaded)
      {
        text_loaded=(!text_draw(y,x1,y1,x2,y2,strng,text_blockers,font));
        if (last_text_time)
        {
          if ((int)(cur_time.diff_time(last_text_time)*1000)>scroll_speed)
          {
              y+=text_step;
            delete last_text_time;
        if (text_loaded)
          last_text_time=new time_marker;
        else
          last_text_time=NULL;
          }
        } else last_text_time=new time_marker;
      }



      if (!strcmp(token,"pan"))
        if (pan_steps<=0) done=1;

      if (!strcmp(token,"text"))
        if (!text_loaded) done=1;

      wm->flush_screen();
      while (wm->event_waiting())
      {
        event ev;
        wm->get_event(ev);
        if (ev.type==EV_KEY)
        {
          switch (ev.key)
          {
            case JK_UP :
            case JK_LEFT :
          if (scroll_speed>=20)
            scroll_speed-=20;
          else text_step--;
          break;
        case JK_RIGHT :
        case JK_DOWN :
          if (text_step<-2)
            text_step++;
          else if (scroll_speed<200) scroll_speed+=20;
          break;
        case JK_ESC : abort=done=1; break;
        case JK_ENTER : done=1; break;
          }
        }
      }


    } while (!done);
    dev=old_dev;
      }

      expect(get_token(s,token),sRIGHT_PAREN,s);

    } while (!abort && token_type(s)!=sRIGHT_PAREN);


    if (!abort)
      next_token(s);

    // free up memory allocated
    while (text_blockers)
    {
      text_blocker *n=text_blockers->next;
      delete text_blockers;
      text_blockers=n;
    }
    if (last_text_time)
      delete last_text_time;
    if (last_pan_time)
      delete last_pan_time;

  } while (!abort && token_type(s)!=sRIGHT_PAREN);
  if (!abort)
    next_token(s);

  free(strng);
  screen->SetClip(cx1, cy1, cx2, cy2);

  the_game->draw(0);
}