Pokaż wiadomości

Ta sekcja pozwala Ci zobaczyć wszystkie wiadomości wysłane przez tego użytkownika. Zwróć uwagę, że możesz widzieć tylko wiadomości wysłane w działach do których masz aktualnie dostęp.


Wiadomości - Xenox93

Strony: [1] 2 3 4 5 ... 13
1
Webowe / Odp: Blokowanie przeładowania całej strony
« dnia: Luty 24, 2017, 17:31:33 »
Jeżeli używasz przeładowywania tylko po to, aby przesłać jakiś parametr/wartość/obiekt, to nie zastanawiałeś się nad JSON'em? Ogólnie AJAX również powinien spełnić swoją rolę oraz nie wiem jak to jest z REST/websocket, ale on również powinien pomóc. Pewności nie mam, ale bliżej skłaniałbym się ku AJAX'owi.

2
Uściślając, to jednak tego zapytania nie da się "schakować", bo nie ma w nim żadnego parametru, typu
"select * from tabela where "+$user_inputchyba że miałeś coś innego na myśli
Tak, ale wcześniej Yabol wspomniał, że używa takiego zapytania
$sql = "SELECT * FROM tbl_data WHERE user_id = 1";

[...]

[code]$sql = "SELECT usr_name FROM tbl_usr WHERE id = 1 AND SELECT * FROM tbl_data WHERE user_id = 1";
[/code]
Gdzie łatwo można wywnioskować, że za jakiś czas user_id nie będzie miał przypisaną wartość 1. A będzie musiał użyć zmiennej.

Owszem SQL Injection jest spowodowane brakiem filtrowania wejścia, ale ciekawe czy Yabol zadbał o to. Dodatkowo podobny atak można wykonać bawiąc się w inżynierię wsteczną, gdzie w kodzie asm można celowo zmienić zapytania. Mowa o aplikacjach na desktopy. W Web zapewne istnieje możliwość przechwycenia HTTP (HTTPS jest już bezpieczne) wraz z danymi do bazy danych: dane logowania do BD, zapytania itp. Co więcej ilość możliwych technik ataku BD zawsze się zmienia, pojawiają się luki w ich serwerach. Więc im mniej się wysyła do sieci, jedynie to co rzeczywiście ma znaczenie to unika się większości ataków.

Gdyby udostępnienie BD światu byłoby bezpieczne, to różne portale społecznościowe i nie tylko udostępniałyby w kodzie taką możliwość. W lepszej sytuacji są użytkownicy PHP, których kod wykonuje się po stronie serwera, natomiast Yabol chce użyć JavaScript lub HTML, co niestety, ale wykonuje się po stronie klienta + w pakietach.

Oprócz SQL Injection można się wspomóc Conditional responses sprawdzając co zwróci zapytanie URL, ogólnie możliwych sposobów przeprowadzenia ataku jest całkiem sporo, kończąc na DDoS.

lethern nie zrozum mnie źle. Masz cały czas rację, gdyż udostępnianie BD na zewnątrz może mieć sens, ale wymaga większej wiedzy na temat bezpieczeństwa i zagrożeń. To co wyżej napisałem, może się nie wydarzyć jeśli zastosuje się pewne zabezpieczenia, ale mało kto czyta książki/blogi/publikacje nt. zabezpieczenia się przed kradzieżą danych z BD. Niestety, ale albo ktoś będzie najlepszy w programowaniu albo w bazach danych. Na pewno lepiej zapobiegać niż łatać.

3
Tu masz opis czym jest API
http://forum.pasja-informatyki.pl/1256/co-to-jest-api

//===============================================================
// INFORMACJE O API
//===============================================================
Rozwiązań tego problemu jest całkiem sporo, np.:
* Zastosowanie protokołu HTTPS
* Zastosowanie wcześniej wspomnianego JSON'a
* połączenie powyższych
* WebSockets - http://www.merixstudio.pl/blog/websockets-jak-dziala-i-gdzie-stosowac/
* wiele innych sposobów na wymianę danych - pamiętaj na wymianę danych

Ogólnie rzecz biorąc, chodzi o to, aby nie dopuścić do sytuacji, gdzie każdy może mieć dostęp do bazy danych.

