Gra MMORPG – kilka pytań

w tym engine godot mozna pisac gry w pythonie, czy tylko c# i ich skryptowy jezyk? Podobno jest mozliwosc pisania w rust.

Można pisać albo w C# lub ich własnym języku; albo korzystać z zewnętrznego API (GDNative) i klepać właściwie w czym się chce. Są już gotowe bindingi do Rusta: https://github.com/GodotNativeTools/godot-rust

Kiedy do pythona powstanie taki kompilator jak numba czy cos na wzor golang?

Już są, tyle że raczej o wąskim zastosowaniu, typu MicroPython. Przy czym Pythona się używa głównie dlatego, że nie jest kompilowany…

Przerabiam kurs Pythona na Udemy, myślę że realnie patrząc muszę na Pythona poświęcić minimim 6 miesięcy, może 8. Nie mogę się wziąć za tworzenie skryptów w GDScript nie znając Pythona.
Niektórzy radzili mi Od razu czytać dokumentację GDScript, ale jednak przekonała mnie ta 2 część ludzi którzy polecili nauczyć się chociaż w stopniu początkującym Pythona.

Kursy na Udemy są bardzo profesjonalnie zrobione. Myślę że poprzerobieniu i zrozumieniu wiedzy w jednym, kupię następne.

Piszę grę w Godot i wykorzystuję do niej ten skryptowy język podobny do Pythona. Czy jest sens inwestować czas i naukę w ten niszowy język? Być może od razu powinienem pisać w Godot w takim języku jak Python, C# czy C++?

Wiesz co...nie jestem expertem, ale ja właśnie dlatego poszedłem w Pythona na początek a nie w GDScript. Jak rzucę projekt gry w Godocie w którym używa się jezyka GDScript to będę potrafił programować w Pythonie, a tutaj już jest ogromne pole do popisu bo z tego co wiem w Pythonie można napisać dosłownie wszystko i jeszcze więcej. Pentesting, cyberbezpieczeństwo, robotyka, skrypty,popularny framework Pythona Django i pewnie wiele więcej :)

Mam do Was pytanie i proszę o rady.

Chodzi o sposób uczenia się, czy warto spisywać sobie podstawowe polecenia np. endswitch()-sprawdzanie końca tekstu, islower()-sprawdzanie czy tekst jest napisany tylko małymi literami itd...czy warto się tego uczyć na pamięć?

Wiem że część z Was pewnie napisze że wraz z klepaniem linijek kodu to mi wejdzie do głowy samo, ale w pracy mam czas (koło godziny dziennie) kiedy mógłbym powtarzać sobie te nazwy i utrwalać która do czego służy. Godzina dziennie, razy 5dni w tygodniu to w miesiącu daje mi dodatkowe 15-20h "nauki". Myślałem też o ściągnięcu jakiegoś kompilatora na telefon z androidem i w przerwach pisać kod ale nie wiem czy to dobry pomysł...

To dobra droga czy raczej może mi przeszkodzić w nauce? :)

Jak masz IDE dobre to robisz kropke i patrzysz co tam masz do dyspozycji...

Samo spisanie sobie ważniejszych haseł nie jest wcale głupie. Po pierwsze - będziesz musiał przy tym się chwilę zastanowić jak je poukładać itp (bo zakładam, że jakoś sensownie je pogrupujesz, a nie ciurkiem jak leci), co może Ci utrwalić znajomość tych poleceń, a po drugie - zawsze będziesz miał pod ręką ściągę z rzeczami, które mogą się przydac.

Natomiast co do wkuwania tej listy na pamięć to lepiej daj sobie spokój, pomysł jest totalnie abstrakcyjny ;)

Wszystko pięknie...nauka idzie do przodu, może nie szybkim tempem ale jednak na przód. Mam tylko pewne pytanie. Uczę się w ten sposób że oglądam kurs z jednego zagadnienia, jeśli trzeba to i kilka razy, potem sam rozwiązuje zadania i włączam odpowiedzi w celu sprawdzenia.

No i tak: wynik mam ten sam ale sposób rozwiązania inny, może bardziej zagmatwany, autor kursu uzyskuje ten sam efekt ale prostszym sposobem. Każdy początkujący tak ma że jego działania są przekombinowane?

Witam, czy istnieją jakieś prostsze rozwiązania tego warunku logicznego dla zapalania świateł w samochodzie ?
Godzinę kombinuję i według mnie jest wszystko dobrze, gdy zmieniam warunki, efekt końcowy też się zmienia, wszystko pracuje jako powinno według mnie.

