Epic Games Free Games x Discord Webhook

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

// Function to format ISO date to readable EST string
// Example output: "Dec 18 at 11:00 AM EST"
function formatToEst(isoString) {
  if (!isoString) return "";
  
  const date = new Date(isoString);
  
  // Format options: "Dec 18", "11:00 AM"
  const options = { 
    timeZone: "America/New_York",
    month: "short", 
    day: "numeric", 
    hour: "numeric", 
    minute: "2-digit",
    hour12: true
  };
  
  // Create the string using standard JS localization
  // This automatically handles Daylight Savings (EDT vs EST)
  const formatted = date.toLocaleString("en-US", options);
  
  // Clean up the format to match your preferred style "Dec 18 at 11:00 AM EST"
  // .toLocaleString returns something like "Dec 18, 11:00 AM"
  return formatted.replace(",", " at") + " EST";
}

// --- Main Execution ---

// Get the list of games from the previous node's output
const allGames = items[0].json.data.Catalog.searchStore.elements;
const results = [];

for (const game of allGames) {
  // 1. Check if the discounted price is 0 (Free)
  // We check specifically for a discountPrice of 0 to avoid demos or free-to-play base games
  if (game.price.totalPrice.discountPrice === 0) {

    // 2. Filter out unwanted "Mystery Game" titles
    if (game.title.includes("Mystery Game")) {
      continue;
    }

    // 3. Get the "Tall" image (looks best on Discord/Mobile notifications)
    const imageObj = game.keyImages.find(img => img.type === 'OfferImageTall') || game.keyImages[0];

    // 4. Get the promo dates safely
    let startDateISO = "";
    let endDateISO = "";
    
    if (game.promotions && game.promotions.promotionalOffers && game.promotions.promotionalOffers.length > 0) {
        const offer = game.promotions.promotionalOffers[0].promotionalOffers[0];
        startDateISO = offer.startDate;
        endDateISO = offer.endDate;
    }

    // 5. Create the clean output item with converted dates
    results.push({
      json: {
        title: game.title,
        description: game.description,
        originalPrice: game.price.totalPrice.fmtPrice.originalPrice, 
        imageUrl: imageObj ? imageObj.url : "",
        storeUrl: `https://store.epicgames.com/en-US/p/${game.offerMappings[0].pageSlug}`,

        // Raw ISO dates (keep these if you need to sort by date later)
        startDateISO: startDateISO,
        endDateISO: endDateISO,
        
        // Format: "Dec 18 at 11:00 AM EST"
        startDate: formatToEst(startDateISO),
        endDate: formatToEst(endDateISO),
        
        // Combined string for notifications
        dateString: `Free Now - ${formatToEst(endDateISO)}` 
      }
    });
  }
}

return results;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

 // Get a reference to the static data for this node, which persists across executions.
const nodeStaticData = $getWorkflowStaticData('node');

// Get all the items from the previous node.
const allGames = $input.all();

// Get the history of games that have already been processed.
// Use a Set for faster lookups.
const gameHistory = new Set(nodeStaticData.gameHistory || []);

// Filter the games to find only the new ones.
// Skip if title is empty.
const newGamesToPost = allGames.filter(item => {
    const title = item.json.title;

    // Skip if title is "" or null/undefined
    if (!title || title.trim() === "") {
        return false;
    }

    // Otherwise check if it's not in history
    return !gameHistory.has(title);
});

// If there are new games to post, update the history.
if (newGamesToPost.length > 0) {
    const newGameTitles = newGamesToPost.map(item => item.json.title);
    newGameTitles.forEach(title => gameHistory.add(title));
    
    nodeStaticData.gameHistory = [...gameHistory];
}

// Return the list of games that are new.
return newGamesToPost;

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

// Helper: Extract Storage from HTML
function getInstallSize(reqsHtml) {
    if (!reqsHtml) return "Unknown";

    // Match the Storage field inside <strong> tags
    const match = reqsHtml.match(
        /<strong>\s*(?:Storage|Hard Drive|Space):\s*<\/strong>\s*([^<]+)/i
    );

    if (match && match[1]) {
        // Extract only the size value (e.g., "75 GB", "120 MB")
        const sizeMatch = match[1].match(/\d+(?:\.\d+)?\s*(?:KB|MB|GB|TB)/i);
        if (sizeMatch) {
            return `~${sizeMatch[0]}`;
        }
    }

    return "Unknown";
}