Wyobraź sobie Twitter lub Facebook, który udostępnia swoją BD całemu światu xD Oni udostępniają swoje API, czyli programowanie obiektowe (choć nie koniecznie - wtedy tworzysz bibliotekę), za pomocą, którego udostępniasz struktury/klasy/funkcje tylko te, które chcesz udostępnić.
Wewnątrz każdego API/biblioteki parsujesz HTTP(S) i/lub JSON'a, ale nie pozwalasz zwykłemu użytkownikowi na podejrzenie JSON'a, tylko może zobaczyć to co Ty chcesz aby było publiczne.

Użyteczny w tym przypadku jest wzorzec architektoniczny MVC(Model-View-Controller) lub MVVM, czyli dzielisz kod na warstwy. Nie jest to konieczne, ale z czasem warto się z nim zapoznać. Idea jest taka, że Controller lub ViewModel udostępnia gotową strukturę z danymi, która ma służyć do wypełnienia czegoś, np. tabeli. Dla przykładu jeżeli twoja tabela ma kolumny:
[ID] [nazwa_użytkownika] [Imię] [Nazwisko] [inne rekordy]

To twój Controller/ViewModel udostępnia tylko te dane, nic innego. Nie ma mowy o pokazaniu czystego JSON'a otrzymanego od serwera.

//===============================================================
// INFORMACJE O SQL Injection
//===============================================================
W dolnym linku spójrz na rozdział Technical implementations
https://en.wikipedia.org/wiki/SQL_injection

lub

http://www.w3schools.com/sql/sql_injection.asp

Dzięki temu otrzymujesz wszystkie dane jakie zawiera dana tabela. O zgrozo jeśli trzymasz w tej tabeli dosłownie wszystkie dane nawet hasła niezaszyfrowane/hash'owane :/

//===============================================================
// PODSUMOWANIE
//===============================================================
Reasumując, Nie musisz stosować programowania obiektowego(OOP) oraz wzorca architektonicznego aby zbudować coś na wzór API/biblioteki. Jednakże zastosowanie chociaż OOP ułatwi Ci implementację oraz rozwijanie funkcjonalności. Stosują to tak wielkie korporacje jak Twitter API czy Facebook API/Platform. Nie warto spoczywać na laurach nawet jeśli nie udostępnisz BD światu, gdyż warto ustrzec się w ogóle przed tak sformułowanymi zapytaniami do bazy danych. Oczywiście pomijam fakt, że im więcej będziesz miał logiki/funkcjonalności na stronie tym bardziej powinieneś zastanowić się nad .NET ASP lub Java EE( Spring Framework ).

4
Zapytania, którego potrzebujesz nazywa się - podzapytanie skorelowane, za pomocą, którego:
1) Wyświetlisz dla każdego użytkownika interesujące Ciebie dane (nawet z kilku tabel - JOIN itp.)
2) Otrzymasz nazwę użytkownika, ich ilość itp.
3) Możesz sobie pogrupować/posortować odpowiedzi wg użytkowników itd.

Nie wiem czy to zapytanie podane przez Ciebie na końcu jest prawidłowe, ale chyba tego tak się nie robi. Pierwszy lepszy link i chyba najodpowiedniejszy dla Ciebie http://www.sqlpedia.pl/podzapytania-skorelowane-sql/ Odpowiednikiem klienta z podanego linku będzie twój użytkownik.

Ogólnie rzecz biorąc lepiej jakbyś udostępnił API(?) czy coś, za pomocą, którego udostępnisz tylko dane, które chcesz przekazać. Ma to na celu uniknięcie różnego rodzaju wycieków danych lub wstrzykiwania kodu SQL itp. Skoro bazę danych udostępniasz na zewnątrz to trzeba zadbać o jego bezpieczeństwo jeszcze bardziej niż w przypadku zwracania wyników przez serwer. Co do tworzenia kodu HTML itp. to może to już wykonywać klient.

Dlaczego wspomniałem o SQL injection? Otóż zapytania typu SELECT * FROM Tabela najłatwiej zhackować :/

