chomp/ModExamples
1
19
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

3.9.3

Browse Source
This commit is contained in:
Dev 2024-07-19 15:56:09 +01:00
parent 5e32ead325
commit 9e02730e03
53 changed files with 261 additions and 313 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -1,4 +1,4 @@
# Mod examples for v3.9.2
# Mod examples for v3.9.3
A collection of example mods that perform typical actions in SPT

4
TypeScript/10ScopesAndTypes/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/10ScopesAndTypes/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/11BundleLoadingSample/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/11BundleLoadingSample/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/12ClassExtensionOverride/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/12ClassExtensionOverride/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/13.1AddTraderWithAssortJSON/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/13.1AddTraderWithAssortJSON/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/13AddTrader/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/13AddTrader/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/14AfterDBLoadHook/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/14AfterDBLoadHook/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/15HttpListenerExample/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/15HttpListenerExample/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/16ImporterUtil/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/16ImporterUtil/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/17AsyncImporterWithDependency1/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/17AsyncImporterWithDependency1/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/17AsyncImporterWithDependency2/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/17AsyncImporterWithDependency2/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/18.1CustomItemServiceLootBox/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/18.1CustomItemServiceLootBox/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/18CustomItemService/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/18CustomItemService/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/19UseExternalLibraries/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/19UseExternalLibraries/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/1LogToConsole/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/1LogToConsole/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/20CustomChatBot/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/20CustomChatBot/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/21CustomCommandoCommand/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/21CustomCommandoCommand/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/22CustomAkiCommand/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/22CustomAkiCommand/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/2EditDatabase/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/2EditDatabase/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/3GetSptConfigFile/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/3GetSptConfigFile/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/4.1UseACustomJson5OrJsonCConfigFile/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/4.1UseACustomJson5OrJsonCConfigFile/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/4UseACustomConfigFile/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/4UseACustomConfigFile/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/5ReplaceMethod/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/5ReplaceMethod/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/6ReferenceAnotherClass/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/6ReferenceAnotherClass/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/7OnLoadHook/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/7OnLoadHook/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/8OnUpdateHook/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/8OnUpdateHook/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;

4
TypeScript/9RouterHooks/types/generators/RagfairOfferGenerator.d.ts vendored
View File

@ -70,10 +70,10 @@ export declare class RagfairOfferGenerator {
* @param items Items in the offer
* @param barterScheme Cost of item (currency or barter)
* @param loyalLevel Loyalty level needed to buy item
* @param sellInOnePiece Set StackObjectsCount to 1
* @param isPackOffer Is offer being created flaged as a pack
* @returns IRagfairOffer
*/
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, sellInOnePiece?: boolean): IRagfairOffer;
protected createOffer(userID: string, time: number, items: Item[], barterScheme: IBarterScheme[], loyalLevel: number, isPackOffer?: boolean): IRagfairOffer;
/**
* Create the user object stored inside each flea offer object
* @param userID user creating the offer

18
TypeScript/9RouterHooks/types/models/eft/ragfair/IRagfairOffer.d.ts vendored
View File

@ -9,23 +9,20 @@ export interface IRagfairOffer {
intId: number;
/** Handbook price */
itemsCost: number;
/** Rouble price */
/** Rouble price per item */
requirementsCost: number;
startTime: number;
endTime: number;
sellInOnePiece: boolean;
/** Rouble price - same as requirementsCost */
summaryCost: number;
user: IRagfairOfferUser;
/** Trader only */
unlimitedCount?: boolean;
loyaltyLevel: number;
buyRestrictionMax?: number;
buyRestrictionCurrent?: number;
locked: boolean;
unlimitedCount: boolean;
/** Rouble price */
summaryCost: number;
user: IRagfairOfferUser;
notAvailable: boolean;
/** TODO - implement this value - not currently used */
CurrentItemCount: number;
priority: boolean;
locked?: boolean;
}
export interface OfferRequirement {
_tpl: string;
@ -37,6 +34,7 @@ export interface IRagfairOfferUser {
nickname?: string;
rating?: number;
memberType: MemberCategory;
selectedMemberCategory?: MemberCategory;
avatar?: string;
isRatingGrowing?: boolean;
aid?: number;