sources for this page

freezing bug:

added in tactical/handle UI.c

void PreventFromTheFreezingBug(SOLDIERTYPE* pSoldier)
{
gfUIInterfaceSetBusy = FALSE;
UnSetUIBusy( pSoldier->ubID );
gTacticalStatus.ubAttackBusyCount = 0;
guiPendingOverrideEvent = LU_ENDUILOCK;
UIHandleLUIEndLock( NULL );
}

in tactical/handle UI.h

void PreventFromTheFreezingBug(SOLDIERTYPE* pSoldier);

in tactical/soldier ani.c

case 485:

// CODE: Try steal.....
UseHandToHand( pSoldier, pSoldier->sPendingActionData2, TRUE );
//jackaians:
//if we are not waiting for the pickup menu to be displayed
if (guiPendingOverrideEvent != G_GETTINGITEM)
{
PreventFromTheFreezingBug(pSoldier);
}
break;

pickup menu:

(need a little modif in ja2bin.dat)

in tactical/handle items.c

/**
* jackaians: pretty bad function. Create an artificial ItemPool, where
* iItemIndex is not the index in the world, but is used to store the index
* of the opponent's slots.
* if only one item, return in ubIndexRet the item's index
*/
UINT8 StealItems(SOLDIERTYPE* pSoldier,SOLDIERTYPE* pOpponent, UINT8* ubIndexRet)
{
UINT8 ubCount=0;
ITEM_POOL *pItemPool,*pTempItemPool,*pTempLastItemPool;
OBJECTTYPE *pObject;
UINT8 i;

//Create a temporary item pool, with index in Opponent's inventory as index
pItemPool=NULL;
for(i=0 ; i<NUM_INV_SLOTS; i++)
{
pObject=pOpponent->inv+i;
if (pObject->usItem!=0)
{
pTempItemPool = (ITEM_POOL*)MemAlloc(sizeof(ITEM_POOL));
++ubCount;
if (pItemPool == NULL)
{
pItemPool = pTempItemPool;
pItemPool->pPrev = NULL;
}
else
{
pTempItemPool->pPrev = pTempLastItemPool;
pTempLastItemPool->pNext = pTempItemPool;
}
pTempItemPool->pNext = NULL;
pTempItemPool->iItemIndex = i;
//very bad, jack, to test if we are stealing?
pTempItemPool->pLevelNode=NULL;//finally not used
pTempLastItemPool=pTempItemPool;
}
}
if (ubCount == 0)
{
DoMercBattleSound( pSoldier, BATTLE_SOUND_NOTHING );
return( 0);
}

//if only one item
if (ubCount == 1)
{
*ubIndexRet=pItemPool->iItemIndex;
MemFree( pItemPool);
return( 1);
}

// Freeze guy!
pSoldier->fPauseAllAnimation = TRUE;

InitializeStealItemPickupMenu( pSoldier, pOpponent, pItemPool, ubCount);
guiPendingOverrideEvent = G_GETTINGITEM;
return( ubCount );
}

