def zawroc(flota, user):
if Fleets.objects.select_for_update().filter(
pk=flota, fleet_owner=user, fleet_back__lt=1).count() > 0:
try:
flota = Fleets.objects.select_for_update().get(pk=flota,
fleet_owner=user,
fleet_back__lt=1)
czas_teraz = int(time())
lot_trwa = czas_teraz - flota.time_start
caly_lot_czas = flota.time - flota.time_start
procent_lotu = float(lot_trwa) / float(caly_lot_czas) / 2
bak_zostanie = flota.bak - (flota.bak * procent_lotu)
flota.bak = bak_zostanie
flota.fleet_resource_deuterium += bak_zostanie
galaxy_end = flota.galaxy_end
flota.galaxy_end = flota.galaxy_start
flota.galaxy_start = galaxy_end
flota.time_start = int(czas_teraz)
flota.time = int(czas_teraz + lot_trwa)
flota.fleet_back = 1
flota.save(force_update=True)
except:
message = "Wybierz poprawną flote"
send_error_message(user=user, message=message)
else:
message = "Nie ma takiej floty do zawrócenia"
send_error_message(user=user, message=message)
def check_mamy_kolonizator(user, planeta):
s_kolonizacyjne = Flota.objects.filter(kolonizacja__gt=0, lata__gt=0)
ilosc = planeta.flota_p_set.filter(budynek__in=s_kolonizacyjne,
ilosc__gt=0).count()
if ilosc > 0:
return True
else:
message = "Niestety nie posiadasz statku kolonizacyjnego"
send_error_message(user=user, message=message)
return False
def check_mamy_recycler(user, planeta):
s_recyclery = Flota.objects.filter(recycler__gt=0, lata__gt=0)
ilosc = planeta.flota_p_set.filter(budynek__in=s_recyclery,
ilosc__gt=0).count()
if ilosc > 0:
return True
else:
message = "Niestety nie posiadasz statku recyclerskiego"
send_error_message(user=user, message=message)
return False
def site_odrzuc(self, object_id=None):
try:
zaproszenie = self.game.user.zaproszenia_set.get(pk=object_id)
sojusz = zaproszenie.sojusz
SojuszLog.objects.create(
sojusz=sojusz,
tekst="<a href='/game/usr/" + str(self.game.user.pk) + "/'>" +
self.game.user.username +
'</a> odrzucił zaproszenie do sojuszu.' + "</a>")
zaproszenie.delete()
message = 'Odrzuciłeś zaproszenie do sojusz: %s' % (sojusz.nazwa, )
send_error_message(user=self.user, message=message)
except:
sojusz = None
return HttpResponseRedirect(url(self.urls.main))
def check_free_planet(user, planeta_id, system_id, galaktyka_id):
if not planeta_id > 0 or planeta_id > MAX_PLANETA or not galaktyka_id > 0 or galaktyka_id > MAX_GALAXY or not \
system_id > 0 or system_id > MAX_SYSTEM:
message = "Niepoprawne dane dotyczące pozycji planety w systemie planetarnym"
send_error_message(user=user, message=message)
return False
if Galaxy.objects.filter(galaxy=galaktyka_id,
system=system_id,
field=planeta_id,
planet__owner__isnull=False).count() > 0:
message = "Niestety planeta " + str(galaktyka_id) + ":" + str(
system_id) + ":" + str(planeta_id) + " jest już zajęta"
send_error_message(user=user, message=message)
return False
return True
def site_change_planets_order(self):
planety = self.game.get_all_planets()
for p_id in planety:
planeta = self.game.get_planet(p_id)
kolej_str = 'kolej_%s' % (p_id)
if kolej_str in self.request.POST:
try:
planeta.kolej = int(self.request.POST[kolej_str])
except:
pass
message = 'Kolejność planet została uaktualniona'
send_error_message(user=self.game.user, message=message)
redirect_url = url(self.urls.main)
if 'HTTP_REFERER' in self.request.META:
if len(self.request.META['HTTP_REFERER']) > 3:
redirect_url = self.request.META['HTTP_REFERER']
return HttpResponseRedirect(redirect_url)
def is_planet_owner(user, planeta_dane, odwrotne=False):
galaxy = Galaxy.objects.get(galaxy=planeta_dane.galaktyka_id,
system=planeta_dane.system_id,
field=planeta_dane.planeta_id)
planet_obj = galaxy.planet
if not odwrotne:
if not planet_obj.owner_id == user.pk:
message = "Niestety planeta %s:%s:%s nie jest twoja" % (
planeta_dane.galaktyka_id, planeta_dane.system_id,
planeta_dane.planeta_id)
send_error_message(user=user, message=message)
return False
return True
else:
if planet_obj.owner_id == user.pk:
message = "Niestety planeta %s:%s:%s jest twoja" % (
planeta_dane.galaktyka_id, planeta_dane.system_id,
planeta_dane.planeta_id)
send_error_message(user=user, message=message)
return True
return False
def check_surowce(request, planeta, dane_floty):
user = request.user
surowce_poprawne = True
try:
zab_met = wieksze_od_zera(int(request.REQUEST['zab_met']))
if zab_met > planeta.metal:
message = "Nie masz tyle metalu na planecie"
send_error_message(user=user, message=message)
surowce_poprawne = False
except:
zab_met = 0
try:
zab_cry = wieksze_od_zera(int(request.REQUEST['zab_cry']))
if zab_cry > planeta.crystal:
message = "Nie masz tyle kryształu na planecie"
send_error_message(user=user, message=message)
surowce_poprawne = False
except:
zab_cry = 0
try:
zab_deu = wieksze_od_zera(int(request.REQUEST['zab_deu']))
if zab_deu > planeta.deuter - dane_floty.zuzycie_deuter:
message = "Nie masz tyle deuteru na planecie"
send_error_message(user=user, message=message)
surowce_poprawne = False
except:
zab_deu = 0
zabieramy = zab_cry + zab_deu + zab_met
if zabieramy > dane_floty.ladownosc:
message = "Nie możesz zabrać tyle ładunku na statki"
send_error_message(user=user, message=message)
surowce_poprawne = False
if not surowce_poprawne:
return False
return [zab_met, zab_cry, zab_deu]
def site_for_sale(self, page=1):
try:
page = int(page)
if page <= 0:
page = 1
except:
page = 1
current_planet = self.game.get_current_planet()
rynek_obj = Rynek(planeta=current_planet)
if self.request.method == 'POST':
rynek_form = RynekForm(instance=rynek_obj, data=self.request.POST)
if rynek_form.is_valid():
co = rynek_form.cleaned_data['co']
co_ile = rynek_form.cleaned_data['co_ile']
# na = rynek_form.cleaned_data['na']
na_ile = rynek_form.cleaned_data['na_ile']
ilosc = rynek_form.cleaned_data['ilosc']
dobre_dane = True
ile_surowca = int(ceil(co_ile * ilosc * 1.05))
if na_ile / co_ile > 100.0 or na_ile / co_ile < 0.01:
message = "Stosunek kupna do sprzedaży musi zawierać sie od 100/1 do 1/100"
send_error_message(user=self.game.user, message=message)
dobre_dane = False
if co_ile < 0 or na_ile < 0:
message = "Wartości muszą być większe od 0"
send_error_message(user=self.game.user, message=message)
dobre_dane = False
if dobre_dane:
if co == 'M':
if ile_surowca > current_planet.metal:
message = "Nie masz tyle metalu na planecie: %s" % ile_surowca
send_error_message(user=self.game.user,
message=message)
dobre_dane = False
else:
current_planet.metal -= ile_surowca
elif co == 'K':
if ile_surowca > current_planet.crystal:
message = "Nie masz tyle kryształu na planecie: %s" % ile_surowca
send_error_message(user=self.game.user,
message=message)
dobre_dane = False
else:
current_planet.crystal -= ile_surowca
elif co == 'D':
if ile_surowca > current_planet.deuter:
message = "Nie masz tyle deuteru na planecie: %s" % ile_surowca
send_error_message(user=self.game.user,
message=message)
dobre_dane = False
else:
current_planet.deuter -= ile_surowca
if Rynek.objects.select_for_update().filter(
planeta__owner=self.game.user).count() > 15:
message = "Osiągnąłeś limit 15 ofert na rynku, nie możesz już więcej wystawić"
send_error_message(user=self.game.user, message=message)
dobre_dane = False
if dobre_dane:
rynek_obj = rynek_form.save(commit=False)
rynek_obj.planeta = current_planet
rynek_obj.ratio = na_ile / co_ile
rynek_obj.save() # tu tak ma byc
message = "Wystawiłeś ofertę na rynku"
send_info_message(user=self.game.user, message=message)
return HttpResponseRedirect(url(self.urls.main))
else:
message = "Musisz podać wszystkie dane"
send_error_message(user=self.game.user, message=message)
else:
rynek_form = RynekForm(instance=rynek_obj)
if "wycofaj" in self.request.GET:
try:
wycofanie = Rynek.objects.select_for_update().get(
pk=self.request.GET['wycofaj'],
planeta__owner=self.game.user)
planeta_wycofania = self.game.get_planet(wycofanie.planeta_id)
ile_surowca = int(wycofanie.co_ile * wycofanie.ilosc)
if wycofanie.co == 'M':
message = "Wycofanie oferty, przybyło metalu na planecie: %s" % ile_surowca
send_info_message(user=self.game.user, message=message)
planeta_wycofania.metal += ile_surowca
elif wycofanie.co == 'K':
message = "Wycofanie oferty, przybyło kryształu na planecie: %s" % ile_surowca
send_info_message(user=self.game.user, message=message)
planeta_wycofania.crystal += ile_surowca
elif wycofanie.co == 'D':
message = "Wycofanie oferty, przybyło deuteru na planecie: %s" % ile_surowca
send_info_message(user=self.game.user, message=message)
planeta_wycofania.deuter += ile_surowca
wycofanie.delete()
return HttpResponseRedirect(url(self.url))
except:
return HttpResponseRedirect(url(self.url))
rynek_twoje = Rynek.objects.filter(planeta__owner=self.game.user)
paginator = Paginator(rynek_twoje, 20, allow_empty_first_page=True)
try:
p = paginator.page(page)
except:
return HttpResponseRedirect(url(self.url))
rynek_obj = p.object_list
topnav = topnav_site(self.game)
return {
"topnav": topnav,
"rynek_twoje": rynek_obj,
"rynek_form": rynek_form,
"paginator": paginator,
"page": page,
"page_list": p,
}
def check_ship_request(GraObject,
request,
planeta,
planeta_dane,
id_statkow,
ship_request,
user,
check_kolonizacja=None,
check_recycler=None):
kolonizacyjny = False
recyclerski = False
bledne_ilosci = False
jakikolwiek_statek = False
dane_floty = Output()
dane_floty.speed = False
dane_floty.bak_pojemnosc = 0
dane_floty.ladownosc = 0
dane_floty.basic_consumption = 0
statki_podsumowanie = []
statki_do_wyslania = Flota_p.objects.values_list(
"budynek_id",
flat=True).filter(planeta=planeta,
budynek__lata__gt=0,
budynek__in=id_statkow).order_by("budynek")
id_statkow = []
for tmp in statki_do_wyslania:
i = GraObject.cache_obj.get_flota_p(planeta.pk, tmp)
try:
ilosc = int(ship_request[i.budynek_id])
except:
ilosc = 0
if ilosc <= i.ilosc and ilosc > 0:
id_statkow.append(i.budynek_id)
true_speed = int(get_speed(GraObject, i.budynek, user))
jakikolwiek_statek = True
statki_podsumowanie.append({
"statek": i.budynek,
"ilosc": ilosc,
"speed": true_speed
})
if not dane_floty.speed or dane_floty.speed > true_speed:
dane_floty.speed = true_speed
if check_kolonizacja and i.budynek.kolonizacja > 0:
kolonizacyjny = True
if check_recycler and i.budynek.recycler > 0:
recyclerski = True
elif ilosc > i.ilosc:
bledne_ilosci = True
dane_floty.bak_pojemnosc += i.budynek.bak * ilosc
if check_recycler:
if i.budynek.recycler:
dane_floty.ladownosc += i.budynek.capacity * ilosc
else:
dane_floty.ladownosc += i.budynek.capacity * ilosc
dane_floty.basic_consumption += i.budynek.c_consumption * ilosc
# dane_floty.speed=int(dane_floty.speed*(planeta_dane.speed_procent/10))
request.session['id_statkow'] = id_statkow
if bledne_ilosci:
message = "Niestety wprowadziłeś błędne ilości statków"
send_error_message(user=user, message=message)
del request.session['id_statkow']
del request.session['ship_request']
del request.session['planeta_dane']
return False
if check_kolonizacja and not kolonizacyjny:
message = "Musisz wybrać statek kolonizacyjny"
send_error_message(user=user, message=message)
del request.session['id_statkow']
del request.session['ship_request']
del request.session['planeta_dane']
return False
if check_recycler and not recyclerski:
message = "Musisz wybrać statek recyclerski"
send_error_message(user=user, message=message)
del request.session['id_statkow']
del request.session['ship_request']
del request.session['planeta_dane']
return False
if not jakikolwiek_statek:
message = "Musisz wybrać statki"
send_error_message(user=user, message=message)
return False
return {
"id_statkow": id_statkow,
"ship_request": ship_request,
"dane_floty": dane_floty,
"statki_podsumowanie": statki_podsumowanie
}
def site_accept(self):
current_planet = self.game.get_current_planet()
if 'planeta_dane' in self.request.session:
planeta_dane = self.request.session['planeta_dane']
else:
return HttpResponseRedirect("/game/overview/")
try:
if self.request.REQUEST.has_key('speed'):
test = float(self.request.REQUEST['speed'])
planeta_dane.speed_procent = test
if not planeta_dane.speed_procent >= 1.0 or not planeta_dane.speed_procent <= 10.0:
planeta_dane.speed_procent = 10.0
except:
return HttpResponseRedirect("/game/fs/spy/")
if not check_is_planet(self.game.user, planeta_dane.planeta_id,
planeta_dane.system_id,
planeta_dane.galaktyka_id):
return HttpResponseRedirect("/game/galaxy/")
if is_planet_owner(self.game.user, planeta_dane, True):
return HttpResponseRedirect("/game/galaxy/")
if 'id_statkow' in self.request.session:
id_statkow = self.request.session['id_statkow']
else:
id_statkow = None
if 'ship_request' in self.request.session:
ship_request = self.request.session['ship_request']
else:
ship_request = None
if not id_statkow or not ship_request:
tmp = get_ship_request(self.game, current_planet, self.request,
self.game.user, planeta_dane)
else:
tmp = get_ship_request(self.game, current_planet, self.request,
self.game.user, planeta_dane, False, False,
False)
if not tmp:
if not id_statkow or not ship_request:
return HttpResponseRedirect("/game/fs/spy/")
else:
tmp = check_ship_request(self.game, self.request,
current_planet, planeta_dane,
id_statkow, ship_request,
self.game.user)
if not tmp:
return HttpResponseRedirect("/game/fs/spy/")
id_statkow = tmp['id_statkow']
ship_request = tmp['ship_request']
dane_floty = tmp['dane_floty']
statki_podsumowanie = tmp['statki_podsumowanie']
dane_floty.odleglosc = odleglosc(current_planet,
planeta_dane.galaktyka_id,
planeta_dane.system_id,
planeta_dane.planeta_id)
dane_floty.czas_lotu = getCzasLotu(planeta_dane.speed_procent,
dane_floty.speed,
dane_floty.odleglosc, FLEET_SPEED)
dane_floty.zuzycie_deuter = get_zuzycie_deuteru(
dane_floty, planeta_dane)
if dane_floty.bak_pojemnosc - dane_floty.zuzycie_deuter < 0:
message = "Nie można zabrać wystarczająco paliwa. Pojemność baków:" + str(
dane_floty.bak_pojemnosc) + ", potrzeba:" + str(
dane_floty.zuzycie_deuter)
send_error_message(user=self.game.user, message=message)
return HttpResponseRedirect("/game/fs/spy/")
if dane_floty.zuzycie_deuter > current_planet.deuter:
message = "Masz za mało deuteru na planecie"
send_error_message(user=self.game.user, message=message)
return HttpResponseRedirect("/game/fs/spy/")
self.request.session['planeta_dane'] = planeta_dane
self.request.session['dane_floty'] = dane_floty
self.request.session['ship_request'] = ship_request
self.request.session['id_statkow'] = id_statkow
topnav = topnav_site(self.game)
return {
"planeta_dane": planeta_dane,
"dane_floty": dane_floty,
'topnav': topnav,
"statki_podsumowanie": statki_podsumowanie
}
def site_send(self):
current_planet = self.game.get_current_planet()
if 'planeta_dane' in self.request.session:
planeta_dane = self.request.session['planeta_dane']
else:
return HttpResponseRedirect("/game/overview/")
if 'id_statkow' in self.request.session:
id_statkow = self.request.session['id_statkow']
else:
return HttpResponseRedirect("/game/overview/")
if 'ship_request' in self.request.session:
ship_request = self.request.session['ship_request']
else:
return HttpResponseRedirect("/game/overview/")
if not check_is_planet(self.game.user, planeta_dane.planeta_id,
planeta_dane.system_id,
planeta_dane.galaktyka_id):
return HttpResponseRedirect("/game/galaxy/")
if is_planet_owner(self.game.user, planeta_dane, True):
return HttpResponseRedirect("/game/galaxy/")
tmp = check_ship_request(self.game, self.request, current_planet,
planeta_dane, id_statkow, ship_request,
self.game.user)
if not tmp:
return HttpResponseRedirect("/game/overview/")
dane_floty = tmp['dane_floty']
id_statkow = tmp['id_statkow']
ship_request = tmp['ship_request']
dane_floty.odleglosc = odleglosc(current_planet,
planeta_dane.galaktyka_id,
planeta_dane.system_id,
planeta_dane.planeta_id)
dane_floty.czas_lotu = getCzasLotu(planeta_dane.speed_procent,
dane_floty.speed,
dane_floty.odleglosc, FLEET_SPEED)
dane_floty.zuzycie_deuter = get_zuzycie_deuteru(
dane_floty, planeta_dane)
if dane_floty.bak_pojemnosc - dane_floty.zuzycie_deuter < 0:
message = "Nie można zabrać wystarczająco paliwa. Pojemność baków:" + str(
dane_floty.bak_pojemnosc) + ", potrzeba:" + str(
dane_floty.zuzycie_deuter)
send_error_message(user=self.game.user, message=message)
return HttpResponseRedirect("/game/fs/spy/")
if dane_floty.zuzycie_deuter > current_planet.deuter:
message = "Masz za mało deuteru na planecie"
send_error_message(user=self.game.user, message=message)
return HttpResponseRedirect("/game/fs/spy/")
current_planet.deuter -= dane_floty.zuzycie_deuter
fleet_array = []
fleet_amount = 0
for i in id_statkow:
fleet_array.append("%s,%s" % (i, ship_request[i]))
fleet_amount += int(ship_request[i])
statek_row = self.game.cache_obj.get_flota_p(
current_planet.pk, int(i))
statek_row.ilosc -= int(ship_request[i])
time_start = time()
galaxy_end = Galaxy.objects.get(galaxy=planeta_dane.galaktyka_id,
system=planeta_dane.system_id,
field=planeta_dane.planeta_id)
flota_row = Fleets.objects.create(fleet_owner=self.game.user,
fleet_mission=6,
fleet_amount=fleet_amount,
fleet_array=";".join(fleet_array),
time_start=time_start,
galaxy_start=current_planet.galaxy,
time=time_start +
dane_floty.czas_lotu,
galaxy_end=galaxy_end,
fleet_resource_metal=0,
fleet_resource_crystal=0,
fleet_resource_deuterium=0,
bak=dane_floty.zuzycie_deuter)
del self.request.session['id_statkow']
del self.request.session['ship_request']
del self.request.session['planeta_dane']
return HttpResponseRedirect("/game/fleet/")
def site_main(self):
self.game.userprofile_podglad_flota()
current_planet = self.game.get_current_planet()
if "fast_fleet_del" in self.request.REQUEST:
self.game.userprofile.fast_fleet.remove(
self.request.REQUEST['fast_fleet_del'])
if "fast_fleet_add" in self.request.REQUEST:
try:
fast_planet = Planets.objects.get(
pk=self.request.REQUEST['fast_fleet_add'])
self.game.userprofile.fast_fleet.add(fast_planet)
except:
pass
try:
page = int(self.request.REQUEST['page'])
if not page > 0:
page = 1
except:
page = 1
paginator = Paginator(self.game.userprofile.fast_fleet.all(),
20,
allow_empty_first_page=True)
if page > paginator.num_pages:
page = paginator.num_pages
p = paginator.page(page)
fast_fleet = p.object_list
if "fs_zawroc" in self.request.REQUEST:
message = "Flotę zawrócono"
send_info_message(user=self.game.user, message=message)
zawroc(self.request.REQUEST['fs_zawroc'], self.game.user)
if "g" in self.request.REQUEST and "s" in self.request.REQUEST and "p" in self.request.REQUEST and "typ" in self.request.REQUEST:
try:
g = int(self.request.REQUEST['g'])
s = int(self.request.REQUEST['s'])
p = int(self.request.REQUEST['p'])
if self.request.REQUEST['typ'] == 'a':
return HttpResponseRedirect(
"/game/fs/atak/?g=%d&s=%d&p=%d" % (g, s, p))
elif self.request.REQUEST['typ'] == 'k':
return HttpResponseRedirect(
"/game/fs/kolonizuj/?g=%d&s=%d&p=%d" % (g, s, p))
elif self.request.REQUEST['typ'] == 'p':
return HttpResponseRedirect(
"/game/fs/przeslij/?g=%d&s=%d&p=%d" % (g, s, p))
elif self.request.REQUEST['typ'] == 't':
return HttpResponseRedirect(
"/game/fs/surowce/?g=%d&s=%d&p=%d" % (g, s, p))
elif self.request.REQUEST['typ'] == 'z':
return HttpResponseRedirect(
"/game/fs/zlom/?g=%d&s=%d&p=%d" % (g, s, p))
elif self.request.REQUEST['typ'] == 's':
return HttpResponseRedirect(
"/game/fs/spy/?g=%d&s=%d&p=%d" % (g, s, p))
except:
message = "Wprowadź poprawne dane do ataku"
send_error_message(user=self.game.user, message=message)
pass
dostepne_statki_tmp = Flota_p.objects.filter(
planeta=current_planet, budynek__lata__gt=0,
ilosc__gt=0).order_by("budynek")
dostepne_statki = []
for i in dostepne_statki_tmp:
d = i
d.speed = int(get_speed(self.game, i.budynek, self.game.user))
dostepne_statki.append(d)
# userprofile.fast_fleet.add(planeta)
floty_own, floty_obce, _ = get_flota(self.game)
topnav = topnav_site(self.game)
return {
"paginator": paginator,
"fast_fleet": fast_fleet,
"floty_own": floty_own,
"floty_obce": floty_obce,
'topnav': topnav,
"dostepne_statki": dostepne_statki
}
def buduj_flote(self, bud, ilosc):
# query = "lock table game_flota_f in ACCESS EXCLUSIVE MODE"
# cursor = connection.cursor()
# cursor.execute(query)
planeta = self.get_current_planet()
if planeta:
flota = Output()
flota.c_met = bud.c_met * ilosc
flota.c_cry = bud.c_cry * ilosc
flota.c_deu = bud.c_deu * ilosc
flota.c_czas = (bud.c_cry + bud.c_met) / GAME_SPEED
flota.mozna = 1
for i in Buildings.objects.filter(minus_czas_flota_tak__gt=0):
level = floor(self.bud_get_level(planeta, i.id))
flota.c_czas = flota.c_czas * eval(i.minus_czas_flota)
flota.c_czas_one = flota.c_czas * 60 * 60
flota.c_czas = flota.c_czas * 60 * 60 * ilosc
flota.z_met = planeta.metal - flota.c_met
if flota.z_met < 0:
message = u"Za mało metalu do wybudowania %s" % (bud.nazwa, )
send_error_message(user=self.user, message=message)
flota.mozna = None
flota.z_cry = planeta.crystal - flota.c_cry
if flota.z_cry < 0:
message = u"Za mało kryształu do wybudowania %s" % (
bud.nazwa, )
send_error_message(user=self.user, message=message)
flota.mozna = None
flota.z_deu = planeta.deuter - flota.c_deu
if flota.z_deu < 0:
message = u"Za mało deuteru do wybudowania %s" % (bud.nazwa, )
send_error_message(user=self.user, message=message)
flota.mozna = None
zaleznosc = split(bud.w_bud, ";")
if flota.mozna:
for zal in zaleznosc:
budynek = split(zal, ",")
if len(budynek) > 1:
if int(budynek[1]) > self.bud_get_level(
planeta, budynek[0]):
message = u"Nie spełnione zależności budynków dla %s" % (
bud.nazwa, )
send_error_message(user=self.user, message=message)
flota.mozna = None
break
if flota.mozna:
zaleznosc = split(bud.w_bad, ";")
for zal in zaleznosc:
badanie = split(zal, ",")
if len(badanie) > 1:
if int(badanie[1]) > self.bad_get_level(
self.user, badanie[0]):
message = u"Nie spełnione zależności badań dla %s" % (
bud.nazwa, )
send_error_message(user=self.user, message=message)
flota.mozna = None
break
if flota.mozna:
czas = self.get_flota_kolejka_czas(planeta)
flota.points = (bud.c_met + bud.c_cry + bud.c_deu) / 1000.0
kolejka = Flota_f.objects.create(budynek=bud,
planeta=planeta,
ilosc=ilosc,
time=czas + flota.c_czas,
points=flota.points,
time_one=flota.c_czas_one *
(ilosc - 1))
self.cache_obj.get_flota_f(planeta.pk, kolejka.pk)
planeta.metal -= flota.c_met
planeta.crystal -= flota.c_cry
planeta.deuter -= flota.c_deu
def wiadomosc_przeslana(request, id):
user = request.user
try:
temat = TematyMod.objects.get(pk=id, rozpatrzony=False)
except:
return HttpResponseRedirect(reverse("cms.views.wiadomosci_przeslane"))
wiadomosci = WiadomosciMod.objects.filter(temat=temat).order_by("data")
if request.method == 'POST':
powod = request.POST.get('powod', '')
if 'na_dni' in request.POST and 'ban_dla' in request.POST and len(
powod) > 0:
try:
ban_dla = int(request.POST['ban_dla'])
na_dni = int(request.POST['na_dni'])
except:
message = "Podaj wszystkie dane"
send_error_message(user=user, message=message)
return HttpResponseRedirect(
reverse("cms.views.wiadomosc_przeslana",
kwargs={"id": temat.pk}))
if na_dni == 0:
temat.uzasadnienie = powod
temat.rozpatrzony = True
temat.save()
message = "Gracze zostali ułaskawieni"
send_info_message(user=user, message=message)
return HttpResponseRedirect(
reverse("cms.views.wiadomosci_przeslane"))
elif na_dni > 7 or na_dni < 1:
message = "Wybierz poprawną ilość dni"
send_error_message(user=user, message=message)
return HttpResponseRedirect(
reverse("cms.views.wiadomosc_przeslana",
kwargs={"id": temat.pk}))
if ban_dla == temat.nadawca.pk:
if not user.is_superuser and temat.nadawca.is_staff:
message = "Nie jesteś adminem, więc nie możesz banować moderatorów"
send_error_message(user=user, message=message)
return HttpResponseRedirect(
reverse("cms.views.wiadomosc_przeslana",
kwargs={"id": temat.pk}))
ban = Bany.objects.create(user=temat.nadawca,
do=datetime.datetime.now() +
datetime.timedelta(days=na_dni),
powod=powod)
temat.ban = ban
temat.uzasadnienie = powod
temat.rozpatrzony = True
temat.save()
elif ban_dla == temat.odbiorca.pk:
if not user.is_superuser and temat.odbiorca.is_staff:
message = "Nie jesteś adminem, więc nie możesz banować moderatorów"
send_error_message(user=user, message=message)
return HttpResponseRedirect(
reverse("cms.views.wiadomosc_przeslana",
kwargs={"id": temat.pk}))
ban = Bany.objects.create(user=temat.odbiorca,
do=datetime.datetime.now() +
datetime.timedelta(days=na_dni),
powod=powod)
temat.ban = ban
temat.uzasadnienie = powod
temat.rozpatrzony = True
temat.save()
else:
message = "Wybierz właściwego gracza"
send_error_message(user=user, message=message)
return HttpResponseRedirect(
reverse("cms.views.wiadomosc_przeslana",
kwargs={"id": temat.pk}))
message = "Gracz został zbanowany"
send_info_message(user=user, message=message)
return HttpResponseRedirect(
reverse("cms.views.wiadomosci_przeslane"))
else:
message = "Podaj wszystkie dane"
send_error_message(user=user, message=message)
return jrender(request, "cms/wiadomosci/przeslana_wiecej.html", {
"temat": temat,
"wiadomosci": wiadomosci
})
def site_take_offer(self):
current_planet = self.game.get_current_planet()
if "id" in self.request.REQUEST:
try:
rynek_obj = Rynek.objects.select_for_update().get(
pk=self.request.REQUEST['id'])
req_obj = Output()
req_obj.user = rynek_obj.planeta.owner
GraAlienObject = BaseGame(req_obj)
GraAlienObject.save_all()
planeta_alien = GraAlienObject.get_planet(rynek_obj.planeta_id)
rynek_obj = Rynek.objects.select_for_update().get(
pk=self.request.REQUEST['id'])
except Rynek.DoesNotExist:
message = "Nie ma już takiej oferty na rynku, wybież inną"
send_error_message(user=self.game.user, message=message)
return HttpResponseRedirect(url(self.urls.main))
else:
message = "Nie ma już takiej oferty na rynku, wybież inną"
send_error_message(user=self.game.user, message=message)
return HttpResponseRedirect(url(self.urls.main))
if rynek_obj.planeta.owner_id == self.game.user.id:
message = "Nie możesz kupić swojej oferty, nawet jeśli jest z innej planety"
send_error_message(user=self.game.user, message=message)
GraAlienObject.save_all()
return HttpResponseRedirect(url(self.urls.main))
try:
ilosc = int(self.request.REQUEST["ilosc"])
except:
send_error_message(user=self.game.user,
message="Wybież prawidłową ilość paczek")
GraAlienObject.save_all()
return HttpResponseRedirect(url(self.urls.main))
if ilosc > rynek_obj.ilosc:
message = "Wybież prawidłową ilość paczek"
send_error_message(user=self.game.user, message=message)
GraAlienObject.save_all()
return HttpResponseRedirect(url(self.urls.main))
ile_oddajemy = ilosc * rynek_obj.na_ile
if rynek_obj.na == 'M':
if ile_oddajemy > current_planet.metal:
message = "Nie masz tyle surowców żeby to kupić"
send_error_message(user=self.game.user, message=message)
GraAlienObject.save_all()
return HttpResponseRedirect(url(self.urls.main))
current_planet.metal -= ile_oddajemy
planeta_alien.metal += ile_oddajemy
elif rynek_obj.na == 'K':
if ile_oddajemy > current_planet.crystal:
message = "Nie masz tyle surowców żeby to kupić"
send_error_message(user=self.game.user, message=message)
GraAlienObject.save_all()
return HttpResponseRedirect(url(self.urls.main))
current_planet.crystal -= ile_oddajemy
planeta_alien.crystal += ile_oddajemy
elif rynek_obj.na == 'D':
if ile_oddajemy > current_planet.deuter:
message = "Nie masz tyle surowców żeby to kupić"
send_error_message(user=self.game.user, message=message)
GraAlienObject.save_all()
return HttpResponseRedirect(url(self.urls.main))
current_planet.deuter -= ile_oddajemy
planeta_alien.deuter += ile_oddajemy
message = "%s kupił %s paczek po %s %s" % (
self.game.user.username, ilosc, rynek_obj.na_ile, dlugie_nazwy[str(
rynek_obj.na).lower()])
send_info_message(user=GraAlienObject.user, message=message)
ile_dostajemy = rynek_obj.co_ile * ilosc
if rynek_obj.co == 'M':
current_planet.metal += ile_dostajemy
elif rynek_obj.co == 'K':
current_planet.crystal += ile_dostajemy
elif rynek_obj.co == 'D':
current_planet.deuter += ile_dostajemy
if ilosc >= rynek_obj.ilosc:
rynek_obj.delete()
else:
rynek_obj.ilosc -= ilosc
rynek_obj.save(force_update=True)
message = "Właśnie kupiłeś surowce"
send_info_message(user=self.game.user, message=message)
GraAlienObject.save_all()
return HttpResponseRedirect(url(self.urls.main))
def site_take_from_dealer(self):
planeta = self.game.get_current_planet()
poprawne_dane = True
if 'co_sprzedaje' not in self.request.POST:
message = "Musisz wybrać co sprzedajesz"
send_error_message(user=self.game.user, message=message)
poprawne_dane = False
else:
co_sprzedaje = self.request.POST['co_sprzedaje']
if co_sprzedaje not in ('m', 'k', 'd'):
message = "Musisz wybrać co sprzedajesz"
send_error_message(user=self.game.user, message=message)
poprawne_dane = False
if 'sprzedaje_na' not in self.request.POST:
message = "Musisz wybrać co kupujesz"
send_error_message(user=self.game.user, message=message)
poprawne_dane = False
else:
sprzedaje_na = self.request.POST['sprzedaje_na']
if sprzedaje_na not in ('m', 'k', 'd'):
message = "Musisz wybrać co kupujesz"
send_error_message(user=self.game.user, message=message)
poprawne_dane = False
try:
ilosc_sprzedawanego = int(self.request.POST['ilosc_sprzedawanego'])
except:
message = "Musisz podać poprawną ilość sprzedawanego surowca"
send_error_message(user=self.game.user, message=message)
poprawne_dane = False
if poprawne_dane:
ile_mam = 0
if co_sprzedaje == 'm':
ile_mam = planeta.metal
elif co_sprzedaje == 'k':
ile_mam = planeta.crystal
elif co_sprzedaje == 'd':
ile_mam = planeta.deuter
if ilosc_sprzedawanego < 0:
message = "Ilość sprzedawanego musi być większa od 0"
send_error_message(user=self.game.user, message=message)
poprawne_dane = False
elif ile_mam < ilosc_sprzedawanego:
message = "Nie masz tyle surowca"
send_error_message(user=self.game.user, message=message)
poprawne_dane = False
else:
ile_kupilismy = floor(
floor(ilosc_sprzedawanego * 0.9) *
grid_sprzedawcy[co_sprzedaje][sprzedaje_na])
if co_sprzedaje == 'm':
planeta.metal -= ilosc_sprzedawanego
elif co_sprzedaje == 'k':
planeta.crystal -= ilosc_sprzedawanego
elif co_sprzedaje == 'd':
planeta.deuter -= ilosc_sprzedawanego
if sprzedaje_na == 'm':
planeta.metal += ile_kupilismy
elif sprzedaje_na == 'k':
planeta.crystal += ile_kupilismy
elif sprzedaje_na == 'd':
planeta.deuter += ile_kupilismy
message = "Kupiłeś %s %s za %s %s" % (
int(ile_kupilismy), dlugie_nazwy[sprzedaje_na],
ilosc_sprzedawanego, dlugie_nazwy[co_sprzedaje])
send_info_message(user=self.game.user, message=message)
return HttpResponseRedirect(url(self.urls.dealer))
def buduj_obrone(self, f, ilosc):
planeta = self.get_current_planet()
msg = []
# query = "lock table game_obrona_f in ACCESS EXCLUSIVE MODE"
# cursor = connection.cursor()
# cursor.execute(query)
if planeta:
flota = Output()
flota.c_met = f.c_met * ilosc
flota.c_cry = f.c_cry * ilosc
flota.c_deu = f.c_deu * ilosc
flota.c_czas = (f.c_cry + f.c_met) / GAME_SPEED
flota.mozna = 1
for i in Buildings.objects.filter(minus_czas_flota_tak__gt=0):
level = floor(self.bud_get_level(planeta, i.id))
flota.c_czas = flota.c_czas * eval(i.minus_czas_flota)
flota.c_czas_one = flota.c_czas * 60 * 60
flota.c_czas = (flota.c_czas * 60 * 60) * ilosc
if f.limit > 0:
tmp = Obrona_f.objects.filter(planeta=planeta, budynek=f)
kol_ilosc = 0
for q in tmp:
kol_ilosc += q.ilosc
try:
float.ilosc = Obrona_p.objects.get(planeta=planeta,
budynek=f).ilosc
except:
flota.ilosc = 0
if f.limit < flota.ilosc + kol_ilosc + ilosc:
message = "Limit dla " + f.nazwa + " został wyczerpany"
send_error_message(user=self.user, message=message)
flota.mozna = None
flota.z_met = planeta.metal - flota.c_met
if flota.z_met < 0:
message = "Za mało metalu do wybudowania " + f.nazwa
send_error_message(user=self.user, message=message)
flota.mozna = None
flota.z_cry = planeta.crystal - flota.c_cry
if flota.z_cry < 0:
message = "Za mało kryształu do wybudowania " + f.nazwa
send_error_message(user=self.user, message=message)
flota.mozna = None
flota.z_deu = planeta.deuter - flota.c_deu
if flota.z_deu < 0:
message = "Za mało deuteru do wybudowania " + f.nazwa
send_error_message(user=self.user, message=message)
flota.mozna = None
zaleznosc = split(f.w_bud, ";")
if flota.mozna:
for zal in zaleznosc:
budynek = split(zal, ",")
if len(budynek) > 1:
if (int(budynek[1]) > int(
self.bud_get_level(planeta, budynek[0]))):
message = "Nie spełnione zależności budynków dla " + f.nazwa
send_error_message(user=self.user, message=message)
flota.mozna = None
break
if flota.mozna:
zaleznosc = split(f.w_bad, ";")
for zal in zaleznosc:
badanie = split(zal, ",")
if len(badanie) > 1:
if (int(badanie[1]) > int(
self.bad_get_level(self.user, badanie[0]))):
message = "Nie spełnione zależności badań dla " + f.nazwa
send_error_message(user=self.user, message=message)
flota.mozna = None
break
if flota.mozna:
czas = self.get_obrona_kolejka_czas(planeta)
flota.points = (f.c_met + f.c_cry + f.c_deu) / 1000.0
kolejka = Obrona_f.objects.create(budynek=f,
planeta=planeta,
ilosc=ilosc,
time=czas + flota.c_czas,
points=flota.points,
time_one=flota.c_czas_one *
(ilosc - 1),
anulowanie=True)
self.cache_obj.get_obrona_f(planeta.pk, kolejka.pk)
planeta.metal -= flota.c_met
planeta.crystal -= flota.c_cry
planeta.deuter -= flota.c_deu
