gemcraft python base stuff

gem.py

#!/usr/bin/env python3

class Gem:
  c=0
  def __init__(self, y=0, o=0, b=0, d=0, g=1, v=None, p=None):
    self.number=Gem.c
    Gem.c+=1
    if v==None:
      v=2**(g-1)
    self.yellow, self.orange, self.black = y, o, b
    self.damage = d
    self.grade=g
    self.value=v
    self.parents=p
  def __add__(self, other):
    if self.grade<other.grade:
      self, other = other, self
    if self.grade==other.grade:
      return Gem(
                  max(self.yellow, other.yellow)*0.88+min(self.yellow, other.yellow)*0.5,
                  max(self.orange, other.orange)*0.88+min(self.orange, other.orange)*0.5,
                  max(self.black, other.black)*0.78+min(self.black, other.black)*0.31,
                  max(self.damage, other.damage)*0.87+min(self.damage, other.damage)*0.71,
                  self.grade+1,
                  self.value+other.value,
                  p=(self, other)
                )
    elif self.grade==other.grade+1:
      return Gem(
                  max(self.yellow, other.yellow)*0.89+min(self.yellow, other.yellow)*0.44,
                  max(self.orange, other.orange)*0.89+min(self.orange, other.orange)*0.44,
                  max(self.black, other.black)*0.79+min(self.black, other.black)*0.29,
                  max(self.damage, other.damage)*0.86+min(self.damage, other.damage)*0.7,
                  self.grade,
                  self.value+other.value,
                  p=(self, other)
                )
    else:
      return Gem(
                  max(self.yellow, other.yellow)*0.9+min(self.yellow, other.yellow)*0.38,
                  max(self.orange, other.orange)*0.9+min(self.orange, other.orange)*0.38,
                  max(self.black, other.black)*0.8+min(self.black, other.black)*0.27,
                  max(self.damage, other.damage)*0.85+min(self.damage, other.damage)*0.69,
                  self.grade,
                  self.value+other.value,
                  p=(self, other)
                )
  def __repr__(self):
    if self.grade==1:
      return "<g1 {}>".format("yellow" if self.yellow!=0 else "orange" if self.orange!=0 else "black")
    else:
      return "<gem val{} g{} id {} y{} o{} b{} dmg{} par({} {})>".format(
                                                                          self.value,
                                                                          self.grade,
                                                                          self.number,
                                                                          self.yellow,
                                                                          self.orange,
                                                                          self.black,
                                                                          self.damage,
                                                                          self.parents[0].number,
                                                                          self.parents[1].number
                                                                        )

def best_from (l, func):
  best=l[0]
  for e in l:
    if func(e, best):
      best=e
  return best

def gemset_comparable (baseset, limit_value, f_end_compare, f_mid_compare):
  gems=[{} for i in range(limit_value+1)]
  best=baseset[0]
  for e in baseset:
    gems[e.value][e.grade]=e
  for value in range(1, limit_value+1):
    print(value)
    for first_val in range(1, value):
      second_val=value-first_val
      for grade1 in gems[first_val]:
        for grade2 in gems[second_val]:
          g=gems[first_val][grade1]+gems[second_val][grade2]
          if g.grade not in gems[value] or f_mid_compare(g, gems[value][g.grade]):
            gems[value][g.grade]=g
            if f_end_compare(g, best):
              best=g
  return gems, best

def gemset_incomparable (baseset, limit_value, f_end_compare, f_limit_solutions):
  gems=[[] for i in range(limit_value+1)]
  for e in baseset:
    gems[e.value].append(e)
  for value in range(2, limit_value+1):
    print(value)
    tmp=gems[value]
    for first_val in range(1, value):
      second_val=value-first_val
      for gem1 in gems[first_val]:
        for gem2 in gems[second_val]:
          tmp.append(gem1+gem2)
    gems[value]=f_limit_solutions(tmp)
  
  best=baseset[0]
  for r in gems:
    for e in r:
      if f_end_compare(e, best):
        best=e
  return gems, best

def print_tree (gem, prefix=""):
  if gem.grade==1:
    print("━ {}".format(gem))
  else:
    print("━{}".format(gem.value))
    print(prefix+"┣", end="")
    print_tree(gem.parents[0], prefix+"┃ ")
    print(prefix+"┗", end="")
    print_tree(gem.parents[1], prefix+"  ")

def print_scheme(gem):
  def parents (g):
    if g.grade==1:
      return [g]
    else:
      return [g]+parents(g.parents[0])+parents(g.parents[1])
  l=list(set(parents(gem)))
  q=sorted([e.number for e in l])
  d={}
  for i in range(len(q)):
    d[q[i]]=i
  def get(g):
    if g.grade==1:
      return ["{:>2} = {}".format(d[g.number], g)]
    else:
      return   get(g.parents[0])\
              +get(g.parents[1])\
              +["{:>2} = {}+{}".format(
                                        d[g.number],
                                        d[g.parents[0].number],
                                        d[g.parents[1].number]
                                      )
                ]
  scheme=sorted(list(set(get(gem))))
  for e in scheme:
    print (e)

gem_simulator.py (program to import from console)

#!/usr/bin/env python3

from gem_simulator import *
import math

ACC=1000

def amp_efficiency (gem):
    if gem.value==1:
        return 0
    return math.log(gem.orange)/math.log(gem.value)

def manafarm_better_amps (g1, g2):
  return (g1.orange+4.68)*g1.black>(g2.orange+4.68)*g2.black

def killing_better_amps (g1, g2):
  return (g1.yellow+6.24)*g1.black**2>(g2.yellow+6.24)*g2.black**2

def manafarm_better_alone(g1, g2):
  return g1.orange*g1.black>g2.orange*g2.black

def amps(g1, g2):
  return amp_efficiency(g1)>amp_efficiency(g2)

def compress_mana (l):
  output=[]
  for e in sorted(l, key=lambda x: (int(x.orange*ACC), -int(x.black*ACC))):
    while len(output)!=0 and output[-1].black-e.black<1/ACC:
      output.pop()
    output.append(e)
  return output

def limit_mana (l):
  grades=[[] for i in range(20)]
  for e in l:
    grades[e.grade].append(e)
  output=[]
  for g in grades:
    output.extend(compress_mana(g))
  return output

def compress_killing (l):
  output=[]
  for e in sorted(l, key=lambda x: (int(x.yellow*ACC), -int(x.black*ACC))):
    while len(output)!=0 and output[-1].black-e.black<1/ACC:
      output.pop()
    output.append(e)
  return output

def limit_killing (l):
  grades=[[] for i in range(20)]
  for e in l:
    grades[e.grade].append(e)
  output=[]
  for g in grades:
    output.extend(compress_killing(g))
  return output

manafarm_method1 = gemset_incomparable ([Gem(o=1), Gem(b=1)], 32, manafarm_better_amps, limit_mana)
manafarm_method2 = gemset_incomparable ([Gem(o=1, b=1)], 16, manafarm_better_amps, limit_mana)

killing_method1 = gemset_incomparable ([Gem(y=1), Gem(b=1)], 32, killing_better_amps, limit_killing)
killing_method2 = gemset_incomparable ([Gem(y=1, b=1)], 16, killing_better_amps, limit_killing)

amps_method2 = gemset_comparable([Gem(o=1)], 16, amps, amps)