/**
* jackaians: function copied from SoldierGetItemFromWorld
* check user's choices and try to place them in his slots
*/
void SoldierStealItemFromSoldier( SOLDIERTYPE *pSoldier, SOLDIERTYPE *pOpponent,ITEM_POOL *pItemPool, INT32 iItemIndex, INT16 sGridNo, INT8 bZLevel, BOOLEAN *pfSelectionList )
{
ITEM_POOL *pTempItemPool;
OBJECTTYPE Object;
INT32 cnt = 0;
BOOLEAN fPickup;
BOOLEAN fFailedAutoPlace = FALSE;
BOOLEAN fShouldSayCoolQuote = FALSE;
BOOLEAN fDidSayCoolQuote = FALSE;

// OK. CHECK IF WE ARE DOING ALL IN THIS POOL....
if ( iItemIndex == ITEM_PICKUP_ACTION_ALL || iItemIndex == ITEM_PICKUP_SELECTION )
{
pTempItemPool = pItemPool;

while( pTempItemPool )
{
fPickup = TRUE;
if ( iItemIndex == ITEM_PICKUP_SELECTION )
{
if ( !pfSelectionList[ cnt ] )
{
fPickup = FALSE;
}
}
// Increment counter...
cnt++;
if ( fPickup )
{
// Make copy of item
memcpy( &Object, pOpponent->inv+pTempItemPool->iItemIndex, sizeof( OBJECTTYPE ) );
if ( ItemIsCool( &Object ) )
{
fShouldSayCoolQuote = TRUE;
}
if ( !AutoPlaceObject( pSoldier, &Object, TRUE ) )
{
AddItemToPool( pSoldier->sGridNo, &Object, 1, pSoldier->bLevel, 0, -1 );
}
DeleteObj(pOpponent->inv+pTempItemPool->iItemIndex);
}
pTempItemPool = pTempItemPool->pNext;
}
}
// OK, check if potentially a good candidate for cool quote
if ( fShouldSayCoolQuote && pSoldier->bTeam == gbPlayerNum )
{
// Do we have this quote..?
if ( QuoteExp_GotGunOrUsedGun[ pSoldier->ubProfile ] == QUOTE_FOUND_SOMETHING_SPECIAL )
{
// Have we not said it today?
if ( !( pSoldier->usQuoteSaidFlags & SOLDIER_QUOTE_SAID_FOUND_SOMETHING_NICE ) )
{
// set flag
pSoldier->usQuoteSaidFlags |= SOLDIER_QUOTE_SAID_FOUND_SOMETHING_NICE;
// Say it....
// We've found something!
TacticalCharacterDialogue( pSoldier, QUOTE_FOUND_SOMETHING_SPECIAL );
fDidSayCoolQuote = TRUE;
}
}
}
// Aknowledge....
if( pSoldier->bTeam == OUR_TEAM && !fDidSayCoolQuote )
{
DoMercBattleSound( pSoldier, BATTLE_SOUND_GOTIT );
}
gpTempSoldier = pSoldier;
gsTempGridno = sGridNo;
SetCustomizableTimerCallbackAndDelay( 1000, CheckForPickedOwnership, TRUE );
}

-in handle items.h

void SoldierStealItemFromSoldier( SOLDIERTYPE *pSoldier, SOLDIERTYPE *pOpponent,ITEM_POOL *pItemPool, INT32 iItemIndex, INT16 sGridNo, INT8 bZLevel, BOOLEAN *pfSelectionList ); UINT8 StealItems(SOLDIERTYPE* pSoldier,SOLDIERTYPE* pOpponent, UINT8* ubIndexRet);

 

-in interface items.c

//jackaians: global variables added for the stealing pickup menu
BOOLEAN gfStealing = FALSE;
SOLDIERTYPE *gpOpponent = NULL;

 

-a few lines to modify:

void ItemPickupOK( GUI_BUTTON *btn, INT32 reason )
{
INT32 cnt = 0;
UINT16 usLastItem;

if(reason & MSYS_CALLBACK_REASON_LBUTTON_DWN )
{
btn->uiFlags |= BUTTON_CLICKED_ON;
}
else if(reason & MSYS_CALLBACK_REASON_LBUTTON_UP )
{
btn->uiFlags &= (~BUTTON_CLICKED_ON );

// OK, pickup item....
gItemPickupMenu.fHandled = TRUE;

if (gfStealing) //jackaians modif
{
usLastItem=gpOpponent->inv[HANDPOS].usItem;
SoldierStealItemFromSoldier( gItemPickupMenu.pSoldier,gpOpponent,gItemPickupMenu.pItemPool, ITEM_PICKUP_SELECTION, gItemPickupMenu.sGridNo, gItemPickupMenu.bZLevel, gItemPickupMenu.pfSelectedArray );
DeletePool(gItemPickupMenu.pItemPool);
if ((gpOpponent->inv[HANDPOS].usItem == NOTHING ) && (usLastItem!=NOTHING))
ReLoadSoldierAnimationDueToHandItemChange( gpOpponent, usLastItem, NOTHING );
}
else
{
// Tell our soldier to pickup this item!
SoldierGetItemFromWorld( gItemPickupMenu.pSoldier, ITEM_PICKUP_SELECTION, gItemPickupMenu.sGridNo, gItemPickupMenu.bZLevel, gItemPickupMenu.pfSelectedArray );
}
}
else if(reason & MSYS_CALLBACK_REASON_LOST_MOUSE )
{
btn->uiFlags &= (~BUTTON_CLICKED_ON );
}
}

