@rpg-engine/long-bow 0.5.8 → 0.5.10

package/dist/mocks/leaderboard.mocks.d.ts

@@ -1,4 +1,4 @@
-import { TopCharacterEntry, TopSkillEntry } from '@rpg-engine/shared';
-export declare const leaderboardLevelRankingItems: Set<TopCharacterEntry>;
-export declare const leaderboardClassRankingItems: Set<TopCharacterEntry>;
-export declare const leaderboardSkillRankingItems: Set<TopSkillEntry>;
+import { IRankingTopCharacterEntry, IRankingTopSkillEntry } from '@rpg-engine/shared';
+export declare const leaderboardLevelRankingItems: Set<IRankingTopCharacterEntry>;
+export declare const leaderboardClassRankingItems: Set<IRankingTopCharacterEntry>;
+export declare const leaderboardSkillRankingItems: Set<IRankingTopSkillEntry>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpg-engine/long-bow",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -83,7 +83,7 @@
   },
   "dependencies": {
     "@rollup/plugin-image": "^2.1.1",
-    "@rpg-engine/shared": "^0.8.72",
+    "@rpg-engine/shared": "^0.8.74",
     "dayjs": "^1.11.2",
     "font-awesome": "^4.7.0",
     "fs-extra": "^10.1.0",

package/src/components/Item/Inventory/ItemContainer.tsx

@@ -13,6 +13,7 @@ import { ItemQuantitySelector } from './ItemQuantitySelector';
 
 import { IPosition } from '../../../types/eventTypes';
 import ModalPortal from '../../Abstractions/ModalPortal';
+import SelectArrow from '../../Arrow/SelectArrow';
 import { ShortcutsSetter } from '../../Shortcuts/ShortcutsSetter';
 import { ItemSlot } from './ItemSlot';
 
@@ -81,12 +82,15 @@ export const ItemContainer: React.FC<IItemContainerProps> = ({
   onPositionChangeEnd,
   onPositionChangeStart,
 }) => {
+  const MAX_SLOTS_PER_PAGE = 20;
   const [quantitySelect, setQuantitySelect] = useState({
     isOpen: false,
     maxQuantity: 1,
-    callback: (_quantity: number) => {},
+    callback: (_quantity: number) => { },
   });
   const [settingShortcutIndex, setSettingShortcutIndex] = useState(-1);
+  const [currentPage, setCurrentPage] = useState(1);
+  const totalPages = Math.ceil(itemContainer.slotQty / MAX_SLOTS_PER_PAGE);
 
   const handleSetShortcut = (item: IItem, index: number) => {
     if (item.type === ItemType.Consumable || item.type === ItemType.Tool) {
@@ -96,8 +100,10 @@ export const ItemContainer: React.FC<IItemContainerProps> = ({
 
   const onRenderSlots = () => {
     const slots = [];
+    const start = (currentPage - 1) * MAX_SLOTS_PER_PAGE;
+    const end = start + MAX_SLOTS_PER_PAGE;
 
-    for (let i = 0; i < itemContainer.slotQty; i++) {
+    for (let i = start; i < end && i < itemContainer.slotQty; i++) {
       slots.push(
         <ItemSlot
           isContextMenuDisabled={disableContextMenu}
@@ -156,6 +162,14 @@ export const ItemContainer: React.FC<IItemContainerProps> = ({
     return slots;
   };
 
+  const goToNextPage = () => {
+    setCurrentPage(current => Math.min(current + 1, totalPages));
+  };
+
+  const goToPreviousPage = () => {
+    setCurrentPage(current => Math.max(current - 1, 1));
+  };
+
   return (
     <>
       <SlotsContainer
@@ -181,6 +195,28 @@ export const ItemContainer: React.FC<IItemContainerProps> = ({
         <ItemsContainer className="item-container-body">
           {onRenderSlots()}
         </ItemsContainer>
+        {totalPages > 1 && (
+          <ArrowContainer>
+            <SelectArrow
+              className='arrow .arrow-up'
+              direction="left"
+              onPointerDown={() => {
+                if (currentPage > 1) {
+                  goToPreviousPage();
+                }
+              }}
+            />
+            <SelectArrow
+              className='arrow .arrow-down'
+              direction="right"
+              onPointerDown={() => {
+                if (currentPage < totalPages) {
+                  goToNextPage();
+                }
+              }}
+            />
+          </ArrowContainer>
+        )}
       </SlotsContainer>
       {quantitySelect.isOpen && (
         <ModalPortal>
@@ -192,7 +228,7 @@ export const ItemContainer: React.FC<IItemContainerProps> = ({
                 setQuantitySelect({
                   isOpen: false,
                   maxQuantity: 1,
-                  callback: () => {},
+                  callback: () => { },
                 });
               }}
               onClose={() => {
@@ -200,7 +236,7 @@ export const ItemContainer: React.FC<IItemContainerProps> = ({
                 setQuantitySelect({
                   isOpen: false,
                   maxQuantity: 1,
-                  callback: () => {},
+                  callback: () => { },
                 });
               }}
             />
@@ -229,3 +265,17 @@ const QuantitySelectorContainer = styled.div`
   align-items: center;
   background-color: rgba(0, 0, 0, 0.5);
 `;
+
+const ArrowContainer = styled.div`
+  margin-top: 10px;
+  margin-bottom: 30px;
+  /* Aplica a margem ao primeiro span (seta para a esquerda) */
+  span:first-child {
+    margin-left: 20px;
+  }
+
+  /* Aplica a margem ao último span (seta para a direita) */
+  span:last-child {
+    margin-right: 20px;
+  }
+`;

package/src/components/Leaderboard/Leaderboard.tsx

@@ -1,46 +1,63 @@
-import { CharacterClass, TopCharacterEntry, TopSkillEntry } from '@rpg-engine/shared';
+import {
+  IRankingTopCharacterEntry,
+  IRankingTopSkillEntry,
+} from '@rpg-engine/shared';
 import React, { useEffect, useRef } from 'react';
 import styled from 'styled-components';
 import { Dropdown, IOptionsProps } from '../Dropdown';
 import { LeaderboardTable } from './LeaderboardTable';
 
-
 export interface ILeaderboardProps {
-  items: Set<TopCharacterEntry> | Set<TopSkillEntry> | null;
+  items: Set<IRankingTopCharacterEntry> | Set<IRankingTopSkillEntry> | null;
   onChangeClassType: (value: string) => void;
   onChangeRankType: (value: string) => void;
   onChangeSkillType: (value: string) => void;
-  skills: string[];
+  skillOptions: string[];
+  rankOptions: string[];
+  classOptions: string[];
   rankType: string;
 }
 
-const rankTypeOptions: IOptionsProps[] = ['Level', 'Class', 'Skill'].map(
-  (itemType, index) => ({
-    id: index + 1,
-    value: itemType,
-    option: itemType,
-  })
-);
-
-const classTypeOptions: IOptionsProps[] = Object.keys(CharacterClass).map((itemType, index) => ({
-  id: index + 1,
-  value: itemType,
-  option: itemType,
-}));
-
 export const Leaderboard = (props: ILeaderboardProps) => {
-  const { items, onChangeRankType, onChangeClassType, rankType, skills, onChangeSkillType } = props;
+  const {
+    items,
+    onChangeRankType,
+    onChangeClassType,
+    rankType,
+    skillOptions,
+    onChangeSkillType,
+    classOptions,
+    rankOptions,
+  } = props;
   const itemsContainer = useRef<HTMLDivElement>(null);
 
   useEffect(() => {
     itemsContainer.current?.scrollTo(0, 0);
   }, []);
 
-  const skillTypeOptions: IOptionsProps[] = skills.map((itemType, index) => ({
-    id: index + 1,
-    value: itemType,
-    option: itemType,
-  }));
+  const rankTypeOptions: IOptionsProps[] = rankOptions.map(
+    (itemType, index) => ({
+      id: index + 1,
+      value: itemType,
+      option: itemType,
+    })
+  );
+
+  const skillTypeOptions: IOptionsProps[] = skillOptions.map(
+    (itemType, index) => ({
+      id: index + 1,
+      value: itemType,
+      option: itemType,
+    })
+  );
+
+  const classTypeOptions: IOptionsProps[] = classOptions.map(
+    (itemType, index) => ({
+      id: index + 1,
+      value: itemType,
+      option: itemType,
+    })
+  );
 
   return (
     <>

package/src/components/Leaderboard/LeaderboardTable.tsx

@@ -1,11 +1,14 @@
-import { TopCharacterEntry, TopSkillEntry } from '@rpg-engine/shared';
+import {
+  IRankingTopCharacterEntry,
+  IRankingTopSkillEntry,
+} from '@rpg-engine/shared';
 import React from 'react';
 import styled from 'styled-components';
 import { uiColors } from '../../constants/uiColors';
 import { Ellipsis } from '../shared/Ellipsis';
 
 export interface ILeaderboardLevelProps {
-  items: Set<TopCharacterEntry> | Set<TopSkillEntry> | null;
+  items: Set<IRankingTopCharacterEntry> | Set<IRankingTopSkillEntry> | null;
   rankType: string;
 }
 
@@ -13,7 +16,7 @@ export const LeaderboardTable: React.FC<ILeaderboardLevelProps> = props => {
   const { items, rankType } = props;
   if (!items) return null;
 
-  function isTopSkillEntry(entry: any): entry is TopSkillEntry {
+  function isTopSkillEntry(entry: any): entry is IRankingTopSkillEntry {
     return 'skill' in entry;
   }
 

package/src/mocks/itemContainer.mocks.ts

@@ -577,7 +577,7 @@ export const itemContainerMock: IItemContainer = {
   _id: '629ba0b6fe3f43002f58f23b',
   name: 'Item Container',
   owner: '629ba0b6fe3f43002f58f23b',
-  slotQty: 20,
+  slotQty: 60,
   slots: {
     0: items[0],
     1: items[1],
@@ -595,6 +595,7 @@ export const itemContainerMock: IItemContainer = {
     13: items[13],
     14: items[14],
     15: items[15],
+    21: items[15],
     //remaining slots are considered null by default
   },
   allowedItemTypes: [],

package/src/mocks/leaderboard.mocks.ts

@@ -1,110 +1,119 @@
-import { TopCharacterEntry, TopSkillEntry } from '@rpg-engine/shared';
+import {
+  IRankingTopCharacterEntry,
+  IRankingTopSkillEntry,
+} from '@rpg-engine/shared';
 
-export const leaderboardLevelRankingItems: Set<TopCharacterEntry> = new Set([
-  {
-    name: 'Player 1',
-    level: 1,
-  },
-  {
-    name: 'Player 2',
-    level: 2,
-  },
-  {
-    name: 'Player 3',
-    level: 3,
-  },
-  {
-    name: 'Player 4',
-    level: 4,
-  },
-  {
-    name: 'Player 5',
-    level: 5,
-  },
-  {
-    name: 'Player 6',
-    level: 6,
-  },
-  {
-    name: 'Player 7',
-    level: 7,
-  },
-  {
-    name: 'Player 8',
-    level: 8,
-  },
-  {
-    name: 'Player 9',
-    level: 9,
-  },
-  {
-    name: 'Player 10',
-    level: 10,
-  },
-]);
+export const leaderboardLevelRankingItems: Set<IRankingTopCharacterEntry> = new Set(
+  [
+    {
+      name: 'Player 1',
+      level: 1,
+    },
+    {
+      name: 'Player 2',
+      level: 2,
+    },
+    {
+      name: 'Player 3',
+      level: 3,
+    },
+    {
+      name: 'Player 4',
+      level: 4,
+    },
+    {
+      name: 'Player 5',
+      level: 5,
+    },
+    {
+      name: 'Player 6',
+      level: 6,
+    },
+    {
+      name: 'Player 7',
+      level: 7,
+    },
+    {
+      name: 'Player 8',
+      level: 8,
+    },
+    {
+      name: 'Player 9',
+      level: 9,
+    },
+    {
+      name: 'Player 10',
+      level: 10,
+    },
+  ]
+);
 
-export const leaderboardClassRankingItems: Set<TopCharacterEntry> = new Set([
-  {
-    name: 'Player 1',
-    level: 1,
-  },
-  {
-    name: 'Player 2',
-    level: 2,
-  },
-  {
-    name: 'Player 3',
-    level: 3,
-  },
-  {
-    name: 'Player 4',
-    level: 4,
-  },
-  {
-    name: 'Player 5',
-    level: 5,
-  },
-  {
-    name: 'Player 6',
-    level: 6,
-  },
-  {
-    name: 'Player 7',
-    level: 7,
-  },
-  {
-    name: 'Player 8',
-    level: 8,
-  },
-  {
-    name: 'Player 9',
-    level: 9,
-  },
-  {
-    name: 'Player 10',
-    level: 10,
-  },
-]);
+export const leaderboardClassRankingItems: Set<IRankingTopCharacterEntry> = new Set(
+  [
+    {
+      name: 'Player 1',
+      level: 1,
+    },
+    {
+      name: 'Player 2',
+      level: 2,
+    },
+    {
+      name: 'Player 3',
+      level: 3,
+    },
+    {
+      name: 'Player 4',
+      level: 4,
+    },
+    {
+      name: 'Player 5',
+      level: 5,
+    },
+    {
+      name: 'Player 6',
+      level: 6,
+    },
+    {
+      name: 'Player 7',
+      level: 7,
+    },
+    {
+      name: 'Player 8',
+      level: 8,
+    },
+    {
+      name: 'Player 9',
+      level: 9,
+    },
+    {
+      name: 'Player 10',
+      level: 10,
+    },
+  ]
+);
 
-export const leaderboardSkillRankingItems: Set<TopSkillEntry> = new Set([
-  {
-    name: 'Player 1',
-    level: 1,
-    skill: 'skill 1',
-  },
-  {
-    name: 'Player 2',
-    level: 2,
-    skill: 'skill 2',
-  },
-  {
-    name: 'Player 3',
-    level: 3,
-    skill: 'skill 3',
-  },
-  {
-    name: 'Player 4',
-    level: 4,
-    skill: 'skill 4',
-  },
-]);
+export const leaderboardSkillRankingItems: Set<IRankingTopSkillEntry> = new Set(
+  [
+    {
+      name: 'Player 1',
+      level: 1,
+      skill: 'skill 1',
+    },
+    {
+      name: 'Player 2',
+      level: 2,
+      skill: 'skill 2',
+    },
+    {
+      name: 'Player 3',
+      level: 3,
+      skill: 'skill 3',
+    },
+    {
+      name: 'Player 4',
+      level: 4,
+      skill: 'skill 4',
+    },
+  ]
+);

package/src/stories/Leaderboard.stories.tsx

@@ -31,9 +31,11 @@ export const Default = Template.bind({});
 Default.args = {
   items: leaderboardLevelRankingItems,
   rankType: 'Level',
-  skills: ['Lumbarjacking'],
-  onChangeRankType: () => { },
-  onChangeClassType: () => { },
+  skillOptions: ['Lumbarjacking'],
+  classOptions: ['Warrior'],
+  rankOptions: ['Level', 'Class', 'Skill'],
+  onChangeRankType: () => {},
+  onChangeClassType: () => {},
 };
 
 export const ClassRanking = Template.bind({});
@@ -41,9 +43,11 @@ export const ClassRanking = Template.bind({});
 ClassRanking.args = {
   items: leaderboardClassRankingItems,
   rankType: 'Class',
-  skills: ['Lumbarjacking'],
-  onChangeRankType: () => { },
-  onChangeClassType: () => { },
+  skillOptions: ['Lumbarjacking'],
+  classOptions: ['Warrior'],
+  rankOptions: ['Level', 'Class', 'Skill'],
+  onChangeRankType: () => {},
+  onChangeClassType: () => {},
 };
 
 export const SkillRanking = Template.bind({});
@@ -51,7 +55,9 @@ export const SkillRanking = Template.bind({});
 SkillRanking.args = {
   items: leaderboardSkillRankingItems,
   rankType: 'Skill',
-  skills: ['Lumbarjacking'],
-  onChangeRankType: () => { },
-  onChangeClassType: () => { },
-};
+  skillOptions: ['Lumbarjacking'],
+  classOptions: ['Warrior'],
+  rankOptions: ['Level', 'Class', 'Skill'],
+  onChangeRankType: () => {},
+  onChangeClassType: () => {},
+};