nitro/nitro-react
1
0
Fork 0
mirror of https://github.com/billsonnn/nitro-react.git synced 2025-02-20 18:52:35 +01:00
Code Issues Packages Projects Releases Wiki Activity

More changes

Browse Source
This commit is contained in:
Bill 2022-03-30 12:42:04 -04:00
parent da1b0c508d
commit afb8b8b48b
12 changed files with 199 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/api/inventory/GroupItem.ts
View File

@ -281,8 +281,8 @@ export class GroupItem
while(index < items.length)
{
const item = items[index];
const locked = (itemIds.indexOf(item.ref) >= 0);
const item = items[index];
const locked = (itemIds.indexOf(item.ref) >= 0);
if(item.locked !== locked)
{

5
src/api/inventory/TradeUserData.ts
View File

@ -6,10 +6,9 @@ export class TradeUserData
constructor(
public userId: number = -1,
public userName: string = '',
public userItems: AdvancedMap<string, GroupItem> = null,
public userItems: AdvancedMap<string, GroupItem> = new AdvancedMap(),
public itemCount: number = 0,
public creditsCount: number = 0,
public accepts: boolean = false,
public canTrade: boolean = false,
public items: AdvancedMap<string, GroupItem> = new AdvancedMap()) {}
public canTrade: boolean = false) {}
}

6
src/components/catalog/views/page/layout/CatalogLayoutBadgeDisplayView.tsx
View File

@ -1,10 +1,6 @@
import { FC } from 'react';
import { LocalizeText } from '../../../../../api';
import { Base } from '../../../../../common/Base';
import { Column } from '../../../../../common/Column';
import { Flex } from '../../../../../common/Flex';
import { Grid } from '../../../../../common/Grid';
import { Text } from '../../../../../common/Text';
import { Base, Column, Flex, Grid, Text } from '../../../../../common';
import { useCatalogContext } from '../../../CatalogContext';
import { CatalogBadgeSelectorWidgetView } from '../widgets/CatalogBadgeSelectorWidgetView';
import { CatalogFirstProductSelectorWidgetView } from '../widgets/CatalogFirstProductSelectorWidgetView';

17
src/components/catalog/views/page/widgets/CatalogBadgeSelectorWidgetView.tsx
View File

