Node System

Better than Matrix, yes?

Spoiler for System:

Code:

---

package org.elixrr.game.node;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

import org.elixrr.entity.player.Player;

/**
 * @author Taylor Moon
 *
 * @since Jan 29, 2013
 * @version 2.2 Update 1, project 3
 */
public abstract class Node {

        /**
        * The player instance
        */
        protected Player player;

        /**
        * The map of nodes that will be overriding the current action
        */
        protected final Map<NodeType, NodeEvent> NODES = Collections
                        .synchronizedMap(new HashMap<NodeType, NodeEvent>());

        /**
        * Called when a player starts their node
        */
        public abstract void start();

        /**
        * Called every game time (a tick timer)
        */
        public abstract void pulse();
       
        /**
        * Called when the node is stopped
        */
        public abstract void stop();

        /**
        * Adds an active node to the node list
        *
        * @param type
        *            The type of node to add
        * @param r
        *            The node event to run
        */
        public final void putNode(NodeType type, NodeEvent r) {
                NODES.put(type, r);
        }

        /**
        * Returns the node event corresponding to the node type
        *
        * @param type
        *            The type
        * @return The node event
        */
        public NodeEvent getNodeEvent(NodeType type) {
                return NODES.get(type);
        }

        /**
        * Returns the node type corresponding to the event
        *
        * @param event
        *            The event
        * @return The node type
        */
        public NodeType getNodeType(NodeEvent event) {
                for (Entry<NodeType, NodeEvent> entry : NODES.entrySet()) {
                        if (entry.getValue() == event)
                                return entry.getKey();
                }
                return null;
        }
}

---

Code:

---

package org.elixrr.game.node;

/**
 * @author Taylor Moon
 *
 * @since Jan 29, 2013
 * @version 2.2 Update 1, project 3
 */
public abstract class NodeEvent {

        /**
        * Called when the specified node event is executed
        */
        public abstract void processThis();

        /**
        * Used to determine if this action should be executed
        */
        public boolean called;

        /**
        * Calls this action
        */
        public void call() {
                called = true;
        }

}

---

Code:

---

package org.elixrr.game.node;

import java.util.HashMap;

import org.elixrr.game.node.impl.Wilderness;

/**
 * @author Taylor Moon
 *
 * @since Jan 29, 2013
 * @version 2.2 Update 1, project 3
 */
@SuppressWarnings("unchecked")
public class NodeHandler {

        /**
        * The nodes that will be handled
        */
        private static final HashMap<Object, Class<Node>> NODES = new HashMap<Object, Class<Node>>();

        static {
                try {
                        NODES.put("Wilderness", (Class<Node>) Class
                                        .forName(Wilderness.class.getCanonicalName()));
                } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                }
        }

        /**
        * Returns the node corresponding to the specified key
        *
        * @param key
        *            The key of the node to get
        * @return The instanced node
        */
        public static Node get(Object key) {
                if (key instanceof Node)
                        return (Node) key;
                Class<Node> node = NODES.get(key);
                if (node == null)
                        return null;
                try {
                        return node.newInstance();
                } catch (Exception e) {
                        return null;
                }
        }

}

---

Code:

---

package org.elixrr.game.node;

import org.elixrr.engine.Processor;
import org.elixrr.entity.player.Player;

/**
 * @author Taylor Moon
 *
 * @since Jan 29, 2013
 * @version 2.2 Update 1, project 3
 */
public class NodeManager extends Processor {

        /**
        * The currently active node
        */
        private Node node;

        /**
        * The last node to be
        */
        private Node lastNode;

        /**
        * The player instance
        */
        private Player player;

        @Override
        public void process(boolean slowEngine) {
                if (slowEngine || node == null)
                        stopProcessing();
                else {
                        startProcessing();
                }
                if (node != null) {
                        node.pulse();
                        for (NodeType type : node.NODES.keySet())
                                if (node.getNodeEvent(type).called) {
                                        node.getNodeEvent(type).processThis();
                                        node.getNodeEvent(type).called = false;
                                }
                }
        }