5
Java / Odp: [Java] Interpretowanie komunikatów sieciowych klient-serwer
« dnia: Sierpień 14, 2016, 16:55:14 »
@matheavyk: dzięki za poszerzenie horyzontów. Nawet nie wiedziałem, że taki operator istnieje w C# oraz, że można go zaimplementować/emulować w Java. Niestety, jedyne zastosowanie jakie w nim widzę, to program działający lokalnie, tzn. bez wymiany komunikatów przez sieć. Również jest podobny do operatora w języku Java - instanceof, który może nie jest obiektowy, ale pozwala na to samo co operator "is"/"as".

@Avaj: Hmmm, jest to dosyć podobne do tego co już zaimplementowałem i działa. Biblioteka, która jest jakby wrapperem biblioteki JSON a którą używam - GSON. Nie ma sensu, zmieniać jej, gdyż na obecną chwilę spełnia swoją rolę oraz nie wymaga pisania n razy deserializacji dla każdego nowego typu złożonego( klasy ). Co ma miejsce w przypadku JSON, gdzie każdą zmienną i jej wartość musimy pobrać w różny sposób, niż od razu za pomocą jednego polecenia wypełnić obiekt danymi.

BTW, problem już został rozwiązany zaraz po dodaniu problemu na forum. Jednakże myślałem, że jest jakiś bardziej elegantszy sposób( smart ), który mógłbym zaimplementować.

Problem był taki, że program nie mógł wiedzieć z góry, z jakim rodzajem wiadomości będzie miał do czynienia, a tym samym jak odpowiednio pobrać dane, a następnie wypełnić nimi dany obiekt.
Wydaje mi się że chciałem (nieświadomie) rozwiązać problem natury teorii obliczalności xD Gdyż mój interpreter tak jak automat "niedeterministyczny" mógł przyjąć dowolny stan/typ wiadomości, czy to dane logowania czy dane rezerwacji sali w dowolnym momencie, które należy odpowiednio zinterpretować. Z interpretacją nie miałem problemu, ale uprzednio musiałem wiedzieć jaka to wiadomość( nagłówek/service ) i tu był mój problem. Chciałem w magiczny sposób, żeby biblioteka/GSON/JSON pobrał ten nagłówek i sam wybrał jak interpretować dane, mając do dyspozycji różne klasy. W sumie udało mi się to, ale w trochę mniej zoptymalizowany sposób ^^
Problem był w tym, że nie da się przewidzieć struktury( chyba najodpowiedniejszy wyraz ) danych zawartych w wiadomości, niezależnie czy to HTTP, JSON (RPC) czy jakiś inny protokół.

Jednakże w informatyce ważniejsze jest rozwiązanie problemu niż utopijna perfekcja prezentowanego kodu, który sam wie, kiedy i jak ma się wykonać - panaceum ;)

Reasumując, dowiedziałem się że powinienem wykorzystać najprostszy protokół HTTP/HTTPS, niż wymyślać swój własny lub teraz zastępować wieloma innymi, które robią dokładnie to samo i prezentują ten sam poziom pod względem jakości kodu. Co do reszty to raczej jest w porządku, bo jest uniwersalnie napisana i w większości przypadków wykorzystywana w ten sam sposób.

6
Java / Odp: [Java] Interpretowanie komunikatów sieciowych klient-serwer
« dnia: Sierpień 10, 2016, 15:39:59 »
Przepraszam, mój błąd, chodziło mi o HTTP.

Sądząc po tym co piszesz próbujesz oprogramować protokół komunikacji tylko z danymi (na dodatek OOP, WTF!) -- to tak nie działa. Zawsze: nagłówek (który pozwoli zinterpretować dane) oraz dane.
W sumie częściowo udało mi się to uzyskać. Tzn, mam jedną wspólną klasę dla wszystkich oraz pewnego rodzaju parser, który rozróżnia żądanie i odpowiednio interpretuje dane. Gdyby tak nie było, to mój kod wyglądałby mniej więcej tak, że jedna klasa, która ma n instrukcji warunkowych wraz z wykonaniem pewnych operacji ;)