isAutomaticMode = True        # Automatyczne włączanie świateł jest włączone lub wyłączone
    
is80PercentLight = False      # Jest dobra widoczność bo jest jasno lub jest zła widoczność
    
isDirectLight = False         # Słońce świeci w oczy kierowcy lub nie
    
isRainy = False               # Są korzystne lub niekorzystne warunki pogodowe

turnLightsOn = isAutomaticMode and( is80PercentLight != True or isDirectLight or isRainy)

# W rozwiązaniu powyższą linijkę autor zastąpił linijką:      turnLightsOn = isAutomaticMode and (not is80PercentLight or isDirectLight or isRainy)
# W powyższej linijce autora słowo "not" na początku nawiasu oznacza że aby światła się włączyły 
#  warunek is80PercentLight nie może być prawdziwy czyli True? Dobrze rozumiem?



print("Automatic mode:   ",isAutomaticMode)
print("Is the light good:",is80PercentLight)
print("Is sun low:       ",isDirectLight)
print("Is it rainy:      ",isRainy)
print("TURN LIGHTS ON:   ",turnLightsOn)

Pytanie umieściłem w komentarzu kodu :)

W arytmetyce bool-owskiej y = a & (~b | c | d) lub inaczej y = a*(~b + c + d) nie skrócisz bo masz cztery różne parametry. Gdyby niektóre z nich się powtarzały to mogłaby zaistnieć sytuacja, że jakiś człon by się zredukował.

jvoytech napisał(a):

W arytmetyce bool-owskiej y = a & (~b | c | d) lub inaczej y = a*(~b + c + d) nie skrócisz bo masz cztery różne parametry. Gdyby niektóre z nich się powtarzały to mogłaby zaistnieć sytuacja, że jakiś człon by się zredukował.

Dobrze rozumiem że Twój warunek można tak wytłumaczyć : By zaistniała sytuacja y musi być spełniony warunek a i minimum jeden z warunków b,c lub d?

Dobrze to rozumiesz, a dokładnie to minimum jeden z warunków ~b,c lub d. Poza tym to nie jest mój tylko Twój warunek :)

Dokładnie to jest liczone w ten sposób: jeżeli warunek a jest fałszem to warunek w nawiasie już nie trzeba liczyć bo to wynika z cechy AND (False and cokolwiek daje False). Jak Jest prawdą to trzeba obliczyć dodatkowo warunek w nawiasie. W nawiasie jak ~b jest prawdą (czyli b jest fałszem) to c i d już nie trzeba sprawdzać bo to nie wpłynie na wynik, taka to cecha OR. I później kolejno sprawdzamy do czasu aż któraś zmienna da True. Tez sposób nieobliczania wyrażeń gdy już dotychczasowych operacji and lub or wynika że dalsze człony nie wpłyną na wynik nazywa się "short circuit", tutaj przykład w działaniu:

In [1]: def get_true():
   ...:     print('giving True')
   ...:     return True

In [2]: def get_false():
   ...:     print('giving False')
   ...:     return False

In [3]: get_false() and get_true()
giving False
Out[3]: False

In [5]: get_true() and get_false()
giving True
giving False
Out[5]: False

Warto o tym pamiętać bo nie wywołanie funkcji w wyrażeniu przy wyrażeniach logicznych może czasami dopiec.

jvoytech napisał(a):

Dobrze to rozumiesz, a dokładnie to minimum jeden z warunków ~b,c lub d. Poza tym to nie jest mój tylko Twój warunek :)

Dokładnie to jest liczone w ten sposób: jeżeli warunek a jest fałszem to warunek w nawiasie już nie trzeba liczyć bo to wynika z cechy AND (False and cokolwiek daje False). Jak Jest prawdą to trzeba obliczyć dodatkowo warunek w nawiasie. W nawiasie jak ~b jest prawdą (czyli b jest fałszem) to c i d już nie trzeba sprawdzać bo to nie wpłynie na wynik, taka to cecha OR. I później kolejno sprawdzamy do czasu aż któraś zmienna da True. Tez sposób nieobliczania wyrażeń gdy już dotychczasowych operacji and lub or wynika że dalsze człony nie wpłyną na wynik nazywa się "short circuit", tutaj przykład w działaniu:

In [1]: def get_true():
   ...:     print('giving True')
   ...:     return True

In [2]: def get_false():
   ...:     print('giving False')
   ...:     return False

