373 lines
9.4 KiB
C#
373 lines
9.4 KiB
C#
#define BOOKTEXTENTRY
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Text;
|
|
using Server;
|
|
using Server.Network;
|
|
using Server.Mobiles;
|
|
using Server.Gumps;
|
|
|
|
namespace Server.Items
|
|
{
|
|
|
|
public delegate void XmlTextEntryBookCallback( Mobile from, object [] args, string response );
|
|
|
|
public class XmlTextEntryBook : BaseEntryBook
|
|
{
|
|
public XmlTextEntryBookCallback m_bookcallback;
|
|
public object [] m_args;
|
|
|
|
public XmlTextEntryBook( int itemID, string title, string author, int pageCount, bool writable,
|
|
XmlTextEntryBookCallback callback, object [] args) : base( itemID, title, author, pageCount, writable )
|
|
{
|
|
m_args = args;
|
|
m_bookcallback = callback;
|
|
}
|
|
|
|
public XmlTextEntryBook( Serial serial ) : base( serial )
|
|
{
|
|
}
|
|
|
|
public void FillTextEntryBook(string text)
|
|
{
|
|
|
|
int pagenum = 0;
|
|
BookPageInfo [] pages = Pages;
|
|
int current = 0;
|
|
|
|
// break up the text into single line length pieces
|
|
while(text != null && current < text.Length)
|
|
{
|
|
int lineCount = 8;
|
|
string[] lines = new string[lineCount];
|
|
|
|
// place the line on the page
|
|
for(int i=0;i<lineCount;i++)
|
|
{
|
|
if(current < text.Length)
|
|
{
|
|
// make each line 25 chars long
|
|
int length = text.Length - current;
|
|
if(length > 20) length = 20;
|
|
lines[i] = text.Substring(current,length);
|
|
current += length;
|
|
}
|
|
else
|
|
{
|
|
// fill up the remaining lines
|
|
lines[i] = String.Empty;
|
|
}
|
|
}
|
|
|
|
if ( pagenum >= PagesCount )
|
|
return;
|
|
Pages[pagenum].Lines = lines;
|
|
pagenum++;
|
|
}
|
|
// empty the remaining contents
|
|
for(int j=pagenum;j < PagesCount; j++)
|
|
{
|
|
if(Pages[j].Lines.Length > 0)
|
|
for(int i=0;i<Pages[j].Lines.Length;i++)
|
|
{
|
|
Pages[j].Lines[i] = String.Empty;
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void Serialize( GenericWriter writer )
|
|
{
|
|
base.Serialize( writer );
|
|
writer.Write( (int) 0 ); // version
|
|
}
|
|
|
|
public override void Deserialize( GenericReader reader )
|
|
{
|
|
base.Deserialize( reader );
|
|
int version = reader.ReadInt();
|
|
|
|
Delete();
|
|
}
|
|
}
|
|
|
|
// -------------------------------------------------------------
|
|
// modifed from Beta-36 distribution version of BaseBook from basebook.cs
|
|
// adds a hook to allow processing of book text on content change
|
|
// -------------------------------------------------------------
|
|
public class BaseEntryBook : Item
|
|
{
|
|
private string m_Title;
|
|
private string m_Author;
|
|
private BookPageInfo[] m_Pages;
|
|
private bool m_Writable;
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public string Title
|
|
{
|
|
get { return m_Title; }
|
|
set { m_Title = value; InvalidateProperties(); }
|
|
}
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public string Author
|
|
{
|
|
get { return m_Author; }
|
|
set { m_Author = value; InvalidateProperties(); }
|
|
}
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public bool Writable
|
|
{
|
|
get { return m_Writable; }
|
|
set { m_Writable = value; }
|
|
}
|
|
|
|
[CommandProperty(AccessLevel.GameMaster)]
|
|
public int PagesCount
|
|
{
|
|
get { return m_Pages.Length; }
|
|
}
|
|
|
|
public BookPageInfo[] Pages
|
|
{
|
|
get { return m_Pages; }
|
|
}
|
|
|
|
[Constructable]
|
|
public BaseEntryBook( int itemID, string title, string author, int pageCount, bool writable) : base( itemID )
|
|
{
|
|
m_Title = title;
|
|
m_Author = author;
|
|
m_Pages = new BookPageInfo[pageCount];
|
|
m_Writable = writable;
|
|
|
|
for ( int i = 0; i < m_Pages.Length; ++i )
|
|
m_Pages[i] = new BookPageInfo();
|
|
}
|
|
|
|
public BaseEntryBook( Serial serial ) : base( serial )
|
|
{
|
|
}
|
|
|
|
public override void Serialize( GenericWriter writer )
|
|
{
|
|
base.Serialize( writer );
|
|
writer.Write( (int) 0 ); // version
|
|
}
|
|
|
|
public override void Deserialize( GenericReader reader )
|
|
{
|
|
base.Deserialize( reader );
|
|
int version = reader.ReadInt();
|
|
}
|
|
#if(BOOKTEXTENTRY)
|
|
public override void OnDoubleClick ( Mobile from )
|
|
{
|
|
from.Send( new EntryBookHeader( from, this ) );
|
|
from.Send( new EntryBookPageDetails( this ) );
|
|
}
|
|
|
|
public static void Initialize()
|
|
{
|
|
// This will hijack the default packet handler for basebooks content change. The header change handlers are left alone and basebook will still handle them.
|
|
// This means that BaseEntryBooks will not support header changes (they are not intended to)
|
|
|
|
//PacketHandlers.Register( 0x66, 0, true, new OnPacketReceive( ContentChange ) );
|
|
|
|
}
|
|
|
|
public static void ContentChange( NetState state, PacketReader pvSrc )
|
|
{
|
|
// need to deal with actual books
|
|
string entryText = String.Empty;
|
|
Mobile from = state.Mobile;
|
|
|
|
int serial = pvSrc.ReadInt32();
|
|
|
|
Item bookitem = World.FindItem(serial);
|
|
|
|
// first try it as a normal basebook
|
|
if (bookitem is BaseBook)
|
|
{
|
|
// do the base book content change
|
|
BaseContentChange(bookitem as BaseBook, state, pvSrc);
|
|
return;
|
|
}
|
|
|
|
// then try it as a text entry book
|
|
BaseEntryBook book = bookitem as BaseEntryBook;
|
|
|
|
if (book == null) return;
|
|
|
|
// get the number of available pages in the book
|
|
int pageCount = pvSrc.ReadUInt16();
|
|
|
|
if ( pageCount > book.PagesCount )
|
|
return;
|
|
|
|
for ( int i = 0; i < pageCount; ++i )
|
|
{
|
|
// get the current page number being read
|
|
int index = pvSrc.ReadUInt16();
|
|
|
|
if ( index >= 1 && index <= book.PagesCount )
|
|
{
|
|
--index;
|
|
|
|
int lineCount = pvSrc.ReadUInt16();
|
|
|
|
if ( lineCount <= 8 )
|
|
{
|
|
string[] lines = new string[lineCount];
|
|
|
|
for ( int j = 0; j < lineCount; ++j )
|
|
{
|
|
if ( (lines[j] = pvSrc.ReadUTF8StringSafe()).Length >= 80 )
|
|
return;
|
|
|
|
}
|
|
|
|
book.Pages[index].Lines = lines;
|
|
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
System.Text.StringBuilder sb = new System.Text.StringBuilder();
|
|
// add the book lines to the entry string
|
|
for ( int i = 0; i < book.PagesCount; ++i )
|
|
{
|
|
for(int j=0;j<book.Pages[i].Lines.Length;j++)
|
|
{
|
|
sb.Append(book.Pages[i].Lines[j]);
|
|
}
|
|
}
|
|
|
|
// send the book text off to be processed by invoking the callback if it is a textentry book
|
|
XmlTextEntryBook tebook = book as XmlTextEntryBook;
|
|
if(tebook != null && tebook.m_bookcallback != null)
|
|
{
|
|
tebook.m_bookcallback(state.Mobile, tebook.m_args, sb.ToString());
|
|
}
|
|
}
|
|
|
|
public static void BaseContentChange(BaseBook book, NetState state, PacketReader pvSrc)
|
|
{
|
|
Mobile from = state.Mobile;
|
|
|
|
if (book == null)
|
|
return;
|
|
|
|
int pageCount = pvSrc.ReadUInt16();
|
|
|
|
if (state.IsEnhancedClient && pageCount == 1)
|
|
{
|
|
book.ContentChangeEC(state, pvSrc);
|
|
return;
|
|
}
|
|
else if (book.Writable && from.InRange(book.GetWorldLocation(), 1))
|
|
{
|
|
if (pageCount > book.PagesCount)
|
|
return;
|
|
|
|
for (int i = 0; i < pageCount; ++i)
|
|
{
|
|
int index = pvSrc.ReadUInt16();
|
|
|
|
if (index >= 1 && index <= book.PagesCount)
|
|
{
|
|
--index;
|
|
|
|
int lineCount = pvSrc.ReadUInt16();
|
|
|
|
if (lineCount <= 8)
|
|
{
|
|
string[] lines = new string[lineCount];
|
|
|
|
for (int j = 0; j < lineCount; ++j)
|
|
if ((lines[j] = pvSrc.ReadUTF8StringSafe()).Length >= 80)
|
|
return;
|
|
|
|
book.Pages[index].Lines = lines;
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if(BOOKTEXTENTRY)
|
|
public sealed class EntryBookPageDetails : Packet
|
|
{
|
|
public EntryBookPageDetails( BaseEntryBook book ) : base( 0x66 )
|
|
{
|
|
EnsureCapacity( 256 );
|
|
|
|
m_Stream.Write( (int) book.Serial );
|
|
m_Stream.Write( (ushort) book.PagesCount );
|
|
|
|
for ( int i = 0; i < book.PagesCount; ++i )
|
|
{
|
|
BookPageInfo page = book.Pages[i];
|
|
|
|
m_Stream.Write( (ushort) (i + 1) );
|
|
m_Stream.Write( (ushort) page.Lines.Length );
|
|
|
|
for ( int j = 0; j < page.Lines.Length; ++j )
|
|
{
|
|
byte[] buffer = Utility.UTF8.GetBytes( page.Lines[j] );
|
|
|
|
m_Stream.Write( buffer, 0, buffer.Length );
|
|
m_Stream.Write( (byte) 0 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public sealed class EntryBookHeader : Packet
|
|
{
|
|
public EntryBookHeader( Mobile from, BaseEntryBook book ) : base ( 0xD4 )
|
|
{
|
|
string title = book.Title == null ? "" : book.Title;
|
|
string author = book.Author == null ? "" : book.Author;
|
|
|
|
byte[] titleBuffer = Utility.UTF8.GetBytes( title );
|
|
byte[] authorBuffer = Utility.UTF8.GetBytes( author );
|
|
|
|
EnsureCapacity( 15 + titleBuffer.Length + authorBuffer.Length );
|
|
|
|
m_Stream.Write( (int) book.Serial );
|
|
m_Stream.Write( (bool) true );
|
|
m_Stream.Write( (bool) book.Writable && from.InRange( book.GetWorldLocation(), 1 ) );
|
|
m_Stream.Write( (ushort) book.PagesCount );
|
|
|
|
m_Stream.Write( (ushort) (titleBuffer.Length + 1) );
|
|
m_Stream.Write( titleBuffer, 0, titleBuffer.Length );
|
|
m_Stream.Write( (byte) 0 ); // terminate
|
|
|
|
m_Stream.Write( (ushort) (authorBuffer.Length + 1) );
|
|
m_Stream.Write( authorBuffer, 0, authorBuffer.Length );
|
|
m_Stream.Write( (byte) 0 ); // terminate
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|