Sądząc po tym co napisałeś, stwierdzam, że podszedłem do sprawy wymyślając koło na nowo. Bo moje założenie jest identyczne z protokołem HTTP, tzn. też mam najpierw usługę( w HTTP jest to nagłówek ) a później dane.
Jednym słowem zamiast korzystać z biblioteki do parsowania HTTP, korzystam z JSON,a robią coś podobnego.
Własnie o taką zaletę OOP mi chodzi - polimorfizm i nie tylko, pozwala na utworzenie pewnego modułu( interfejs/klasa abstrakcyjna ), którego działanie mogę zmienić pisząc nową klasę rozszerzającą w/w moduł.

Dzięki za pomoc. Coś mi się wydaje, że będę musiał poczytać jeszcze o zastosowaniu w/w protokołu.

7
Java / Odp: [Java] Interpretowanie komunikatów sieciowych klient-serwer
« dnia: Sierpień 10, 2016, 15:24:15 »
W środku możesz co najwyżej zdefiniować POJO typu:
class LoginRequest {
   public String login;
   public String password;
}
i jego używać do deserializacji przychodzących requestów z Gson.fromJson.
Takie coś właśnie użyłem i mam problem przy deserializacji, bo nie wiem na samym początku jakie dane zawiera, więc nie wiem jaką klasę podać, np.: LoginRequest, RoomReservationRequest itd. itd. Czemu? Wiadomo, że serwer może odebrać każdy rodzaj żądania w danej chwili. Co innego, gdybym miał do czynienia z aplikacją, która każde żądanie wysyła step-by-step, czyli kolejność żądań jest znana z góry ^^

Tak więc sporo tego już jest, no i nie jest to zgodne z zasadą DRY, czyli posiadaniem dwóch dokładnie tych samych danych w dwóch klasach, gdzie druga mogłaby korzystać z obiektu typu tej pierwszej klasy, np. klasa LoginEvent zawiera obiekt typu klasy Account - agregacja. Tak więc wcześniej wymieniona zasada jest jak najbardziej spełniona. Przykład podany przez Ciebie ignoruje tę zasadę oraz zaletę stosowania OOP ;)

Reasumując, takie coś już miałem, choć jak to już nazwałeś, było przekombinowane, przyznaję się.

Co do HTML HTTP to jeszcze nie korzystałem z tego protokołu do wymiany danych poprzez sieć. No i muszę się przyznać, że nie wiem za bardzo jak miałoby to wyglądać, gdyż zawsze kojarzy mi się ze stronami WWW.
Ofc, następny projekt, który będę pisał, aby zrozumieć język Java wraz z resztą technologii będzie opierał się na wymianie danych z użyciem znanych protokołów ^^

Teraz po uproszczeniu już nie korzystam z tak rozbudowanej funkcjonalności. Mam chyba wszystko czego potrzebuję. Tak przynajmniej wydaje mi się, że znalazłem pewien kompromis między lepszym kodem, a tym czego oczekuję na tyle na ile pozwala mi mój poziom wiedzy.

8
Java / [Java] Interpretowanie komunikatów sieciowych klient-serwer
« dnia: Sierpień 09, 2016, 23:51:43 »
Witam,

mam problem bardziej z OOP i podejściem od strony implementacji rozwiązania problemu jakim jest interpretowanie komunikatów sieciowych, jakimi mogą być żądania i rezultat wcześniej wspomnianych żądań.

Nie od dziś wiadomo, że wysłanie zapytania do serwera czy istnieje konto użytkownika a czy dana sala jest zarezerwowana danego dnia różnią się niezbędnymi parametrami do wykonania w/w zapytania.

Jako rozwiązanie tego problemu postanowiłem użyć biblioteki GSON( upraszcza do minimum użycie JSON ), aby ustalić pewien wspólny standard wymiany komunikatów.

Standard komunikatów sieciowych:
{
  "service": "login",
  "content": {
    "login": "",
    "password": "",
    "error": ""
  }
}
service- usługa, czego dotyczy komunikat
content- zawartość komunikatu zależna od usługi




NetRequest - klasa abstrakcyjna wszystkich komunikatów( żądań/wyników )
public class NetRequest<T> {
   
    protected String service;
    protected T content;
   
    //==========================================================================
   