void ItemPickupCancel( GUI_BUTTON *btn, INT32 reason )
{
INT32 cnt = 0;

if(reason & MSYS_CALLBACK_REASON_LBUTTON_DWN )
{
btn->uiFlags |= BUTTON_CLICKED_ON;
if (gfStealing) //jackaians modif
{
DeletePool(gItemPickupMenu.pItemPool);
}
}
else if(reason & MSYS_CALLBACK_REASON_LBUTTON_UP )
{
btn->uiFlags &= (~BUTTON_CLICKED_ON );

// OK, pickup item....
gItemPickupMenu.fHandled = TRUE;
}
else if(reason & MSYS_CALLBACK_REASON_LOST_MOUSE )
{
btn->uiFlags &= (~BUTTON_CLICKED_ON );
}
}

/**
* jackaians: copied from InitializeItemPickupMenu
*/
BOOLEAN InitializeStealItemPickupMenu( SOLDIERTYPE *pSoldier, SOLDIERTYPE *pOpponent, ITEM_POOL *pItemPool, UINT8 ubCount)
{
VOBJECT_DESC VObjectDesc;
UINT8 ubString[48];
INT16 sCenX, sCenY, sX, sY, sCenterYVal;
INT8 bZLevel =pOpponent->bLevel;
INT16 sGridNo =pOpponent->sGridNo;
INT32 cnt;
gpOpponent =pOpponent;
gfStealing =TRUE;

// Erase other menus....
EraseInterfaceMenus( TRUE );

// Make sure menu is located if not on screen
LocateSoldier( pOpponent->ubID, FALSE );

// memset values
memset( &gItemPickupMenu, 0, sizeof( gItemPickupMenu ) );

//Set item pool value
gItemPickupMenu.pItemPool = pItemPool;

InterruptTime();
PauseGame();
LockPauseState( 18 );
// Pause timers as well....
PauseTime( TRUE );

// Alrighty, cancel lock UI if we havn't done so already
UnSetUIBusy( pSoldier->ubID );

// Change to INV panel if not there already...
gfSwitchPanel = TRUE;
gbNewPanel = SM_PANEL;
gubNewPanelParam = (UINT8)pSoldier->ubID;

gItemPickupMenu.ubTotalItems = ubCount;

// Determine # of slots per page
if ( gItemPickupMenu.ubTotalItems > NUM_PICKUP_SLOTS )
{
gItemPickupMenu.bNumSlotsPerPage = NUM_PICKUP_SLOTS;
}
else
{
gItemPickupMenu.bNumSlotsPerPage = gItemPickupMenu.ubTotalItems;
}

VObjectDesc.fCreateFlags = VOBJECT_CREATE_FROMFILE;
FilenameForBPP("INTERFACE\\itembox.sti", VObjectDesc.ImageFile);
CHECKF( AddVideoObject( &VObjectDesc, &(gItemPickupMenu.uiPanelVo) ) );

// Memalloc selection array...
gItemPickupMenu.pfSelectedArray = MemAlloc(( sizeof( UINT8 ) * gItemPickupMenu.ubTotalItems ) );
// seto to 0
memset( gItemPickupMenu.pfSelectedArray, 0, ( sizeof( UINT8 ) * gItemPickupMenu.ubTotalItems ) );

// Calcualate dimensions
CalculateItemPickupMenuDimensions( );

// Get XY
{
// First get mouse xy screen location
if( sGridNo != NOWHERE )
{
sX = gusMouseXPos;
sY = gusMouseYPos;
}
else
{
sX = 0;
sY = 0;
}

// CHECK FOR LEFT/RIGHT
if ( ( sX + gItemPickupMenu.sWidth ) > 640 )
{
sX = 640 - gItemPickupMenu.sWidth - ITEMPICK_START_X_OFFSET;
}
else
{
sX = sX + ITEMPICK_START_X_OFFSET;
}

// Now check for top
// Center in the y
sCenterYVal = gItemPickupMenu.sHeight / 2;

sY -= sCenterYVal;

if ( sY < gsVIEWPORT_WINDOW_START_Y )
{
sY = gsVIEWPORT_WINDOW_START_Y;
}

// Check for bottom
if ( ( sY + gItemPickupMenu.sHeight ) > 340 )
{
sY = 340 - gItemPickupMenu.sHeight;
}

}

// Set some values
gItemPickupMenu.sX = sX;
gItemPickupMenu.sY = sY;
gItemPickupMenu.bCurSelect = 0;
gItemPickupMenu.pSoldier = pSoldier;
gItemPickupMenu.fHandled = FALSE;
gItemPickupMenu.sGridNo = sGridNo;
gItemPickupMenu.bZLevel = bZLevel;
gItemPickupMenu.fAtLeastOneSelected = FALSE;
gItemPickupMenu.fAllSelected = FALSE;

//Load images for buttons
FilenameForBPP("INTERFACE\\itembox.sti", ubString );
gItemPickupMenu.iUpButtonImages = LoadButtonImage( ubString, -1,5,-1,10,-1 );
gItemPickupMenu.iDownButtonImages = UseLoadedButtonImage( gItemPickupMenu.iUpButtonImages, -1, 7, -1, 12, -1 );
gItemPickupMenu.iAllButtonImages = UseLoadedButtonImage( gItemPickupMenu.iUpButtonImages, -1, 6, -1,11, -1 );
gItemPickupMenu.iCancelButtonImages = UseLoadedButtonImage( gItemPickupMenu.iUpButtonImages, -1, 8, -1, 13, -1 );
gItemPickupMenu.iOKButtonImages = UseLoadedButtonImage( gItemPickupMenu.iUpButtonImages, -1, 4, -1, 9, -1 );

// Build a mouse region here that is over any others.....
MSYS_DefineRegion( &(gItemPickupMenu.BackRegion ), (INT16)( 532 ), (INT16)( 367 ), (INT16)( 640 ),(INT16)( 480 ), MSYS_PRIORITY_HIGHEST,
CURSOR_NORMAL, MSYS_NO_CALLBACK, MSYS_NO_CALLBACK );
// Add region
MSYS_AddRegion( &(gItemPickupMenu.BackRegion ) );

// Build a mouse region here that is over any others.....
MSYS_DefineRegion( &(gItemPickupMenu.BackRegions ), (INT16)(gItemPickupMenu.sX ), (INT16)(gItemPickupMenu.sY), (INT16)(gItemPickupMenu.sX + gItemPickupMenu.sWidth ),(INT16)( gItemPickupMenu.sY + gItemPickupMenu.sHeight ), MSYS_PRIORITY_HIGHEST,
CURSOR_NORMAL, MSYS_NO_CALLBACK, MSYS_NO_CALLBACK );
// Add region
MSYS_AddRegion( &(gItemPickupMenu.BackRegions ) );

// Create buttons
if ( gItemPickupMenu.bNumSlotsPerPage == NUM_PICKUP_SLOTS && gItemPickupMenu.ubTotalItems > NUM_PICKUP_SLOTS )
{
gItemPickupMenu.iUpButton = QuickCreateButton( gItemPickupMenu.iUpButtonImages, (INT16)(sX + ITEMPICK_UP_X), (INT16)(sY + gItemPickupMenu.sButtomPanelStartY + ITEMPICK_UP_Y),
BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
DEFAULT_MOVE_CALLBACK, (GUI_CALLBACK)ItemPickupScrollUp );

SetButtonFastHelpText( gItemPickupMenu.iUpButton, ItemPickupHelpPopup[ 1 ] );

gItemPickupMenu.iDownButton = QuickCreateButton( gItemPickupMenu.iDownButtonImages, (INT16)(sX + ITEMPICK_DOWN_X), (INT16)(sY + gItemPickupMenu.sButtomPanelStartY + ITEMPICK_DOWN_Y),
BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
DEFAULT_MOVE_CALLBACK, (GUI_CALLBACK)ItemPickupScrollDown );

SetButtonFastHelpText( gItemPickupMenu.iDownButton, ItemPickupHelpPopup[ 3 ] );

}

gItemPickupMenu.iOKButton = QuickCreateButton( gItemPickupMenu.iOKButtonImages, (INT16)(sX + ITEMPICK_OK_X), (INT16)(sY + gItemPickupMenu.sButtomPanelStartY + ITEMPICK_OK_Y),
BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
DEFAULT_MOVE_CALLBACK, (GUI_CALLBACK)ItemPickupOK );
SetButtonFastHelpText( gItemPickupMenu.iOKButton, ItemPickupHelpPopup[ 0 ] );

gItemPickupMenu.iAllButton = QuickCreateButton( gItemPickupMenu.iAllButtonImages, (INT16)(sX + ITEMPICK_ALL_X), (INT16)(sY + gItemPickupMenu.sButtomPanelStartY + ITEMPICK_ALL_Y),
BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
DEFAULT_MOVE_CALLBACK, (GUI_CALLBACK)ItemPickupAll );
SetButtonFastHelpText( gItemPickupMenu.iAllButton, ItemPickupHelpPopup[ 2 ] );

gItemPickupMenu.iCancelButton = QuickCreateButton( gItemPickupMenu.iCancelButtonImages, (INT16)(sX + ITEMPICK_CANCEL_X), (INT16)(sY + gItemPickupMenu.sButtomPanelStartY + ITEMPICK_CANCEL_Y),
BUTTON_TOGGLE, MSYS_PRIORITY_HIGHEST,
DEFAULT_MOVE_CALLBACK, (GUI_CALLBACK)ItemPickupCancel );
SetButtonFastHelpText( gItemPickupMenu.iCancelButton, ItemPickupHelpPopup[ 4 ] );

DisableButton( gItemPickupMenu.iOKButton );

// Create regions...
sCenX = gItemPickupMenu.sX;
sCenY = gItemPickupMenu.sY + ITEMPICK_GRAPHIC_Y;

for ( cnt = 0; cnt < gItemPickupMenu.bNumSlotsPerPage; cnt++ )
{
// Build a mouse region here that is over any others.....
MSYS_DefineRegion( &(gItemPickupMenu.Regions[cnt]), (INT16)(sCenX ), (INT16)(sCenY + 1), (INT16)(sCenX + gItemPickupMenu.sWidth ),(INT16)( sCenY + ITEMPICK_GRAPHIC_YSPACE ), MSYS_PRIORITY_HIGHEST,
CURSOR_NORMAL, ItemPickMenuMouseMoveCallback, ItemPickMenuMouseClickCallback );
// Add region
MSYS_AddRegion( &(gItemPickupMenu.Regions[cnt]) );
MSYS_SetRegionUserData( &(gItemPickupMenu.Regions[cnt]), 0, cnt );

sCenY += ITEMPICK_GRAPHIC_YSPACE;
}

//Save dirty rect
//gItemPickupMenu.iDirtyRect = RegisterBackgroundRect( BGND_FLAG_PERMANENT | BGND_FLAG_SAVERECT, NULL, gItemPickupMenu.sX, gItemPickupMenu.sY, (INT16)(gItemPickupMenu.sX + gItemPickupMenu.sWidth ) , (INT16)(gItemPickupMenu.sY + gItemPickupMenu.sHeight ) );

SetupPickupPage(0);
gfInItemPickupMenu = TRUE;

// Ignore scrolling
gfIgnoreScrolling = TRUE;

HandleAnyMercInSquadHasCompatibleStuff( (INT8) CurrentSquad( ), NULL, TRUE );
gubSelectSMPanelToMerc = pSoldier->ubID;
ReEvaluateDisabledINVPanelButtons( );
DisableTacticalTeamPanelButtons( TRUE );

//gfSMDisableForItems = TRUE;
return( TRUE );

}
void DeletePool(ITEM_POOL *pItemPool)
{
ITEM_POOL *pItemPoolToDelete;
while(pItemPool!=NULL)
{
pItemPoolToDelete=pItemPool;
pItemPool=pItemPool->pNext;
MemFree(pItemPoolToDelete);
}
}

 