In [3]: get_false() and get_true()
giving False
Out[3]: False

In [5]: get_true() and get_false()
giving True
giving False
Out[5]: False

Warto o tym pamiętać bo nie wywołanie funkcji w wyrażeniu przy wyrażeniach logicznych może czasami dopiec.

Rozumiem...czyli w programowanie (False and True) daje False ale tylko jeśli te warunki są razem w nawiasie tak? To tak jakby pod False podstawić - a pod True + i - z + dają -.

Uczę się list...ale do tej pory w tym szkoleniu w listach mam najwięcej funkcji do zapamiętania. Dalej nie mam pojęcia jak za pomocą tego można stworzyć grę...no ale to dopiero początek mojej przygody z Pythonem więc mam nadzieję że ze mną wszystko w porządku i każdy na początku ma mętlik w głowie. Jedno co mnie cieszy to to że się angażuje, wszystko robię tak jak jest napisane w kursie, podczas rozwiązywania zadań nie zaglądam do podpowiedzi. Mam nadzieję że efekty przyjdą z czasem :)

Teraz zaczynam Tuple(krotki) cokolwiek to jest. Zastanawiam się czy nie kupić jakiegoś szkolenia z podstaw Linuxa, bo skoro mam swój ambitny plan stworzenia MMORPG to znajomość linuxa jako serwera to podstawa pewnie. 2 dni w tygodniu poświęciłbym na naukę Linuxa a resztę na naukę programowania.

Macie jakieś zdanie na ten temat?:)

wojtek1492 napisał(a):

Rozumiem...czyli w programowanie (False and True) daje False ale tylko jeśli te warunki są razem w nawiasie tak? To tak jakby pod False podstawić - a pod True + i - z + dają -.

Nie, Python widzi pierwszy False, potem and i ignoruje drugi parametr bo cokolwiek by tam nie było False/True wynik dla and daje zawsze False. Z plusem i minusem trochę nietrafione bo np. w przypadku mnożenia trzeba sprawdzić zawsze znak drugiego parametru bo ma wpływ na znak całości. To jest jak np. z pierwiastkowaniem: sqrt(a) + sqrt(b) gdy a jest ujemne nie obliczamy kolejnego pierwiastka tylko rzucamy wyjątek. Pierwiastka po plusie nie obliczamy bo już nie ma takiej potrzeby.

False/True and False/True - wystarczy tylko stwierdzić, że pierwszy człon jest False wtedy całość jest False obojętne co jest na drugie pozycji
False/True and False/True and False/True - j.w.
False/True and False/True or False/True - tutaj or powoduje, że trzeci człon może mieć wpływ na całkowity wynik

Chodzi mi o pewien typ błędów, weźmy jeszcze taki przykład:

for i in range(10):
    warunek1 = check(...)
    if (warunek1 and get_bool_from_file(file)):
        pass

W pętli 10 razy jest testowany warunek w if-ie. Jeżeli np. wydawało by ci się, że get_bool_from_file odczyta 10 razy coś z pliku to możesz się zdziwić, bo jak python stwierdzi że warunek1 jest fałszem to tej funkcji nie wywoła. Takie "krótkozwarciowe" obliczanie warunków czasami może przysporzyć sporo kłopotów, jak się jest początkującym. Trzeba wtedy zmienić kolejność:

if (get_bool_from_file(file) and warunek1)

niby proste a jednak kolejność ma czasami znaczenie, nawiasy też czasami na nie wpływają przy bardziej skomplikowanych warunkach. Bez testowania się nie obędzie.

Teraz zaczynam Tuple(krotki) cokolwiek to jest. Zastanawiam się czy nie kupić jakiegoś szkolenia z podstaw Linuxa, bo skoro mam swój ambitny plan stworzenia MMORPG to znajomość linuxa jako serwera to podstawa pewnie. 2 dni w tygodniu poświęciłbym na naukę Linuxa a resztę na naukę programowania.

Krotki to w skrócie niemutowalne listy, do których po stworzeniu nie można dodawać ani odejmować elementów. Co to daje? np. może taka krotka posłużyć jako klucz w słowniku:

d = {}
d[1,2,3] = 1
d[1,1,1] = 2
print(d)
lista =1,1,1
print(d[lista])

Witam, według mnie te "dwie" linijki kodu oznaczają to samo:
To:

elif weakness and (fever or musclePain):
    print("Just take a rest")

i to:

elif not (musclePain and fever) and weakness:
    print("Just take a rest!")

