mlsscript.cpp

[游戏开发参考书-用DirectX编写RPG游戏]这是一个系列的丛书如果你都看并且懂的话你就可以你工作啦！

          sINTEntry *Ptr = (sINTEntry*)Action->Entries[i].Data;

          // Get min value
          GetNextWord(Text, fp, 2048);
          Ptr->Min = atol(Text);

          // Get max value
          GetNextWord(Text, fp, 2048);
          Ptr->Max = atol(Text);

          // Reset value to min
          Ptr->Value = Ptr->Min;
        } else

        // FLOAT type, get min and max values
        if(!stricmp(Text, "FLOAT")) {
          // Set to FLOAT type and allocate FLOAT entry
          Action->Entries[i].Type = _FLOAT;
          Action->Entries[i].Data = (void*)new sFLOATEntry();
          sFLOATEntry *Ptr = (sFLOATEntry*)Action->Entries[i].Data;

          // Get min value
          GetNextWord(Text, fp, 2048);
          Ptr->Min = (float)atof(Text);

          // Get max value
          GetNextWord(Text, fp, 2048);
          Ptr->Max = (float)atof(Text);

          // Reset value to min
          Ptr->Value = Ptr->Min;
        } else

        // BOOL type, no options
        if(!stricmp(Text, "BOOL")) {
          // Set to BOOL type and allocate BOOL entry
          Action->Entries[i].Type = _BOOL;
          Action->Entries[i].Data = (void*)new sBOOLEntry();
          sBOOLEntry *Ptr = (sBOOLEntry*)Action->Entries[i].Data;

          // Set value to TRUE
          Ptr->Value = TRUE;
        } else

        // CHOICE type, get number of entries and entry's texts
        if(!stricmp(Text, "CHOICE")) {
          // Set to CHOICE type and allocate CHOICE entry
          Action->Entries[i].Type = _CHOICE;
          Action->Entries[i].Data = (void*)new sCHOICEEntry();
          sCHOICEEntry *Ptr = (sCHOICEEntry*)Action->Entries[i].Data;

          // Get the number of choices
          GetNextWord(Text, fp, 1024);
          Ptr->Num = atol(Text);
          Ptr->Text = new char*[Ptr->Num];

          // Get each entry text
          for(j=0;j<Ptr->Num;j++) {
            Ptr->Text[j] = new char[256];
            GetNextQuotedLine(Ptr->Text[j], fp, 256);
          }

          // Set choice to 1st
          Ptr->Selection = 0;
        }
      }
    }
  }
  
  fclose(fp);

  return TRUE;
}

BOOL cMLSScript::FreeActions()
{
  delete m_ActionParent;
  m_ActionParent = NULL;
  m_NumActions = 0;

  return TRUE;
}

BOOL cMLSScript::GetNextQuotedLine(char *Data, FILE *fp, long MaxSize)
{
  int c;
  long Pos = 0;
  
  // Read until a quote is reached (or EOF)
  while(1) {
    if((c = fgetc(fp)) == EOF)
      return FALSE;

    if(c == '"') {
      // Read until next quote (or EOF)
      while(1) {
        if((c = fgetc(fp)) == EOF)
          return FALSE;

        // Return text when 2nd quote found
        if(c == '"') {
          Data[Pos] = 0;
          return TRUE;
        }

        // Add acceptable text to line
        if(c != 0x0a && c != 0x0d) {
          if(Pos < MaxSize-1)
            Data[Pos++] = c;
        }
      }
    }
  }
}

BOOL cMLSScript::GetNextWord(char *Data, FILE *fp, long MaxSize)
{
  int  c;
  long Pos = 0;

  // Reset word to empty
  Data[0] = 0;

  // Read until an acceptable character found
  while(1) {
    if((c = fgetc(fp)) == EOF) {
      Data[0] = 0;
      return FALSE;
    }

    // Check for start of word
    if(c != 32 && c != 0x0a && c != 0x0d) {
      Data[Pos++] = c;

      // Loop until end of word (or EOF)
      while((c=fgetc(fp)) != EOF) {
        // Break on acceptable word seperators
        if(c == 32 || c == 0x0a || c == 0x0d)
          break;

        // Add if enough room left
        if(Pos < MaxSize-1)
          Data[Pos++] = c;
      }

      // Add end of line to text
      Data[Pos] = 0;

      return TRUE;
    }
  }
}

long cMLSScript::GetNumActions()
{
  return m_NumActions;
}

sAction *cMLSScript::GetActionParent()
{
  return m_ActionParent;
}

sAction *cMLSScript::GetAction(long Num)
{
  long i;
  sAction *Ptr;

  if(Num >= m_NumActions)
    return NULL;

  Ptr = m_ActionParent;
  for(i=0;i<(m_NumActions-Num-1);i++)
    Ptr = Ptr->Next;

  return Ptr;
}

