NHL points 25>26

They will not transfer articles, coins, or purchased items from one year to the next. Taking from the line. What happens in Vegas, stays in Vegas. The line now is. What happens in 25, stays in 25.

Hey there. Points aren't able to be transferred since they were purchased for NHL 25. The expectation is that the intent is to use them in the game they were purchased for.

Why do FC and Madden still allow it but NHL doesn’t please? 

I don't have any details on that.

They have adopted the premise. That all activity within the said year. It being 25 here. Remains in the context of that years game. I have no problem with content not being transferred. But when it comes to points acquired by actual cash. I believe they should alter their current policy and either. Transfer the points bought. Or allow packs in their place. 

It’s been a standard thing for years for NHL, Madden and FIFA/FC. We’ve always had a one time points transfer (Not coins) when you started the new game.

NHL is the only one to stop this from NHL 24 to 25, hence why I asked in another post before I purchased the ultimate edition this year. I don’t want to get burned again and

Are you saying FC and Madden are now adopting the no points transfer to 26 as well or just NHL? (I didn’t buy madden this year, so don’t know & I won’t know about FC until it starts) Unless I missed it, I didn’t see that anywhere online or in the TOS. I’ll be pissed if FC is not allowing it any longer as I have saved quite a bit of points from my ultimate edition purchases over the years. 

They should have told us that point transfers to the newer game version was/is no longer in effect, “BEFORE” they put them up for sale. 

Criminals. 

YOu know I buy a golf membership, and I have money on my tab it will carry over to the next year. 

EA, this is not hard maybe 50 lines of code.  

I asked Claude 

"

Give me the coding for a video game to transfer funds from one season to the NExt.

In this example NHL 25 takes money and you can buy EA points to buy player cards.

But I have 5000 coins left over and the new game is coming out. I want to show how easily it can be done to write to the code to transfer the funds to the new game"

Literally 30 seconds later: 

/**
 * EDUCATIONAL DEMONSTRATION: Cross-Season Currency Transfer System
 * This shows how game publishers COULD implement season-to-season transfers
 * Note: This is a simplified model for educational purposes only
 */

class GameCurrencySystem {
    constructor() {
        // Simulated backend database
        this.userDatabase = new Map();
        this.conversionRates = {
            'NHL24_to_NHL25': 0.8,  // 20% depreciation
            'NHL25_to_NHL26': 0.75, // 25% depreciation
        };
        this.transferLimits = {
            minTransfer: 1000,
            maxTransfer: 50000,
            cooldownDays: 365
        };
    }

    /**
     * Register user account across multiple game versions
     */
    registerUser(userId, email) {
        if (!this.userDatabase.has(userId)) {
            this.userDatabase.set(userId, {
                userId,
                email,
                accounts: {},
                transferHistory: [],
                createdAt: new Date()
            });
        }
        return this.userDatabase.get(userId);
    }

    /**
     * Add currency to a specific game version
     */
    addCurrency(userId, gameVersion, amount) {
        const user = this.userDatabase.get(userId);
        if (!user) throw new Error('User not found');
        
        if (!user.accounts[gameVersion]) {
            user.accounts[gameVersion] = {
                balance: 0,
                earned: 0,
                purchased: 0,
                transferred: 0
            };
        }
        
        user.accounts[gameVersion].balance += amount;
        user.accounts[gameVersion].earned += amount;
        
        return user.accounts[gameVersion].balance;
    }

    /**
     * Core transfer logic with business rules
     */
    transferCurrency(userId, fromGame, toGame, amount) {
        const user = this.userDatabase.get(userId);
        if (!user) throw new Error('User not found');
        
        // Validation checks
        const validation = this.validateTransfer(user, fromGame, toGame, amount);
        if (!validation.valid) {
            return { success: false, error: validation.error };
        }
        
        // Get conversion rate
        const conversionKey = `${fromGame}_to_${toGame}`;
        const rate = this.conversionRates[conversionKey] || 1.0;
        
        // Calculate transferred amount after conversion
        const transferredAmount = Math.floor(amount * rate);
        
        // Execute transfer
        user.accounts[fromGame].balance -= amount;
        user.accounts[fromGame].transferred += amount;
        
        if (!user.accounts[toGame]) {
            user.accounts[toGame] = {
                balance: 0,
                earned: 0,
                purchased: 0,
                transferred: 0
            };
        }
        
        user.accounts[toGame].balance += transferredAmount;
        
        // Log transfer
        const transfer = {
            from: fromGame,
            to: toGame,
            originalAmount: amount,
            convertedAmount: transferredAmount,
            rate: rate,
            timestamp: new Date(),
            transactionId: this.generateTransactionId()
        };
        
        user.transferHistory.push(transfer);
        
        return {
            success: true,
            transaction: transfer,
            newBalances: {
                [fromGame]: user.accounts[fromGame].balance,
                [toGame]: user.accounts[toGame].balance
            }
        };
    }

