[Release] node-csro-proxy - CSRO-R proxy in Javascript (ES6)

// To create a new packet handle you will need to follow these steps:
// - Open folder src/controllers
// - Create a file with your own unique name then .js
// - Now follow this pattern to create your own handle:

// In my case the handle will be named UniqueKilled and it will really do as it says - something when unique got killed
// this is an actually working feature that gives silk to users based on configuration provided in src/config/AgentServer.js

async function UniqueKilled( // this functions params will always have inserted some prototypes from the main process that you can utilize further:
    {
        logger,  // logger logs the files per unique IP user instance (all chars from same ip in one log file)
        config: {
            UNIQUES, // we get some configuration variable defined in src/config/AgentServer.js
        },
        stream: { // silkroadsecurity api to create/read packets
            reader,
            writer,
        },
        memory, // Our thing handles session using 
        api: {
            account, // this is SRO_R_ACCOUNT api (auto generated from sequelize models)
            shard, // this is SRO_R_SHARD api 
        }
    },
    packet, // this is the packet itself that comes through the registered opcode in src/config/AgentServer.js 
) {
    try {
        const current_charname = memory.get('CharName16'); //whoami (this got stored in the temporary instance memory since the moment of character selection - see SelectCharacter.js controller.
        const read = new reader(packet.data); // initialize reading

        if (read.uint8() == 6) { // read
            const uniqueId = read.uint16(); //read
            const arg1 = read.uint8(); //read again
            const arg2 = read.uint16(); // and again..
            const killer_name = read.string(); //read even more

            if (killer_name == current_charname) {
                const unique_config = UNIQUES[uniqueId] || false;
                const UserJID = memory.get('UserJID');
                const CharID = memory.get('CharID');

                // Retrieve actual char information from the shard database
                const {
                    data: [
                        {
                            CurLevel,
                        }
                    ]
                } = await shard.get(`/_char`, {
                    params: {
                        sort: JSON.stringify(['CharID']),
                        filter: JSON.stringify({
                            CharID,
                        }),
                    }
                });

                // drop a line of log for this event in the log file (to that specific user).
                logger.log('info', 'killed_unique', { 
                    UserJID,
                    killer_name,
                    CurLevel,
                    reward_config: unique_config,
                    unique_id: uniqueId,
                });

                // we may wanna dispatch this event to discord here later or even do something more , that can go here.. 
                if (unique_config && CurLevel <= unique_config.cap) { // some basic logic
                    // Dispatch silk reward
                    await account.post(`/reward-silk`, { // add silks to the user
                        UserJID,
                        CharID,
                        amount: unique_config.reward,
                    });

                    // Send a notice to user after the unique kill:
                    const write = new writer(); // this is class from silkroad-security more here: https://github.com/EmirAzaiez/SilkroadSecurityJS
                    write.uint8(7); // write some bytes
                    write.string(`Great! You got ${unique_config.reward} silk for killing [${unique_config.name}]`); // write some message

                    return [ // you can return multiple packets to various directions
                        { // packet 1:
                            packet, 
                            target: 'client', // we can say 'remote' or 'client' -- too obvious: remote is the actual server, client = the guy playing your game.
                        },
                        { // packet 2:
                            packet: {
                                opcode: 0x3026, // custom or an existing opcode to send
                                data: write.toData(),
                            },
                            target: 'client',
                        },
                    ];
                }
            }
        }

        return [{ packet, target: 'client' }]; // this will jus trigger the if-not condition and return the packet to the client
    } catch (e) {
        return [{ packet }];
    }
}

export default UniqueKilled; // here we export the controller from file

// open src/controllers/index.js and import that controller from above
// keep in mind this file is required to index the controller name in the the respective
// module config file (in my example we're using AgentServer and packet 0x300C)

import RedirectAgentServer from './RedirectAgentServer';
import SelectCharacter from './SelectCharacter';
import UpdateWeather from './UpdateWeather';
import SilkDisplay from './SilkDisplay';
import ItemMallToken from './ItemMallToken';
import ItemMallBuy from './ItemMallBuy';
import FixPartyMatching from './FixPartyMatching';
import UniqueKilled from './UniqueKilled'; //<---- this guy

export {
    RedirectAgentServer,
    SelectCharacter,
    UpdateWeather,
    SilkDisplay,
    ItemMallToken,
    ItemMallBuy,
    FixPartyMatching,
    UniqueKilled, // <--- we also export it 
};