// Initialize empty array for embeds
let embeds = [];

// Get all items from the current input (Steam Details)
const items = $input.all();

// Access the original Epic Games data from the previous node
const epicItems = $('Loop Over Items').all();

for (let i = 0; i < items.length; i++) {
    const item = items[i];
    
    // --- 1. GET EPIC DATA ---
    const epicData = epicItems[i] ? epicItems[i].json : {};
    
    const title = epicData.title || "";
    const storeUrl = epicData.storeUrl || "https://store.epicgames.com";
    const imageUrl = epicData.imageUrl || "";
    const endDate = epicData.endDate || "Limited Time";
    const epicDescription = epicData.description || "";

    // --- 2. EXTRACT STEAM DATA ---
    let genres = "Unknown";
    let originalPrice = "Unknown";
    let developers = "Unknown";
    let releaseDate = "Unknown";
    let gameModes = "Unknown";
    let installSize = "Unknown"; 
    let steamDescription = "";
    
    const steamKey = Object.keys(item.json)[0];
    
    if (steamKey && item.json[steamKey].success) {
        const game = item.json[steamKey].data;
        
        // A. Developers
        if (game.developers && game.developers.length > 0) {
            developers = game.developers.join(", ");
        }
        
        // B. Genres
        if (game.genres) {
            genres = game.genres.map(g => g.description).slice(0, 3).join(", ");
        }
        
        // C. Price
        if (game.price_overview) {
            if (game.price_overview.initial_formatted) {
                originalPrice = `~~${game.price_overview.initial_formatted}~~`;
            } else if (game.price_overview.initial > 0) {
                originalPrice = `~~$${(game.price_overview.initial / 100).toFixed(2)}~~`;
            }
        } else if (game.is_free) {
            originalPrice = "Free To Play";
        }
        
        // D. Release Date
        if (game.release_date) {
            releaseDate = game.release_date.date;
        }

        // E. Game Modes
        if (game.categories) {
            const relevantModes = game.categories
                .map(c => c.description)
                .filter(desc => 
                    desc === "Single-player" || 
                    desc === "Multi-player" || 
                    desc === "Co-op" || 
                    desc === "Online Co-op" ||
                    desc === "PvP" || 
                    desc === "Shared/Split Screen"
                );
            
            if (relevantModes.length > 0) {
                gameModes = [...new Set(relevantModes)].join(" / ");
            }
        }

        // F. Install Size
        if (game.pc_requirements) {
            // Check minimum requirements first
            installSize = getInstallSize(game.pc_requirements.minimum);
            // If not found, check recommended
            if (installSize === "Unknown" && game.pc_requirements.recommended) {
                installSize = getInstallSize(game.pc_requirements.recommended);
            }
        }
        
        // G. Steam Description (for fallback)
        steamDescription = game.short_description;
    }

    // --- 3. BUILD DISCORD EMBED ---
    var content = {
        "author": {
            "name": "Free Game Alert",
            "icon_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/31/Epic_Games_logo.svg/1200px-Epic_Games_logo.svg.png"
        },
        "title": title,
        "url": storeUrl,
        "color": 30962, 
        // Use Epic Description first, fallback to Steam, then generic default
        "description": epicDescription || steamDescription || "Check store for details.",
        
        "thumbnail": {
            "url": imageUrl
        },
        "fields": [
            // Row 1
            { "name": "Genre", "value": genres, "inline": true },
            { "name": "Price", "value": originalPrice, "inline": true },
            { "name": "Release Date", "value": releaseDate, "inline": true },
            
            // Row 2
            { "name": "Developer", "value": developers, "inline": true },
            { "name": "Game Mode", "value": gameModes, "inline": true },
            { "name": "Size", "value": installSize, "inline": true },
            
            // Row 3
            { "name": "Offer Ends", "value": endDate, "inline": false }
        ],
        "footer": {
            "text": "Epic Games Store • Steam Metadata",
            "icon_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/3/31/Epic_Games_logo.svg/1200px-Epic_Games_logo.svg.png"
        }
    };
    
    embeds.push(content);
}

const payload = {
    username: "Free Game Alert",
    avatar_url: "https://upload.wikimedia.org/wikipedia/commons/6/6c/Input-gaming.png",
    embeds: embeds
};

return [{json: {body: payload}}];