cromer
/
qt-agistudio
1
0
Fork 0
Code Issues Pull Requests Releases 2 Wiki Activity
qt-agistudio/src/words.cpp

528 lines
15 KiB
C++
Raw Blame History

/*
* QT AGI Studio :: Copyright (C) 2000 Helen Zommer
*
* Almost all of this code was adapted from the Windows AGI Studio
* developed by Peter Kelly.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include "game.h"
#include "words.h"
#include "menu.h"
#include "wordsedit.h"
#include <stdio.h>
#include <sys/types.h>
#ifndef _WIN32
#include <unistd.h>
#endif
#include <sys/stat.h>
#include <stdlib.h>
#include <ctype.h>
static TWordGroup NewWordGroup[MaxWordGroups];
static int ResPos;
static bool EndOfFileReached;
//***************************************************
WordList::WordList()
{
}
//***************************************************
static byte ReadByte(void)
{
byte ret;
if(ResPos < ResourceData.Size){
ret = ResourceData.Data[ResPos];
ResPos++;
}
else{
ret = 0;
EndOfFileReached = true;
}
return ret;
}
//***************************************************
static int ReadMSLSWord(void)
{
byte MSbyte,LSbyte;
MSbyte = ReadByte();
LSbyte = ReadByte();
return (MSbyte*256 + LSbyte);
}
//***************************************************
int WordList::GetNew_GroupIndex(int GroupNum)
{
int CurIndex;
if (NumGroups > 0){
for(CurIndex = 0; CurIndex < NumGroups; CurIndex++){
if (NewWordGroup[CurIndex].GroupNum == GroupNum){
return CurIndex;
}
}
}
return -1;
}
//************************************************
int WordList::GetWordGroupIndex(int GroupNum)
{
int CurIndex;
if (NumGroups > 0){
for (CurIndex = 0;CurIndex<NumGroups;CurIndex++){
if (WordGroup[CurIndex].GroupNum == GroupNum)
return CurIndex;
}
}
return -1;
}
//************************************************
static string GetWord(string s)
//returns the part of a string before the last ' '
{
int pos = s.find_last_of(' ');
return s.substr(0,pos);
}
static int GetGroupNum(string s)
//returns the number after the last ' ' in a string
{
int pos = s.find_last_of(' ');
return atoi(s.substr(pos+1).c_str());
}
//************************************************
int WordList::read(char *filename)
{
string CurWord,PrevWord;
byte CurByte,CharsFromPrevWord;
int CurIndex,CurAddGroup,GroupIndex,GroupNum;
int LowestRemainingGroup,SecondLowestRemainingGroup,SecondLowestRemainingGroupIndex=0;
int GroupAddOrder[MaxWordGroups];
FILE *fptr=fopen(filename,"rb");
if(fptr==NULL){
menu->errmes("Error opening file %s",filename);
return 1;
}
struct stat buf;
fstat(fileno(fptr),&buf);
int size=buf.st_size;
if(size > MaxResourceSize){
menu->errmes("Error: File %s is too big (>%d bytes)",filename,MaxResourceSize);
return 1;
}
EndOfFileReached = false;
ResourceData.Size=size;
fread(ResourceData.Data,size,1,fptr);
fclose(fptr);
NumGroups = 0;
ResPos = 0;
ResPos = ReadMSLSWord(); //start of words section
PrevWord = "";
do{
CurWord = "";
CharsFromPrevWord = ReadByte();
if (CharsFromPrevWord > PrevWord.length()){
CharsFromPrevWord = PrevWord.length();
}
if (CharsFromPrevWord > 0){
CurWord = PrevWord.substr(0,CharsFromPrevWord);
}
do{
CurByte = ReadByte();
if (CurByte < 0x80)CurWord += (CurByte ^ 0x7f);
}while(CurByte < 0x80 && !EndOfFileReached);
//we must check for end of file, otherwise if the file is invalid, the
//program may read indefinitely.
if(EndOfFileReached){
menu->errmes("Error! Invalid WORDS.TOK file.");
return 1;
}
CurWord += (0x7F ^ (CurByte-0x80));
GroupNum = ReadMSLSWord();
if (CurWord != PrevWord){ //this word different to previous, so add it
//in this way, no duplicates are added
GroupIndex = GetNew_GroupIndex(GroupNum);
if (GroupIndex >= 0){ //group exists
NewWordGroup[GroupIndex].Words.add(CurWord);
}
else{
if (NumGroups >= MaxWordGroups){
menu->errmes("Error ! Too many groups !");
return 1;
}
NumGroups++;
NewWordGroup[NumGroups-1].GroupNum = GroupNum;
NewWordGroup[NumGroups-1].Words = TStringList();
NewWordGroup[NumGroups-1].Words.add(CurWord);
}//group doesn't exist - create new one
PrevWord = CurWord;
}
CurByte = ReadByte();
if (CurByte == 0 && ResPos >= ResourceData.Size-1) EndOfFileReached = true;
else ResPos--;
}while(!EndOfFileReached);
LowestRemainingGroup = -1;
for (CurAddGroup = 0; CurAddGroup < NumGroups; CurAddGroup++){
SecondLowestRemainingGroup = 65536;
for (CurIndex = 0; CurIndex < NumGroups; CurIndex++){
if (NewWordGroup[CurIndex].GroupNum < SecondLowestRemainingGroup &&
NewWordGroup[CurIndex].GroupNum > LowestRemainingGroup){
SecondLowestRemainingGroup = NewWordGroup[CurIndex].GroupNum;
SecondLowestRemainingGroupIndex = CurIndex;
}
}
GroupAddOrder[CurAddGroup] = SecondLowestRemainingGroupIndex;
LowestRemainingGroup = SecondLowestRemainingGroup;
}
for (CurIndex = 0; CurIndex < NumGroups; CurIndex++){
WordGroup[CurIndex].GroupNum = NewWordGroup[GroupAddOrder[CurIndex]].GroupNum;
WordGroup[CurIndex].Words.lfree();
WordGroup[CurIndex].Words.copy(NewWordGroup[GroupAddOrder[CurIndex]].Words);
NewWordGroup[GroupAddOrder[CurIndex]].Words.lfree();
}
return 0;
}
//**************************************************
void WordList::clear()
{
for (int i = 0;i< NumGroups;i++){
WordGroup[i].Words.lfree();
}
NumGroups = 3;
WordGroup[0].GroupNum = 0;
WordGroup[0].Words = TStringList();
WordGroup[0].Words.add("a");
WordGroup[1].GroupNum = 1;
WordGroup[1].Words = TStringList();
WordGroup[1].Words.add("anyword");
WordGroup[2].GroupNum = 9999;
WordGroup[2].Words = TStringList();
WordGroup[2].Words.add("rol");
}
//**************************************************
int WordList::save(char *filename)
{
FILE *fptr;
int CurGroupIndex,NumEmptyWordGroups;
int CurWord,CurChar;
byte CurByte;
int LetterLoc[28];
string ThisWord,PrevWord;
int CurFirstLetter;
char FirstLetter;
int ThisGroupNum;
byte CharsFromPrevWord;
string s;
for(CurGroupIndex=0,NumEmptyWordGroups=0;CurGroupIndex<NumGroups;CurGroupIndex++){
if (WordGroup[CurGroupIndex].Words.num==0){
NumEmptyWordGroups++;
}
}
if (NumEmptyWordGroups > 0){
sprintf(tmp,"Warning: There are %d empty word groups.\nThese will not be saved.",NumEmptyWordGroups);
menu->warnmes(tmp);
}
if((fptr=fopen(filename,"wb"))==NULL){
menu->errmes("Error opening file %s",filename);
return 1;
}
TStringList AllWords = TStringList();
for(CurGroupIndex = 0; CurGroupIndex<NumGroups;CurGroupIndex++){
if (WordGroup[CurGroupIndex].Words.num > 0){
for(CurWord =0;CurWord<WordGroup[CurGroupIndex].Words.num;CurWord++){
s = WordGroup[CurGroupIndex].Words.at(CurWord) + " " + IntToStr(WordGroup[CurGroupIndex].GroupNum);
AllWords.addsorted((char *)s.c_str());
}
}
}
CurByte=0;
fwrite(&CurByte,1,51,fptr);
for (CurFirstLetter = 1;CurFirstLetter <= 26;CurFirstLetter++){
LetterLoc[CurFirstLetter] = 0;
}
FirstLetter = 'a';
LetterLoc[1] = ftell(fptr);
for (CurWord = 0; CurWord < AllWords.num; CurWord++){
ThisWord = GetWord(AllWords.at(CurWord));
if (ThisWord[0] != FirstLetter && ThisWord[0]>=97 && ThisWord[0]<=122){
FirstLetter = ThisWord[0];
LetterLoc[FirstLetter-96] = ftell(fptr);
}
ThisGroupNum = GetGroupNum(AllWords.at(CurWord));
//work out # chars from prev word
CharsFromPrevWord = 0;
CurChar = 0;
bool FinishedComparison = false;
do{
if(CurChar < (int)ThisWord.length() && (int)PrevWord.length() > CurChar && PrevWord[CurChar] == ThisWord[CurChar])
CharsFromPrevWord++;
else FinishedComparison=true;
CurChar++;
}while(! FinishedComparison);
if (CharsFromPrevWord >= ThisWord.length()){
CharsFromPrevWord = ThisWord.length()-1;
}
//write # chars from prev word
fwrite(&CharsFromPrevWord,1,1,fptr);
PrevWord = ThisWord;
ThisWord = ThisWord.substr( CharsFromPrevWord,ThisWord.length()-CharsFromPrevWord);
if (ThisWord.length() > 1){
for(CurChar =0;CurChar <(int)ThisWord.length()-1;CurChar++){
CurByte = 0x7f ^ ThisWord[CurChar];
fwrite(&CurByte,1,1,fptr);
}
}
CurByte = 0x80 + (0x7f ^ ThisWord[ThisWord.length()-1]);
fwrite(&CurByte,1,1,fptr);
//write group number
CurByte = ThisGroupNum / 256;
fwrite(&CurByte,1,1,fptr);
CurByte = ThisGroupNum % 256;
fwrite(&CurByte,1,1,fptr);
}
CurByte = 0;
fwrite(&CurByte,1,1,fptr);
fseek(fptr,0,SEEK_SET);
for(CurFirstLetter = 1;CurFirstLetter <=26;CurFirstLetter++){
CurByte = LetterLoc[CurFirstLetter] / 256;
fwrite(&CurByte,1,1,fptr);
CurByte = LetterLoc[CurFirstLetter] % 256;
fwrite(&CurByte,1,1,fptr);
}
AllWords.lfree();
fclose(fptr);
return 0;
}
//**************************************************
int WordList::add_group(int num)
{
int i;
for (i = 0;i< NumGroups;i++){
if(num == WordGroup[i].GroupNum){
menu->errmes("Group %d already exists.",num);
return -1;
}
if(WordGroup[i].GroupNum > num){
break;
}
}
NumGroups++;
for(int k=NumGroups;k>i;k--){
WordGroup[k]=WordGroup[k-1];
}
WordGroup[i].Words = TStringList();
WordGroup[i].GroupNum = num;
return i;
}
//**************************************************
int WordList::delete_group(int num)
{
for(int i=num;i<NumGroups-1;i++){
WordGroup[i]=WordGroup[i+1];
}
NumGroups--;
return 0;
}
//**************************************************
int WordList::delete_word(char *word,int SelectedGroup)
{
if(SelectedGroup<0)return -1;
for(int k=0;k<WordGroup[SelectedGroup].Words.num;k++){
if(!strcmp(word,WordGroup[SelectedGroup].Words.at(k).c_str())){
WordGroup[SelectedGroup].Words.del(k);
return k;
}
}
return -1;
}
//**************************************************
int WordList::change_number(int oldnum, int newnum)
{
int i;
for (i = 0;i< NumGroups;i++){
if(newnum == WordGroup[i].GroupNum){
menu->errmes("Group %d already exists.",newnum);
return -1;
}
if(WordGroup[i].GroupNum > newnum){
break;
}
}
TStringList cur_g = TStringList();
cur_g.copy(WordGroup[oldnum].Words);
if(oldnum < i){
i--;
for(int k=oldnum;k<i;k++){
WordGroup[k]=WordGroup[k+1];
}
}
else{
for(int k=oldnum;k>i;k--){
WordGroup[k]=WordGroup[k-1];
}
}
WordGroup[i].Words = cur_g;
WordGroup[i].GroupNum = newnum;
return i;
}
//************************************************************
bool WordList::GroupExists(int GroupNum)
{
int CurGroupIndex;
if (NumGroups > 0){
for (CurGroupIndex=0;CurGroupIndex<NumGroups;CurGroupIndex++){
if(WordGroup[CurGroupIndex].GroupNum == GroupNum)return true;
}
}
return false;
}
//************************************************************
bool WordList::InsertWordGroup(int GroupNum)
{
int CurGroupIndex,InsertPosition=0;
bool InsertPositionFound;
if (NumGroups >= MaxWordGroups){
menu->errmes("Error! Too many groups (max %d).",MaxWordGroups);
return false;
}
CurGroupIndex = 0;
InsertPositionFound = false;
do{
if (WordGroup[CurGroupIndex].GroupNum > GroupNum){
InsertPosition = CurGroupIndex;
InsertPositionFound = true;
}
else CurGroupIndex++;
}while(!InsertPositionFound && (CurGroupIndex < NumGroups));
if (CurGroupIndex > NumGroups - 1)InsertPosition = NumGroups;
WordGroup[NumGroups].Words = TStringList();
if (NumGroups > 0){
for (CurGroupIndex = NumGroups - 1;CurGroupIndex>=InsertPosition;CurGroupIndex--){
WordGroup[CurGroupIndex+1].GroupNum = WordGroup[CurGroupIndex].GroupNum;
WordGroup[CurGroupIndex+1].Words.lfree();
WordGroup[CurGroupIndex+1].Words.copy(WordGroup[CurGroupIndex].Words);
}
}
NumGroups++;
WordGroup[InsertPosition].GroupNum = GroupNum;
WordGroup[InsertPosition].Words.lfree();
return true;
}
//************************************************************
int WordList::GroupIndexOfWord(string word)
//returns the group index of the group containing the specified word}
{
for (int i = 0;i< NumGroups;i++){
for(int k = 0;k<WordGroup[i].Words.num;k++){
if(WordGroup[i].Words.at(k) == word){
return i;
}
}
}
return -1;
}
//************************************************************
void WordList::merge(const WordList& NewWordList)
{
int CurIndex,CurWord,GroupIndex,NumWordsAdded,GroupIndexOfExistingWord;
string ThisWord;
WhatToDoWithExistingWords = AskUser;
if(NewWordList.NumGroups==0)return;
NumWordsAdded = 0;
for (CurIndex = 0;CurIndex<NewWordList.NumGroups;CurIndex++){
if (!GroupExists(NewWordList.WordGroup[CurIndex].GroupNum))
InsertWordGroup(NewWordList.WordGroup[CurIndex].GroupNum);
GroupIndex = GetWordGroupIndex(NewWordList.WordGroup[CurIndex].GroupNum);
if (GroupIndex >= 0 && NewWordList.WordGroup[CurIndex].Words.num > 0){
for (CurWord= 0;CurWord<NewWordList.WordGroup[CurIndex].Words.num;CurWord++){
GroupIndexOfExistingWord = GroupIndexOfWord(NewWordList.WordGroup[CurIndex].Words.at(CurWord));
if ((GroupIndexOfExistingWord < 0) || ((GroupIndexOfExistingWord >= 0) && (OKToReplaceWord(NewWordList.WordGroup[CurIndex].Words.at(CurWord),WordGroup[GroupIndexOfExistingWord].GroupNum,WordGroup[GroupIndex].GroupNum)))){
delete_word((char *)NewWordList.WordGroup[CurIndex].Words.at(CurWord).c_str(),GroupIndexOfExistingWord);
WordGroup[GroupIndex].Words.addsorted(NewWordList.WordGroup[CurIndex].Words.at(CurWord));
NumWordsAdded++;
}
}
}//{if (GroupIndex >= 0) and (NewWordList.WordGroup[CurIndex].Words.Count > 0)}
}
}
//************************************************************
bool WordList::OKToReplaceWord(string TheWord,int OldGroupNum, int NewGroupNum)
{
if (WhatToDoWithExistingWords == AlwaysReplace)return true;
if (WhatToDoWithExistingWords == NeverReplace)return false;
if (OldGroupNum == NewGroupNum)return true;
ReplaceWord *ask = new ReplaceWord(TheWord,OldGroupNum,NewGroupNum);
int AskResult = ask->exec();
if (AskResult == mrYesToAll)WhatToDoWithExistingWords = AlwaysReplace;
if (AskResult == mrNoToAll)WhatToDoWithExistingWords = NeverReplace;
if (AskResult == mrYes || AskResult == mrYesToAll)return true;
else return false;
}
//************************************************************
Reference in New Issue View Git Blame Copy Permalink