    public String getService() {
   
        return service;
    }
    public T getContent() {
   
        return content;
    }
   
    //==========================================================================
   
    @Override
    public String toString() {
       
        return new StringBuilder( "service:" ).append( service ).append( ",content:" ).append( content ).toString();
    }
}

a następnie klasa rozszerzająca powyższą klasę abstrakcyjną

public class LoginNetRequest extends NetRequest<Account> {
   
    public LoginNetRequest( Account account ) {
       
        service = "login";
        content = account;
    }
}

Jeszcze parę klas pośredniczących czyli:
Event - klasa abstrakcyjna wszystkich klas, które sprawdzają czy są w stanie obsłużyć dane żądanie, jeśli nie to wywołują kolejny obiekt
public abstract class Event
{
    private Event event = null;
    protected Client client;
   
    //==========================================================================
   
    public Event( Client client ) {
       
        this.client = client;
    }
   
    //==========================================================================
   
    public final Event add( Event event ) {
       
        this.event = event;
       
        return this.event;
    }
    public final Event get() {
       
        return event;
    }
   
    //==========================================================================
   
    public void forward( final NetRequest command ) throws Exception {
       
        if( event != null )
            event.handle( command );
    }
   
    //==========================================================================
   
    public abstract void handle( final NetRequest command ) throws Exception;
}

LoginEvent - klasa rozszerzająca klasę Event
public class LoginEvent extends Event
{
    public LoginEvent( Client client )
    {
        super( client );
    }
   
    //==========================================================================

    /**
     * @param command
     * @throws Exception
     */
    @Override
    public void handle( NetRequest command ) throws Exception {
       
        if( command.getService().equals( "login" ) ) {
           
            Account account = (Account)( command.getContent() );
            LoginNetRequest request = new LoginNetRequest( account );
           
            // Sprawdzenie w BD czy takie konto istnieje - LoginDBRequest !!!
            if( !account.getLogin().equals( "1" ) || !account.getPassword().equals( "1" ) )
                account.setError( "IncorrectLoginDataException" );
           
            client.sendMsg( request );
        }
        else
            forward( command );
    }
}

Interpreter - na końcu klasa, która trzyma wszystkie obiekty typu Event
public class Interpreter
{
    protected Event event;
   
    //==========================================================================
   
    public Interpreter( Client client ) {
       
        event = new LoginEvent( client );
    }
    public Interpreter( Interpreter interpreter ) {
       
        event = interpreter.getEvent();
    }
   
    //==========================================================================
   
    public Event getEvent() {
       
        return event;
    }
   
    //==========================================================================
   
    public void exec( final NetRequest command ) throws Exception {
        event.handle( command );
    }
}



Jak pewnie każdy już zauważył, użyłem typów generycznych oraz takich wzorców projektowych jak Composite oraz Chain of Responsibility. Były mi potrzebne, gdyż wszystkie dane GSON od razu zapisuje do/odczytuje z klasy Account.

Sami przyznacie, że jest to spore ułatwienie. Pisząc teraz zapytanie o rezerwację sali tak właściwie tworzę drugą klasę, która rozszerza w/w klasę abstrakcyjną ustawiając typ generyczny na RoomReservation. Na dodatek jak chcę obsłużyć komunikat, np. rezerwacji sal, to piszę nową klasę, która rozszerza klasę Event, a obiekt typu nowo utworzonej klasy dodaję do interpretera i to właściwie tyle.

Pewnie zapytacie, skoro działa to w czym tkwi problem. Otóż w samej metodzie, gdzie wiadomość jest pobierana a następnie konwertowana z łańcucha znaków na obiekt typu NetRequest - polimorfizm ^^

Najpierw spójrzcie na samą metodę:
private NetRequest getMsg() throws Exception {
   
    try {
       
        String request = in.readObject().toString();
       
        if( request.isEmpty() )
            throw new BlankCommandException();
           
        System.out.println( request );
       
        return new Gson().fromJson( request, LoginNetRequest.class ); <- chodzi o tę linijkę
       
    } catch( java.io.EOFException e ) {
       
        throw new BlankCommandException();
    }
}
Musi tam być przekazana klasa LoginNetRequest, gdyż jeżeli użyję NetRequest zapytanie nie zakończy się sukcesem. Patrząc na przykład wiadomo czemu, chodzi o tę część protected T content; z klasy NetRequest. Jak wiadomo mogą przyjść różne żądania, np. raz o zarezerwowaną salę a raz o wylogowanie, dlatego klasa NetRequest jest dla mnie zbawienna.