        /**
        * Returns the last active node
        *
        * @return The last node
        */
        public Node getLastNode() {
                return lastNode;
        }

        /**
        * Starts and returns the started node
        *
        * @param nodeObject
        *            The node object
        * @return The started node
        */
        public Node start(Object nodeObject) {
                Node node = NodeHandler.get(nodeObject);
                if (node == null)
                        return lastNode != null ? lastNode : null;
                if (lastNode != null && this.node != null) {
                        lastNode.stop();
                        this.node.stop();
                }
                node.player = this.player;
                node.start();
                this.node = node;
                lastNode = node;
                return node;
        }

        /**
        * Stops the currently active node
        *
        * @return The stopped node
        */
        public Node stopCurrentNode() {
                if (node == null)
                        throw new java.util.MissingResourceException(
                                        "Found no node to stop", this.getClass().getName(),
                                        "-P.THREAD_");
                node.stop();
                node = null;
                return lastNode;
        }

        /**
        * Returns the current node
        *
        * @return The node
        */
        public Node getNode() {
                return node;
        }

        /**
        * Returns if the player is currently in a node
        *
        * @return If a player is currently in a node
        */
        public boolean hasActiveNode() {
                return node != null;
        }

}

---

Code:

---

package org.elixrr.game.node;

/**
 * @author Taylor Moon
 *
 * @since Jan 29, 2013
 * @version 2.2 Update 1, project 3
 */
public enum NodeType {
       
        LOGOUT, LOGIN, DEATH, ITEMS_DROPPED_ON_DEATH;

}

---

When my game engine processes the node manager of the player

Code:

---

if (p.disposal.nodeManager().hasActiveNode()
                                && !PROCESSORS.contains(p.disposal.nodeManager()))
                        PROCESSORS.add(p.disposal.nodeManager());
                else {
                        PROCESSORS.remove(p.disposal.nodeManager());
                }

---

A representation of a node (Wilderness handler)

Code:

---

package org.elixrr.game.node.impl;

import org.elixrr.game.node.Node;
import org.elixrr.game.node.NodeEvent;
import org.elixrr.game.node.NodeType;

/**
 * @author Taylor Moon
 *
 * @since Jan 29, 2013
 * @version 2.2 Update 1, project 3
 */
public class Wilderness extends Node {

        @Override
        public void start() {
                player.addAttribute("Wilderness_Level",
                                World.getWildernessLevel(player.getMapLocation().getRegionID()));
                player.addAttibute("CAN_PVP");// Recognized .6 seconds after start

                /*
                * Called upon login
                */
                putNode(NodeType.LOGIN, new NodeEvent() {

                        @Override
                        public void processThis() {
                                player.disposal.nodeManager().start("Wilderness");
                        }
                });

                /*
                * Called when items are about to be dropped on death
                */
                putNode(NodeType.ITEMS_DROPPED_ON_DEATH, new NodeEvent() {

                        @Override
                        public void processThis() {
                                for (Item untradeable : player.disposal.inventory().untradeableItems) {
                                        player.disposal.inventory().replaceAndDontUpdate(
                                                        untradeable, Economy.getItemValue(untradeable));
                                }
                        }
                });
        }

        @Override
        public void pulse() {
                player.addAttribute("Wilderness_Level",
                                World.getWildernessLevel(player.getMapLocation().getRegionID()));
        }

        @Override
        public void stop() {
                player.removeAttribute("Wilderness_Level");
                player.removeAttribute("CAN_PVP");
                if (World.getWildernessLevel(player.getMapLocation().getRegionID()) != -1)
                        player.move(new MapLocation(0, 0, 0));// Need coords
                // TODO remove interfaces
        }

}

---

When a node event is called by an action somewhere in the game

Code:

---

@Override
        public void die(boolean dropItems) {
                if (disposal.nodeManager().getNode().getNodeEvent(NodeType.DEATH) != null) {
                        disposal.nodeManager().getNode().getNodeEvent(NodeType.DEATH).call();
                        return;
                }
                if (dropItems) {

                } else {

                }
        }

