Sythe.org MMORPG accusations

The third and final thread I would like to make is regarding the Sythe.org MMORPG.

The same cowards referenced in the other two threads (in particular some guy named Zypur who hangs around with a dozen other general failures who have nothing better to do than troll me) have repeatedly accused me of ripping off sythe.org members. They accuse me of fabricating the Sythe.org MMORPG project in order to bring in donations.

First I would like to present evidence of work completed, and then I would like to hear their counter arguments (accusations) against me, in their own words.

Screenshots from the work:





Source code structure of the work:

Code:

D:\javaprojects\smallgame\src\SytheMMO>for /r %g in (*) do @echo %g
D:\javaprojects\smallgame\src\SytheMMO\SytheGame.java
D:\javaprojects\smallgame\src\SytheMMO\DisplayClasses\GameScreen.java
D:\javaprojects\smallgame\src\SytheMMO\GameLogic\AnimatedSpriteSpecial.java
D:\javaprojects\smallgame\src\SytheMMO\GameLogic\CharacterClass.java
D:\javaprojects\smallgame\src\SytheMMO\GameLogic\Player.java
D:\javaprojects\smallgame\src\SytheMMO\GameLogic\Transient.java
D:\javaprojects\smallgame\src\SytheMMO\MapClasses\GameArena.java
D:\javaprojects\smallgame\src\SytheMMO\MapClasses\GameMap.java
D:\javaprojects\smallgame\src\SytheMMO\MapClasses\ImmutableMap.java
D:\javaprojects\smallgame\src\SytheMMO\MapClasses\MapNotFoundException.java
D:\javaprojects\smallgame\src\SytheMMO\MapClasses\MapLayer\EntityLayer.java
D:\javaprojects\smallgame\src\SytheMMO\MapClasses\MapLayer\FloorLayer.java
D:\javaprojects\smallgame\src\SytheMMO\MapClasses\MapLayer\OverlayLayer.java
D:\javaprojects\smallgame\src\SytheMMO\MapClasses\MapLayer\WalkableLayer.java
D:\javaprojects\smallgame\src\SytheMMO\MapClasses\MapLayer\WallLayer.java
D:\javaprojects\smallgame\src\SytheMMO\MapClasses\MapLayer\Abstract\ListLayer.java
D:\javaprojects\smallgame\src\SytheMMO\MapClasses\MapLayer\Abstract\ListLayerEntry.java
D:\javaprojects\smallgame\src\SytheMMO\MapClasses\MapLayer\Abstract\MapLayer.java
D:\javaprojects\smallgame\src\SytheMMO\MapClasses\MapLayer\Abstract\TileLayer.java
D:\javaprojects\smallgame\src\SytheMMO\MapUtilities\MapMaker.java
D:\javaprojects\smallgame\src\SytheMMO\ResourceClasses\Constants.java
D:\javaprojects\smallgame\src\SytheMMO\ResourceClasses\ResourceManager.java
D:\javaprojects\smallgame\src\SytheMMO\ResourceUtilities\BuildResourcesTable.java
D:\javaprojects\smallgame\src\SytheMMO\ResourceUtilities\TileSQLTemplateGenerator.java
D:\javaprojects\smallgame\src\SytheMMO\ResourceUtilities\WallTileSQLTemplateGenerator.java

Lines of code completed in the work:

Code:

D:\javaprojects\smallgame\src\SytheMMO>for /r %g in (*) do @wc -l %g | cut -d" " -f1
223
47
40
65
67
244
416
106
166
10
66
26
67
67
51
75
47
79
111
588
31
217
147
157
246

Total LOC: 3359

Code sample from the work (Transient.java -- a class for dealing with animated directional sprites stored in a zip format.)

Code:

package SytheMMO.GameLogic;

import com.golden.gamedev.object.AnimatedSprite;

import javax.imageio.ImageIO;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipEntry;
import java.util.*;
import java.io.IOException;
import java.io.ByteArrayOutputStream;
import java.awt.image.BufferedImage;
import java.awt.*;
import java.lang.reflect.Field;