Możliwości jakie mi przychodzą przez kilka dni siedzenia nad problemem jest sporo, ale żadne mnie nie satysfakcjonują, gdyż tworzą nielogiczny kod, np. jeden z najlepszych to chyba ten:

Event
public abstract class Event
{
    protected Client client;
   
    //==========================================================================
   
    public Event( Client client ) {
       
        this.client = client;
    }
   
    //==========================================================================
   
    public abstract void exec( final NetRequest command ) throws Exception;
}

LoginEvent
public class LoginEvent extends Event {
   
    public LoginEvent( Client client )
    {
        super( client );
    }
   
    //==========================================================================

    /**
     * @param command
     * @throws Exception
     */
    @Override
    public void exec( NetRequest command ) throws Exception {
       
        Gson gson = new Gson();
       
        Account account = gson.fromJson( command.getContent(), Account.class );
           
        // Sprawdzenie w BD czy takie konto istnieje - LoginDBRequest !!!
        if( !account.getLogin().equals( "1" ) || !account.getPassword().equals( "1" ) )
            account.setError( "IncorrectLoginDataException" );
       
        client.sendMsg( new NetRequest( command.getService(), gson.toJson( account )  ) );
    }
}

NetRequest
public class NetRequest {
   
    protected String service;
    protected String content;
   
    //==========================================================================
   
    public NetRequest( String service, String content ) {
       
        this.service = service;
        this.content = content;
    }
   
    //==========================================================================
   
    public String getService() {
   
        return service;
    }
    public String getContent() {
   
        return content;
    }
   
    //==========================================================================
   
    @Override
    public String toString() {
       
        return new StringBuilder( "service:" ).append( service ).append( ",content:" ).append( content ).toString();
    }
}

Interpreter
public class Interpreter
{
    private final Map< String, Event > commands = new HashMap<>();
           
    //==========================================================================
           
    public Interpreter( Client client ) {
       
        commands.put( "login", new LoginEvent( client ) );
    }
   
    //==========================================================================
   
    public void exec( NetRequest command ) throws Exception {
       
        if( !commands.containsKey( command.getService() ) )
            return;
       
        commands.get( command.getService() ).exec( command );
    }
}

Prywatna metoda do pobierania komunikatów przez serwer
private NetRequest getMsg() throws Exception {
       
        try {
           
            String request = in.readObject().toString();
       
            if( request.isEmpty() )
                throw new BlankCommandException();

            System.out.println( request );

            JSONObject obj = new JSONObject( request );
       
            String service = obj.getString( "service" );
            String content = obj.getString( "content" );

            return new NetRequest( service, content );
       
        } catch( java.io.EOFException e ) {
           
            throw new BlankCommandException();
        }
    }

Klasa NetRequest zamiast przyjmować typ generyczny będzie ustawiona na sztywno jako String, czyli protected String content;

I dopiero, gdy konkretny obiekt typu Event jest w stanie obsłużyć dane żądanie, mógłby za pomocą GSON tworzyć klasę Account.

Tylko jak każdy z Was zauważył co najmniej dwa razy korzystam z GSON i raz na samym początku z czystego JSON. Jeżeli jest to jedyne rozsądne rozwiązanie to będę musiał iść w tę stronę. Korzyści też całkiem sporo, unikam pisania każdej klasy to każdego możliwego żądania ^^

Jeżeli okaże się że ostateczne rozwiązanie jest chyba najlepsze to tak zrobię. W przeciwnym przypadku przynajmniej czegoś się nauczę od doświadczonych programistów :]

PS. Jak na razie zastosowałem najprostsze rozwiązanie i wszystko działa jak należy. Widzę nawet pewne zalety. Jednakże jeśli ktoś będzie miał lepszy pomysł z chęcią wysłucham :)