    /**
     * Validate transfer eligibility
     */
    validateTransfer(user, fromGame, toGame, amount) {
        // Check if source account exists and has funds
        if (!user.accounts[fromGame]) {
            return { valid: false, error: 'Source game account not found' };
        }
        
        if (user.accounts[fromGame].balance < amount) {
            return { valid: false, error: 'Insufficient balance' };
        }
        
        // Check transfer limits
        if (amount < this.transferLimits.minTransfer) {
            return { valid: false, error: `Minimum transfer is ${this.transferLimits.minTransfer} coins` };
        }
        
        if (amount > this.transferLimits.maxTransfer) {
            return { valid: false, error: `Maximum transfer is ${this.transferLimits.maxTransfer} coins` };
        }
        
        // Check cooldown period
        const lastTransfer = user.transferHistory
            .filter(t => t.from === fromGame)
            .sort((a, b) => b.timestamp - a.timestamp)[0];
            
        if (lastTransfer) {
            const daysSinceTransfer = (new Date() - lastTransfer.timestamp) / (1000 * 60 * 60 * 24);
            if (daysSinceTransfer < this.transferLimits.cooldownDays) {
                return { 
                    valid: false, 
                    error: `Transfer cooldown: ${Math.ceil(this.transferLimits.cooldownDays - daysSinceTransfer)} days remaining` 
                };
            }
        }
        
        // Check if conversion rate exists
        const conversionKey = `${fromGame}_to_${toGame}`;
        if (!this.conversionRates[conversionKey]) {
            return { valid: false, error: 'Transfer between these versions not supported' };
        }
        
        return { valid: true };
    }

    /**
     * Generate unique transaction ID
     */
    generateTransactionId() {
        return 'TXN_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
    }

    /**
     * Get user's complete currency profile
     */
    getUserProfile(userId) {
        const user = this.userDatabase.get(userId);
        if (!user) return null;
        
        const totalValue = Object.entries(user.accounts).reduce((sum, [game, account]) => {
            return sum + account.balance;
        }, 0);
        
        return {
            userId: user.userId,
            accounts: user.accounts,
            totalValue,
            transferHistory: user.transferHistory,
            eligibleTransfers: this.getEligibleTransfers(user)
        };
    }

    /**
     * Determine which transfers are currently available
     */
    getEligibleTransfers(user) {
        const eligible = [];
        
        for (const [fromGame, fromAccount] of Object.entries(user.accounts)) {
            if (fromAccount.balance >= this.transferLimits.minTransfer) {
                for (const conversionKey of Object.keys(this.conversionRates)) {
                    const [source, , target] = conversionKey.split('_');
                    if (source === fromGame) {
                        eligible.push({
                            from: fromGame,
                            to: target,
                            maxAmount: Math.min(fromAccount.balance, this.transferLimits.maxTransfer),
                            rate: this.conversionRates[conversionKey]
                        });
                    }
                }
            }
        }
        
        return eligible;
    }
}

// DEMONSTRATION USAGE
console.log("=== GAME CURRENCY TRANSFER DEMO ===\n");

const system = new GameCurrencySystem();

// Create user and add NHL 25 coins
const userId = 'USER_12345';
system.registerUser(userId, '[edit: email address removed]');
system.addCurrency(userId, 'NHL25', 5000);

console.log("Initial State:");
console.log(`NHL 25 Balance: 5000 coins\n`);

// Attempt transfer to NHL 26
console.log("Attempting Transfer: 5000 coins from NHL 25 → NHL 26");
console.log("Conversion Rate: 0.75 (25% depreciation)");
console.log("Expected Result: 3750 coins in NHL 26\n");

const result = system.transferCurrency(userId, 'NHL25', 'NHL26', 5000);

if (result.success) {
    console.log("✓ Transfer Successful!");
    console.log(`Transaction ID: ${result.transaction.transactionId}`);
    console.log(`Amount Deducted: ${result.transaction.originalAmount} coins`);
    console.log(`Amount Received: ${result.transaction.convertedAmount} coins`);
    console.log("\nNew Balances:");
    console.log(`NHL 25: ${result.newBalances.NHL25} coins`);
    console.log(`NHL 26: ${result.newBalances.NHL26} coins`);
} else {
    console.log(`✗ Transfer Failed: ${result.error}`);
}

// Show complete profile
console.log("\n=== USER PROFILE ===");
const profile = system.getUserProfile(userId);
console.log(JSON.stringify(profile, null, 2));