import SytheMMO.ResourceClasses.ResourceManager;

public class Transient {
    private int transientID = -1;


    private AnimatedSprite direction0 = null;
    private AnimatedSprite direction1 = null;
    private AnimatedSprite direction2 = null;
    private AnimatedSprite direction3 = null;
    private AnimatedSprite direction4 = null;
    private AnimatedSprite direction5 = null;
    private AnimatedSprite direction6 = null;
    private AnimatedSprite direction7 = null;


    public void render(Graphics2D g, int direction, int x, int y) {


        switch (direction) {
            case 0:
                direction0.render(g, x, y);
                break;
            case 1:
                direction1.render(g, x, y);
                break;
            case 2:
                direction2.render(g, x, y);
                break;
            case 3:
                direction3.render(g, x, y);
                break;
            case 4:
                direction4.render(g, x, y);
                break;
            case 5:
                direction5.render(g, x, y);
                break;
            case 6:
                direction6.render(g, x, y);
                break;
            case 7:
                direction7.render(g, x, y);
                break;
        }
    }

    public Transient() {

    }

    public Transient(AnimatedSprite direction0, AnimatedSprite direction1, AnimatedSprite direction2, AnimatedSprite direction3, AnimatedSprite direction4, AnimatedSprite direction5, AnimatedSprite direction6, AnimatedSprite direction7, int transientID) {
        this.direction0 = direction0;
        this.direction1 = direction1;
        this.direction2 = direction2;
        this.direction3 = direction3;
        this.direction4 = direction4;
        this.direction5 = direction5;
        this.direction6 = direction6;
        this.direction7 = direction7;
        this.transientID = transientID;
    }


    public Transient(ZipInputStream zis) throws IOException {
        ZipEntry ze = null;


        //      Direction   --- Frame ---- String_name
        HashMap<Integer, HashMap<Integer, BufferedImage>> directionsContainingFrames = new HashMap<Integer, HashMap<Integer, BufferedImage>>(8);
        HashMap<Integer, HashMap<Integer, Point>> directionsContainingFramesMidPoints = new HashMap<Integer, HashMap<Integer, Point>>(8);
        //HashMap<>

        while ((ze = zis.getNextEntry()) != null) {
            String rawFrameName = ze.getName();


            if (rawFrameName.startsWith("f")) {


                int direction = Integer.parseInt(rawFrameName.substring(1, 3));
                int frame = Integer.parseInt(rawFrameName.substring(4, 6));


                if (rawFrameName.endsWith(".png")) {
                    // process the images
                    HashMap<Integer, BufferedImage> dir = directionsContainingFrames.get(direction);
                    if (dir == null) {
                        dir = new HashMap<Integer, BufferedImage>(25);
                    }
                    dir.put(frame, ImageIO.read(zis));
                    directionsContainingFrames.put(direction, dir);

                } else if (rawFrameName.endsWith(".info")) {
                    // process the image meta data
                    ByteArrayOutputStream baos = new ByteArrayOutputStream();
                    byte[] buffer = new byte[1024];
                    int readBytes = 0;
                    while ((readBytes = zis.read(buffer)) > 0) {
                        baos.write(buffer, 0, readBytes);
                    }

                    HashMap<Integer, Point> dir = directionsContainingFramesMidPoints.get(direction);
                    if (dir == null) {
                        dir = new HashMap<Integer, Point>(25);
                    }

                    Point midPoint = new Point();
                    String[] infoLines = new String(baos.toByteArray()).split("\r\n");
                    int countFoundElements = 0;
                    for (String line : infoLines) {
                        String[] parts = line.split(" = ", 2);
                        if (parts[0].toLowerCase().equals("#midx")) {
                            midPoint.x = Integer.parseInt(parts[1]);
                            if (countFoundElements++ >= 2) break;
                        } else if (parts[0].toLowerCase().equals("#midy")) {
                            midPoint.y = Integer.parseInt(parts[1]);
                            if (countFoundElements++ >= 2) break;
                        }
                    }

                    dir.put(frame, midPoint);

                    directionsContainingFramesMidPoints.put(direction, dir);
                    baos.close();
                }


            }
        }

        // zip has been processed, hashmaps filled, so unpack to proper class structures:

        Iterator<Integer> directionIt = directionsContainingFrames.keySet().iterator();
        while (directionIt.hasNext()) {
            int currentDirection = directionIt.next();


            // first we want to manufacture a bufferedImageArray for instantiating the animatedSpriteSpecial for this current direction...

            HashMap<Integer, BufferedImage> frames = directionsContainingFrames.get(currentDirection);
            HashMap<Integer, Point> midPoints = directionsContainingFramesMidPoints.get(currentDirection);

            int frameCount = frames.keySet().size();
            BufferedImage[] bufferedImageArray = new BufferedImage[frameCount];
            Point[] midPointArray = new Point[frameCount];

            ArrayList sortedFrameNumbers = new ArrayList(frames.keySet());
            Collections.sort(sortedFrameNumbers);
            int count = 0;

            Iterator<Integer> frameIt = sortedFrameNumbers.iterator();
            while (frameIt.hasNext()) {
                int currentFrame = frameIt.next();
                bufferedImageArray[count] = frames.get(currentFrame);
                midPointArray[count] = midPoints.get(currentFrame);
                count++;
            }

            ResourceManager.log("Tranisent: Loaded " + count + " frames ...");


            // finally instantiate an animatedSpriteSpecial for it

            AnimatedSpriteSpecial ass = new AnimatedSpriteSpecial(bufferedImageArray, midPointArray);

            switch (currentDirection) {
                case 0:
                    direction0 = ass;
                    break;
                case 1:
                    direction1 = ass;
                    break;
                case 2:
                    direction2 = ass;
                    break;
                case 3:
                    direction3 = ass;
                    break;
                case 4:
                    direction4 = ass;
                    break;
                case 5:
                    direction5 = ass;
                    break;
                case 6:
                    direction6 = ass;
                    break;
                case 7:
                    direction7 = ass;
                    break;
            }
        }

        // don't cross ... uhh... close the streams!
        //zis.close();


    }


