def site_report(self, object_id):
try:
temat = Tematy.objects.get(pk=object_id)
except Tematy.DoesNotExist:
return HttpResponseRedirect(url(self.main.main))
if self.request.method == 'POST':
form = RaportujTemat(data=self.request.POST)
if form.is_valid():
t_rap = TematyMod.objects.create(
powod=form.cleaned_data['powod'],
kto_raportowal=self.game.user,
nadawca=temat.nadawca,
odbiorca=temat.odbiorca,
temat=temat.temat,
data=temat.data)
for w in temat.wiadomosci_set.all():
WiadomosciMod.objects.create(temat=t_rap,
tekst=w.tekst,
kto=w.kto,
data=w.data)
self.game.send_message("Raport został przyjęty")
return HttpResponseRedirect(url(self.url.list))
else:
form = RaportujTemat()
topnav = topnav_site(self.game)
return {"topnav": topnav, "temat": temat, "form": form}
def site_czlonkowie(self):
sojusz_uzytkownika = self.game.get_sojusz()
if not sojusz_uzytkownika:
return HttpResponseRedirect(url(self.urls.main))
czlonek_sojusz = self.game.get_sojusz_czlonek()
if self.request.REQUEST.has_key(
"del") and self.game.soj_czy_moze_wyrzucac():
if Czlonkowie.objects.select_for_update().filter(
sojusz=sojusz_uzytkownika,
pk=self.request.REQUEST['del']).count() > 0:
czlonek = Czlonkowie.objects.select_for_update().get(
sojusz=sojusz_uzytkownika, pk=self.request.REQUEST['del'])
if not czlonek.wlasciciel:
czlonek.delete()
else:
ile_wlascicieli = Czlonkowie.objects.filter(
sojusz=sojusz_uzytkownika, wlasciciel=True).count()
if czlonek_sojusz.wlasciciel and ile_wlascicieli >= 2:
czlonek.delete()
czlonkowie = sojusz_uzytkownika.czlonkowie_set.order_by("data")
topnav = topnav_site(self.game)
return {
"topnav": topnav,
"czlonkowie": czlonkowie,
"self.game": self.game,
}
def site_profil_edytuj(self):
sojusz_uzytkownika = self.game.get_sojusz()
if not sojusz_uzytkownika:
return HttpResponseRedirect(url(self.urls.main))
if not self.game.soj_czy_moze_edytowac_opis():
self.game.send_message(
"Nie masz uprawnień do edycji opisu sojuszu")
return HttpResponseRedirect(url(self.urls.profil))
if self.request.method == 'POST':
form = SojuszForm(self.request.POST,
self.request.FILES,
instance=sojusz_uzytkownika)
if form.is_valid():
obj = form.save(commit=False)
if not obj.avatar:
obj.avatar = sojusz_uzytkownika.avatar
obj.save() # tu tak ma byc
self.game.send_message("Opis sojuszu został zapisany")
return HttpResponseRedirect(url(self.urls.my))
else:
form = SojuszForm(instance=sojusz_uzytkownika)
topnav = topnav_site(self.game)
return {"topnav": topnav, "form": form, "self.game": self.game}
def site_zaproszenia(self):
sojusz_uzytkownika = self.game.get_sojusz()
if not sojusz_uzytkownika:
return HttpResponseRedirect(url(self.urls.main))
if self.request.REQUEST.has_key(
"del") and self.game.soj_czy_moze_zapraszac():
sojusz_uzytkownika.zaproszenia_set.filter(
pk=self.request.REQUEST['del']).delete()
zaproszenia = sojusz_uzytkownika.zaproszenia_set.order_by("data")
if self.request.REQUEST.has_key("nick"):
try:
zapraszany = User.objects.get(
username=self.request.REQUEST['nick'])
sojusz_mozesz = self.game.soj_czy_moze_zapraszac()
if not sojusz_mozesz:
self.game.send_message('Nie masz uprawnień do zapraszania')
return HttpResponseRedirect(url(self.urls.zaproszenia))
return HttpResponseRedirect(
url(self.urls.wyslij_zaproszenie, object_id=zapraszany.id))
except User.DoesNotExist:
self.game.send_message('Nie ma takiego gracza')
return HttpResponseRedirect(url(self.urls.zaproszenia))
topnav = topnav_site(self.game)
return {
"topnav": topnav,
"zaproszenia": zaproszenia,
"self.game": self.game
}
def site_show(self, object_id):
try:
userprofile = UserProfile.objects.get(pk=object_id)
except UserProfile.DoesNotExist:
return HttpResponseRedirect(url(self.all_urls.main.main))
topnav = topnav_site(self.game)
return {"u": userprofile, "topnav": topnav}
def site_show(self, object_id):
topnav = topnav_site(self.game)
raport = Raporty.objects.get(pk=object_id, user=self.game.user)
if self.request.REQUEST.get('delete', None):
raport.delete()
return HttpResponseRedirect(url(self.urls.list))
return {"raport": raport, "topnav": topnav}
def site_list(self):
tematy = Tematy.objects.filter(
(Q(nadawca=self.game.user) & Q(n_del='N'))
| (Q(odbiorca=self.game.user) & Q(o_del='N'))).order_by("-data")
self.game.userprofile.new_message = 0
topnav = topnav_site(self.game)
return {"topnav": topnav, "tematy": tematy}
def site_badania(self, object_id=0):
planeta = self.game.get_current_planet()
budynek = get_object_or_404(Badania, pk=object_id)
topnav = topnav_site(self.game)
return {"topnav": topnav, "budynek": budynek}
def site_obrona(self, object_id=0):
planeta = self.game.get_current_planet()
budynek = get_object_or_404(Obrona, pk=object_id)
budynek.opis_dlugi = unicode(budynek.opis_dlugi).replace("\n", "<br>")
topnav = topnav_site(self.game)
return {"topnav": topnav, "budynek": budynek}
def site_choose(self):
current_planet = self.game.get_current_planet()
dane = Output()
try:
dane.planeta_id = int(self.request.REQUEST['p'])
dane.system_id = int(self.request.REQUEST['s'])
dane.galaktyka_id = int(self.request.REQUEST['g'])
if 'ship_request' in self.request.session:
del self.request.session['ship_request']
except:
if 'planeta_dane' in self.request.session:
dane = self.request.session['planeta_dane']
else:
return HttpResponseRedirect("/game/galaxy/")
if not check_is_planet(self.game.user, dane.planeta_id, dane.system_id,
dane.galaktyka_id):
return HttpResponseRedirect("/game/galaxy/")
if 'ship_request' in self.request.session:
ship_request = self.request.session['ship_request']
if not self.request.REQUEST.has_key("cp"):
del self.request.session['ship_request']
else:
ship_request = None
if is_planet_owner(self.game.user, dane, True):
return HttpResponseRedirect("/game/galaxy/")
topnav = topnav_site(self.game)
dostepne_statki_tmp = Flota_p.objects.values_list(
'budynek_id', flat=True).filter(planeta=current_planet,
budynek__lata__gt=0,
ilosc__gt=0).order_by("budynek")
dostepne_statki = []
for i in dostepne_statki_tmp:
d = Output()
statek = self.game.cache_obj.get_flota_p(current_planet.pk, i)
d.nazwa = statek.budynek.nazwa
d.ilosc = statek.ilosc
d.pk = statek.pk
d.speed = int(get_speed(self.game, statek.budynek, self.game.user))
if ship_request:
try:
d.value = int(ship_request[d.statek.budynek_id])
except:
d.value = 0
else:
d.value = 0
dostepne_statki.append(d)
self.request.session['planeta_dane'] = dane
return {
"dane": dane,
'topnav': topnav,
"dostepne_statki": dostepne_statki
}
def site_show(self, object_id):
try:
sojusz = Sojusz.objects.get(pk=object_id)
except:
self.game.send_message("Nie ma takiego sojuszu")
return HttpResponseRedirect(url(self.urls.main))
czlonkowie = sojusz.czlonkowie_set.order_by("data")
topnav = topnav_site(self.game)
return {"topnav": topnav, "sojusz": sojusz, "czlonkowie": czlonkowie}
def site_main(self):
sojusz_uzytkownika = self.game.get_sojusz()
if sojusz_uzytkownika:
return HttpResponseRedirect(url(self.urls.my))
topnav = topnav_site(self.game)
zaproszenia = self.game.user.zaproszenia_set.order_by("data")
return {
"topnav": topnav,
"zaproszenia": zaproszenia,
}
def site_przeglad(self):
sojusz_uzytkownika = self.game.get_sojusz()
if not sojusz_uzytkownika:
return HttpResponseRedirect(url(self.urls.main))
wydarzenia = sojusz_uzytkownika.sojuszlog_set.order_by("-id")
topnav = topnav_site(self.game)
return {
"topnav": topnav,
"sojusz": sojusz_uzytkownika,
"wydarzenia": wydarzenia
}
def site_main(self, galaxy=None, system=None):
current_planet = self.game.get_current_planet()
current_galaxy = self.game.get_galaxy(current_planet.galaxy_id)
try:
galaxy = int(galaxy)
except:
pass
try:
system = int(system)
except:
pass
try:
galaxy = int(self.request.REQUEST['galaxy'])
except:
pass
try:
system = int(self.request.REQUEST['system'])
except:
pass
if not galaxy > 0 or galaxy > MAX_GALAXY:
galaxy = current_galaxy.galaxy
if not system > 0 or system > MAX_SYSTEM:
system = current_galaxy.system
if galaxy > MAX_GALAXY:
galaxy = 1
if system > MAX_SYSTEM:
system = 1
fields = []
dane = Output()
dane.galaxy = galaxy
dane.system = system
for i in range(1, MAX_PLANETA + 1):
try:
fields.append(
Galaxy.objects.get(galaxy=galaxy, system=system, field=i))
except:
fields.append(None)
topnav = topnav_site(self.game)
jsbody = 'onmousemove="tt_Mousemove(event);"'
return {
"jsbody": jsbody,
"topnav": topnav,
"fields": fields,
"dane": dane,
"models": models,
}
def site_show(self, page=0):
try:
page = int(page)
if page <= 0:
page = 1
except:
page = 1
zaznaczony_user = None
if self.request.method == 'POST' and self.request.POST.has_key('user'):
try:
punkty = UserProfile.objects.filter(user__username=self.request.POST['user'])
except:
punkty = UserProfile.objects.filter(user__username__icontains=self.request.POST['user'])
if punkty.count() > 0:
zaznaczony_user = punkty[0].user
punkty = punkty[0].points
start = ceil((UserProfile.objects.filter(points__gt=punkty).order_by("-points",
"user").count() + 1) /
STATS_PERPAGE)
page = start + 1
paginator = Paginator(UserProfile.objects.all().order_by("-points", "user"), STATS_PERPAGE,
allow_empty_first_page=True)
try:
p = paginator.page(page)
except InvalidPage:
page = 1
p = paginator.page(1)
stats_tmp = p.object_list
od = int((page - 1) * STATS_PERPAGE)
stats = []
count = 1
for s in stats_tmp:
st = Output()
st.user = s
st.miejsce = count + od
count += 1
stats.append(st)
topnav = topnav_site(self.game)
return {"topnav": topnav, "stats": stats, "paginator": paginator, "page": page, "p": p,
"zaznaczony_user": zaznaczony_user}
def site_show(self, object_id=None):
try:
temat = Tematy.objects.get(
Q(pk=object_id),
Q(nadawca=self.game.user) | Q(odbiorca=self.game.user))
if self.game.user == temat.odbiorca:
temat.o_prz = 'T'
elif self.game.user == temat.nadawca:
temat.n_prz = 'T'
if not temat.data:
temat.data = strftime("%Y-%m-%d %H:%M:%S")
temat.save(force_update=True)
if "text" in self.request.REQUEST:
text = self.request.REQUEST['text']
new = Wiadomosci.objects.create(
temat=temat,
tekst=text,
kto=self.game.user,
data=strftime("%Y-%m-%d %H:%M:%S"))
alien_userprofile = None
if self.game.user == temat.odbiorca:
temat.n_prz = 'N'
temat.n_del = 'N'
alien_user, alien_userprofile = self.game.lock_alien_user(
temat.nadawca_id)
elif self.request.user == temat.nadawca:
temat.o_prz = 'N'
temat.o_del = 'N'
alien_user, alien_userprofile = self.game.lock_alien_user(
temat.odbiorca_id)
temat.data = new.data
temat.save(force_update=True)
if alien_userprofile:
alien_userprofile.new_message += 1
alien_userprofile.save(force_update=True)
wiadomosci = Wiadomosci.objects.filter(
temat=temat).order_by("data")
except Tematy.DoesNotExist:
return HttpResponseRedirect("/game/overview/")
topnav = topnav_site(self.game)
return {"topnav": topnav, "temat": temat, "wiadomosci": wiadomosci}
def site_wyslij_zaproszenie(self, object_id=None):
try:
zapraszany = User.objects.get(pk=object_id)
except:
raise Http404
sojusz_uzytkownika = self.game.get_sojusz()
if not sojusz_uzytkownika:
return HttpResponseRedirect(url(self.urls.main))
if not self.game.soj_czy_moze_zapraszac():
self.game.send_message("Nie możesz zapraszać")
return HttpResponseRedirect(url(self.urls.zaproszenia))
elif self.game.soj_czy_nie_nalezy(
zapraszany,
sojusz_uzytkownika) and self.game.soj_czy_nie_zaproszony(
zapraszany, sojusz_uzytkownika):
zaproszenie_obj = Zaproszenia(user=zapraszany,
sojusz=sojusz_uzytkownika,
od=self.game.user)
if self.request.method == 'POST':
form = ZaproszenieForm(data=self.request.REQUEST,
instance=zaproszenie_obj)
if form.is_valid():
form.save()
self.game.send_message("Zaproszenie zostało wysłane")
SojuszLog.objects.create(
sojusz=sojusz_uzytkownika,
tekst='Gracz ' + "<a href='/game/usr/" +
str(zapraszany.pk) + "/'>" + zapraszany.username +
'</a> został zaproszony przez gracza ' + "<a "
"href='/game/usr/" + str(self.game.user.pk) + "/'>" +
self.game.user.username + "</a>")
return HttpResponseRedirect(url(self.urls.zaproszenia))
else:
form = ZaproszenieForm(instance=zaproszenie_obj)
topnav = topnav_site(self.game)
return {"topnav": topnav, "form": form, "zapraszany": zapraszany}
else:
self.game.send_message(
"Użytkownik już był zapraszany lub jest w plemieniu")
return HttpResponseRedirect(url(self.urls.zaproszenia))
def site_list(self):
self.game.userprofile.nowe_raporty = 0
typ = self.request.REQUEST.get('typ', None)
if self.request.POST.has_key('zaznaczone'):
zaznaczone = self.request.POST.getlist('zaznaczone')
if self.request.POST.has_key('del'):
Raporty.objects.filter(user=self.game.user,
pk__in=zaznaczone).delete()
if typ == 'powrot':
raporty = Raporty.objects.filter(user=self.game.user,
typ='B').order_by("-id")
elif typ == 'kolonizacja':
raporty = Raporty.objects.filter(user=self.game.user,
typ='K').order_by("-id")
elif typ == 'przeslij':
raporty = Raporty.objects.filter(user=self.game.user,
typ='P').order_by("-id")
elif typ == 'transport':
raporty = Raporty.objects.filter(user=self.game.user,
typ='T').order_by("-id")
elif typ == 'atak':
raporty = Raporty.objects.filter(user=self.game.user,
typ='A').order_by("-id")
elif typ == 'zlom':
raporty = Raporty.objects.filter(user=self.game.user,
typ='Z').order_by("-id")
elif typ == 'szpieg':
raporty = Raporty.objects.filter(user=self.game.user,
typ='S').order_by("-id")
elif typ == 'all':
raporty = Raporty.objects.filter(
user=self.game.user).order_by("-id")
else:
raporty = Raporty.objects.filter(user=self.game.user).exclude(
typ='B').order_by("-id")
topnav = topnav_site(self.game)
return {"raporty": raporty, "topnav": topnav}
def site_zaloz(self):
if Czlonkowie.objects.select_for_update().filter(
user=self.game.user).count() > 0 > 0:
return HttpResponseRedirect(url(self.urls.main))
if self.request.method == 'POST':
form = SojuszForm(self.request.POST, self.request.FILES)
if form.is_valid():
obj = form.save(commit=False)
obj.save() # tu tak ma byc
czlonek = Czlonkowie.objects.create(user=self.game.user,
sojusz=obj,
wlasciciel=True)
SojuszLog.objects.create(
sojusz=obj,
tekst='Sojuszu został założony przez ' +
"<a href='/game/usr/" + str(self.game.user.pk) + "/'>" +
self.game.user.username + "</a>")
return HttpResponseRedirect(url(self.urls.profil))
else:
form = SojuszForm()
topnav = topnav_site(self.game)
return {"topnav": topnav, "form": form}
def site_main(self):
try:
typ = self.request.REQUEST['typ']
except:
typ = None
planety = self.game.get_all_planets()
planets = []
budynki = None
badania = None
floty = None
obrona = None
razem = {}
colspan = 0
if typ == 'budynki':
budynki = Buildings.objects.all().order_by('id')
colspan = len(budynki)
for p_id in planety:
self.game.cron_function(p_id)
planeta = self.game.get_planet(p_id)
pl = Output()
pl.planeta = planeta
pl.budynki = []
for b in budynki:
level = self.game.bud_get_level(planeta, b.pk)
if b.pk in razem:
razem[b.pk] += level
else:
razem[b.pk] = level
pl.budynki.append(level)
# pl.planeta.powierzchnia_max = planeta.powierzchnia_max
planets.append(pl)
elif typ == 'badania':
badania = Badania.objects.all().order_by('id')
colspan = len(badania)
for b in badania:
level = self.game.bad_get_level(self.game.user, b.pk)
if b.pk in razem:
razem[b.pk] += level
else:
razem[b.pk] = level
planets.append(level)
elif typ == 'flota':
floty = Flota.objects.all().order_by('id')
colspan = len(floty)
for p_id in planety:
self.game.cron_function(p_id)
planeta = self.game.get_planet(p_id)
pl = Output()
pl.planeta = planeta
pl.floty = []
for f in floty:
try:
ilosc = planeta.flota_p_set.get(budynek=f).ilosc
except:
ilosc = 0
if f.pk in razem:
razem[f.pk] += ilosc
else:
razem[f.pk] = ilosc
pl.floty.append(ilosc)
planets.append(pl)
elif typ == 'obrona':
obrona = Obrona.objects.all().order_by('id')
colspan = len(obrona)
for p_id in planety:
self.game.cron_function(p_id)
planeta = self.game.get_planet(p_id)
pl = Output()
pl.planeta = planeta
pl.obrona = []
for f in obrona:
try:
ilosc = planeta.obrona_p_set.get(budynek=f).ilosc
except:
ilosc = 0
if f.pk in razem:
razem[f.pk] += ilosc
else:
razem[f.pk] = ilosc
pl.obrona.append(ilosc)
planets.append(pl)
else:
typ = 'surowce'
razem['met'] = 0
razem['cry'] = 0
razem['deu'] = 0
razem['ene_used'] = 0
razem['ene_max'] = 0
for p_id in planety:
planeta = self.game.get_planet(p_id)
self.game.cron_function(p_id)
pl = Output()
pl.planeta = planeta
razem['met'] += planeta.metal
razem['cry'] += planeta.crystal
razem['deu'] += planeta.deuter
razem['ene_used'] += planeta.energy_used
razem['ene_max'] += planeta.energy_max
pl.planeta.powierzchnia_max = planeta.powierzchnia_max
planets.append(pl)
colspan += 5
topnav = topnav_site(self.game)
return {
'topnav': topnav,
"colspan": colspan,
"razem": razem,
"planety": planets,
"budynki": budynki,
"badania": badania,
"obrona": obrona,
"floty": floty,
"typ": typ
}
def site_edit(self):
current_planet = self.game.get_current_planet()
if self.game.userprofile:
if self.request.method == 'POST':
form_change = ChangePassMail(self.request.POST)
if form_change.is_valid():
pass1 = form_change.cleaned_data['password1']
pass2 = form_change.cleaned_data['password2']
email = form_change.cleaned_data['email']
if pass1 == pass2 and len(pass1) >= 5:
salt = sha1(str(random.random())).hexdigest()[:5]
activation_key = sha1(salt + pass1).hexdigest()
ZmianaHasla.objects.create(user=self.game.user,
haslo=pass1,
hash=activation_key)
message = render_to_string('mail/change.txt', {
'link':
'%s/change_pass/%s' % (URL, activation_key)
})
subject = 'Link z %s' % (URL, )
subject = ''.join(subject.splitlines())
send_mail(subject, message,
settings.DEFAULT_FROM_EMAIL,
[self.game.user.email])
message = "Żeby dokończyć zmianę hasła, odbierz pocztę z emaila i kliknij w link"
send_info_message(user=self.game.user, message=message)
if email:
salt = sha1(str(random.random())).hexdigest()[:5]
activation_key = sha1(salt + email).hexdigest()
ZmianaMaila.objects.create(user=self.game.user,
email=email,
hash=activation_key)
message = render_to_string('mail/change.txt', {
'link':
'%s/change_email/%s' % (URL, activation_key)
})
subject = 'Link z %s' % (URL, )
subject = ''.join(subject.splitlines())
send_mail(subject, message,
settings.DEFAULT_FROM_EMAIL,
[self.game.user.email])
message = "Żeby dokończyć zmianę emaila, odbierz pocztę ze starego emaila i kliknij w link"
send_info_message(user=self.game.user, message=message)
form = UserprofileForm(self.request.POST,
self.request.FILES,
instance=self.game.userprofile)
if form.is_valid():
obj = form.save(commit=False)
if not obj.avatar:
obj.avatar = self.game.userprofile.avatar
obj.save() # tu tak ma byc
return HttpResponseRedirect(url(self.url))
else:
form = UserprofileForm(instance=self.game.userprofile)
form_change = ChangePassMail()
topnav = topnav_site(self.game)
return {
"topnav": topnav,
"form": form,
'form_change': form_change,
"u": self.game.userprofile
}
return HttpResponseRedirect(url(self.all_urls.main.main))
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_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 site_main(self):
self.game.userprofile_podglad_flota()
if "fs_zawroc" in self.request.REQUEST:
fun.zawroc(self.request.REQUEST['fs_zawroc'], self.game.user)
if "rename_planet" in self.request.REQUEST:
self.game.rename_planet(self.request.REQUEST["rename_planet"])
current_planet = self.game.get_current_planet()
galaxyrow = self.game.get_galaxy(current_planet.galaxy_id)
planety_klucze = self.game.get_all_planets()
planety_klucze.remove(self.game.current_planet_id)
output = fun.Output()
output.planets = []
for k in planety_klucze:
output.planets.append(self.game.get_planet(k))
output.other_data = fun.Output()
output.other_data.time = strftime(
"%c") # strftime("%a %b %H:%M:%S")#date("D M d H:i:s",time());
output.current_planet = current_planet
if (galaxyrow):
output.current_galaxy = galaxyrow
output.user_data = fun.Output()
output.user_data.user_rank = UserProfile.objects.filter(
points__gt=self.game.userprofile.points).order_by(
"-points").count() + 1
output.user_data.userprofile = self.game.userprofile
output.user_data.user = self.game.user
output.user_data.user_points = int(
self.game.userprofile.points_obrona) + int(
self.game.userprofile.points_builds) + int(
self.game.userprofile.points_flota) + int(
self.game.userprofile.points_tech)
output.other_data.max_users = User.objects.all().count()
output.current_zajete = fun.Output()
output.current_zajete.budowanie = current_planet.zajety_budowaniem()
output.current_zajete.badanie = current_planet.zajety_badaniem()
output.current_zajete.obrona = current_planet.zajety_obrona()
output.current_zajete.flota = current_planet.zajety_flota()
if not output.current_zajete.budowanie and not output.current_zajete.badanie and not output.current_zajete.obrona and not output.current_zajete.flota:
output.current_zajete.building_free = "Oczekuje"
topnav = topnav_site(self.game)
timesql = 0.0
for q in connection.queries:
if 'time' in q:
timesql += float(q['time'])
seen = {}
duplicate = 0
for q in connection.queries:
sql = q["sql"]
c = seen.get(sql, 0)
if c:
duplicate += 1
q["seen"] = c
seen[sql] = c + 1
if self.game.userprofile.podglad_flota == True:
floty_own, floty_obce, floty = fun.get_flota(self.game)
else:
floty_own, floty_obce, floty = fun.get_flota(self.game, 1)
output.other_data.procent = current_planet.get_procent_producji()
return {
'output': output,
'topnav': topnav,
"floty": floty,
"floty_own": floty_own,
"floty_obce": floty_obce,
"sqltime": timesql,
"duplicate": duplicate,
}
def site_main(self):
current_planet = self.game.get_current_planet()
bud = Buildings.objects.all()
bad = Badania.objects.all()
flo = Flota.objects.all()
obr = Obrona.objects.all()
budynki = []
for i in bud:
budynek = Output()
budynek.id = i.pk
budynek.nazwa = i.nazwa
budynek.zal_bud = []
for zal_b in split(i.w_bud, ";"):
zbud = split(zal_b, ",")
if len(zbud) > 1:
tmp = Output()
tmp.nazwa = Buildings.objects.get(pk=zbud[0]).nazwa
tmp.level = zbud[1]
level = int(
self.game.bud_get_level(current_planet, zbud[0]))
if int(zbud[1]) <= level:
tmp.spelnione = 1
budynek.zal_bud.append(tmp)
budynek.zal_bad = []
for zal_b in split(i.w_bad, ";"):
zbud = split(zal_b, ",")
if len(zbud) > 1:
tmp = Output()
tmp.nazwa = Badania.objects.get(pk=zbud[0]).nazwa
tmp.level = zbud[1]
level = int(
self.game.bad_get_level(self.game.user, zbud[0]))
if int(zbud[1]) <= level:
tmp.spelnione = 1
budynek.zal_bad.append(tmp)
budynki.append(budynek)
badania = []
for i in bad:
badanie = Output()
badanie.id = i.pk
badanie.nazwa = i.nazwa
badanie.zal_bud = []
for zal_b in split(i.w_bud, ";"):
zbud = split(zal_b, ",")
if len(zbud) > 1:
tmp = Output()
tmp.nazwa = Buildings.objects.get(pk=zbud[0]).nazwa
tmp.level = zbud[1]
level = int(
self.game.bud_get_level(current_planet, zbud[0]))
if int(zbud[1]) <= level:
tmp.spelnione = 1
badanie.zal_bud.append(tmp)
badanie.zal_bad = []
for zal_b in split(i.w_bad, ";"):
zbud = split(zal_b, ",")
if len(zbud) > 1:
tmp = Output()
tmp.nazwa = Badania.objects.get(pk=zbud[0]).nazwa
tmp.level = zbud[1]
level = int(
self.game.bad_get_level(self.game.user, zbud[0]))
if int(zbud[1]) <= level:
tmp.spelnione = 1
badanie.zal_bad.append(tmp)
badania.append(badanie)
floty = []
for i in flo:
flota = Output()
flota.id = i.pk
flota.nazwa = i.nazwa
flota.zal_bud = []
for zal_b in split(i.w_bud, ";"):
zbud = split(zal_b, ",")
if len(zbud) > 1:
tmp = Output()
tmp.nazwa = Buildings.objects.get(pk=zbud[0]).nazwa
tmp.level = zbud[1]
level = int(
self.game.bud_get_level(current_planet, zbud[0]))
if int(zbud[1]) <= level:
tmp.spelnione = 1
flota.zal_bud.append(tmp)
flota.zal_bad = []
for zal_b in split(i.w_bad, ";"):
zbud = split(zal_b, ",")
if len(zbud) > 1:
tmp = Output()
tmp.nazwa = Badania.objects.get(pk=zbud[0]).nazwa
tmp.level = zbud[1]
level = int(
self.game.bad_get_level(self.game.user, zbud[0]))
if int(zbud[1]) <= level:
tmp.spelnione = 1
flota.zal_bad.append(tmp)
floty.append(flota)
obronne = []
for i in obr:
obrona = Output()
obrona.id = i.pk
obrona.nazwa = i.nazwa
obrona.zal_bud = []
for zal_b in split(i.w_bud, ";"):
zbud = split(zal_b, ",")
if len(zbud) > 1:
tmp = Output()
tmp.nazwa = Buildings.objects.get(pk=zbud[0]).nazwa
tmp.level = zbud[1]
level = int(
self.game.bud_get_level(current_planet, zbud[0]))
if int(zbud[1]) <= level:
tmp.spelnione = 1
obrona.zal_bud.append(tmp)
obrona.zal_bad = []
for zal_b in split(i.w_bad, ";"):
zbud = split(zal_b, ",")
if len(zbud) > 1:
tmp = Output()
tmp.nazwa = Badania.objects.get(pk=zbud[0]).nazwa
tmp.level = zbud[1]
level = int(
self.game.bad_get_level(self.game.user, zbud[0]))
if int(zbud[1]) <= level:
tmp.spelnione = 1
obrona.zal_bad.append(tmp)
obronne.append(obrona)
topnav = topnav_site(self.game)
return {
"topnav": topnav,
"budynki": budynki,
"badania": badania,
"floty": floty,
"obronne": obronne,
}
def site_dealer(self):
topnav = topnav_site(self.game)
return {
"topnav": topnav,
}
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 site_main(self):
current_planet = self.game.get_current_planet()
budynki_produkujace = Buildings.objects.filter(czy_produkcja__gt=0)
flota_produkujaca = Flota.objects.filter(czy_produkcja__gt=0)
budynki = current_planet.budynki_p_set.filter(budynek__in=budynki_produkujace).order_by("budynek")
flota = current_planet.flota_p_set.filter(budynek__in=flota_produkujaca).order_by("budynek")
if self.request.POST:
for tmp in budynki:
b = self.game.cache_obj.get_budynek_p(current_planet.pk, tmp.budynek_id)
if b:
building_key = "bud_%s" % b.budynek_id
if building_key in self.request.POST:
try:
tmp_procenty = int(self.request.POST[building_key])
if (tmp_procenty <= 100) and tmp_procenty >= 0:
b.procent = tmp_procenty
except:
pass
for tmp in flota:
b = self.game.cache_obj.get_flota_p(current_planet.pk, tmp.budynek_id)
if b:
building_key = "flo_%s" % b.budynek_id
if building_key in self.request.POST:
try:
tmp_procenty = int(self.request.POST[building_key])
if (tmp_procenty <= 100) and tmp_procenty >= 0:
b.procent = tmp_procenty
except:
pass
# self.game.cron_function(current_planet.pk)
# self.game.save_all()
surowce = []
resources = []
for tmp in budynki:
i = Output()
i.dane = self.game.cache_obj.get_budynek_p(current_planet.pk, tmp.budynek_id)
i.czy_budynek = 1
resources.append(i)
for tmp in flota:
i = Output()
i.dane = self.game.cache_obj.get_flota_p(current_planet.pk, tmp.budynek_id)
i.czy_statek = 1
resources.append(i)
produkcja = Output()
produkcja.metal = 0
produkcja.crystal = 0
produkcja.deuter = 0
produkcja.energy = 0
ilosc_produkujacych = 0
procenty = 0
for b in resources:
sur = Output()
statek = b.dane
sur.statek = b
sur.nazwa = statek.budynek.nazwa
procent = statek.procent
procenty += procent
ilosc_produkujacych += 1
level = statek.level
ilosc = statek.ilosc
temp_max = current_planet.temp_max
# sur.metal = sur.crystal = sur.deuter = sur.energy = 0
sur.metal = int(eval(statek.budynek.met_formula))
sur.id = statek.budynek_id
produkcja.metal += sur.metal
sur.crystal = int(eval(statek.budynek.cry_formula))
produkcja.crystal += sur.crystal
sur.deuter = int(eval(statek.budynek.deu_formula))
produkcja.deuter += sur.deuter
sur.energy = int(eval(statek.budynek.ene_formula))
produkcja.energy += sur.energy
surowce.append(sur)
try:
produkcja.procent = int(procenty / ilosc_produkujacych)
except:
produkcja.procent = 0
produkcja.metal_dzien = produkcja.metal * 24
produkcja.metal_tydzien = produkcja.metal_dzien * 7
produkcja.metal_miesiac = produkcja.metal_dzien * 30
produkcja.metal_ladownosc_procent = int(current_planet.metal * 100 / current_planet.metal_max)
produkcja.crystal_dzien = produkcja.crystal * 24
produkcja.crystal_tydzien = produkcja.crystal_dzien * 7
produkcja.crystal_miesiac = produkcja.crystal_dzien * 30
produkcja.crystal_ladownosc_procent = int(current_planet.crystal * 100 / current_planet.crystal_max)
produkcja.deuter_dzien = produkcja.deuter * 24
produkcja.deuter_tydzien = produkcja.deuter_dzien * 7
produkcja.deuter_miesiac = produkcja.deuter_dzien * 30
produkcja.deuter_ladownosc_procent = int(current_planet.deuter * 100 / current_planet.deuter_max)
topnav = topnav_site(self.game)
return {
'topnav': topnav, "surowce": surowce,
"planet": current_planet, "produkcja": produkcja
}
def site_main(self, page=1):
# current_planet = self.game.get_current_planet()
sort_form = RynekSearch(self.request.POST,
prefix="sortowanie_surowiec")
# rynek = Rynek.objects.exclude(planeta__owner=user).order_by("ratio")
rynek = Rynek.objects.order_by("ratio")
sortowanie_surowiec_co = None
if 'handlarz_sort_surowiec_co' in self.request.session:
sortowanie_surowiec_co = self.request.session[
'handlarz_sort_surowiec_co']
sortowanie_surowiec_na = None
if 'handlarz_sort_surowiec_na' in self.request.session:
sortowanie_surowiec_na = self.request.session[
'handlarz_sort_surowiec_na']
try:
page = int(page)
if page <= 0:
page = 1
except:
page = 1
if sort_form.is_valid():
if sort_form.cleaned_data['co'] in ('M', 'K', 'D'):
sortowanie_surowiec_co = sort_form.cleaned_data['co']
elif sort_form.cleaned_data['co'] == '-':
sortowanie_surowiec_co = None
else:
sort_form.cleaned_data['co'] = sortowanie_surowiec_co
if sort_form.cleaned_data['na'] in ('M', 'K', 'D'):
sortowanie_surowiec_na = sort_form.cleaned_data['na']
elif sort_form.cleaned_data['na'] == '-':
sortowanie_surowiec_na = None
else:
sort_form.cleaned_data['na'] = sortowanie_surowiec_na
self.request.session[
'handlarz_sort_surowiec_co'] = sortowanie_surowiec_co
self.request.session[
'handlarz_sort_surowiec_na'] = sortowanie_surowiec_na
if sortowanie_surowiec_co:
rynek = rynek.filter(co=sortowanie_surowiec_co)
if sortowanie_surowiec_na:
rynek = rynek.filter(na=sortowanie_surowiec_na)
paginator = Paginator(rynek, 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": rynek_obj,
"sort_form": sort_form,
"paginator": paginator,
"page": page,
"page_list": p,
}
def site_compose(self, object_id=None):
topnav = topnav_site(self.game)
#try:
user = None
if "nick" in self.request.REQUEST:
object_id = self.request.REQUEST['nick']
try:
user = User.objects.get(username__exact=object_id)
except User.DoesNotExist:
pass
else:
try:
user = User.objects.exclude(pk=self.game.user.pk).get(
pk=object_id)
except User.DoesNotExist:
pass
if not user:
self.game.send_message("Błędny odbiorca wiadomości")
return HttpResponseRedirect(url(self.urls.list))
alien_user, alien_userprofile = self.game.lock_alien_user(user.pk)
errors = []
if self.request.method == 'POST':
if 'temat' not in self.request.POST or not len(
self.request.POST['temat']) > 0:
errors.append("Tytuł wiadomości jest wymagany!!!")
if ('wiadomosc' not in self.request.POST
) or not len(self.request.POST['wiadomosc']) > 0:
errors.append("Treść wiadomości jest wymagana!!!")
if not errors:
new_t = Tematy.objects.create(
nadawca=self.game.user,
odbiorca=alien_user,
n_del='N',
o_del='N',
n_prz='T',
o_prz='N',
temat=self.request.POST['temat'],
data=strftime("%Y-%m-%d %H:%M:%S"))
Wiadomosci.objects.create(temat=new_t,
tekst=self.request.POST['wiadomosc'],
kto=self.game.user,
data=strftime("%Y-%m-%d %H:%M:%S"))
self.request.session['msg'] = "Wiadomość została wysłana"
alien_userprofile.new_message += 1
alien_userprofile.save(force_update=True)
return HttpResponseRedirect(
url(self.urls.show, object_id=new_t.id))
chars = string.letters + string.digits
ticket1 = ''.join([random.choice(chars) for _ in range(16)])
ticket2 = ''.join([random.choice(chars) for _ in range(16)])
ktory = random.randint(0, 1)
self.request.session['ticket1'] = ticket1
self.request.session['ticket2'] = ticket2
self.request.session['ktory'] = ktory
return {
"dane1": ticket1,
"dane2": ticket2,
"ktory": ktory,
"errors": errors,
"alien_user": alien_user,
"topnav": topnav,
"req": self.request.REQUEST
}