// src/config/AgentServer.js 
// just about the line 107 you should find the object 'middlewares'
middlewares: {
        client: { // client -> remote opcode handlers
            0x7001: 'SelectCharacter',
            0x3012: 'SilkDisplay',
            0x7069: 'FixPartyMatching',
            // 0x7565: 'ItemMallToken',
            // 0x7034: 'ItemMallBuy',
        },
        remote: { // remote -> client opcode handlers
            0x3809: 'UpdateWeather',
            0x300C: 'UniqueKilled', //<-- just add this line and we're done, hit save
        },
    },
// remote stands for the agent/gateway or downloadserver
// client is the game itself (way too obvious)

import dotenv from 'dotenv';

dotenv.config();

export default {
    // AgentServer
    ':12': { // <-- IP AGENT1 FROM
        host: process.env.REDIRECT_AGENT_IP || '138.201.58.79', // <-- IP TO
        port: process.env.REDIRECT_AGENT_PORT || 8002, // <-- PORT TO
    },
    ':13': { // <-- IP AGENT2 FROM
        host: process.env.REDIRECT_AGENT2_IP || '138.201.58.79', // <-- IP TO
        port: process.env.REDIRECT_AGENT2_PORT || 8002, // <-- PORT TO
    },
    ':15': { // <-- IP AGENT3 FROM
        host: process.env.REDIRECT_AGENT3_IP || '138.201.58.79', // <-- IP TO
        port: process.env.REDIRECT_AGENT3_PORT || 8002, // <-- PORT TO
    },
    /// you can keep using the above pattern to create basically unlimited (good question) amount of agent redirects see file RedirectAgentServer.js for more info

    // DownloadServer -- same thing as agent but for the gateway -> download
    // '148.251.195.215:16002': { // <-- IP FROM
    //     host: process.env.REDIRECT_DOWNLOAD_IP || '127.0.0.1', // <-- IP TO
    //     port: process.env.REDIRECT_DOWNLOAD_PORT || 8003, // <-- PORT TO
    // },
};

// Lets say we want a table
// open src/models/account/index.js and src/models/account/TB_User.js 

// the model (basically define the columns and their types in respective table):
export default (db, types) => db.define('TB_User', {
  JID: {
    type: types.INTEGER,
    allowNull: false,
    primaryKey: true
  },
  StrUserID: {
    type: types.STRING(25),
    allowNull: false
  },
  password: {
    type: types.STRING(50),
    allowNull: false
  },
  Status: {
    type: types.TINYINT,
    allowNull: true
  },
  GMrank: {
    type: types.TINYINT,
    allowNull: true
  },
  Name: {
    type: types.STRING(25),
    allowNull: true
  },
  Email: {
    type: types.STRING(50),
    allowNull: true
  },
  sex: {
    type: types.CHAR(2),
    allowNull: true
  },
  certificate_num: {
    type: types.STRING(30),
    allowNull: true
  },
  address: {
    type: types.STRING(100),
    allowNull: true
  },
  postcode: {
    type: types.STRING(10),
    allowNull: true
  },
  phone: {
    type: types.STRING(20),
    allowNull: true
  },
  mobile: {
    type: types.STRING(20),
    allowNull: true
  },
  regtime: {
    type: types.DATE,
    allowNull: true
  },
  reg_ip: {
    type: types.STRING(25),
    allowNull: true
  },
  Time_log: {
    type: types.DATE,
    allowNull: true
  },
  freetime: {
    type: types.INTEGER,
    allowNull: true
  },
  sec_primary: {
    type: types.TINYINT,
    allowNull: true
  },
  sec_content: {
    type: types.TINYINT,
    allowNull: true
  },
  AccPlayTime: {
    type: types.INTEGER,
    allowNull: true
  },
  LatestUpdateTime_ToPlayTime: {
    type: types.INTEGER,
    allowNull: true
  },
  TotalLoggedOutTime: {
    type: types.BIGINT,
    allowNull: true
  },
  LastLoggedOuttime: {
    type: types.DATE,
    allowNull: true
  },
  EmailValidate: {
    type: types.TINYINT,
    allowNull: true
  },
  NickName: {
    type: types.STRING(50),
    allowNull: true
  }
}, {
  sequelize: db,
  tableName: 'TB_User',
  schema: 'dbo',
  hasTrigger: true,
  timestamps: false
});


// see how these two files are linked together:
import _Notice from './_Notice'; 
import TB_User from './TB_User'; // <-- the sequelize model we want
import SK_Silk from './SK_Silk';

export {
    _Notice,
    TB_User, // <-- just export it and it will appear on API_Account service as a route {HOSTNAME}:{PORT}/tb_user and will support POST, GET, DELETE, PUT methods
    SK_Silk,
}