BOOL cMLSScript::ExpandDefaultActionText(char *Buffer, sAction *Action)
{
  long i, Pos, Num;
  char Text[256];

  // Copy action text into buffer if no Entries
  if(!Action->NumEntries) {
    strcpy(Buffer, Action->Text);
    return TRUE;
  }
  
  // Expand Entry types into action text
  Pos = 0;
  Num = 0;
  for(i=0;i<(long)strlen(Action->Text);i++) {

    // Expand the Entry into text based on values, text, etc
    if(Action->Text[i] == '~') {

      if(Action->Entries[Num].Type == _TEXT) {
        memcpy(&Buffer[Pos], "(*TEXT*)", 8);
        Pos += 8;
      } else 

      if(Action->Entries[Num].Type == _INT) {
        sINTEntry *Ptr = (sINTEntry*)Action->Entries[Num].Data;
        sprintf(Text, "(*%lu*)", Ptr->Min);
        memcpy(&Buffer[Pos], Text, strlen(Text));
        Pos += strlen(Text);
      } else

      if(Action->Entries[Num].Type == _FLOAT) {
        sFLOATEntry *Ptr = (sFLOATEntry*)Action->Entries[Num].Data;
        sprintf(Text, "(*%lf*)", Ptr->Min);
        memcpy(&Buffer[Pos], Text, strlen(Text));
        Pos += strlen(Text);
      } else

      if(Action->Entries[Num].Type == _BOOL) {
        memcpy(&Buffer[Pos], "(*TRUE*)", 7);
        Pos += 7;
      } else

      if(Action->Entries[Num].Type == _CHOICE) {
        sCHOICEEntry *Ptr = (sCHOICEEntry*)Action->Entries[Num].Data;
        memcpy(&Buffer[Pos], "(*", 2);
        Pos+=2;
        memcpy(&Buffer[Pos], Ptr->Text[0], strlen(Ptr->Text[0]));
        Pos += strlen(Ptr->Text[0]);
        memcpy(&Buffer[Pos], "*)", 2);
        Pos+=2;
      }

      Num++;
    } else {
      Buffer[Pos++] = Action->Text[i];
    }
  }
  Buffer[Pos] = 0;

  return TRUE;
}

BOOL cMLSScript::ExpandActionText(char *Buffer, sAction *Action)
{
  long i, j, Pos, Num;
  char Text[256];

  // Copy action text into buffer if no Entries
  if(!Action->NumEntries) {
    strcpy(Buffer, Action->Text);
    return TRUE;
  }
  
  // Expand Entry types into action text
  Pos = 0;
  Num = 0;

  for(i=0;i<(long)strlen(Action->Text);i++) {

    // Expand the Entry into text based on values, text, etc
    if(Action->Text[i] == '~') {

      if(Action->Entries[Num].Type == _TEXT) {
        sTEXTEntry *Ptr = (sTEXTEntry*)Action->Entries[Num].Data;

        // Prefix characters
        memcpy(&Buffer[Pos], "(*", 2);
        Pos+=2;

        // Copy over at most 16 characters
        for(j=0;j<16;j++) {
          if(!Ptr->Text[j])
            break;

          Buffer[Pos++] = Ptr->Text[j];
        }

        // Append characters
        memcpy(&Buffer[Pos], "*)", 2);
        Pos+=2;
      } else 

      if(Action->Entries[Num].Type == _INT) {
        sINTEntry *Ptr = (sINTEntry*)Action->Entries[Num].Data;
        sprintf(Text, "(*%lu*)", Ptr->Value);
        memcpy(&Buffer[Pos], Text, strlen(Text));
        Pos += strlen(Text);
      } else

      if(Action->Entries[Num].Type == _FLOAT) {
        sFLOATEntry *Ptr = (sFLOATEntry*)Action->Entries[Num].Data;
        sprintf(Text, "(*%lf*)", Ptr->Value);
        memcpy(&Buffer[Pos], Text, strlen(Text));
        Pos += strlen(Text);
      } else

      if(Action->Entries[Num].Type == _BOOL) {
        sBOOLEntry *Ptr = (sBOOLEntry*)Action->Entries[Num].Data;
        if(Ptr->Value == TRUE)
          memcpy(&Buffer[Pos], "(*TRUE *)", 8);
        else
          memcpy(&Buffer[Pos], "(*FALSE*)", 8);
        Pos += 8;
      } else

      if(Action->Entries[Num].Type == _CHOICE) {
        sCHOICEEntry *Ptr = (sCHOICEEntry*)Action->Entries[Num].Data;
        memcpy(&Buffer[Pos], "(*", 2);
        Pos+=2;
        memcpy(&Buffer[Pos], Ptr->Text[Ptr->Selection], strlen(Ptr->Text[Ptr->Selection]));
        Pos += strlen(Ptr->Text[Ptr->Selection]);
        memcpy(&Buffer[Pos], "*)", 2);
        Pos+=2;
      }

      Num++;
    } else {
      Buffer[Pos++] = Action->Text[i];
    }
  }
  Buffer[Pos] = 0;

  return TRUE;
}