@ -1,6 +1,5 @@
import { StringDataType } from '@nitrots/nitro-renderer';
import { FC, useEffect, useMemo, useState } from 'react';
import { IBadgeItem } from '../../../../../api';
import { AutoGrid, AutoGridProps, LayoutBadgeImageView, LayoutGridItem } from '../../../../../common';
import { useSharedInventoryBadges } from '../../../../../hooks';
import { useCatalogContext } from '../../../CatalogContext';
@ -15,20 +14,20 @@ interface CatalogBadgeSelectorWidgetViewProps extends AutoGridProps
export const CatalogBadgeSelectorWidgetView: FC<CatalogBadgeSelectorWidgetViewProps> = props =>
{
const { columnCount = 5, ...rest } = props;
const [ currentBadge, setCurrentBadge ] = useState<IBadgeItem>(null);
const [ currentBadgeCode, setCurrentBadgeCode ] = useState<string>(null);
const { currentOffer = null, setPurchaseOptions = null } = useCatalogContext();
const { badges = [] } = useSharedInventoryBadges();
const { badgeCodes = [] } = useSharedInventoryBadges();
const previewStuffData = useMemo(() =>
{
if(!currentBadge) return null;
if(!currentBadgeCode) return null;
const stuffData = new StringDataType();
stuffData.setValue([ '0', currentBadge.badgeCode, '', '' ]);
stuffData.setValue([ '0', currentBadgeCode, '', '' ]);
return stuffData;
}, [ currentBadge ]);
}, [ currentBadgeCode ]);
useEffect(() =>
{
@ -48,11 +47,11 @@ export const CatalogBadgeSelectorWidgetView: FC<CatalogBadgeSelectorWidgetViewPr
return (
<AutoGrid columnCount={ columnCount } { ...rest }>
{ badges && (badges.length > 0) && badges.map((badge, index) =>
{ badgeCodes && (badgeCodes.length > 0) && badgeCodes.map((badgeCode, index) =>
{
return (
<LayoutGridItem key={ index } itemActive={ (currentBadge === badge) } onClick={ event => setCurrentBadge(badge) }>
<LayoutBadgeImageView badgeCode={ badge.badgeCode } />
<LayoutGridItem key={ index } itemActive={ (currentBadgeCode === badgeCode) } onClick={ event => setCurrentBadgeCode(badgeCode) }>
<LayoutBadgeImageView badgeCode={ badgeCode } />
</LayoutGridItem>
);
}) }

51
src/components/inventory/InventoryView.tsx
View File

@ -1,10 +1,9 @@
import { BadgePointLimitsEvent, ILinkEventTracker, IRoomSession, RoomEngineObjectEvent, RoomEngineObjectPlacedEvent, RoomPreviewer, RoomSessionEvent, TradingOpenComposer } from '@nitrots/nitro-renderer';
import { BadgePointLimitsEvent, ILinkEventTracker, IRoomSession, RoomEngineObjectEvent, RoomEngineObjectPlacedEvent, RoomPreviewer, RoomSessionEvent } from '@nitrots/nitro-renderer';
import { FC, useCallback, useEffect, useState } from 'react';
import { AddEventLinkTracker, GetLocalization, GetRoomEngine, LocalizeText, RemoveLinkEventTracker, SendMessageComposer, UnseenItemCategory } from '../../api';
import { AddEventLinkTracker, GetLocalization, GetRoomEngine, LocalizeText, RemoveLinkEventTracker, UnseenItemCategory } from '../../api';
import { isObjectMoverRequested, setObjectMoverRequested } from '../../api/inventory/InventoryUtilities';
import { NitroCardContentView, NitroCardHeaderView, NitroCardTabsItemView, NitroCardTabsView, NitroCardView } from '../../common';
import { InventoryTradeRequestEvent } from '../../events';
import { UseMessageEventHook, UseRoomEngineEvent, UseRoomSessionManagerEvent, useSharedInventoryUnseenTracker, UseUiEvent } from '../../hooks';
import { UseMessageEventHook, UseRoomEngineEvent, UseRoomSessionManagerEvent, useSharedInventoryTrade, useSharedInventoryUnseenTracker } from '../../hooks';
import { InventoryBadgeView } from './views/InventoryBadgeView';
import { InventoryBotView } from './views/InventoryBotView';
import { InventoryFurnitureView } from './views/InventoryFurnitureView';
@ -24,40 +23,15 @@ export const InventoryView: FC<{}> = props =>
const [ currentTab, setCurrentTab ] = useState<string>(TABS[0]);
const [ roomSession, setRoomSession ] = useState<IRoomSession>(null);
const [ roomPreviewer, setRoomPreviewer ] = useState<RoomPreviewer>(null);
const { isTrading = false, stopTrading = null } = useSharedInventoryTrade();
const { getCount = null, resetCategory = null } = useSharedInventoryUnseenTracker();
const close = useCallback(() =>
const close = () =>
{
// close the trade
// if(furnitureState.tradeData)
// {
// switch(furnitureState.tradeData.state)
// {
// case TradeState.TRADING_STATE_RUNNING:
// SendMessageComposer(new TradingCloseComposer());
// return;
// default:
// SendMessageComposer(new TradingCancelComposer());
// return;
// }
// }
if(isTrading) stopTrading();
setIsVisible(false);
}, []);
const onInventoryTradeRequestEvent = useCallback((event: InventoryTradeRequestEvent) =>
{
switch(event.type)
{
case InventoryTradeRequestEvent.REQUEST_TRADE: {
const tradeEvent = (event as InventoryTradeRequestEvent);
SendMessageComposer(new TradingOpenComposer(tradeEvent.objectId));
}
}
}, []);
UseUiEvent(InventoryTradeRequestEvent.REQUEST_TRADE, onInventoryTradeRequestEvent);
}
const onRoomEngineObjectPlacedEvent = useCallback((event: RoomEngineObjectPlacedEvent) =>
{
@ -143,13 +117,8 @@ export const InventoryView: FC<{}> = props =>
useEffect(() =>
{
if(!isVisible)
{
// if trading show it
}
}, [ isVisible ]);
const isTrading = false;
if(!isVisible && isTrading) setIsVisible(true);
}, [ isVisible, isTrading ]);
if(!isVisible) return null;

39
src/components/inventory/views/InventoryBadgeView.tsx
View File

@ -1,16 +1,16 @@
import { FC, useEffect } from 'react';
import { IBadgeItem, LocalizeBadgeName, LocalizeText, UnseenItemCategory } from '../../../api';
import { LocalizeBadgeName, LocalizeText, UnseenItemCategory } from '../../../api';
import { AutoGrid, Button, Column, Flex, Grid, LayoutBadgeImageView, LayoutGridItem, Text } from '../../../common';
import { useSharedInventoryBadges, useSharedInventoryUnseenTracker } from '../../../hooks';
export const InventoryBadgeView: FC<{}> = props =>
{
const { badges = [], activeBadges = [], selectedBadge = null, isWearingBadge = null, canWearBadges = null, toggleBadge = null, selectBadge = null } = useSharedInventoryBadges();
const { badgeCodes = [], activeBadgeCodes = [], selectedBadgeCode = null, isWearingBadge = null, canWearBadges = null, toggleBadge = null, selectBadge = null, getBadgeId = null } = useSharedInventoryBadges();
const { getCount = null, resetCategory = null, isUnseen = null, removeUnseen = null } = useSharedInventoryUnseenTracker();
useEffect(() =>
{
if(!badges || !badges.length) return;
if(!badgeCodes || !badgeCodes.length) return;
return () =>
{
@ -20,23 +20,24 @@ export const InventoryBadgeView: FC<{}> = props =>
resetCategory(UnseenItemCategory.BADGE);
}
}, [ badges, getCount, resetCategory ]);
}, [ badgeCodes, getCount, resetCategory ]);
const InventoryBadgeItemView: FC<{ badge: IBadgeItem }> = props =>
const InventoryBadgeItemView: FC<{ badgeCode: string }> = props =>
{
const { badge = null, children = null, ...rest } = props;
const unseen = isUnseen(UnseenItemCategory.BADGE, badge.id);
const { badgeCode = null, children = null, ...rest } = props;
const badgeId = getBadgeId(badgeCode);
const unseen = isUnseen(UnseenItemCategory.BADGE, badgeId);
const select = () =>
{
selectBadge(badge);
selectBadge(badgeCode);
if(unseen) removeUnseen(UnseenItemCategory.BADGE, badge.id);
if(unseen) removeUnseen(UnseenItemCategory.BADGE, badgeId);
}
return (
<LayoutGridItem itemActive={ (selectedBadge === badge) } itemUnseen={ unseen } onMouseDown={ select } { ...rest }>
<LayoutBadgeImageView badgeCode={ badge.badgeCode } />
<LayoutGridItem itemActive={ (selectedBadgeCode === badgeCode) } itemUnseen={ unseen } onMouseDown={ select } { ...rest }>
<LayoutBadgeImageView badgeCode={ badgeCode } />
{ children }
</LayoutGridItem>
);
@ -46,11 +47,11 @@ export const InventoryBadgeView: FC<{}> = props =>
<Grid>
<Column size={ 7 } overflow="hidden">
<AutoGrid columnCount={ 4 }>
{ badges && (badges.length > 0) && badges.map((badge, index) =>
{ badgeCodes && (badgeCodes.length > 0) && badgeCodes.map((badgeCode, index) =>
{
if(activeBadges.indexOf(badge) >= 0) return null;
if(activeBadgeCodes.indexOf(badgeCode) >= 0) return null;
return <InventoryBadgeItemView key={ index } badge={ badge } />
return <InventoryBadgeItemView key={ index } badgeCode={ badgeCode } />
}) }
</AutoGrid>
</Column>
@ -58,16 +59,16 @@ export const InventoryBadgeView: FC<{}> = props =>
<Column overflow="hidden" gap={ 2 }>
<Text>{ LocalizeText('inventory.badges.activebadges') }</Text>
<AutoGrid columnCount={ 3 }>
{ activeBadges && (activeBadges.length > 0) && activeBadges.map((badge, index) => <InventoryBadgeItemView key={ index } badge={ badge } />) }
{ activeBadgeCodes && (activeBadgeCodes.length > 0) && activeBadgeCodes.map((badgeCode, index) => <InventoryBadgeItemView key={ index } badgeCode={ badgeCode } />) }
</AutoGrid>
</Column>
{ !!selectedBadge &&
{ !!selectedBadgeCode &&
<Column grow justifyContent="end" gap={ 2 }>
<Flex alignItems="center" gap={ 2 }>
<LayoutBadgeImageView shrink badgeCode={ selectedBadge.badgeCode } />
<Text>{ LocalizeBadgeName(selectedBadge.badgeCode) }</Text>
<LayoutBadgeImageView shrink badgeCode={ selectedBadgeCode } />
<Text>{ LocalizeBadgeName(selectedBadgeCode) }</Text>
</Flex>
<Button variant={ (isWearingBadge(selectedBadge) ? 'danger' : 'success') } disabled={ !isWearingBadge(selectedBadge) && !canWearBadges() } onClick={ event => toggleBadge(selectedBadge) }>{ LocalizeText(isWearingBadge(selectedBadge) ? 'inventory.badges.clearbadge' : 'inventory.badges.wearbadge') }</Button>
<Button variant={ (isWearingBadge(selectedBadgeCode) ? 'danger' : 'success') } disabled={ !isWearingBadge(selectedBadgeCode) && !canWearBadges() } onClick={ event => toggleBadge(selectedBadgeCode) }>{ LocalizeText(isWearingBadge(selectedBadgeCode) ? 'inventory.badges.clearbadge' : 'inventory.badges.wearbadge') }</Button>
</Column> }
</Column>
</Grid>

28
src/components/inventory/views/InventoryTradeView.tsx
View File

@ -26,9 +26,9 @@ export const InventoryTradeView: FC<InventoryTradeViewProps> = props =>
const canTradeItem = (isWallItem: boolean, spriteId: number, category: number, groupable: boolean, stuffData: IObjectData) =>
{
if(!ownUser || ownUser.accepts || !ownUser.items) return false;
if(!ownUser || ownUser.accepts || !ownUser.userItems) return false;
if(ownUser.items.length < MAX_ITEMS_TO_TRADE) return true;
if(ownUser.userItems.length < MAX_ITEMS_TO_TRADE) return true;
if(!groupable) return false;
@ -50,7 +50,7 @@ export const InventoryTradeView: FC<InventoryTradeViewProps> = props =>
}
}
return !!ownUser.items.getValue(type);
return !!ownUser.userItems.getValue(type);
}
const attemptItemOffer = (count: number) =>
@ -71,7 +71,7 @@ export const InventoryTradeView: FC<InventoryTradeViewProps> = props =>
if(!coreItem) coreItem = item;
}
const ownItemCount = ownUser.items.length;
const ownItemCount = ownUser.userItems.length;
if((ownItemCount + itemIds.length) <= 1500)
{
@ -130,12 +130,7 @@ export const InventoryTradeView: FC<InventoryTradeViewProps> = props =>
{
const newValue = (prevValue - 1);
if(newValue === 0)
{
setTradeState(TradeState.TRADING_STATE_CONFIRMING);
clearInterval(interval);
}
if(newValue === 0) clearInterval(interval);
return newValue;
});
@ -144,6 +139,15 @@ export const InventoryTradeView: FC<InventoryTradeViewProps> = props =>
return () => clearInterval(interval);
}, [ tradeState, setTradeState ]);
useEffect(() =>
{
if(countdownTick !== 0) return;
setTradeState(TradeState.TRADING_STATE_CONFIRMING);
}, [ countdownTick, setTradeState ]);
if((tradeState === TradeState.TRADING_STATE_READY) || !ownUser || !otherUser) return null;
return (
<Grid>
<Column size={ 4 } overflow="hidden">
@ -179,7 +183,7 @@ export const InventoryTradeView: FC<InventoryTradeViewProps> = props =>
<AutoGrid columnCount={ 3 }>
{ Array.from(Array(MAX_ITEMS_TO_TRADE), (e, i) =>
{
const item = (ownUser.items.getWithIndex(i) || null);
const item = (ownUser.userItems.getWithIndex(i) || null);
if(!item) return <LayoutGridItem key={ i } />;
@ -205,7 +209,7 @@ export const InventoryTradeView: FC<InventoryTradeViewProps> = props =>
<AutoGrid columnCount={ 3 }>
{ Array.from(Array(MAX_ITEMS_TO_TRADE), (e, i) =>
{
const item = (otherUser.items.getWithIndex(i) || null);
const item = (otherUser.userItems.getWithIndex(i) || null);
if(!item) return <LayoutGridItem key={ i } />;

63
src/hooks/inventory/common/TradingUtilities.ts
View File

@ -9,40 +9,41 @@ export const parseTradeItems = (items: ItemDataStructure[]) =>
const existingItems = new AdvancedMap<string, GroupItem>();
const totalItems = items.length;
if(!totalItems) return null;
for(const item of items)
if(totalItems)
{
const spriteId = item.spriteId;
const category = item.category;
let name = (item.furniType + spriteId);
if(!item.isGroupable || isExternalImage(spriteId))
for(const item of items)
{
name = ('itemid' + item.itemId);
const spriteId = item.spriteId;
const category = item.category;
let name = (item.furniType + spriteId);
if(!item.isGroupable || isExternalImage(spriteId))
{
name = ('itemid' + item.itemId);
}
if(item.category === FurniCategory.POSTER)
{
name = (item.itemId + 'poster' + item.stuffData.getLegacyString());
}
else if(item.category === FurniCategory.GUILD_FURNI)
{
name = '';
}
let groupItem = ((item.isGroupable && !isExternalImage(item.spriteId)) ? existingItems.getValue(name) : null);
if(!groupItem)
{
groupItem = createGroupItem(spriteId, category, item.stuffData);
existingItems.add(name, groupItem);
}
groupItem.push(new FurnitureItem(item));
}
if(item.category === FurniCategory.POSTER)
{
name = (item.itemId + 'poster' + item.stuffData.getLegacyString());
}
else if(item.category === FurniCategory.GUILD_FURNI)
{
name = '';
}
let groupItem = ((item.isGroupable && !isExternalImage(item.spriteId)) ? existingItems.getValue(name) : null);
if(!groupItem)
{
groupItem = createGroupItem(spriteId, category, item.stuffData);
existingItems.add(name, groupItem);
}
groupItem.push(new FurnitureItem(item));
}
return existingItems;

99
src/hooks/inventory/useSharedInventoryBadges.ts
View File

@ -2,34 +2,35 @@ import { BadgeReceivedEvent, BadgesEvent, RequestBadgesComposer, SetActivatedBad
import { useCallback, useEffect, useState } from 'react';
import { useBetween } from 'use-between';
import { BatchUpdates, UseMessageEventHook } from '..';
import { GetConfiguration, IBadgeItem, SendMessageComposer } from '../../api';
import { GetConfiguration, SendMessageComposer } from '../../api';
import { useSharedVisibility } from '../useSharedVisibility';
const useInventoryBadges = () =>
{
const [ isVisible, setIsVisible ] = useState(false);
const [ needsUpdate, setNeedsUpdate ] = useState(true);
const [ badges, setBadges ] = useState<IBadgeItem[]>([]);
const [ activeBadges, setActiveBadges ] = useState<IBadgeItem[]>([]);
const [ selectedBadge, setSelectedBadge ] = useState<IBadgeItem>(null);
const [ badgeCodes, setBadgeCodes ] = useState<string[]>([]);
const [ badgeIds, setBadgeIds ] = useState<number[]>([]);
const [ activeBadgeCodes, setActiveBadgeCodes ] = useState<string[]>([]);
const [ selectedBadgeCode, setSelectedBadgeCode ] = useState<string>(null);
const maxBadgeCount = GetConfiguration<number>('user.badges.max.slots', 5);
const isWearingBadge = (badge: IBadgeItem) => (activeBadges.indexOf(badge) >= 0);
const canWearBadges = () => (activeBadges.length < maxBadgeCount);
const isWearingBadge = (badgeCode: string) => (activeBadgeCodes.indexOf(badgeCode) >= 0);
const canWearBadges = () => (activeBadgeCodes.length < maxBadgeCount);
const toggleBadge = (badge: IBadgeItem) =>
const toggleBadge = (badgeCode: string) =>
{
setActiveBadges(prevValue =>
setActiveBadgeCodes(prevValue =>
{
const newValue = [ ...prevValue ];
const index = newValue.indexOf(badge);
const index = newValue.indexOf(badgeCode);
if(index === -1)
{
if(!canWearBadges()) return prevValue;
newValue.push(badge);
newValue.push(badgeCode);
}
else
{
@ -38,7 +39,7 @@ const useInventoryBadges = () =>
const composer = new SetActivatedBadgesComposer();
for(let i = 0; i < maxBadgeCount; i++) composer.addActivatedBadge((newValue[i] && newValue[i].badgeCode) || null);
for(let i = 0; i < maxBadgeCount; i++) composer.addActivatedBadge(newValue[i] || null);
SendMessageComposer(composer);
@ -46,11 +47,20 @@ const useInventoryBadges = () =>
});
}
const selectBadge = (badge: IBadgeItem) =>
const selectBadge = (badgeCode: string) =>
{
if(badges.indexOf(badge) === -1) return;
if(badgeCodes.indexOf(badgeCode) === -1) return;
setSelectedBadge(badge);
setSelectedBadgeCode(badgeCode);
}
const getBadgeId = (badgeCode: string) =>
{
const index = badgeCodes.indexOf(badgeCode);
if(index === -1) return 0;
return (badgeIds[index] || 0);
}
const onBadgesEvent = useCallback((event: BadgesEvent) =>
@ -59,25 +69,14 @@ const useInventoryBadges = () =>
BatchUpdates(() =>
{
setBadges(prevValue =>
{
const newValue: IBadgeItem[] = [];
const badgeCodes = parser.getAllBadgeCodes();
const newBadgeCodes = parser.getAllBadgeCodes();
const newBadgeIds: number[] = [];
for(const badgeCode of badgeCodes) newValue.push({ id: parser.getBadgeId(badgeCode), badgeCode });
for(const newBadgeCode of newBadgeCodes) newBadgeIds.push(parser.getBadgeId(newBadgeCode));
return newValue;
});
setActiveBadges(prevValue =>
{
const newValue: IBadgeItem[] = [];
const badgeCodes = parser.getActiveBadgeCodes();
for(const badgeCode of badgeCodes) newValue.push({ id: parser.getBadgeId(badgeCode), badgeCode });
return newValue;
});
setBadgeCodes(newBadgeCodes);
setBadgeIds(newBadgeIds);
setActiveBadgeCodes(parser.getActiveBadgeCodes());
});
}, []);
@ -87,33 +86,45 @@ const useInventoryBadges = () =>
{
const parser = event.getParser();
setBadges(prevValue =>
{
const newValue = [ ...prevValue ];
BatchUpdates(() =>
{
setBadgeCodes(prevValue =>
{
const newValue = [ ...prevValue ];
newValue.push({ id: parser.badgeId, badgeCode: parser.badgeCode });
return newValue;
});
newValue.push(parser.badgeCode);
return newValue;
});
setBadgeIds(prevValue =>
{
const newValue = [ ...prevValue ];
newValue.push(parser.badgeId);
return newValue;
})
});
}, []);
UseMessageEventHook(BadgeReceivedEvent, onBadgeReceivedEvent);
useEffect(() =>
{
if(!badges || !badges.length) return;
if(!badgeCodes || !badgeCodes.length) return;
setSelectedBadge(prevValue =>
setSelectedBadgeCode(prevValue =>
{
let newValue = prevValue;
if(newValue && (badges.indexOf(newValue) === -1)) newValue = null;
if(newValue && (badgeCodes.indexOf(newValue) === -1)) newValue = null;
if(!newValue) newValue = badges[0];
if(!newValue) newValue = badgeCodes[0];
return newValue;
});
}, [ badges ]);
}, [ badgeCodes ]);
useEffect(() =>
{
@ -124,7 +135,7 @@ const useInventoryBadges = () =>
setNeedsUpdate(false);
}, [ isVisible, needsUpdate ]);
return { badges, activeBadges, selectedBadge, isWearingBadge, canWearBadges, toggleBadge, selectBadge, setIsVisible };
return { badgeCodes, activeBadgeCodes, selectedBadgeCode, isWearingBadge, canWearBadges, toggleBadge, selectBadge, getBadgeId, setIsVisible };
}
export const useSharedInventoryBadges = () =>

14
src/hooks/inventory/useSharedInventoryFurni.ts
View File

@ -116,7 +116,12 @@ const useInventoryFurni = () =>
const group = newValue[index];
const item = group.remove(existingId);
if(!item) index++;
if(!item)
{
index++;
continue;
}
if(getPlacingItemId() === item.ref)
{
@ -183,7 +188,12 @@ const useInventoryFurni = () =>
const group = newValue[index];
const item = group.remove(parser.itemId);
if(!item) index++;
if(!item)
{
index++;
continue;
}
if(getPlacingItemId() === item.ref)
{

50
src/hooks/inventory/useSharedInventoryTrade.ts
View File

@ -1,9 +1,11 @@
import { AdvancedMap, TradingAcceptComposer, TradingAcceptEvent, TradingCloseEvent, TradingCloseParser, TradingCompletedEvent, TradingConfirmationComposer, TradingConfirmationEvent, TradingListItemEvent, TradingListItemRemoveComposer, TradingNotOpenEvent, TradingOpenEvent, TradingOpenFailedEvent, TradingOpenFailedParser, TradingOtherNotAllowedEvent, TradingUnacceptComposer, TradingYouAreNotAllowedEvent } from '@nitrots/nitro-renderer';
import { AdvancedMap, TradingAcceptComposer, TradingAcceptEvent, TradingCancelComposer, TradingCloseComposer, TradingCloseEvent, TradingCloseParser, TradingCompletedEvent, TradingConfirmationComposer, TradingConfirmationEvent, TradingListItemEvent, TradingListItemRemoveComposer, TradingNotOpenEvent, TradingOpenComposer, TradingOpenEvent, TradingOpenFailedEvent, TradingOpenFailedParser, TradingOtherNotAllowedEvent, TradingUnacceptComposer, TradingYouAreNotAllowedEvent } from '@nitrots/nitro-renderer';
import { useCallback, useState } from 'react';
import { useBetween } from 'use-between';
import { useSharedInventoryFurni } from '.';
import { BatchUpdates, UseMessageEventHook } from '..';
import { CloneObject, GetRoomSession, GetSessionDataManager, GroupItem, LocalizeText, NotificationUtilities, SendMessageComposer, TradeState, TradeUserData, TradingNotificationMessage, TradingNotificationType } from '../../api';
import { InventoryTradeRequestEvent } from '../../events';
import { UseUiEvent } from '../events';
import { parseTradeItems } from './common';
const useInventoryTrade = () =>
@ -12,6 +14,7 @@ const useInventoryTrade = () =>
const [ otherUser, setOtherUser ] = useState<TradeUserData>(null);
const [ tradeState, setTradeState ] = useState(TradeState.TRADING_STATE_READY);
const { groupItems = [], setGroupItems = null } = useSharedInventoryFurni();
const isTrading = (tradeState >= TradeState.TRADING_STATE_RUNNING);
const progressTrade = () =>
{
@ -49,6 +52,35 @@ const useInventoryTrade = () =>
SendMessageComposer(new TradingListItemRemoveComposer(item.id));
}
const stopTrading = () =>
{
if(!isTrading) return;
switch(tradeState)
{
case TradeState.TRADING_STATE_RUNNING:
SendMessageComposer(new TradingCloseComposer());
return;
default:
SendMessageComposer(new TradingCancelComposer());
return;
}
}
const onInventoryTradeRequestEvent = useCallback((event: InventoryTradeRequestEvent) =>
{
switch(event.type)
{
case InventoryTradeRequestEvent.REQUEST_TRADE: {
const tradeEvent = (event as InventoryTradeRequestEvent);
SendMessageComposer(new TradingOpenComposer(tradeEvent.objectId));
}
}
}, []);
UseUiEvent(InventoryTradeRequestEvent.REQUEST_TRADE, onInventoryTradeRequestEvent);
const onTradingAcceptEvent = useCallback((event: TradingAcceptEvent) =>
{
const parser = event.getParser();
@ -102,6 +134,7 @@ const useInventoryTrade = () =>
{
setOwnUser(null);
setOtherUser(null);
setTradeState(TradeState.TRADING_STATE_READY);
});
}, [ ownUser ]);
@ -115,6 +148,7 @@ const useInventoryTrade = () =>
{
setOwnUser(null);
setOtherUser(null);
setTradeState(TradeState.TRADING_STATE_READY);
});
}, []);
@ -143,18 +177,18 @@ const useInventoryTrade = () =>
{
newValue.creditsCount = parser.firstUserNumCredits;
newValue.itemCount = parser.firstUserNumItems;
newValue.items = firstUserItems;
newValue.userItems = firstUserItems;
}
else
{
newValue.creditsCount = parser.secondUserNumCredits;
newValue.itemCount = parser.secondUserNumItems;
newValue.items = secondUserItems;
newValue.userItems = secondUserItems;
}
const tradeIds: number[] = [];
for(const groupItem of newValue.items.getValues())
for(const groupItem of newValue.userItems.getValues())
{
let i = 0;
@ -188,13 +222,13 @@ const useInventoryTrade = () =>
{
newValue.creditsCount = parser.firstUserNumCredits;
newValue.itemCount = parser.firstUserNumItems;
newValue.items = firstUserItems;
newValue.userItems = firstUserItems;
}
else
{
newValue.creditsCount = parser.secondUserNumCredits;
newValue.itemCount = parser.secondUserNumItems;
newValue.items = secondUserItems;
newValue.userItems = secondUserItems;
}
return newValue;
@ -206,8 +240,6 @@ const useInventoryTrade = () =>
const onTradingNotOpenEvent = useCallback((event: TradingNotOpenEvent) =>
{
const parser = event.getParser();
console.log(parser);
}, []);
UseMessageEventHook(TradingNotOpenEvent, onTradingNotOpenEvent);
@ -287,7 +319,7 @@ const useInventoryTrade = () =>
UseMessageEventHook(TradingYouAreNotAllowedEvent, onTradingYouAreNotAllowedEvent);
return { ownUser, otherUser, tradeState, setTradeState, groupItems, progressTrade, removeItem };
return { ownUser, otherUser, tradeState, setTradeState, isTrading, groupItems, progressTrade, removeItem, stopTrading };
}
export const useSharedInventoryTrade = () => useBetween(useInventoryTrade);

2
src/hooks/inventory/useSharedInventoryUnseenTracker.ts
View File

@ -109,8 +109,6 @@ const useInventoryUnseenTracker = () =>
{
const parser = event.getParser();
console.log(parser);
setUnseenItems(prevValue =>
{
const newValue = new Map(prevValue);