OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1831 Commits
81 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: 4b4de0e135
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '4b4de0e135'
${ noResults }
CWE-ou-minkata/Sources/Plasma/FeatureLib/pfKI/pfKI.cpp

1378 lines
45 KiB
Raw Blame History

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
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 3 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, see <http://www.gnu.org/licenses/>.
Additional permissions under GNU GPL version 3 section 7
If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
//////////////////////////////////////////////////////////////////////////////
// //
// pfKI Functions //
// //
//////////////////////////////////////////////////////////////////////////////
#include "pfKI.h"
#include "plgDispatch.h"
#include "hsResMgr.h"
#include "pfGameGUIMgr/pfGameGUIMgr.h"
#include "pfGameGUIMgr/pfGUITagDefs.h"
#include "pfGameGUIMgr/pfGUIDialogMod.h"
#include "pfGameGUIMgr/pfGUIControlHandlers.h"
#include "pfGameGUIMgr/pfGUIDialogHandlers.h"
#include "pfGameGUIMgr/pfGUIEditBoxMod.h"
#include "pfGameGUIMgr/pfGUIListBoxMod.h"
#include "pfGameGUIMgr/pfGUIButtonMod.h"
#include "pfGameGUIMgr/pfGUIListElement.h"
#include "pfGameGUIMgr/pfGUITextBoxMod.h"
#include "pfGameGUIMgr/pfGUIRadioGroupCtrl.h"
#include "plGImage/plDynamicTextMap.h"
#include "plNetClient/plNetClientMgr.h"
#include "plNetClient/plNetKI.h"
#include "pnNetCommon/plNetMsg.h"
#include "plNetTransport/plNetTransportMember.h"
#include "pfMessage/pfKIMsg.h"
#include "plMessage/plMemberUpdateMsg.h"
#include "pnMessage/plTimeMsg.h"
#include "pnMessage/plRemoteAvatarInfoMsg.h"
#define kKITempID_ListOfLists 25
#define kKITempID_MsgDestRadio 26
#define kKITempID_SendBtn 27
#define kKITempID_CurrPlayerText 30
#define kKITempID_PlayerList 31
#define kKITempID_ChatModeBtn 32
#define kKITempID_BlackBarDlg 33
#define kKITempID_BarKIButtons 34
#define kDesiredKIVersion 0
#define kMaxNumChatItems 42
//// Static Class Stuff //////////////////////////////////////////////////////
pfKI *pfKI::fInstance = nil;
//// Dialog Proc Definitions /////////////////////////////////////////////////
class plKIYesNoBox : public pfGUIDialogProc
{
protected:
pfGUICtrlProcObject *fCBProc;
uint32_t fNoCBValue, fYesCBValue;
public:
plKIYesNoBox() { fCBProc = nil; fNoCBValue = 0; fYesCBValue = 0; }
virtual void DoSomething( pfGUIControlMod *ctrl )
{
uint32_t cbValue = 0;
if( ctrl->GetTagID() == kKIYesBtn )
{
cbValue = fYesCBValue;
}
else if( ctrl->GetTagID() == kKINoBtn )
{
cbValue = fNoCBValue;
}
fDialog->Hide();
// Call da callback
if( fCBProc != nil )
fCBProc->UserCallback( cbValue );
}
void SetMessage( const char *msg )
{
pfGUITextBoxMod *ctrl = pfGUITextBoxMod::ConvertNoRef( fDialog->GetControlFromTag( kKIStaticText ) );
ctrl->SetText( msg );
}
void Ask( const char *msg, pfGUICtrlProcObject *callbackProc, uint32_t noCBValue, uint32_t yesCBValue )
{
SetMessage( msg );
fCBProc = callbackProc;
fNoCBValue = noCBValue;
fYesCBValue = yesCBValue;
fDialog->Show();
}
};
//// BlackBar Proc ///////////////////////////////////////////////////////////
class plBlackBarProc : public pfGUIDialogProc
{
protected:
pfGUIDialogMod *fKIMiniDlg, *fKIMainDlg;
pfGUIDialogProc *fOrigProc;
static bool fExpected;
static pfGUIRadioGroupCtrl *fKIButtons;
public:
plBlackBarProc( pfGUIDialogMod *miniKI, pfGUIDialogMod *mainKI, pfGUIDialogProc *origProc )
{
fOrigProc = origProc;
if( fOrigProc != nil )
fOrigProc->IncRef();
fKIMiniDlg = miniKI;
fKIMainDlg = mainKI;
fExpected = false;
}
virtual ~plBlackBarProc()
{
if( fOrigProc != nil && fOrigProc->DecRef() )
delete fOrigProc;
}
virtual void OnShow( void )
{
fKIButtons = pfGUIRadioGroupCtrl::ConvertNoRef( fDialog->GetControlFromTag( kKITempID_BarKIButtons ) );
if( fKIButtons != nil )
{
fKIButtons->SetValue( -1 );
fKIMiniDlg->Hide();
fKIMainDlg->Hide();
}
if( fOrigProc != nil ) fOrigProc->OnShow();
}
virtual void OnHide( void ) { if( fOrigProc != nil ) fOrigProc->OnHide(); }
virtual void OnInit( void ) { if( fOrigProc != nil ) fOrigProc->OnInit(); }
virtual void DoSomething( pfGUIControlMod *ctrl )
{
if( ctrl->GetTagID() == kKITempID_BarKIButtons )
{
fExpected = true;
if( fKIButtons->GetValue() == 0 ) fKIMiniDlg->Show(); else fKIMiniDlg->Hide();
if( fKIButtons->GetValue() == 1 ) fKIMainDlg->Show(); else fKIMainDlg->Hide();
fExpected = false;
}
else if( fOrigProc != nil )
fOrigProc->DoSomething( ctrl );
}
static void ClearKIButtons( void )
{
if( fKIButtons != nil && !fExpected )
fKIButtons->SetValue( -1 );
}
};
bool plBlackBarProc::fExpected = false;
pfGUIRadioGroupCtrl *plBlackBarProc::fKIButtons = nil;
//// KIMain Proc /////////////////////////////////////////////////////////////
class plKIMainProc : public pfGUIDialogProc
{
protected:
pfGUIListBoxMod *fOther;
plKIYesNoBox *fYesNoDlg;
pfGUIDialogMod *fMiniDlg;
plKIFolder *fKIFolder;
public:
plKIAddEditBox *fAddRemoveHandler;
plKIMainProc( pfGUIControlMod *other, plKIYesNoBox *yesNo, pfGUIDialogMod *miniDlg );
virtual void DoSomething( pfGUIControlMod *ctrl );
virtual void OnHide( void );
virtual void UserCallback( uint32_t userValue );
virtual void OnInit( void );
virtual void OnShow( void );
void GrabVaultFolder( void );
void UpdateTextList( void );
void UpdateTextPreview( void );
void AddNewItem( const char *title, const char *text );
void EditCurrItem( const char *newText );
void SetCurrentAvatar( plKey avKey );
};
class plKIAddEditBox : public pfGUIDialogProc
{
protected:
pfGUIListBoxMod *fList;
pfGUIDialogMod *fParentDlg;
plKIMainProc *fMainProc;
public:
bool fEditing;
plKIAddEditBox( pfGUIListBoxMod *list, pfGUIDialogMod *p, plKIMainProc *mainProc )
{
fList = list;
fParentDlg = p;
fEditing = false;
fMainProc = mainProc;
}
virtual void DoSomething( pfGUIControlMod *ctrl )
{
if( ctrl->GetTagID() != kKINoBtn )
{
// Get the string and add it to the list
pfGUIEditBoxMod *edit = pfGUIEditBoxMod::ConvertNoRef( fDialog->GetControlFromTag( kKITestEditBox ) );
if( ctrl != (pfGUIControlMod *)edit || !edit->WasEscaped() )
{
if( fEditing )
fMainProc->EditCurrItem( edit->GetBuffer() );
else
fMainProc->AddNewItem( "TestTitle", edit->GetBuffer() );
}
}
fEditing = false;
// Both controls should close the dialog
fDialog->Hide();
}
virtual void OnShow( void )
{
pfGUIEditBoxMod *edit = pfGUIEditBoxMod::ConvertNoRef( fDialog->GetControlFromTag( kKITestEditBox ) );
if( fEditing )
{
if( fList->GetSelection() != -1 )
{
pfGUIListElement *el = fList->GetElement( fList->GetSelection() );
if( el->GetType() == pfGUIListElement::kText )
edit->SetText( ( (pfGUIListText *)el )->GetText() );
}
}
else
edit->ClearBuffer();
fDialog->SetFocus( edit );
}
};
class pfKITextItemElement : public pfGUIListText
{
protected:
plKITextNoteElement *fDataItem;
public:
pfKITextItemElement( plKITextNoteElement *source ) : pfGUIListText()
{
fDataItem = source;
}
virtual const char *GetText( void ) { return fDataItem->GetText(); }
virtual void SetText( const char *text ) { fDataItem->SetText( text ); }
plKITextNoteElement *GetSource( void ) { return fDataItem; }
};
class pfKIListItemElement : public pfGUIListText
{
protected:
plKIFolder *fFolder;
public:
pfKIListItemElement( plKIFolder *folder) : pfGUIListText(), fFolder( folder ) {}
virtual const char *GetText( void ) { return fFolder->GetName(); }
virtual void SetText( const char *text ) { }
plKIFolder *GetFolder( void ) { return fFolder; }
};
plKIMainProc::plKIMainProc( pfGUIControlMod *other, plKIYesNoBox *yesNo, pfGUIDialogMod *miniDlg )
{
fOther = (pfGUIListBoxMod *)other;
fYesNoDlg = yesNo;
fMiniDlg = miniDlg;
fKIFolder = nil;
}
void plKIMainProc::DoSomething( pfGUIControlMod *ctrl )
{
if( ctrl->GetTagID() == kKIAddButton )
{
pfGUIDialogMod *dlg = pfGameGUIMgr::GetInstance()->GetDialogFromTag( kKIEntryDlg );
dlg->Show();
}
else if( ctrl->GetTagID() == kKIEditButton )
{
// Edit btn
if( fOther->GetSelection() != -1 )
{
pfGUIDialogMod *dlg = pfGameGUIMgr::GetInstance()->GetDialogFromTag( kKIEntryDlg );
fAddRemoveHandler->fEditing = true;
dlg->Show();
}
}
else if( ctrl->GetTagID() == kKIRemoveButton )
{
// Remove btn - remove all selected items
if( fOther->GetSelection() != -1 )
fYesNoDlg->Ask( "Are you sure you wish to remove this item?", this, 0, 1 );
}
else if( ctrl->GetTagID() == kKITestEditBox ) // Yeah, yeah, i know
{
// List box. Gets sent/called when selection changes.
UpdateTextPreview();
}
else if( ctrl->GetTagID() == kKITempID_ListOfLists )
{
// Change lists
pfGUIListBoxMod *list = pfGUIListBoxMod::ConvertNoRef( fDialog->GetControlFromTag( kKITempID_ListOfLists ) ); // Temp tag ID
if( list->GetSelection() != -1 )
{
pfKIListItemElement *whichList = (pfKIListItemElement *)list->GetElement( list->GetSelection() );
fKIFolder = whichList->GetFolder();
}
else
fKIFolder = nil;
UpdateTextList();
}
}
void plKIMainProc::UpdateTextPreview( void )
{
pfGUIControlMod *editBtn = fDialog->GetControlFromTag( kKIEditButton );
pfGUIControlMod *removeBtn = fDialog->GetControlFromTag( kKIRemoveButton );
pfGUIControlMod *sendBtn = fDialog->GetControlFromTag( kKITempID_SendBtn );
pfGUITextBoxMod *text = pfGUITextBoxMod::ConvertNoRef( fDialog->GetControlFromTag( kKITestControl2 ) );
if( fOther->GetSelection() != -1 && fOther->GetElement( fOther->GetSelection() )->GetType() == pfGUIListElement::kText )
{
pfGUIListText *element = (pfGUIListText *)fOther->GetElement( fOther->GetSelection() );
text->SetText( element->GetText() );
sendBtn->SetVisible( true );
editBtn->SetVisible( true );
removeBtn->SetVisible( true );
}
else
{
text->SetText( "" );
sendBtn->SetVisible( false );
editBtn->SetVisible( false );
removeBtn->SetVisible( false );
}
}
void plKIMainProc::AddNewItem( const char *title, const char *text )
{
if( fKIFolder != nil )
{
plKITextNoteElement *item = new plKITextNoteElement();
item->SetTitle( title );
item->SetText( text );
fKIFolder->AddElement(item);
}
}
void plKIMainProc::EditCurrItem( const char *newText )
{
pfKITextItemElement *listEl = (pfKITextItemElement *)fOther->GetElement( fOther->GetSelection() );
listEl->GetSource()->SetText( newText );
}
void plKIMainProc::OnHide( void )
{
plBlackBarProc::ClearKIButtons();
}
void plKIMainProc::UserCallback( uint32_t userValue )
{
if( userValue == 1 )
{
// Yes/no callback for removing an element
if( fOther->GetSelection() != -1 )
{
pfKITextItemElement *listEl = (pfKITextItemElement *)fOther->GetElement( fOther->GetSelection() );
// This will result in a callback to update our list
fKIFolder->RemoveElement( listEl->GetSource() );
}
}
}
void plKIMainProc::OnShow( void )
{
GrabVaultFolder();
UpdateTextList();
}
void plKIMainProc::GrabVaultFolder( void )
{
int16_t sel = -1;
plKI *kiVault = plNetClientMgr::GetInstance()->GetPlayerKI();
fKIFolder = kiVault->FindFolder( plKIFolder::MatchesName( "INBOX" ) );
// Populate list-of-lists
pfGUIListBoxMod *listsList = pfGUIListBoxMod::ConvertNoRef( fDialog->GetControlFromTag( kKITempID_ListOfLists ) ); // Temp tag ID
listsList->LockList();
listsList->ClearAllElements();
plKIFolderVec * folders = kiVault->GetFolders();
for( plKIFolderVec::const_iterator folderIter = folders->begin(); folderIter != folders->end(); ++folderIter )
{
uint16_t id = listsList->AddElement( new pfKIListItemElement( *folderIter ) );
if( *folderIter == fKIFolder )
sel = id;
}
listsList->SetSelection( sel );
listsList->UnlockList();
}
void plKIMainProc::UpdateTextList( void )
{
pfGUIControlMod *addBtn = fDialog->GetControlFromTag( kKIAddButton );
int i;
if( fKIFolder == nil )
{
fOther->ClearAllElements();
UpdateTextPreview();
addBtn->SetVisible( false );
return;
}
addBtn->SetVisible( true );
plKIElementVec *items = fKIFolder->GetElements();
fOther->LockList();
fOther->ClearAllElements();
for( i = 0; i < items->size(); i++ )
{
plKITextNoteElement *note = plKITextNoteElement::ConvertNoRef( (*items)[ i ] );
hsAssert( note != nil, "What the *#($& is a non-text item doing in the text item list??" );
fOther->AddElement( new pfKITextItemElement( note ) );
}
fOther->UnlockList();
UpdateTextPreview();
}
void plKIMainProc::OnInit( void )
{
}
void plKIMainProc::SetCurrentAvatar( plKey avKey )
{
static char str[ 512 ];
pfGUITextBoxMod *text = pfGUITextBoxMod::ConvertNoRef( fDialog->GetControlFromTag( kKITempID_CurrPlayerText ) );
const char *avName = plNetClientMgr::GetInstance()->GetPlayerName( avKey );
if( text != nil )
{
if( avName == nil )
text->SetText( "Selected:" );
else
{
sprintf( str, "%s", avName );
text->SetText( str );
}
}
}
//// MiniKI Proc /////////////////////////////////////////////////////////////
#define kHackFlagLocalMsg 0x800
class pfKIChatElement : public pfGUIListElement
{
protected:
plKITextNoteElement *fDataItem;
hsColorRGBA fTextColor;
char *fString;
uint32_t fFlags;
public:
pfKIChatElement( plKITextNoteElement *source ) : pfGUIListElement( 0 )
{
fDataItem = source;
fFlags = 0;
if( strcmp( source->GetTitle(), plNetClientMgr::GetInstance()->GetPlayerName() ) == 0 )
fFlags |= kHackFlagLocalMsg;
fString = new char[ strlen( source->GetTitle() ) + strlen( source->GetText() ) + 3 ];
sprintf( fString, "%s: %s", source->GetTitle(), source->GetText() );
}
pfKIChatElement( const char *user, const char *msg, uint32_t flags ) : pfGUIListElement( 0 )
{
fDataItem = nil;
fFlags = flags;
if( strcmp( user, plNetClientMgr::GetInstance()->GetPlayerName() ) == 0 )
fFlags |= kHackFlagLocalMsg;
if( fFlags & pfKIMsg::kAdminMsg )
fTextColor.Set( 0, 0, 1, 1 );
else if( fFlags & pfKIMsg::kPrivateMsg )
fTextColor.Set( 1, 0, 0, 1 );
else
fTextColor.Set( 1, 1, 1, 1 );
if( user == nil )
user = " ";
if( msg == nil )
msg = " ";
fString = new char[ strlen( user ) + strlen( msg ) + 3 ];
sprintf( fString, "%s: %s", user, msg );
}
virtual ~pfKIChatElement() { delete [] fString; }
virtual void Draw( plDynamicTextMap *textGen, uint16_t x, uint16_t y, uint16_t maxWidth, uint16_t maxHeight )
{
if( fFlags & kHackFlagLocalMsg )
fTextColor.a = fColors->fSelForeColor.a;
else
fTextColor.a = fColors->fForeColor.a;
textGen->SetTextColor( fTextColor, fColors->fTransparent && fColors->fBackColor.a == 0.f );
textGen->DrawWrappedString( x + 2, y, fString, maxWidth - 4, maxHeight );
}
virtual void GetSize( plDynamicTextMap *textGen, uint16_t *width, uint16_t *height )
{
*width = textGen->GetVisibleWidth() - 4;
textGen->CalcWrappedStringSize( fString, width, height );
if( height != nil )
*height += 0;
*width += 4;
}
virtual int CompareTo( pfGUIListElement *rightSide )
{
return -2;
}
plKITextNoteElement *GetSource( void ) { return fDataItem; }
};
class pfKIListPlayerItem : public pfGUIListText
{
protected:
plKey fPlayerKey;
public:
pfKIListPlayerItem( plKey key, bool inRange = false ) : pfGUIListText(), fPlayerKey( key )
{
static char str[ 256 ];
if( key == nil )
SetText( "<Everyone>" );
else
{
const char *name = plNetClientMgr::GetInstance()->GetPlayerName( key );
if( inRange )
{
sprintf( str, ">%s<", name != nil ? name : key->GetName() );
SetText( str );
}
else
SetText( name != nil ? name : key->GetName() );
}
ISetJustify( true );
}
plKey GetPlayerKey( void ) { return fPlayerKey; }
};
class plKIMiniProc : public pfGUIDialogProc
{
protected:
pfGUIDialogMod *fMainDlg;
pfGUIListBoxMod *fChatList;
plKIFolder *fChatVaultFolder;
bool fChatting, fInited;
float fFadeOutTimer, fFadeOutDelay;
float fForeAlpha, fSelForeAlpha;
bool fLocalClientIsAdmin;
public:
plKIMiniProc( pfGUIDialogMod *main )
{
fMainDlg = main;
fChatting = false;
fFadeOutDelay = 20.f;
fFadeOutTimer = 0.f;
fInited = false;
fLocalClientIsAdmin = false;
}
void SetLocalClientAsAdmin( bool yes ) { fLocalClientIsAdmin = yes; }
virtual void OnInit( void )
{
fForeAlpha = fDialog->GetColorScheme()->fForeColor.a;
fSelForeAlpha = fDialog->GetColorScheme()->fSelForeColor.a;
fInited = true;
}
virtual void DoSomething( pfGUIControlMod *ctrl )
{
if( ctrl->GetTagID() == kKIYesBtn )
{
fDialog->Hide();
fMainDlg->Show();
}
else if( ctrl->GetTagID() == kKITestControl2 ) // I.E. chat box
{
pfGUIEditBoxMod *edit = pfGUIEditBoxMod::ConvertNoRef( ctrl );
pfGUIControlMod *label = fDialog->GetControlFromTag( kKIStaticText );
if( !edit->WasEscaped() )
SendChatItem( edit->GetBuffer() );
EnterChatMode( false );
}
else if( ctrl->GetTagID() == kKITempID_PlayerList )
{
pfGUIListBoxMod *list = pfGUIListBoxMod::ConvertNoRef( ctrl );
if( list != nil ) // it BETTER be
{
if( list->GetSelection() == -1 && list->GetNumElements() > 0 )
list->SetSelection( 0 );
}
}
}
virtual void OnShow( void )
{
// Get our chat list
fChatList = pfGUIListBoxMod::ConvertNoRef( fDialog->GetControlFromTag( kKITestEditBox ) );
EnterChatMode( false );
// Start with the chat not showing
fFadeOutTimer = 0.f;
IncFadeOutTimer( fFadeOutDelay + 2.f );
GrabChatList();
UpdateChatList();
RefreshUserList();
}
virtual void OnHide( void )
{
plBlackBarProc::ClearKIButtons();
}
virtual void OnCtrlFocusChange( pfGUIControlMod *oldCtrl, pfGUIControlMod *newCtrl )
{
if( oldCtrl != nil && oldCtrl->GetTagID() == kKITestControl2 &&
( newCtrl == nil || newCtrl->GetTagID() != kKITempID_ChatModeBtn ) )
{
// We were chatting and lost focus, so hide the chatting controls
EnterChatMode( false );
}
}
void SetFadeOutDelay( hsScalar secs ) { fFadeOutDelay = secs; }
void EnterChatMode( bool enteringNotLeaving )
{
pfGUIEditBoxMod *edit = pfGUIEditBoxMod::ConvertNoRef( fDialog->GetControlFromTag( kKITestControl2 ) );
pfGUIControlMod *label = fDialog->GetControlFromTag( kKIStaticText );
if( enteringNotLeaving )
{
if( !fDialog->IsVisible() )
fDialog->Show();
edit->ClearBuffer();
edit->SetVisible( true );
label->SetVisible( true );
fDialog->SetFocus( edit );
IncFadeOutTimer( -fFadeOutTimer );
}
else
{
edit->SetVisible( false );
label->SetVisible( false );
}
fChatting = enteringNotLeaving;
}
bool IsChatting( void ) const { return fChatting; }
void GrabChatList( void )
{
/* plKI *kiVault = plNetKI::GetInstance();
if( kiVault != nil )
fChatVaultList = kiVault->FindList( &plKIList::MatchesListDefID( plKITextChatMsgsIRcvdList::Index() ) );
else
fChatVaultList = nil;
*/ }
plKIFolder *GetChatFolder( void ) const { return fChatVaultFolder; }
void RefreshUserList( void )
{
int i;
if( !fDialog->IsVisible() )
return;
pfGUIListBoxMod *userList = pfGUIListBoxMod::ConvertNoRef( fDialog->GetControlFromTag( kKITempID_PlayerList ) );
if( userList != nil )
{
plKey currKey = nil;
if( userList->GetNumElements() > 0 && userList->GetSelection() != -1 )
currKey = ( (pfKIListPlayerItem *)userList->GetElement( userList->GetSelection() ) )->GetPlayerKey();
userList->LockList();
userList->ClearAllElements();
if( plNetClientMgr::GetInstance() != nil )
{
userList->AddElement( new pfKIListPlayerItem( nil ) );
plNetTransportMember **members = nil;
plNetClientMgr::GetInstance()->TransportMgr().GetMemberListDistSorted( members );
if( members != nil )
{
for( i = 0; i < plNetClientMgr::GetInstance()->TransportMgr().GetNumMembers(); i++ )
{
plNetTransportMember *mbr = members[ i ];
if( mbr != nil && mbr->GetAvatarKey() != nil )
{
bool inRange = ( i < plNetListenList::kMaxListenListSize || plNetListenList::kMaxListenListSize==-1) &&
( mbr->GetDistSq() < plNetListenList::kMaxListenDistSq );
userList->AddElement( new pfKIListPlayerItem( mbr->GetAvatarKey(), inRange ) );
}
}
delete [] members;
}
}
if( currKey == nil )
{
if( userList->GetNumElements() > 0 )
userList->SetSelection( 0 );
}
else
{
for( i = 0; i < userList->GetNumElements(); i++ )
{
if( ( (pfKIListPlayerItem *)userList->GetElement( i ) )->GetPlayerKey() == currKey )
{
userList->SetSelection( i );
break;
}
}
if( i == userList->GetNumElements() && userList->GetNumElements() > 0 )
userList->SetSelection( 0 );
}
userList->UnlockList();
}
}
virtual void HandleExtendedEvent( pfGUIControlMod *ctrl, uint32_t event )
{
// The only controls that will trigger a HandleExtendedEvent() are the ones that we want
// to have force the text to show
if( pfGUIListBoxMod::ConvertNoRef( ctrl ) == nil || event != pfGUIListBoxMod::kListCleared )
IncFadeOutTimer( -fFadeOutTimer );
}
void IncFadeOutTimer( float delSeconds )
{
if( !fInited )
return;
if( fDialog->GetFocus() && fDialog->GetFocus()->GetTagID() == kKITestControl2 )
delSeconds = -fFadeOutTimer;
bool didntChange = ( fFadeOutTimer <= fFadeOutDelay && fFadeOutTimer + delSeconds <= fFadeOutDelay )
|| ( fFadeOutTimer > fFadeOutDelay + 1.f && delSeconds >= 0.f );
pfGUIColorScheme *colors = fDialog->GetColorScheme();
fFadeOutTimer += delSeconds;
if( fFadeOutTimer > fFadeOutDelay )
{
if( fFadeOutTimer > fFadeOutDelay + 1.f )
{
colors->fForeColor.a = 0.f;
colors->fSelForeColor.a = 0.f;
}
else
{
colors->fForeColor.a = fForeAlpha * ( fFadeOutDelay + 1.f - fFadeOutTimer );
colors->fSelForeColor.a = fSelForeAlpha * ( fFadeOutDelay + 1.f - fFadeOutTimer );
}
}
else
{
colors->fForeColor.a = fForeAlpha;
colors->fSelForeColor.a = fSelForeAlpha;
}
if( !didntChange )
fDialog->RefreshAllControls();
}
void UpdateChatList( void )
{
if( !fDialog->IsVisible() )
return;
fChatList->LockList(); // Makes updates faster
// fChatList->ClearAllElements();
/* if( fChatVaultList != nil )
{
int i;
plKIElementVec *items = fChatVaultList->GetElements();
for( i = 0; i < items->size(); i++ )
{
plKITextNoteElement *note = plKITextNoteElement::ConvertNoRef( (*items)[ i ] );
hsAssert( note != nil, "What the *#($& is a non-text item doing in the text item list??" );
fChatList->AddElement( new pfKIChatElement( note ) );
}
}
*/
fChatList->UnlockList();
fChatList->ScrollToBegin();
}
/* void ReceivedChatItem( plKIElement *element )
{
if( fChatList == nil )
return;
plKITextNoteElement *note = plKITextNoteElement::ConvertNoRef( element );
if( note != nil )
fChatList->AddElement( new pfKIChatElement( note ) );
fChatList->ScrollToBegin();
}
*/
void ReceivedChatItem( const char *user, const char *msg, uint32_t flags )
{
if( fChatList == nil )
return;
if( !fDialog->IsVisible() )
fDialog->Show();
fChatList->AddElement( new pfKIChatElement( user, msg, flags ) );
if( fChatList->GetNumElements() > kMaxNumChatItems )
fChatList->RemoveElement( 0 );
fChatList->ScrollToBegin();
IncFadeOutTimer( -fFadeOutTimer );
}
void SendChatItem( const char *text )
{
// if( fChatVaultList != nil )
{
const char *userName = plNetClientMgr::GetInstance()->GetPlayerName();
/* plKITextNoteElement *item = new plKITextNoteElement();
item->SetTitle( plNetClientMgr::GetInstance()->GetPlayerName() );
item->SetText( text );
fChatVaultList->AddElement( item );
*/
pfGUIListBoxMod *userList = pfGUIListBoxMod::ConvertNoRef( fDialog->GetControlFromTag( kKITempID_PlayerList ) );
pfKIListPlayerItem *currPlayer = nil;
int mbrIndex = -1;
uint32_t msgFlags;
if( userList != nil && userList->GetNumElements() > 0 && userList->GetSelection() != -1 )
currPlayer = (pfKIListPlayerItem *)userList->GetElement( userList->GetSelection() );
if( currPlayer != nil && currPlayer->GetPlayerKey() != nil )
mbrIndex = plNetClientMgr::GetInstance()->TransportMgr().FindMember( currPlayer->GetPlayerKey() );
pfKIMsg *msg = new pfKIMsg( pfKIMsg::kHACKChatMsg );
msg->SetString( text );
msg->SetUser( userName );
if( fLocalClientIsAdmin )
msg->SetFlags( pfKIMsg::kAdminMsg );
if( mbrIndex != -1 )
{
// Send to one player
msg->SetFlags( msg->GetFlags() | pfKIMsg::kPrivateMsg );
msg->SetTimeStamp( 0 ); // Remove timestamp
// write message (and label) to ram stream
hsRAMStream stream;
hsgResMgr::ResMgr()->WriteCreatable( &stream, msg );
// put stream in net msg wrapper
plNetMsgGameMessageDirected netMsgWrap;
netMsgWrap.StreamInfo()->CopyStream( &stream );
netMsgWrap.StreamInfo()->SetStreamType( msg->ClassIndex() ); // type of game msg
netMsgWrap.SetTimeOffset( 0 );
netMsgWrap.SetClassName( msg->ClassName() );
netMsgWrap.SetSenderPlayerID( plNetClientMgr::GetInstance()->GetPlayerID() );
// set directed client receiver
netMsgWrap.Receivers()->AddReceiverPlayerID( plNetClientMgr::GetInstance()->TransportMgr().GetMember( mbrIndex )->GetPlayerID() );
// send
msgFlags = msg->GetFlags();
plNetClientMgr::GetInstance()->SendMsg( &netMsgWrap, 0 );
}
else
{
// Broadcast to all
msg->SetBCastFlag(plMessage::kNetPropagate | plMessage::kNetForce);
msg->SetBCastFlag(plMessage::kLocalPropagate, 0);
msgFlags = msg->GetFlags();
plgDispatch::MsgSend( msg );
}
fChatList->AddElement( new pfKIChatElement( userName, text, msgFlags ) );
fChatList->ScrollToBegin();
IncFadeOutTimer( -fFadeOutTimer );
if( fChatList->GetNumElements() > kMaxNumChatItems )
fChatList->RemoveElement( 0 );
}
}
void SetCurrentAvatar( plKey avKey )
{
static char str[ 512 ];
int i;
pfGUITextBoxMod *text = pfGUITextBoxMod::ConvertNoRef( fDialog->GetControlFromTag( kKITempID_CurrPlayerText ) );
const char *avName = plNetClientMgr::GetInstance()->GetPlayerName( avKey );
if( text != nil )
{
if( avKey == nil || avName == nil )
text->SetText( "" );
else
{
sprintf( str, "%s", avName );
text->SetText( str );
}
IncFadeOutTimer( -fFadeOutTimer );
}
pfGUIListBoxMod *userList = pfGUIListBoxMod::ConvertNoRef( fDialog->GetControlFromTag( kKITempID_PlayerList ) );
if( userList != nil && userList->GetNumElements() > 0 )
{
if( avKey == nil )
userList->SetSelection( 0 );
else
{
for( i = 0; i < userList->GetNumElements(); i++ )
{
pfKIListPlayerItem *el = (pfKIListPlayerItem *)userList->GetElement( i );
if( el != nil && el->GetPlayerKey() == avKey )
{
userList->SetSelection( i );
break;
}
}
}
}
}
};
//// Callback From the KI Vault //////////////////////////////////////////////
class pfKITextVaultCallback : public plKICallback
{
protected:
plKIMainProc *fTextDlgProc;
plKIMiniProc *fMiniProc;
public:
pfKITextVaultCallback( plKIMainProc *proc, plKIMiniProc *miniProc )
{
fTextDlgProc = proc;
fMiniProc = miniProc;
}
void KIFolderAdded( plKIFolder *folder )
{
}
void KIFolderRemoved()
{
}
void KIElementAddedToFolder( plKIElement *elem, plKIFolder *folder )
{
fTextDlgProc->UpdateTextList();
// if( folder == fMiniProc->GetChatFolder() )
// fMiniProc->ReceivedChatItem( elem );
}
void KIElementChanged( plKIElement *elem )
{
fTextDlgProc->UpdateTextList();
}
void KIElementSeen( plKIElement *elem )
{
}
void KIElementRemovedFromFolder( plKIFolder *folder )
{
fTextDlgProc->UpdateTextList();
// if( folder == fMiniProc->GetChatFolder() )
// fMiniProc->UpdateChatList();
}
void KIAllChanged( void )
{
// Gotta re-grab the list
fTextDlgProc->GrabVaultFolder();
fTextDlgProc->UpdateTextList();
fMiniProc->GrabChatList();
fMiniProc->UpdateChatList();
}
void KISelectedBuddyChanged( plKIPlayerElement *elem )
{
}
void KISendModeChanged( int newMode )
{
}
};
//// Constructor & Destructor ////////////////////////////////////////////////
pfKI::pfKI()
{
// fKIVaultCallback = nil;
// fInstance = this;
}
pfKI::~pfKI()
{
pfGameGUIMgr::GetInstance()->UnloadDialog( "KIMain" );
pfGameGUIMgr::GetInstance()->UnloadDialog( "KIEntry" );
pfGameGUIMgr::GetInstance()->UnloadDialog( "KIYesNo" );
pfGameGUIMgr::GetInstance()->UnloadDialog( "KIMini" );
pfGameGUIMgr::GetInstance()->UnloadDialog( "KIBlackBar" );
// delete fKIVaultCallback;
// fInstance = nil;
}
void pfKI::Init( void )
{
#ifdef USE_INTERNAL_PLAYERBOOK
IInitPlayerBook();
#endif // USE_INTERNAL_PLAYERBOOK
pfGameGUIMgr *mgr = pfGameGUIMgr::GetInstance();
// Load KI dat files
mgr->LoadDialog( "KIBlackBar" );
#ifdef USE_INTERNAL_KI
mgr->LoadDialog( "KIMini" );
mgr->LoadDialog( "KIMain" );
mgr->LoadDialog( "KIEntry" );
mgr->LoadDialog( "KIYesNo" );
pfGUIDialogMod *yesNoDlg = mgr->GetDialogFromTag( kKIYesNoDlg );
pfGUIDialogMod *mainDlg = mgr->GetDialogFromTag( kKIMainDialog );
pfGUIDialogMod *arDlg = mgr->GetDialogFromTag( kKIEntryDlg );
pfGUIDialogMod *miniDlg = mgr->GetDialogFromTag( kKIMiniDialog );
pfGUIDialogMod *blackBarDlg = mgr->GetDialogFromTag( kKITempID_BlackBarDlg );
if( yesNoDlg == nil || mainDlg == nil || arDlg == nil || miniDlg == nil )
{
hsStatusMessage( "==== WARNING: KI Interface not inited (GUI data missing) ====" );
return;
}
if( mainDlg->GetVersion() != kDesiredKIVersion )
{
char str[ 512 ];
sprintf( str, "Incorrect KI dataset version. KI will not be loaded. (Looking for version %d, found version %d)",
kDesiredKIVersion, mainDlg->GetVersion() );
hsMessageBox( str, "Error", hsMessageBoxNormal );
return;
}
// Init our yes/no dialog
fYesNoProc = new plKIYesNoBox;
yesNoDlg->SetHandler( fYesNoProc );
// Init our main dialog
pfGUIListBoxMod *listOfLists = pfGUIListBoxMod::ConvertNoRef( mainDlg->GetControlFromTag( kKITempID_ListOfLists ) );
pfGUIListBoxMod *list = pfGUIListBoxMod::ConvertNoRef( mainDlg->GetControlFromTag( kKITestEditBox ) );
pfGUIControlMod *editBtn = mainDlg->GetControlFromTag( kKIEditButton );
pfGUIControlMod *removeBtn = mainDlg->GetControlFromTag( kKIRemoveButton );
pfGUIRadioGroupCtrl *destRadio = pfGUIRadioGroupCtrl::ConvertNoRef( mainDlg->GetControlFromTag( kKITempID_MsgDestRadio ) );
fMainProc = new plKIMainProc( list, fYesNoProc, miniDlg );
mainDlg->SetHandler( fMainProc );
destRadio->SetValue( 0 );
// Init our add/remove text item dialog
fAddEditProc = new plKIAddEditBox( pfGUIListBoxMod::ConvertNoRef( list ), mainDlg, fMainProc );
arDlg->SetHandler( fAddEditProc );
fMainProc->fAddRemoveHandler = fAddEditProc;
// Make us a proc for our mini dialog's maximize button
fMiniProc = new plKIMiniProc( mainDlg );
miniDlg->SetHandler( fMiniProc );
// Set the callback for the ki vault thingy
plKI *kiVault = plNetClientMgr::GetInstance()->GetPlayerKI();
fKIVaultCallback = new pfKITextVaultCallback( fMainProc, fMiniProc );
kiVault->AddCallback( fKIVaultCallback );
// Finally, show our KI main dialog
if( blackBarDlg != nil )
{
blackBarDlg->SetHandler( new plBlackBarProc( miniDlg, mainDlg, blackBarDlg->GetHandler() ) );
blackBarDlg->Show();
}
else
miniDlg->Show();
// Register for KI messages
plgDispatch::Dispatch()->RegisterForExactType( pfKIMsg::Index(), GetKey() );
plgDispatch::Dispatch()->RegisterForExactType( plRemoteAvatarInfoMsg::Index(), GetKey() );
plgDispatch::Dispatch()->RegisterForExactType( plMemberUpdateMsg::Index(), GetKey() );
plgDispatch::Dispatch()->RegisterForExactType( plTimeMsg::Index(), GetKey() );
#endif // USE_INTERNAL_KI
}
bool pfKI::MsgReceive( plMessage *msg )
{
pfKIMsg *kiMsg = pfKIMsg::ConvertNoRef( msg );
if( kiMsg != nil )
{
if ( fMiniProc != nil )
{
switch ( kiMsg->GetCommand() )
{
case pfKIMsg::kHACKChatMsg:
fMiniProc->ReceivedChatItem( kiMsg->GetUser(), kiMsg->GetString(), kiMsg->GetFlags() );
break;
case pfKIMsg::kEnterChatMode:
fMiniProc->EnterChatMode( !fMiniProc->IsChatting() );
break;
case pfKIMsg::kSetChatFadeDelay:
fMiniProc->SetFadeOutDelay( kiMsg->GetDelay() );
break;
case pfKIMsg::kSetTextChatAdminMode:
fMiniProc->SetLocalClientAsAdmin( kiMsg->GetFlags() & pfKIMsg::kAdminMsg ? true : false );
break;
}
}
return true;
}
plRemoteAvatarInfoMsg *avInfo = plRemoteAvatarInfoMsg::ConvertNoRef( msg );
if( avInfo != nil )
{
if( fMainProc != nil )
fMainProc->SetCurrentAvatar( avInfo->GetAvatarKey() );
if( fMiniProc != nil )
fMiniProc->SetCurrentAvatar( avInfo->GetAvatarKey() );
return true;
}
plMemberUpdateMsg *userUpdateMsg = plMemberUpdateMsg::ConvertNoRef( msg );
if( userUpdateMsg != nil )
{
if( fMiniProc != nil )
fMiniProc->RefreshUserList();
return true;
}
plTimeMsg *time = plTimeMsg::ConvertNoRef( msg );
if( time != nil )
{
if( fMiniProc != nil )
fMiniProc->IncFadeOutTimer( time->DelSeconds() );
return true;
}
return hsKeyedObject::MsgReceive( msg );
}
//////////////////////////////////////////////////////////////////////////////
//// Player Book Stuff ///////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
#include "plNetCommon/plNetAvatarVault.h"
#include "pfGameGUIMgr/pfGUICheckBoxCtrl.h"
#include "plMessage/plLinkToAgeMsg.h"
#include "pfGameGUIMgr/pfGUIDynDisplayCtrl.h"
#include "plGImage/plDynamicTextMap.h"
#include "plGImage/plJPEG.h"
//// plPlayerBookProc ////////////////////////////////////////////////////////
class plPlayerBookProc : public pfGUIDialogProc
{
protected:
pfGUIRadioGroupCtrl *fRadio;
pfGUITextBoxMod *fDescTextBox;
public:
virtual void DoSomething( pfGUIControlMod *ctrl )
{
if( ctrl->GetTagID() == kPBSaveSlotRadio )
{
if( plNetClientMgr::GetInstance()->IsEnabled() )
{
plPlayerLinkPoint &linkPt = plNetClientMgr::GetInstance()->GetLinkPoint( fRadio->GetValue() );
fDescTextBox->SetText( linkPt.GetDescription() );
}
}
else if( ctrl->GetTagID() == kPBLinkToBtn )
{
if( plNetClientMgr::GetInstance()->IsEnabled() )
{
plLinkBackToAgeMsg *msg = new plLinkBackToAgeMsg;
msg->AddReceiver( plNetClientMgr::GetInstance()->GetKey() );
msg->fSavedLinkPointNum = fRadio->GetValue();
plgDispatch::MsgSend( msg );
}
else
{
}
}
else if( ctrl->GetTagID() == kPBSaveLinkBtn )
{
if( plNetClientMgr::GetInstance()->IsEnabled() )
{
plNetClientMgr::GetInstance()->SaveLinkPoint( fRadio->GetValue(), "Description" );
}
else
{
}
}
}
virtual void OnShow( void )
{
fDescTextBox = pfGUITextBoxMod::ConvertNoRef( fDialog->GetControlFromTag( kKIStaticText ) );
fDescTextBox->SetText( "" );
fRadio = pfGUIRadioGroupCtrl::ConvertNoRef( fDialog->GetControlFromTag( kPBSaveSlotRadio ) );
fRadio->SetValue( 0 );
pfGUIDynDisplayCtrl *disp = pfGUIDynDisplayCtrl::ConvertNoRef( fDialog->GetControlFromTag( kPBSaveSlotPrev1 ) );
plDynamicTextMap *map = disp->GetMap( 0 );
map->ClearToColor( hsColorRGBA().Set( 1, 0, 0, 1 ) );
plMipmap *img = plJPEG::Instance().ReadFromFile( "e:\\plasma20\\data\\localdata\\testfile.jpg" );
if( img == nil )
return;
map->DrawImage( 4, 4, img );
}
};
//// IInitPlayerBook /////////////////////////////////////////////////////////
void pfKI::IInitPlayerBook( void )
{
pfGameGUIMgr *mgr = pfGameGUIMgr::GetInstance();
mgr->LoadDialog( "PBDialog" );
pfGUIDialogMod *pbDialog = mgr->GetDialogFromTag( kPlayerBook );
if( pbDialog == nil )
return;
fPBProc = new plPlayerBookProc();
pbDialog->SetHandler( fPBProc );
pbDialog->Show();
}