9
FrozenShade ma rację, nie ma innej możliwości uzyskania tego co chcesz niż shader i przetwarzanie danych wejściowych( czyt. klatka/zdjęcie ) w Pixel/Fragment shader ;)

Ostatecznie możesz wspomóc się efektem stosowanym w post-processing'u, tzn. rysowanie full-screen quad'a itp. Zależy co chcesz osiągnąć i jak ^^

Ogólnie twoje rozwiązanie przypomina mi nakładanie znaku wodnego, który używa się choćby w TV ( logo kanału telewizyjnego ) w lewym/prawym górnym rogu.

Ostatecznie jak chcesz utrwalić efekt swojej pracy, to możesz zapisać jako plik wideo.

10
Design / Odp: Pomysł: Questy komponowane przez graczy
« dnia: Kwiecień 20, 2016, 14:45:15 »
Z tego co wyczytałem, jest to pierwsze podejście/pierwszy krok w stronę rozwiniętego AI - NPC.
Z twojego opisu wynika, że idziesz w dobrą stronę, jeśli chodzi o przeniesienie behawiorystyki do gier. I masz rację, że nie musisz każdej mikro przyczyny programować na sztywno. Owszem potrzebny będzie Ci pewien opis/nadanie cech postaciom, ale gdy to się zrobi reszta należy do algorytmów.

Wydaje mi się że wystarczy zaprogramować cechy charakteru/osobowości, które każdy z nas ma. Do tego losowanie chorób jak i chorób psychicznych, które odgrywają również kluczową rolę w decyzjach postaci. Jeśli jest naukowe badanie, które podaje w % na jakie choroby może cierpieć postać to sprawa uproszczona ;)

Na pewno nie musisz skupiać się na synonimach, przez które każdy z nas myśli, że to nieskończona praca. Do tego odpada sporo fachowych terminologii, czyli pozostaje Ci tylko te pozostałe potrzebne do egzystencji.

Z pewnością sporo pracy czeka Ciebie przy przeniesieniu zachowań psychologicznych do gry. Ale gdy Ci się to uda przynajmniej w 30% to gra na pewno nie będzie statyczna.

Tak więc, wszystko zmierza w dobrym kierunku oraz mam nadzieję, że pomysł będzie dalej rozwijany ^^

11
Projektowanie kodu / Odp: [Java] Wzorzec projektowy do gry Saper
« dnia: Październik 01, 2015, 21:38:09 »
Ale ja nie stawiam dwa razy miny na polu, bo mój kod wygląda w ten sposób:
for( int i=0, x=0, y=0; i < amount_mins; ++i )
{
          x = generator.nextInt( width );
          y = generator.nextInt( height );
           
          board.get( login )[y][x] = -1; // Wstawiam -1, nie dodaję
}

Jeśli chodzi o ilość min wokół danego pola, to nie ma mowy o policzeniu dwukrotnie tego samego, gdyż jednocześnie 'i' oraz 'j' nie będą równe 1 nie więcej niż raz <- przykład dla pola[1][1].

12
Projektowanie kodu / Odp: [Java] Wzorzec projektowy do gry Saper
« dnia: Wrzesień 30, 2015, 19:16:29 »
Racja mój błąd, nie mam poprawnie zaimplementowanego algorytmu liczenia bomb dla pól znajdujących się na krawędziach, dzięki ;)
A co do generatora liczb pseudolosowych to nie zastanawiałem się bo doszedłem do wniosku, że skoro nie ma flagi/funkcji ani metody do ustawienia czy liczby mają się powtarzać to znaczy, że domyślnie taka opcja jest ustawiona, a już na pewno w takim języku jakim jest Java. Ale racja, może być tak, że się mylę.

13
Projektowanie kodu / Odp: [Java] Wzorzec projektowy do gry Saper
« dnia: Wrzesień 30, 2015, 18:13:36 »
Trochę zmieniłem, np. usunąłem/dodałem 'else', przeniosłem warunek sprawdzania rogów na przedostatnie miejsce itp., gdyż kod był trochę nieczytelny, ale warunków nie zmieniałem, gdyż są poprawne.
Z kolei kod zawsze będzie działał, nie ważne jakie by nie były podane wartości pól, gwarantuje to wcześniejsza inicjalizacja tablicy dwuwymiarowej wartością 0 ^^