-modifying a few lines to have this

pObject = (gfStealing)? gpOpponent->inv+ gItemPickupMenu.ItemPoolSlots[ cnt ]->iItemIndex :&(gWorldItems[ gItemPickupMenu.ItemPoolSlots[ cnt ]->iItemIndex ].o );

- in weapons.c, function UseHandToHand

if ( pSoldier->bTeam == gbPlayerNum && pTargetSoldier->bTeam != gbPlayerNum && !(pTargetSoldier->uiStatusFlags & SOLDIER_VEHICLE) && !AM_A_ROBOT( pTargetSoldier ) && !TANK( pTargetSoldier ) )
{
// made a steal; give experience
StatChange( pSoldier, STRAMT, 8, FALSE );
}
if (( iDiceRoll <= iHitChance * 2 / 3) || (pTargetSoldier->bCollapsed))
{
if (StealItems(pSoldier, pTargetSoldier,&ubIndexRet) == 1)
{
ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, Message[ STR_STOLE_SOMETHING ], pSoldier->name, ShortItemNames[ pTargetSoldier->inv[ubIndexRet].usItem ] );
if (!AutoPlaceObject( pSoldier, &(pTargetSoldier->inv[ubIndexRet]), TRUE ))
AddItemToPool( pSoldier->sGridNo, &(pTargetSoldier->inv[HANDPOS]), 1, pSoldier->bLevel, 0, -1 );
DeleteObj( &(pTargetSoldier->inv[ubIndexRet]) );
}
}
else if ( pTargetSoldier->inv[HANDPOS].usItem != NOTHING )
{
ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, Message[ STR_STOLE_SOMETHING ], pSoldier->name, ShortItemNames[ pTargetSoldier->inv[HANDPOS].usItem ] );
usOldItem = pTargetSoldier->inv[HANDPOS].usItem;
if ( pSoldier->bTeam == gbPlayerNum )
{
DoMercBattleSound( pSoldier, BATTLE_SOUND_CURSE1 );
}

// Item dropped somewhere... roll based on the same chance to determine where!
iDiceRoll = (INT32) PreRandom( 100 );
if (iDiceRoll < iHitChance)
{
// Drop item in the our tile
AddItemToPool( pSoldier->sGridNo, &(pTargetSoldier->inv[HANDPOS]), 1, pSoldier->bLevel, 0, -1 );
}
else
{
// Drop item in the target's tile
AddItemToPool( pTargetSoldier->sGridNo, &(pTargetSoldier->inv[HANDPOS]), 1, pSoldier->bLevel, 0, -1 );
}
DeleteObj( &(pTargetSoldier->inv[HANDPOS]) );
// Reload buddy's animation...
ReLoadSoldierAnimationDueToHandItemChange( pTargetSoldier, usOldItem, NOTHING );
}
else
{
fFailure=TRUE;
}
// Reload buddy's animation...
//ReLoadSoldierAnimationDueToHandItemChange( pTargetSoldier, usOldItem, NOTHING );