---

Feedback please

NodeType enum will require changes for every Node you add; fix that up so you have an enum-per-class for the NodeTypes otherwise that main one will be populated when you add more shit.

Gj tho skimmed thru it

Quote:

---

Originally Posted by Tyluur [Only registered and activated users can see links. Click Here To Register...]

NodeType enum will require changes for every Node you add; fix that up so you have an enum-per-class for the NodeTypes otherwise that main one will be populated when you add more shit.

Gj tho skimmed thru it

---

What? And ty.

Quote:

---

Originally Posted by Taylor Moon [Only registered and activated users can see links. Click Here To Register...]

What? And ty.

---

Hes pretty much saying your making it harder then what it really is. Basically ur making not a enum for every class u make.

Quote:

---

Originally Posted by CheaterXman [Only registered and activated users can see links. Click Here To Register...]

Basically ur making not a enum for every class u make.

---

wtf are you talking about

Screw everything I said :fp: tried to make his post look simplier

Ok let's get this straight, your naming is terrible and made is confusing as fuck to understand what this is from just skimming your classes. Before I'll comment on the functionality etc I want to point out some naming issues first:

First of all where did you come up with the name Node? A node is nothing more than something in a chain or other form of connection with an abstract name. However your 'nodes' are known what they do, so why name them Node, they are simply some form of tasks?! Nodes are for example the nodes in a list, but if I know what they nodes represents then I have no reason to call them nodes anymore. Furthermore events are triggered and when triggered tasks are executed. Something subscribes on an event handler and when triggered the event handler makes the calls to the task, but why call your tasks Nodes? And how is your NodeHandler handling anything? It's just a class holding a reference to a static collection of 'nodes' and a method to return one. And your NodeManager? What is it managing? All it does is check whether event were triggered and executes the behaviour programmed to be executed when triggered (the task).

But from what I can see you've been trying to make a system that contains certain tasks for certain events and based on what phase the player is in there is a subset of those tasks available to the engine? If so you've made it more complex than necessary.

Quote:

---

Originally Posted by Maxi [Only registered and activated users can see links. Click Here To Register...]

Ok let's get this straight, your naming is terrible and made is confusing as fuck to understand what this is from just skimming your classes. Before I'll comment on the functionality etc I want to point out some naming issues first:

First of all where did you come up with the name Node? A node is nothing more than something in a chain or other form of connection with an abstract name. However your 'nodes' are known what they do, so why name them Node, they are simply some form of tasks?! Nodes are for example the nodes in a list, but if I know what they nodes represents then I have no reason to call them nodes anymore. Furthermore events are triggered and when triggered tasks are executed. Something subscribes on an event handler and when triggered the event handler makes the calls to the task, but why call your tasks Nodes? And how is your NodeHandler handling anything? It's just a class holding a reference to a static collection of 'nodes' and a method to return one. And your NodeManager? What is it managing? All it does is check whether event were triggered and executes the behaviour programmed to be executed when triggered (the task).

But from what I can see you've been trying to make a system that contains certain tasks for certain events and based on what phase the player is in there is a subset of those tasks available to the engine? If so you've made it more complex than necessary.

---

Calm down.

I know what node means in computing. People happen to use the node naming in this situation, so I went with it.

Summary: If a task is awaiting execution and the player is in an active 'event handler' (node) the task that is waiting execution is denied and replaced with the task given in the node. Otherwise, the default action is executed.

But since you cared enough to write a novel for me, I'll change the method, variable, and class names and re post the edited code.

I don't care to sound stupid but what is this used for?

Resuming. Does same shit with a more complicated code and naming..... Even i had to look twice to understand -.-.

Correct if im wrong from what i see u set a node to death:
disposal.nodeManager().getNode().getNodeEvent(Node Type.DEATH) !

And from thereon when it dies it does the code on death node all time.... Whats the purpose then if its same all time?