PS S:\CSGO> & “C:/Program Files (x86)/Python313/python.exe” s:/CSGO/csgo_game.py
Enter your username: LOGAN
Owner privileges enabled.
===== CS:GO CASE GAME V3 =====
[OWNER] [Money: $0.00] [Level: 1] [XP: 0/100]
- Open Case
- View Inventory
- Jackpot Gamble
- Offer Trade
- Accept Trade
- Decline Trade
- Clicker Mode
- View Profile
- Exit Game
all of these work and i had help from the ai but i still understood most of it
import random
import time
# =========================
# CONFIGURATION
# =========================
OWNER = “LOGAN” # Only ALL-CAPS LOGAN is the owner
# Harsher base rarities
RARITIES = {
“Common”: 0.80,
“Uncommon”: 0.15,
“Rare”: 0.04,
“Epic”: 0.009,
“Gold”: 0.001
}
WEAR = {
“Factory New”: 1.5,
“Minimal Wear”: 1.3,
“Field-Tested”: 1.0,
“Well-Worn”: 0.8,
“Battle-Scarred”: 0.6
}
ITEMS = {
“AK-47”: {
“skins”: {
“Redline”: {“rarity”: “Rare”, “base_price”: 120},
“Vulcan”: {“rarity”: “Epic”, “base_price”: 300},
“Safari Mesh”: {“rarity”: “Common”, “base_price”: 5}
}
},
“M4A1-S”: {
“skins”: {
“Golden Coil”: {“rarity”: “Epic”, “base_price”: 250},
“Decimator”: {“rarity”: “Rare”, “base_price”: 110},
“Basilisk”: {“rarity”: “Uncommon”, “base_price”: 25}
}
},
“Knife”: {
“skins”: {
“Karambit Fade”: {“rarity”: “Gold”, “base_price”: 1500},
“Karambit Doppler”: {“rarity”: “Gold”, “base_price”: 2000},
“Rust Coat”: {“rarity”: “Rare”, “base_price”: 200}
}
},
“Gloves”: {
“skins”: {
“Crimson Weave”: {“rarity”: “Epic”, “base_price”: 600},
“Pandora’s Box”: {“rarity”: “Gold”, “base_price”: 3000},
“Snakebite”: {“rarity”: “Rare”, “base_price”: 150}
}
},
“OwnerKnife”: {
“skins”: {
“Dragon Emperor”: {“rarity”: “Mythic”, “base_price”: 5000}
}
}
}
CASES = {
“Mil-Spec Case”: {
“weapons”: [“AK-47”, “M4A1-S”],
“roll_speed”: 0.03,
“owner_only”: False,
“min_level”: 1
},
“Knife Case”: {
“weapons”: [“Knife”, “Gloves”],
“roll_speed”: 0.03,
“owner_only”: False,
“min_level”: 5
},
“Owner Exclusive Case”: {
“weapons”: [“OwnerKnife”],
“roll_speed”: 0.03,
“owner_only”: True,
“min_level”: 10
},
“Budget Case”: {
“weapons”: [“AK-47”, “M4A1-S”],
“roll_speed”: 0.02,
“owner_only”: False,
“min_level”: 1
},
“High Roller Case”: {
“weapons”: [“Knife”, “Gloves”, “OwnerKnife”],
“roll_speed”: 0.04,
“owner_only”: False,
“min_level”: 8
}
}
# =========================
# PLAYER SYSTEM
# =========================
INVENTORIES = {} # username -> list of items
PLAYERS = {} # username -> {“money”: float, “level”: int, “xp”: int}
def get_player(username):
if username not in PLAYERS:
PLAYERS[username] = {“money”: 0.0, “level”: 1, “xp”: 0}
return PLAYERS[username]
def add_xp(username, amount):
player = get_player(username)
player[“xp”] += amount
while player[“xp”] >= 100:
player[“xp”] -= 100
player[“level”] += 1
print(f“\n{username} leveled up! Now level {player[‘level’]}.\n”)
def hud(username, jackpot_chance=None):
player = get_player(username)
money = player[“money”]
level = player[“level”]
xp = player[“xp”]
if username == OWNER:
if jackpot_chance is not None:
print(f“[OWNER] [Money: ${money:.2f}] [Level: {level}] [XP: {xp}/100] [JP Chance: {int(jackpot_chance*100)}%]”)
else:
print(f“[OWNER] [Money: ${money:.2f}] [Level: {level}] [XP: {xp}/100]”)
else:
print(f“[Money: ${money:.2f}] [Level: {level}] [XP: {xp}/100]”)
def show_profile(username):
print()
hud(username)
print()
def clicker_mode(username):
print(“\n=== CLICKER MODE ===”)
print(“Press ENTER to click. Type ‘exit’ and press ENTER to stop.\n”)
while True:
hud(username)
cmd = input()
if cmd.strip().lower() == “exit”:
print(“\nExiting clicker mode.\n”)
break
player = get_player(username)
gain_money = 1.0
gain_xp = 5
if username == OWNER:
gain_money = 2.0
gain_xp = 8
player[“money”] += gain_money
add_xp(username, gain_xp)
# =========================
# CORE ROLL LOGIC
# =========================
def roll_rarity():
r = random.random()
cumulative = 0
for rarity, chance in RARITIES.items():
cumulative += chance
if r <= cumulative:
return rarity
return “Common”
def roll_rarity_for_user(username):
rarity = roll_rarity()
if username == OWNER:
if rarity == “Common” and random.random() < 0.2:
rarity = “Uncommon”
elif rarity == “Uncommon” and random.random() < 0.15:
rarity = “Rare”
elif rarity == “Rare” and random.random() < 0.1:
rarity = “Epic”
elif rarity == “Epic” and random.random() < 0.05:
rarity = “Gold”
return rarity
def roll_wear():
return random.choice(list(WEAR.keys()))
def roll_skin(weapon, rarity):
skins = ITEMS[weapon][“skins”]
matching = [s for s, d in skins.items() if d[“rarity”] == rarity]
if not matching:
matching = list(skins.keys())
return random.choice(matching)
def calculate_price(weapon, skin, wear):
base = ITEMS[weapon][“skins”][skin][“base_price”]
return round(base * WEAR[wear], 2)
def owner_bonus_roll(username, weapon, rarity):
if weapon not in [“Knife”, “Gloves”]:
return weapon, rarity
if username == OWNER:
if random.random() < 0.50:
return “OwnerKnife”, “Mythic”
else:
if random.random() < 0.001:
return “OwnerKnife”, “Mythic”
return weapon, rarity
# =========================
# INVENTORY SYSTEM
# =========================
def add_to_inventory(username, weapon, skin, wear, price, rarity):
if username not in INVENTORIES:
INVENTORIES[username] = []
INVENTORIES[username].append({
“weapon”: weapon,
“skin”: skin,
“wear”: wear,
“price”: price,
“rarity”: rarity
})
def show_inventory(username):
items = INVENTORIES.get(username, [])
if not items:
print(“\nYour inventory is empty.\n”)
return
print(f“\nInventory of {username}:”)
for i, item in enumerate(items, start=1):
print(f“{i}. [{item[‘rarity’]}] {item[‘weapon’]} | {item[‘skin’]} ({item[‘wear’]}) – ${item[‘price’]}”)
print()
# =========================
# SCROLLING CASE ANIMATION
# =========================
last_open_time = 0
COOLDOWN = 1.5 # seconds between case opens
def can_open_case():
global last_open_time
now = time.time()
if now – last_open_time < COOLDOWN:
wait = round(COOLDOWN – (now – last_open_time), 2)
print(f“Slow down! Wait {wait} seconds.\n”)
return False
last_open_time = now
return True
def format_item_for_strip(item):
return f“[{item[‘rarity’]}] {item[‘weapon’]} | {item[‘skin’]}”
def build_roll_strip(case_name, username):
case = CASES[case_name]
weapons = case[“weapons”]
rarity = roll_rarity_for_user(username)
weapon = random.choice(weapons)
weapon, rarity = owner_bonus_roll(username, weapon, rarity)
skin = roll_skin(weapon, rarity)
wear = roll_wear()
price = calculate_price(weapon, skin, wear)
winning_item = {
“weapon”: weapon,
“skin”: skin,
“rarity”: rarity,
“wear”: wear,
“price”: price
}
strip = []
for _ in range(20):
r = roll_rarity()
w = random.choice(weapons)
w, r2 = owner_bonus_roll(username, w, r)
s = roll_skin(w, r2)
wr = roll_wear()
p = calculate_price(w, s, wr)
strip.append({
“weapon”: w,
“skin”: s,
“rarity”: r2,
“wear”: wr,
“price”: p
})
insert_index = random.randint(len(strip) – 5, len(strip) – 1)
strip[insert_index] = winning_item
return strip, winning_item
def play_scroll_animation(strip):
print(“\nRolling case…\n”)
for item in strip:
line = format_item_for_strip(item)
print(f“| {line} |”)
time.sleep(0.05)
# =========================
# OPEN CASE FUNCTION
# =========================
def open_case(case_name, username):
if case_name not in CASES:
print(“Invalid case name.”)
return
player = get_player(username)
case = CASES[case_name]
if player[“level”] < case.get(“min_level”, 1):
print(f“You must be at least level {case[‘min_level’]} to open this case.\n”)
return
if case[“owner_only”] and username != OWNER:
print(“You are not allowed to open this case.\n”)
return
if not can_open_case():
return
hud(username)
strip, winning_item = build_roll_strip(case_name, username)
play_scroll_animation(strip)
weapon = winning_item[“weapon”]
skin = winning_item[“skin”]
rarity = winning_item[“rarity”]
wear = winning_item[“wear”]
price = winning_item[“price”]
print(“\nYou unboxed:”)
print(f” Weapon: {weapon}”)
print(f” Skin: {skin}”)
print(f” Rarity: {rarity}”)
print(f” Wear: {wear}”)
print(f” Value: ${price}\n”)
add_to_inventory(username, weapon, skin, wear, price, rarity)
choice = input(“Do you want to sell this item for its value? (y/n): “).strip().lower()
if choice == “y”:
player[“money”] += price
INVENTORIES[username].pop()
print(f“Item sold for ${price}. New balance: ${player[‘money’]:.2f}\n”)
else:
print(“Item kept in inventory.\n”)
add_xp(username, 10)
# =========================
# JACKPOT SYSTEM (PER-ITEM GAMBLE)
# =========================
def compute_jackpot_chance(username, price):
chance = 0.50 # base 50/50
if price > 500:
chance += 0.05
if price > 1500:
chance += 0.10
if price > 3000:
chance += 0.15
if username == OWNER:
chance += 0.10
chance -= 0.30 # brutal penalty
chance = max(0.05, min(chance, 0.90))
return chance
def jackpot_gamble(username):
items = INVENTORIES.get(username, [])
if not items:
print(“\nYou have no items to gamble.\n”)
return
show_inventory(username)
try:
idx = int(input(“Choose an item number to gamble: “)) – 1
except:
print(“Invalid input.\n”)
return
if idx < 0 or idx >= len(items):
print(“Invalid item selection.\n”)
return
item = items[idx]
price = item[“price”]
chance = compute_jackpot_chance(username, price)
print(“\n=== JACKPOT GAMBLE ===”)
if username == OWNER:
hud(username, jackpot_chance=chance)
else:
hud(username)
print(f“Gambling: [{item[‘rarity’]}] {item[‘weapon’]} | {item[‘skin’]} (${item[‘price’]})”)
roll = random.random()
time.sleep(0.8)
if roll <= chance:
print(“\nYOU WON THE JACKPOT!\n”)
item[“price”] += 500
print(f“Item value increased by 500. New value: ${item[‘price’]:.2f}”)
if random.random() < 0.10:
knife_weapon = “Knife”
knife_skin = “Karambit Fade”
knife_rarity = “Gold”
knife_wear = “Factory New”
knife_price = calculate_price(knife_weapon, knife_skin, knife_wear)
add_to_inventory(username, knife_weapon, knife_skin, knife_wear, knife_price, knife_rarity)
print(f“Bonus knife awarded: {knife_weapon} | {knife_skin} (${knife_price})”)
print()
else:
print(“\nYou lost the jackpot.\n”)
item[“price”] -= 1000
if item[“price”] < 0:
item[“price”] = 0
print(f“Item value decreased by 1000. New value: ${item[‘price’]:.2f}”)
if random.random() < 0.05:
removed = INVENTORIES[username].pop(idx)
print(f“The item was lost completely: {removed[‘weapon’]} | {removed[‘skin’]}”)
print()
# =========================
# TRADING SYSTEM (to improve later)
# =========================
PENDING_TRADES = {}
def offer_trade(sender, receiver, s_index, r_index):
if sender not in INVENTORIES or receiver not in INVENTORIES:
print(“Both players must have inventories.”)
return
if s_index >= len(INVENTORIES[sender]) or s_index < 0:
print(“Invalid sender item index.”)
return
if r_index >= len(INVENTORIES[receiver]) or r_index < 0:
print(“Invalid receiver item index.”)
return
trade = {
“sender”: sender,
“receiver”: receiver,
“sender_item”: INVENTORIES[sender][s_index],
“receiver_item”: INVENTORIES[receiver][r_index]
}
PENDING_TRADES[receiver] = trade
print(f“\n{sender} offered a trade to {receiver}:”)
print(f” {sender} gives: {trade[‘sender_item’][‘weapon’]} | {trade[‘sender_item’][‘skin’]}”)
print(f” {receiver} gives: {trade[‘receiver_item’][‘weapon’]} | {trade[‘receiver_item’][‘skin’]}\n”)
def accept_trade(receiver):
if receiver not in PENDING_TRADES:
print(“No trade offer to accept.”)
return
trade = PENDING_TRADES.pop(receiver)
sender = trade[“sender”]
INVENTORIES[sender].remove(trade[“sender_item”])
INVENTORIES[receiver].remove(trade[“receiver_item”])
INVENTORIES[sender].append(trade[“receiver_item”])
INVENTORIES[receiver].append(trade[“sender_item”])
print(f“\n{receiver} accepted the trade! Items swapped.\n”)
def decline_trade(receiver):
if receiver not in PENDING_TRADES:
print(“No trade offer to decline.”)
return
del PENDING_TRADES[receiver]
print(f“\n{receiver} declined the trade.\n”)
# =========================
# CASE NAME NORMALIZER
# =========================
def normalize_case_name(user_input):
cleaned = user_input.strip().lower().replace(“-“, “”).replace(” “, “”)
for case in CASES:
key = case.lower().replace(“-“, “”).replace(” “, “”)
if cleaned in key:
return case
best_match = None
best_score = 0
for case in CASES:
key = case.lower().replace(“-“, “”).replace(” “, “”)
score = sum(1 for c in cleaned if c in key)
if score > best_score:
best_score = score
best_match = case
if best_score >= 3:
print(f“\nDid you mean: {best_match}?”)
return best_match
return None
# =========================
# MAIN MENU
# =========================
def main_menu(username):
while True:
print(“\n===== CS:GO CASE GAME V3 =====”)
hud(username)
print(“1. Open Case”)
print(“2. View Inventory”)
print(“3. Jackpot Gamble”)
print(“4. Offer Trade”)
print(“5. Accept Trade”)
print(“6. Decline Trade”)
print(“7. Clicker Mode”)
print(“8. View Profile”)
print(“9. Exit Game”)
choice = input(“\nChoose an option: “)
if choice == “1”:
print(“\nAvailable Cases:”)
for case in CASES:
print(f“- {case}”)
case_input = input(“Enter case name: “)
case_name = normalize_case_name(case_input)
if not case_name:
print(“\nInvalid case name. Available cases:”)
for case in CASES:
print(f“- {case}”)
print()
else:
open_case(case_name, username)
elif choice == “2”:
show_inventory(username)
elif choice == “3”:
jackpot_gamble(username)
elif choice == “4”:
receiver = input(“Enter the username to trade with: “)
show_inventory(username)
try:
s_index = int(input(“Your item number: “)) – 1
show_inventory(receiver)
r_index = int(input(“Their item number: “)) – 1
offer_trade(username, receiver, s_index, r_index)
except:
print(“Invalid input.”)
elif choice == “5”:
accept_trade(username)
elif choice == “6”:
decline_trade(username)
elif choice == “7”:
clicker_mode(username)
elif choice == “8”:
show_profile(username)
elif choice == “9”:
print(“\nExiting game…\n”)
break
else:
print(“Invalid choice.”)
# =========================
# ENTRY POINT
# =========================
if __name__ == “__main__”:
username = input(“Enter your username: “)
if username == OWNER:
print(“Owner privileges enabled.”)
else:
print(“Standard player mode.”)
if username not in INVENTORIES:
INVENTORIES[username] = []
get_player(username)
main_menu(username)