pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2025-12-12 01:11:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove unused files

Browse Source 
idk where these came from, NUKE EM!
This commit is contained in:
Michael Cook (mackal) 2021-02-12 02:42:03 -05:00
parent 507bbe83f3
commit 8b4a886d01
5 changed files with 0 additions and 311 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
zone/CMakeLists.txt
View File

@ -247,7 +247,6 @@ SET(zone_headers
quest_interface.h
questmgr.h
quest_parser_collection.h
raid.h
raids.h
raycast_mesh.h
skills.h

1
zone/lua_raid.cpp
View File

@ -4,7 +4,6 @@
#include <luabind/luabind.hpp>
#include <luabind/object.hpp>
#include "raid.h"
#include "masterentity.h"
#include "lua_raid.h"
#include "lua_entity.h"

101
zone/quest.cpp
View File

@ -1,101 +0,0 @@
/* EQEMu: Everquest Server Emulator
Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)
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; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product;
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "../common/debug.h"
#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Disgrace: for windows compile
#ifdef WIN32
#include <windows.h>
#define snprintf _snprintf
#else
#include "../common/unix.h"
#endif
#include "quest.h"
pquest_entry Quest::m_pQuests;
int Quest::m_nQuests;
Quest::Quest()
{
m_pQuests = NULL;
m_nQuests = 0;
}
Quest::~Quest()
{
for( int i=0;i<m_nQuests;i++ )
{
delete m_pQuests[ i ].m_pQuestName;
delete m_pQuests[ i ].m_pQuestText;
delete m_pQuests[ i ].m_pQuestEnd;
}
delete[] m_pQuests;
}
bool ZoneDatabase::OpenQuery(char* zonename) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
MYSQL_RES* result;
MYSQL_ROW row;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT name, text, end, npcID, questobject, priceobject, cash, exp FROM quest WHERE zone='%s'", zonename), errbuf, &result)) {
delete[] query;
Quest::m_nQuests = mysql_num_rows( result );
if( Quest::m_nQuests )
{
int l_cnt = 0;
Quest::m_pQuests = new quest_entry[ Quest::m_nQuests ];
while(row = mysql_fetch_row(result)) {
Quest::m_pQuests[ l_cnt ].m_pQuestName = new char[ strlen( row[0] )+1 ];
strcpy( Quest::m_pQuests[ l_cnt ].m_pQuestName, row[0] );
Quest::m_pQuests[ l_cnt ].m_pQuestText = new char[ strlen( row[1] )+1 ];
strcpy( Quest::m_pQuests[ l_cnt ].m_pQuestText, row[1] );
Quest::m_pQuests[ l_cnt ].m_pQuestEnd = new char[ strlen( row[2] )+1 ];
strcpy( Quest::m_pQuests[ l_cnt ].m_pQuestEnd, row[2] );
Quest::m_pQuests[ l_cnt ].m_iNpcId = atoi( row[3] );
Quest::m_pQuests[ l_cnt ].m_iQuestObject= atoi( row[4] );
Quest::m_pQuests[ l_cnt ].m_iQuestPrice = atoi( row[5] );
Quest::m_pQuests[ l_cnt ].m_iQuestCash = atoi( row[6] );
Quest::m_pQuests[ l_cnt ].m_iQuestExp = atoi( row[7] );
cerr << "Quests '" << Quest::m_pQuests[ l_cnt ].m_pQuestName << "' , NPCID " << Quest::m_pQuests[ l_cnt ].m_iNpcId << endl;
l_cnt++;
}
mysql_free_result(result);
return true;
}
mysql_free_result(result);
}
cerr << "Error in ZoneDatabase::OpenQuest query '" << query << "' " << errbuf << endl;
delete[] query;
return false;
}
pquest_entry Quest::Test( int NpcId, int QuestObject )
{
for( int i=0;i<m_nQuests;i++ )
if( m_pQuests[ i ].m_iNpcId == NpcId && m_pQuests[ i ].m_iQuestObject == QuestObject )
return &m_pQuests[ i ];
return NULL;
}

47
zone/quest.h
View File

@ -1,47 +0,0 @@
/* EQEMu: Everquest Server Emulator
Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)
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; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY except by those people which sell it, which
are required to give you total support for your newly bought product;
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __QUEST_H__
#define __QUEST_H__
#include "zonedb.h"
#include "zone_store.h"
typedef struct _tag_quest_entry{
char *m_pQuestName;
char *m_pQuestText;
char *m_pQuestEnd;
int m_iNpcId;
int m_iQuestObject;
int m_iQuestPrice;
int m_iQuestCash;
int m_iQuestExp;
}quest_entry,*pquest_entry;
class Quest{
public:
Quest();
~Quest();
static pquest_entry Test(int NpcId, int QuestObject);
static pquest_entry m_pQuests;
static int m_nQuests;
};
#endif

161
zone/raid.h
View File

@ -1,161 +0,0 @@
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
MA 02111-1307, USA */
/* Parser needs these defines always, even if USE_RAID is not defined */
#define RAID_TYPE_0 1 /* Striping */
#define RAID_TYPE_x 2 /* Some new modes */
#define RAID_TYPE_y 3
#define RAID_DEFAULT_CHUNKS 4
#define RAID_DEFAULT_CHUNKSIZE 256*1024 /* 256kB */
extern const char *raid_type_string[];
#ifdef __cplusplus
extern "C" {
#endif
const char *my_raid_type(int raid_type);
#ifdef __cplusplus
}
#endif
#if defined(USE_RAID) && !defined(DONT_USE_RAID)
#ifdef __GNUC__
#pragma interface /* gcc class implementation */
#endif
#include "my_dir.h"
/* Trap all occurences of my_...() in source and use our wrapper around this function */
#ifdef MAP_TO_USE_RAID
#define my_read(A,B,C,D) my_raid_read(A,B,C,D)
#define my_write(A,B,C,D) my_raid_write(A,B,C,D)
#define my_pwrite(A,B,C,D,E) my_raid_pwrite(A,B,C,D,E)
#define my_pread(A,B,C,D,E) my_raid_pread(A,B,C,D,E)
#define my_chsize(A,B,C) my_raid_chsize(A,B,C)
#define my_close(A,B) my_raid_close(A,B)
#define my_tell(A,B) my_raid_tell(A,B)
#define my_seek(A,B,C,D) my_raid_seek(A,B,C,D)
#define my_lock(A,B,C,D,E) my_raid_lock(A,B,C,D,E)
#define my_fstat(A,B,C) my_raid_fstat(A,B,C)
#endif /* MAP_TO_USE_RAID */
#ifdef __cplusplus
extern "C" {
#endif
void init_raid(void);
void end_raid(void);
bool is_raid(File fd);
File my_raid_create(const char *FileName, int CreateFlags, int access_flags,
uint raid_type, uint raid_chunks, ulong raid_chunksize,
myf MyFlags);
File my_raid_open(const char *FileName, int Flags,
uint raid_type, uint raid_chunks, ulong raid_chunksize,
myf MyFlags);
int my_raid_rename(const char *from, const char *to, uint raid_chunks,
myf MyFlags);
int my_raid_delete(const char *from, uint raid_chunks, myf MyFlags);
int my_raid_redel(const char *old_name, const char *new_name,
uint raid_chunks, myf MyFlags);
my_off_t my_raid_seek(File fd, my_off_t pos, int whence, myf MyFlags);
my_off_t my_raid_tell(File fd, myf MyFlags);
uint my_raid_write(File,const byte *Buffer, uint Count, myf MyFlags);
uint my_raid_read(File Filedes, byte *Buffer, uint Count, myf MyFlags);
uint my_raid_pread(File Filedes, byte *Buffer, uint Count, my_off_t offset,
myf MyFlags);
uint my_raid_pwrite(int Filedes, const byte *Buffer, uint Count,
my_off_t offset, myf MyFlags);
int my_raid_lock(File,int locktype, my_off_t start, my_off_t length,
myf MyFlags);
int my_raid_chsize(File fd, my_off_t newlength, myf MyFlags);
int my_raid_close(File, myf MyFlags);
int my_raid_fstat(int Filedes, struct stat *buf, myf MyFlags);
#ifdef __cplusplus
}
class RaidName {
public:
RaidName(const char *FileName);
~RaidName();
bool IsRaid();
int Rename(const char * from, const char * to, myf MyFlags);
private:
uint _raid_type; /* RAID_TYPE_0 or RAID_TYPE_1 or RAID_TYPE_5 */
uint _raid_chunks; /* 1..n */
ulong _raid_chunksize; /* 1..n in bytes */
};
class RaidFd {
public:
RaidFd(uint raid_type, uint raid_chunks , ulong raid_chunksize);
~RaidFd();
File Create(const char *FileName, int CreateFlags, int access_flags,
myf MyFlags);
File Open(const char *FileName, int Flags, myf MyFlags);
my_off_t Seek(my_off_t pos,int whence,myf MyFlags);
my_off_t Tell(myf MyFlags);
int Write(const byte *Buffer, uint Count, myf MyFlags);
int Read(const byte *Buffer, uint Count, myf MyFlags);
int Lock(int locktype, my_off_t start, my_off_t length, myf MyFlags);
int Chsize(File fd, my_off_t newlength, myf MyFlags);
int Fstat(int fd, MY_STAT *stat_area, myf MyFlags );
int Close(myf MyFlags);
static bool IsRaid(File fd);
static DYNAMIC_ARRAY _raid_map; /* Map of RaidFD* */
private:
uint _raid_type; /* RAID_TYPE_0 or RAID_TYPE_1 or RAID_TYPE_5 */
uint _raid_chunks; /* 1..n */
ulong _raid_chunksize; /* 1..n in bytes */
ulong _total_block; /* We are operating with block no x (can be 0..many). */
uint _this_block; /* can be 0.._raid_chunks */
uint _remaining_bytes; /* Maximum bytes that can be written in this block */
my_off_t _position;
my_off_t _size; /* Cached file size for faster seek(SEEK_END) */
File _fd;
File *_fd_vector; /* Array of File */
off_t *_seek_vector; /* Array of cached seek positions */
inline void Calculate()
{
DBUG_ENTER("RaidFd::_Calculate");
DBUG_PRINT("info",("_position: %lu _raid_chunksize: %d, _size: %lu",
(ulong) _position, _raid_chunksize, (ulong) _size));
_total_block = (ulong) (_position / _raid_chunksize);
_this_block = _total_block % _raid_chunks; /* can be 0.._raid_chunks */
_remaining_bytes = (uint) (_raid_chunksize - (_position - _total_block * _raid_chunksize));
DBUG_PRINT("info",
("_total_block: %d this_block: %d _remaining_bytes:%d",
_total_block, _this_block, _remaining_bytes));
DBUG_VOID_RETURN;
}
};
#endif /* __cplusplus */
#endif /* USE_RAID */