Mam rację ?

A co jak musclePain i fever będzie na true? Albo oba będą na false?

To nie są tożsame warunki

W LogiSim na bramkach:

widać, że dla przypadku (True,True,True) oba warunki różnią się

jak chcesz zmienić and na or i odwrotnie to musisz skorzystać z prawa DeMorgana:

a && = !(!a || !b)
a || = !(!a && !b)

tutaj przykład w pythonie dla dwóch wejść i testowanie wszystkimi możliwymi kombinacjami:

tests_for_two_inputs = [(x & (1<<1) != 0 , x & (1<<0) != 0 ) for x in range(2**2)]
print(tests_for_two_inputs)
for a,b in tests_for_two_inputs:
     y1 = a and b
     y2 = not ( (not a) or (not b) )
     print(f'test[{a},{b}] -> y1 = {y1}, y2 = {y2}')

output:

[(False, False), (False, True), (True, False), (True, True)]
test[False,False] -> y1 = False, y2 = False
test[False,True] -> y1 = False, y2 = False
test[True,False] -> y1 = False, y2 = False
test[True,True] -> y1 = True, y2 = True

Dziękuję Wam za pomoc i wyjaśnienia ale ten kod i bramki logiczne są dla mnie mało zrozumiałe :) Pójdę swoim tokiem, przećwiczę te przykłady logiczne jeszcze raz :)

w kodzie jest porównanie wyników dwóch funkcji a && b i !(!a || !b), dla wszystkich możliwych kombinacji wejść. Idealnych dowód na prawo DeMorgana. Co do bramek to z góry założyłem, że coś o nich wiesz i wydawało mi się, że to może coś rozjaśnić, więc zignoruj to.

Napisałeś, że według ciebie podane dwa złożone warunki to jest to samo, tylko że trzeba to jakoś udowodnić. Przy trzech zmiennych typu bool kombinacji będzie 2^3 (niewiele). Można więc wygenerować 8 kombinacji wartości (weakness, fever, musclePain) i porównać wyniki obu warunków. Wtedy nie ma "wydaje mi się", tylko mamy idealny dowód i możemy napisać "na 100% te dwa warunki to jedno i to samo" albo że ".. są różne".

Wstawię swój kod i podam treść polecenia:

Napisz wyrażenie if, które:

-jeśli występują wszystkie 3 objawy wyświetli komunikat "suspicion of influenza"
-jeśli występuje osłabienie (weakness) ale nie ma gorączki lub nie ma bólu mięśni to wyświetli "Just take a rest!"
-w przeciwnym razie wyświetli "you may be cold"

musclePain = True
fever = False
weakness = True
 
if musclePain and fever and weakness:           ### Jeżeli wszystkie parametry są prawdziwe to:
    print("Suspicion of influenza")
elif weakness and not(fever or musclePain):    ### Jeżeli jest weakness i nie ma(fever lub musclePain) to:  (Dokładnie tak jak w drugim myślniku polecenia)
    print("Just take a rest!")
else:                                                                 ###   W przeciwnym wypadku:                
    print("You may be could!")

Przy becnych parametrach dostaję zwrot z else czyli "You may be could!". Według mnie powinienem dostać "Just take a rest!" poniewąż jest weaknes i nie ma jednego z dwóch fever or musclePain.

Chyba że ja jestem taki tępy...muszę to zrozumieć bo to są podstawy.

A to działający kod który ja sam "wymyśliłem" po godzinie rozkminy:

if musclePain and fever and weakness:
    print("Suspicion of influenza")
elif weakness or not(fever or musclePain):
    print("Just take a rest!")
else:
    print("You may be could!")

A to kod z rozwiązania zadania:

if musclePain and fever and weakness:
    print("suspicion of influenza")
elif not (musclePain and fever) and weakness:    ### Nie rozumiem czemu w nawiasie jest and skoro polecenie mówi o tym że ma nie być jednego lub drugiego ale nie obu naraz.
    print("Just take a rest!")
else:
    print("you may be cold")

not (musclePain and fever) To zwróci Ci True jeśli tylko jeden z warunków będzie spełniony (czyli gość ma tylko gorączkę np.). A to not(fever or musclePain): zwróci Ci True jeśli nie będzie miał gorączki oraz nie będzie miał bólu mięśni.

Zobacz - to (fever or musclePain) Masz gorączkę lub ból mięśni to dostaniesz True. I wtedy negujesz ten True za pomocą not