// Górna krawędź
if( i == 0 )
    if( i < (height-1) )
        if( board.get( login )[i+1][j] == -1 )
            board.get( login )[i][j]++;
// Dolna krawędź
else if( i == (height-1) )
    if( i > 0 )
        if( board.get( login )[i-1][j] == -1 )
            board.get( login )[i][j]++;

// Lewa krawędź
if( j == 0 )
    if( j < (width-1) )
        if( board.get( login )[i][j+1] == -1 )
            board.get( login )[i][j]++;
// Prawa krawędź
else if( j == (width-1) )
    if( j > 0 )
        if( board.get( login )[i][j-1] == -1 )
            board.get( login )[i][j]++;

// Rogi
if( (i == 0) && (j == 0) )
{
    if( (i < (height-1)) && (j < (width-1)) )
        if( board.get( login )[i+1][j+1] == -1 )
            board.get( login )[i][j]++;
}
else if( (i == 0) && (j == (width-1)) )
{
    if( (i < (height-1)) && (j > 0) )
        if( board.get( login )[i+1][j-1] == -1 )
            board.get( login )[i][j]++;
}
else if( (i == (height-1)) && (j == (width-1)) )
{
    if( (i > 0) && (j > 0) )
        if( board.get( login )[i-1][j-1] == -1 )
            board.get( login )[i][j]++;
}
else if( (i == (height-1)) && (j == 0) )
{
    if( (i > 0) && (j > (width-1)) )
        if( board.get( login )[i-1][j+1] == -1 )
            board.get( login )[i][j]++;
}
// Środek i pozostałe pola nie przylegające do krawędzi
else
{
    if( board.get( login )[i-1][j-1] == -1 )
        board.get( login )[i][j]++;

    if( board.get( login )[i-1][j] == -1 )
        board.get( login )[i][j]++;

    if( board.get( login )[i-1][j+1] == -1 )
        board.get( login )[i][j]++;

    if( board.get( login )[i][j+1] == -1 )
        board.get( login )[i+1][j+1]++;

    if( board.get( login )[i+1][j+1] == -1 )
        board.get( login )[i+1][j]++;

    if( board.get( login )[i+1][j] == -1 )
        board.get( login )[i+1][j-1]++;

    if( board.get( login )[i+1][j-1] == -1 )
        board.get( login )[i][j-1]++;

    if( board.get( login )[i][j-1] == -1 )
        board.get( login )[i][j]++;
}

14
Projektowanie kodu / Odp: [Java] Wzorzec projektowy do gry Saper
« dnia: Wrzesień 29, 2015, 21:09:23 »
http://sendfile.pl/pobierz/512167---8848.html

Wstawiam kod Sapera lokalnego, tzn. brak w nim modułu sieciowego, który jest zaczęty, ale nie jest ukończony. W najbliższym czasie zamierzam zrobić refaktoryzację kodu wybierając te wzorce, które w danym czasie mi się przydadzą.
Parę rzeczy może w nim nie działać, ale ogólna logika aplikacji funkcjonuje. Tak w ogóle z mojego kodu niczego się nie nauczysz.

Z góry uprzedzam, że ten kod jest drogą przez mękę oraz pełen grzechów typu singleton ^^

15
Projektowanie kodu / Odp: [Java] Wzorzec projektowy do gry Saper
« dnia: Wrzesień 28, 2015, 16:01:00 »
W sumie masz rację, chyba będzie to najlepsza opcja. Tylko mam jeszcze pytanie, które ostatnio zadałem. Czy lepiej od razu brać się za sieć, później za bazę danych, a na końcu za dopieszczanie GUI? Bo na obecną chwilę moja implementacji komunikacji klient <-> serwer jest gorsza niż GUI.

W sumie to pytanie dot. nie tylko tego projektu, ale projektów w ogóle. Czy warto zaczynać programowanie od interfejsu-szczegółów czy lepiej od ogólnych założeń?

Strony: [1] 2 3 4 5 ... 13