    public void update(long elapsedTime, int direction) {
        switch (direction) {
            case 0:
                direction0.update(elapsedTime);
                break;
            case 1:
                direction1.update(elapsedTime);
                break;
            case 2:
                direction2.update(elapsedTime);
                break;
            case 3:
                direction3.update(elapsedTime);
                break;
            case 4:
                direction4.update(elapsedTime);
                break;
            case 5:
                direction5.update(elapsedTime);
                break;
            case 6:
                direction6.update(elapsedTime);
                break;
            case 7:
                direction7.update(elapsedTime);
                break;
        }
    }
}

Video footage of work in operation:






Now I'll hear your accusations from your own mouths, that is if you're not too cowardly to post them here.

 

Well, because frankly I'm sick of it. I'm sick of them, and I'm sick of their snickering shit. If they have valid claims to make against me then they should front up and make them, else they should fuck off.

And now I can direct them to this very thread, should ever the issue arise again. Morally repugnant human beings need to be put out in the light and shown for what they are. Scammers, fraudsters, liars, libelers, and plain flat out good for nothing cheating whining failures. And yes, I am talking about people who frequent ghostirc.

 

Doesn't give the full path.

Yes it was suspended due to lack of community interest (particularly on the side of anyone actually contributing).

 

I have no plans for opening it back up at this point. But if I do, I will be taking creative contributions toward it only. (Artwork, map designs, music, sounds, storyline.)

 

The point of the thread is really not to discuss what the game was going to be.

Briefly, I had always envisioned it being more like a diablo-like mmo, but its own game, not a cheap takeoff of another game.

Architecturally it is a unique design, in that it has p2p or "swarm" gameplay, and a system of rules for adjudicating the authoritative game outcome from a swarm of peers with no central play server, only a central score server. The mechanisms for doing this are built in to the map level, you can see "ARENA" in the top right, that defines the swarm you belong to -- which is all the players on your current territory of the map.