-jeśli występuje osłabienie (weakness) ale nie ma gorączki lub nie ma bólu mięśni to wyświetli "Just take a rest!"

wydaje mi się, że zamiast:

elif weakness and not(fever or musclePain):

powinno chyba być:

elif weakness and ( (not fever) or (not musclePain)):

Edit:
Oczywiście taki warunek

((not fever) or (not musclePain))

wyszedł mi z treści zadania, a po zastosowaniu prawa deMorgana mamy

not (fever and musclePain)

czyli jest to jedno i to samo

Jeszcze przypomniał mi się stary dobry sposób z tablicą, czyli wypisanie wszystkich możliwych kombinacji argumentów i wyniki funkcji:

dzięki temu udało mi się skrócić warunki bo od razu widać, że podejrzanie przeziębienia jest w każdym przypadku gdy nie ma osłabienia:

all_values = [(x&(1<<2) != 0, x & (1<<1) != 0 , x & (1<<0) != 0 ) for x in range(2**3)]

def check(weakness, fever, musclePain):
    if musclePain and fever and weakness:
        return "influenza"
    elif not (musclePain and fever) and weakness:
        return "Just take a rest!"
    else:
        return "you may be cold"

def check2(weakness, fever, musclePain):
    if musclePain and fever and weakness:
        return "influenza"
    elif not weakness:
        return "you may be cold"
    else:
        return "Just take a rest!"

print('check:')
print('\n'.join( [f'w={w},f={f},p={p} -> {check(w,f,p)}' for w,f,p in all_values]) )

print('\ncheck2:')
print('\n'.join( [f'w={w},f={f},p={p} -> {check2(w,f,p)}' for w,f,p in all_values]) )

Tak swoją drogą ten test robi z prawie całej populacji zdrowych ludzi podejrzanych o to że jest się chorym. Trzeba tylko udowodnić że nie jest się wielbłądem ;D

Edit:
po dłuższym wpatrywaniu się w tablicę udało mi się jeszcze bardziej skrócić if-y:

def check3(weakness, fever, musclePain):
    if not weakness:
        return "you may be cold"
    elif fever and musclePain:
        return "influenza"
    else:
        return "Just take a rest!"

print('\ncheck3:')
print('\n'.join( [f'w={w},f={f},p={p} -> {check3(w,f,p)}' for w,f,p in all_values]) )

Tylko, że teraz jest to mniej czytelne

anonimowy napisał(a):

Tylko, że teraz jest to mniej czytelne

być może, ale chciałem przedstawić jeden ze sposobów jak takie warunki budować. Jak dostajemy w podpunktach opis logiki to można kodować wprost ale czasami logika też jest podana w formie tabeli. Mniej czytelny to byłby taki jedno-linijkowiec:

def check5(w, f, p):
    return 'cold' if not w else 'influenza' if f and p else 'rest'

Powiedzcie mi że nie doszliście do tego Od razu na początku swojej nauki :P Bo dla mnie póki co to jest dość skomplikowane, tzn ten kod który tutaj wstawiacie:) Każdy początkujący "programista" patrzy na kod jak na książkę w innym języku ?:) Mam nadzieję że wraz ze wzrostem zrobionych ćwiczeń i zadań będę rozumiał coraz więcej :)

Edit: Dziękuję Wam bardzo za pomoc i rady:) To daje mi dodatkową motywację do nauki Pythona :)

Na wszystko potrzeba czasu. Ja jak zaczynałem też nie rozumiałem prostych rzeczy no ale wtedy młody byłem więc ciezko ocenić

Od 2 dni ćwiczę pętle. Zagniezdzone są w sumie dużym wyzwaniem na ten moment. Oglądam filmik ze szkolenia tak by zrozumieć ogólnie o czym będzie lekcja, potem robię notatki z tego kodu. Za co odpowiada ta funkcja itp i wtedy przechodzę do ćwiczeń.

Nie ukrywam że czasami nie potrafię rozwiazac zadania i musze "podglądać" w rozwiązaniu i wtedy mam te myśl w głowie że nie nauczę się programowania skoro poległem na tak prostej rzeczy. Ale z drugiej strony coraz więcej umiem i nie poddaje się. Zostało mi jeszcze 7h kursu dla początkujących.

Nie tykam silnika gry, blendera, nic. na razie samo programowanie. W wolnych chwilach szukam i czytam o jakiś zagadnieniach sieciowych albo prostych aplikacjach klient-serwer.

Dlaczego zagniezdzone petle wydaja Ci sie takie trudne?