[RM2K3] DYNRPG COMPILING ERROR

Posts

I wanted to start making plugins for DynRPG, but I can't seem to compile an altered plugin that I messed around with. I keep getting these errors, no idea how to resolve them. I have the DynRPG lib linked. I'm sure of this because I got a host of different errors when I didn't have it linked.

Build Log;
obj\Release\main.o:main.cpp:(.text+0x1a2): undefined reference to `RPG::DStringPtr::DStringPtr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)'
obj\Release\main.o:main.cpp:(.text+0x1f1): undefined reference to `RPG::DStringPtr::~DStringPtr()'
obj\Release\main.o:main.cpp:(.text+0x308): undefined reference to `RPG::DStringPtr::DStringPtr(RPG::DStringPtr&)'
obj\Release\main.o:main.cpp:(.text+0x34a): undefined reference to `RPG::DStringPtr::DStringPtr(RPG::DStringPtr&)'
obj\Release\main.o:main.cpp:(.text+0x5e8): undefined reference to `RPG::DStringPtr::s_str()'
obj\Release\main.o:main.cpp:(.text+0x67a): undefined reference to `RPG::DStringPtr::operator=(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)'
obj\Release\main.o:main.cpp:(.text+0xc96): undefined reference to `RPG::DStringPtr::DStringPtr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)'
obj\Release\main.o:main.cpp:(.text+0xcf2): undefined reference to `RPG::DStringPtr::~DStringPtr()'
obj\Release\main.o:main.cpp:(.text+0xdec): undefined reference to `RPG::DStringPtr::DStringPtr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)'
obj\Release\main.o:main.cpp:(.text+0xe42): undefined reference to `RPG::DStringPtr::~DStringPtr()'
obj\Release\main.o:main.cpp:(.text+0x1c8b): undefined reference to `RPG::Actor::partyMember(int)'
obj\Release\main.o:main.cpp:(.text+0x1c9f): undefined reference to `RPG::Actor::partyMember(int)'
obj\Release\main.o:main.cpp:(.text+0x1cdc): undefined reference to `RPG::Actor::partyMember(int)'
obj\Release\main.o:main.cpp:(.text+0x1d69): undefined reference to `RPG::Actor::partyMember(int)'
obj\Release\main.o:main.cpp:(.text+0x1dc3): undefined reference to `RPG::Actor::partyMember(int)'
obj\Release\main.o:main.cpp:(.text+0x1dd6): more undefined references to `RPG::Actor::partyMember(int)' follow
obj\Release\main.o:main.cpp:(.text+0x1fae): undefined reference to `RPG::Battler::getAgility()'
obj\Release\main.o:main.cpp:(.text+0x2099): undefined reference to `RPG::Battler::getAgility()'
obj\Release\main.o:main.cpp:(.text+0x22b2): undefined reference to `RPG::Actor::partyMember(int)'
obj\Release\main.o:main.cpp:(.text+0x22be): undefined reference to `RPG::Actor::partyMember(int)'
obj\Release\main.o:main.cpp:(.text+0x245c): undefined reference to `RPG::Actor::partyMember(int)'
obj\Release\main.o:main.cpp:(.text+0x248d): undefined reference to `RPG::Actor::partyMember(int)'
obj\Release\main.o:main.cpp:(.text+0x2528): undefined reference to `RPG::Actor::partyMember(int)'
obj\Release\main.o:main.cpp:(.text+0x268d): more undefined references to `RPG::Actor::partyMember(int)' follow
obj\Release\main.o:main.cpp:(.text+0x2e3a): undefined reference to `RPG::loadConfiguration(char*, char*)'
My first thought is, which version of DynRPG are you using? There's the original by Cherry, and the v0.30+ by PepsiOtaku and bugmenot. If you're trying to use one which the plugin you started with wasn't using, there might be some inconsistencies. Try seeing if you can compile the plugin you started with without any alterations. If you can, that means something you changed is causing your issues; if you can't, it's probably an environmental problem.
The original plugin won't work without DynRPG v0.30+ by: Andrew King (PepsiOtaku). The plugin references things that don't exist in the original DynRPG, v0.14a, thus can't be compiled. I am using Code Blocks with the GNU GCC compiler, linked with DynRPG v0.30+ lib.

Here's the original coding, which can't be compiled either without the same errors.
// ATB Overhaul
// by PepsiOtaku
// Version 1.6

#include <DynRPG/DynRPG.h>
#include <vector>

#define ATB_PARTY RPG::Actor::partyMember(i)->atbValue
#define ATB_MON RPG::monsters->atbValue

std::map<std::string, std::string> configuration;

int confAddValue;
int confHeroSpeedVarM;
int confBattlerStartVar;
int confMonsterSpeedVarM;
int confDefaultHeroSpeed;
int confDefaultMonsterSpeed;
int confAtbModeSwitch;
int confActiveSpeed;
int confWaitSpeed;
bool atbWait;
bool monsterAction = false;
bool confAgilMult;
bool condCheckFail;
bool preventEarlyResume = false;
bool animPlaying = false;
bool confStartInWaitMode = false;
bool confOnlyShowCommandWhenFocused = false;
bool confFixSelectionBarHeight = false;
bool speedInitialize = false;
int confFreezeSwitch;
std::string condExceptionSet;

std::vector<int> exceptionVect;

unsigned char frameTimer = 0;

bool onStartup (char *pluginName) {
configuration = RPG::loadConfiguration(pluginName);
confAtbModeSwitch = atoi(configuration.c_str());
confAddValue = atoi(configuration.c_str());
confAgilMult = configuration == "true";
confHeroSpeedVarM = atoi(configuration.c_str()); // Convert String to Int
confMonsterSpeedVarM = atoi(configuration.c_str());
confBattlerStartVar = atoi(configuration.c_str());
confDefaultHeroSpeed = atoi(configuration.c_str());
confDefaultMonsterSpeed = atoi(configuration.c_str());
confActiveSpeed = atoi(configuration.c_str());
confWaitSpeed = atoi(configuration.c_str());
confFreezeSwitch = atoi(configuration.c_str());
confStartInWaitMode = configuration == "true";
confOnlyShowCommandWhenFocused = configuration == "true";
confFixSelectionBarHeight = configuration == "true";
// get the condition exceptions
condExceptionSet = configuration;
std::string delimiter = ",";
size_t pos = 0;
int token;
while ((pos = condExceptionSet.find(delimiter)) != std::string::npos) {
token = atoi(condExceptionSet.substr(0, pos).c_str());
exceptionVect.push_back(token);
condExceptionSet.erase(0, pos + delimiter.length());
}
token = atoi(condExceptionSet.c_str());
exceptionVect.push_back(token);

return true;
}

void initializeSpeedVars(){
if (RPG::variables == 0) RPG::variables = confDefaultHeroSpeed;
if (RPG::variables == 0) RPG::variables = confDefaultMonsterSpeed;
}

// this will reset RPG::BattleSpeed. NOTE: RPG::battleSpeed is only set to 100 (default), 0 (for Wait Mode), or 75 (for Active Mode)
// onFrame only makes alterations to individual battler's ATB bars
void resumeAtb(){
if (atbWait) {
if (RPG::system->atbMode == RPG::ATBM_WAIT) RPG::battleSpeed = 100; // wait mode should stop the atb bar when heroes are selecting actions
else RPG::battleSpeed = confActiveSpeed; // active mode should still move the atb bar by the % set in confActiveSpeed (100 is the default speed)
atbWait = false;
}
}

void onNewGame(){
// initialize the master speed variables based on what's in DynRPG.ini
initializeSpeedVars();
if (RPG::switches) RPG::system->atbMode = RPG::ATBM_ACTIVE;
else RPG::system->atbMode = RPG::ATBM_WAIT;
}

void onLoadGame(int id, char *data, int length) {
// initialize the master speed variables based on what's in DynRPG.ini
//initializeSpeedVars(); // Probably shouldn't do this onLoadGame because saves might have them set to something else
// initialize the Active/Wait system based on what the ATB Mode Switch is in the save file
if (RPG::switches) RPG::system->atbMode = RPG::ATBM_ACTIVE;
else RPG::system->atbMode = RPG::ATBM_WAIT;
speedInitialize = false; // Just in case
}

bool onSetSwitch(int id, bool value) {
// if ATBmodeSwitch is on, set it to active, otherwise if off, set to wait
if (id == confAtbModeSwitch) { // this was moved from ragnadyn since it was more appropriate here
if (value) RPG::system->atbMode = RPG::ATBM_ACTIVE;
else RPG::system->atbMode = RPG::ATBM_WAIT;
} else if (id == confFreezeSwitch) {
if (value) {
// same as @halt_atb but other plugins can call it
if (RPG::system->atbMode == RPG::ATBM_WAIT) RPG::battleSpeed = confWaitSpeed; // wait mode should stop the atb bar when heroes are selecting actions
else RPG::battleSpeed = confActiveSpeed;
atbWait = true;
preventEarlyResume = true;
} else {
// same as @resume_atb
preventEarlyResume = false;
resumeAtb();
}
}
return true;
}

void initHeroSpeed() {
// Initialize hero speed variables
for (int i=0; i<4; i++){
RPG::variables = RPG::variables;
}
}

void initMonsterSpeed() {
// Initialize monster speed variables
for (int i=0; i<8; i++){
RPG::variables = RPG::variables;
}
}

void onDrawScreen() {
// This has to be onDrawScreen because F12 calls the reset game function before onFrame is called or something (fun)
if (RPG::isBattleTest && (GetKeyState(VK_F12) & 0x8000)) {
speedInitialize = false;
}
}

void onFrame (RPG::Scene scene){
if (scene == RPG::SCENE_BATTLE)
{
// Set Active/Wait if starting up a test battle
if (RPG::isBattleTest && (RPG::variables != confDefaultHeroSpeed)) {
if (confStartInWaitMode) {
RPG::system->atbMode = RPG::ATBM_WAIT; // wait mode should stop the atb bar when heroes are selecting actions
if (confAtbModeSwitch > 0) RPG::switches = false;
} else {
RPG::system->atbMode = RPG::ATBM_ACTIVE;
if (confAtbModeSwitch > 0) RPG::switches = true;
}
initializeSpeedVars();
}
// Speed initialization at start of battle
if (RPG::battleData->battlePhase == RPG::BPHASE_BATTLE && !speedInitialize) {
initHeroSpeed();
initMonsterSpeed();
speedInitialize = true;
}
if (!atbWait) { // do not do the following if the ATB bar is set to 0 or a monster is performing an action
frameTimer++;
if (frameTimer > 10)
{
frameTimer = 0;
animPlaying = false;
for (int i=0; i<8; i++)
{
if (RPG::monsters) if (RPG::monsters->animData->isAnimationPlaying) animPlaying = true;
// Heroes
if (i<4 && RPG::Actor::partyMember(i)) {
if (RPG::Actor::partyMember(i)->animData->isAnimationPlaying) animPlaying = true;
for (unsigned int j=0; j<exceptionVect.size(); j++)
{
if (RPG::Actor::partyMember(i)->conditions[exceptionVect] != 0)
{
ATB_PARTY = 0;
condCheckFail = true;
break;
} else condCheckFail = false;
}
if (!condCheckFail) // Just check this first
{
//printf("onFrame: party condition checks\n");
if ((RPG::Actor::partyMember(i)->conditions == 0 // ... the hero is alive
&& RPG::Actor::partyMember(i)->actionStatus == RPG::AS_IDLE // ... the hero is idle
&& RPG::battleData->battlePhase == RPG::BPHASE_BATTLE) // ... the hero has not yet won the battle
&& !animPlaying
// 14 is the animation id for battle won for whatever reason-- should be 11
&& !RPG::switches // Other plugins need a means of freezing battle
)
{
if (ATB_PARTY < 300000) {
if (confAgilMult == true)
ATB_PARTY = ATB_PARTY + ((confAddValue*RPG::Actor::partyMember(i)->getAgility())*RPG::variables);
else ATB_PARTY = ATB_PARTY + (confAddValue*RPG::variables);
} else {
ATB_PARTY = 300000;
}
if (ATB_PARTY < 0)
ATB_PARTY = 0;
}
}
}

// Monsters
if (RPG::monsters)
{
for (unsigned int j=0; j<exceptionVect.size(); j++)
{
if (RPG::monsters->conditions[exceptionVect] != 0)
{
condCheckFail = true;
break;
} else condCheckFail = false;
}
if (!condCheckFail) // Just check this first
{
if ((RPG::monsters->conditions == 0 // the monster is alive
)//&& RPG::monsters->actionStatus == RPG::AS_IDLE)
&& !animPlaying
&& !RPG::switches // Other plugins need a means of freezing battle
&& (!RPG::battleData->winMonTarget->choiceActive || !RPG::battleData->winPartyTarget->choiceActive
|| !RPG::battleData->winItem->choiceActive || !RPG::battleData->winSkill->choiceActive)
)
{
if (ATB_MON < 300000) {
if (confAgilMult == true)
ATB_MON = ATB_MON + (((confAddValue* RPG::monsters->getAgility())*RPG::variables)/2);
else ATB_MON = ATB_MON + ((confAddValue*RPG::variables)/2);
} else {
ATB_MON = 300000;
}
if (ATB_MON < 0)
ATB_MON = 0;
}
}
}
}
}
}
if (RPG::battleData->battlePhase != RPG::BPHASE_BATTLE) {
speedInitialize = false;
}

} else if (atbWait && scene != RPG::SCENE_BATTLE) {
resumeAtb();
frameTimer = 0;
speedInitialize = false;
}
}

void setCursorHeight(RPG::Window *&window) {
if (window) {
if (window->cursorHeight != 16) {
window->cursorHeight = 16;
window->updateCursor(window->currentChoice);
}
}
}

// anytime the battle status window refreshes
bool onBattleStatusWindowDrawn(int x, int selection, bool selActive, bool isTargetSelection, bool isVisible) {
if (confOnlyShowCommandWhenFocused) {
if (RPG::battleData->winCommand->choiceActive) {
RPG::battleData->winCommand->x = 244;
} else {
RPG::battleData->winCommand->x = 320;
}
}
if (RPG::system->scene == RPG::SCENE_BATTLE && confFixSelectionBarHeight) {
setCursorHeight(RPG::battleData->winCommand);
setCursorHeight(RPG::battleData->winItem);
setCursorHeight(RPG::battleData->winSkill);
}

if (isTargetSelection && (RPG::battleData->winMonTarget->choiceActive || RPG::battleData->winPartyTarget->choiceActive ||
RPG::battleData->winItem->choiceActive || RPG::battleData->winSkill->choiceActive)) {
atbWait = true;
RPG::battleSpeed = 0;
} else {
if (atbWait && RPG::battleSpeed == 0 && RPG::system->atbMode == RPG::ATBM_ACTIVE && !preventEarlyResume) {
resumeAtb();
if (RPG::battleData->winParty->choiceActive || RPG::battleData->winCommand->choiceActive) atbWait = true;
}
}

if ((selActive && !atbWait)
|| (atbWait && (RPG::battleData->winParty->choiceActive || RPG::battleData->winCommand->choiceActive))) {
if (RPG::system->atbMode == RPG::ATBM_WAIT) RPG::battleSpeed = confWaitSpeed; // wait mode should stop the atb bar when heroes are selecting actions
else RPG::battleSpeed = confActiveSpeed; // active mode should still move the atb bar by the % set in confActiveSpeed (100 is the default speed)
atbWait = true;
}

// if the party member dies (or has a condition with a status restriction) while the status window was open
if (selection >= 0 && selection < 4 && !isTargetSelection && selActive) {
if (RPG::Actor::partyMember(selection))
{
for (unsigned int j=0; j<exceptionVect.size(); j++)
{
if ((RPG::Actor::partyMember(selection)->conditions != 0) ||
(RPG::Actor::partyMember(selection)->conditions[exceptionVect] != 0)) {
// Nailed it!
RPG::battleData->winCommand->choiceActive = false;
RPG::battleData->winItem->choiceActive = false;
RPG::battleData->winSkill->choiceActive = false;
RPG::battleData->winMonTarget->choiceActive = false;
RPG::battleData->winPartyTarget->choiceActive = false;

RPG::battleData->winParty->choiceActive = true;
if (RPG::battleData->readyPartySlot != -1) {
//RPG::battleData->winParty->choiceActive = true;
RPG::battleData->winParty->currentChoice = RPG::battleData->readyPartySlot;
} else {
//RPG::battleData->winParty->choiceActive = false;
}
RPG::Actor::partyMember(selection)->atbValue = 0;
resumeAtb(); // resume the ATB bar
break;
}
}
}
}
return true;
}

bool onDoBattlerAction(RPG::Battler* battler, bool firstTry) {
atbWait = true;
RPG::battleSpeed = 0;
return true;
}
bool onBattlerActionDone(RPG::Battler* battler, bool success) {
if (success && RPG::system->atbMode == RPG::ATBM_WAIT) resumeAtb();
return true;
}

// do not move ATB bar when event commands are running
bool onEventCommand(RPG::EventScriptLine* scriptLine, RPG::EventScriptData* scriptData,
int eventId, int pageId, int lineId, int* nextLineId) {
if (RPG::system->scene == RPG::SCENE_BATTLE && eventId == 0) { // battle events
if (scriptData->currentLineId == 0) // when an event page starts
// *******************************************************
atbWait = true;
// *******************************************************
else if (scriptLine->command == RPG::EVCMD_END_OF_EVENT) // when an event page ends
resumeAtb();
}
return true;
}

bool onComment ( const char* text,
const RPG::ParsedCommentData* parsedData,
RPG::EventScriptLine* nextScriptLine,
RPG::EventScriptData* scriptData,
int eventId,
int pageId,
int lineId,
int* nextLineId )
{
std::string cmd = parsedData->command;
if(!cmd.compare("init_hero_speed"))
{
initHeroSpeed();
return false;
}
if(!cmd.compare("init_monster_speed"))
{
initMonsterSpeed();
return false;
}
if(!cmd.compare("condition_speed_check"))
{
// parameter 1: condition ID
if (parsedData->parametersCount >= 3 && parsedData->parameters.type == RPG::PARAM_NUMBER
&& parsedData->parameters.type == RPG::PARAM_NUMBER
&& parsedData->parameters.type == RPG::PARAM_NUMBER) {
for (int i=0; i<8; i++){
if (i<4){
if (RPG::Actor::partyMember(i)) {
if (RPG::Actor::partyMember(i)->conditions[parsedData->parameters.number] != 0)
RPG::variables = parsedData->parameters.number;
}
}
if (RPG::monsters) {
if (RPG::monsters->conditions[parsedData->parameters.number] != 0)
RPG::variables = parsedData->parameters.number;
}
}
}
return false;
}
if(!cmd.compare("halt_atb"))
{
if (RPG::system->atbMode == RPG::ATBM_WAIT) RPG::battleSpeed = confWaitSpeed; // wait mode should stop the atb bar when heroes are selecting actions
else RPG::battleSpeed = confActiveSpeed;
atbWait = true;
preventEarlyResume = true;
return false;
}
if(!cmd.compare("resume_atb"))
{
preventEarlyResume = false;
resumeAtb();
return false;
}
return true;
}

void onExit() {
exceptionVect.clear();
}

I did some further testing and I can compile, no problem, with DynRPG v0.14a using a different plugin, but I always get errors with v0.30+, using version-specific callbacks from that version.
About the only thing I can think of is maybe your project environment is set up to reference v0.14a, so whenever the code tries to do something v0.30+ specific it can't find it.
How would I fix that? I tried deleting the old lib and getting a fresh copy of v0.30+ to replace it, but I still get the errors. I also tried directly placing the lib in code blocks and directly linking it from there, but still the same thing happens. I could just use v0.14a to make plugins, but it's quite limited compared to v0.30+.

Edit: I got less errors, but still can't compile.

obj\Release\battle_atb_overhaul.o:battle_atb_overhaul.cpp:(.text+0x1a2): undefined reference to `RPG::DStringPtr::DStringPtr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)'

obj\Release\battle_atb_overhaul.o:battle_atb_overhaul.cpp:(.text+0x5e8): undefined reference to `RPG::DStringPtr::s_str()'

obj\Release\battle_atb_overhaul.o:battle_atb_overhaul.cpp:(.text+0x67a): undefined reference to `RPG::DStringPtr::operator=(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)'

obj\Release\battle_atb_overhaul.o:battle_atb_overhaul.cpp:(.text+0xc96): undefined reference to `RPG::DStringPtr::DStringPtr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)'

obj\Release\battle_atb_overhaul.o:battle_atb_overhaul.cpp:(.text+0xdec): undefined reference to `RPG::DStringPtr::DStringPtr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)'

obj\Release\battle_atb_overhaul.o:battle_atb_overhaul.cpp:(.text+0x2e3a): undefined reference to `RPG::loadConfiguration(char*, char*)'


Edit2: I noticed this address doesn't seem right, but I'm new to code blocks so I am unsure.

Program Files (x86)/CodeBlocks/MinGW/bin/../lib/gcc/mingw32/5.1.0/../../../../mingw32/bin/ld.exe: obj\Release\battle_atb_overhaul.o: bad reloc address 0x44 in section `.rdata'
collect2.exe: error: ld returned 1 exit status


EDIT3: I have successfully compiled the plugin. It was the compiler not being configured correctly. Thanks for your input. Hopefully I won't run into anymore issues compiling plugins.
On another note, am I allowed to submit plugins that are built upon, credit included of course? I am currently adding code to the ATB Overhaul plugin to create a turn based system, but I'm not sure if I can submit my plugin if I used someones else' plugin as the base. I would credit them of course.
That would be a question for site admin, and you might try PMing PepsiOtaku to see if he minds. I doubt there'd be any issue.
Will do, but I might actually just make my own plugin now. While messing with the ATB plugin I noticed I could just create an addendum plugin to work in conjunction with the ATB plugin to create a turn based system.
Can someone explain how to use this?

int RPG::Battler::getSkillPower( int skillId, RPG::Battler* target)

When I use something like this,

RPG::variables = RPG::Actor::partyMember(partyIndex)->getSkillPower(skillIndex, RPG::monsters(partyIndex));

I get a return of 0. If partyindex is 1, should it not return the damage value of partymember(1) using the defined skill on monster(1)? I should mention I use a comment command to retrieve this info whenever a battler makes an action. Perhaps the return value is 0 because the comment command asks for the info at an invalid time, but if that is so then is there anything I can do?
My first thought is, how many actors and how many monsters are there in the scenario you're working with? If partyIndex is 1, RPG::Actor::partyMember and RPG::monsters will actually retrieve info from the second actor and monster, because they're zero-based. So if there isn't a second actor or second monster (or maybe the second monster has an immunity to the skill involved or something), maybe that would cause the result you're seeing.
I created a monster group with 5 monsters, all the same, and 1 hero. It still returned a value of 0. I think the problem is I am using a comment command to retrieve the value. I'm using this site for info.

http://www.rewking.com/dynrpg/class_r_p_g_1_1_battler.html#a4d1ffd6c081a092756e8340a54ca5c60

I've tried using RPG::Battler::getAttributeResist, RPG::Battler::getAttackPower, and RPG::Battler::getSkillPower, but I can't get them to work. Perhaps I am misunderstanding how to properly use them. Here is the code I am using for now.

if( 0 == cmd.compare( "dyndataaccess_get_skill_power" ) )
{ // Returns Skill damage before hits.
// Parameter 0: The index of the RM2K3 variable to store data
variableIndex = (int) parsedData->parameters.number;
// Parameter 1: The party index of the actor
partyIndex = (int) parsedData->parameters.number - 1;
// Parameter 2: Database ID of the skill
skillIndex = (int) parsedData->parameters.number;
// Store the data in the RM2K3 variable
RPG::variables(variableIndex) = RPG::Actor::partyMember(partyIndex)->getSkillPower(skillIndex, RPG::monsters(partyIndex));


I also tried this using this,
RPG::variables(variableIndex) = RPG::Actor::partyMember(0)->getSkillPower(11, RPG::monsters(0));
This should return the value of the 1st party member using the 11th skill on enemy 1, but it returns 0 still.
I don't see anything wrong with how you're doing it. I've never tried using any of those get functions myself.
I tried the other get commands, HP, MP, etc and I have no issue with those. I think maybe those 3 functions aren't actually implemented or need to be used in a very specific way. I ended up finding a work around, for what I needed, so I guess it worked out. I just got the skill info, user stats, and target stats and calculated the skill power manually.
I went and tried my code again and it worked this time. After looking at my posted code, I noticed I didn't define skillIndex as an int variable by using () around it when referencing it. All good now.
Does anyone know what this error means, "cannot load 'plugin name' plugin (DynRPG 1114)". This error occurs when I load up the game with my plugin. There are no compiling errors either. This occurs when I declare an object from the Window or Image class and try to run a function with it. I've narrowed the error to just these two lines of code.

RPG::Window myWindow; //Happens with an Image class too.
myWindow.create(64, 64, 16, 16, false);


The game will load after the plugin error, but the plugin clearly isn't loaded. I've made sure that I am using the correct compiler and correct version of DynRPG for my game and header, multiple times, so I'm pretty sure that isn't my issue. I am using CodeBlocks to make the plugin.

I also run into a compiling error when pointing to certain Window objects, such as "RPG::SceneFile->winInfo* winPtr;". This will result in the error "expected unqualified-id before '->' token".
I don't have time right now to actually try things and verify how it works myself, but I think your problem may have to do with treating classes as objects and similar syntax errors. If your attempts to use Image look like what you did with Window above, then that definitely wouldn't work. The Image class's create function is static, which means it's used like this:

RPG::Image * imagePtr = RPG::Image::create();


That said, the Window class appears to be different, so I'm not sure how it works without playing with it.

Similarly, RPG::SceneFile is a class, not an object or a pointer to an object. What you want is RPG::fileSaveLoad, which is a static reference to the actual object. I think it should look like this:

RPG::WindowSaveFile * winPtr = RPG::fileSaveLoad->winInfo[index];

Isn't "RPG::Image myImage;" supposed to create an object of class "Image"? Won't this "RPG::Image * imagePtr = RPG::Image::create();" just create a pointer "Ptr" to the address of function "RPG::Image::create();"? It doesn't actually call the function and if it did you would get a compiling error because you called the function without an object. I am still learning c++, so I am probably wrong here.

So I have tried adding your line of code to this, but it doesn't result in anything happening.
RPG::Image * imagePtr = RPG::Image::create(320,240); //This calls the function to create a new image, right?
RPG::Image myImage; //This declares the Image object for RPG::Image::drawString, right?
textString = "This is a test."; //string was declared earlier, used for drawString function
myImage.drawString(96, 96, textString, 1); //draws a string of variable textString to the new image???

So what am I doing wrong here? By declaring object "RPG::Image myImage;" it should inheret all functions of class Image, so shouldn't I be using "myImage.create();"? Even if I do this though, it still results in nothing happening in game. Both lines of code compile no errors too.

Sorry if my questions sound really dumb, still learning.

Edit: I noticed the text plugin requires you to show a picture before being able to draw text, so maybe there are more steps required then calling the function? Unfortunately the text plugin isn't open source, so I can't open it up and see how he made it work.

Edit2: So I ran into another issue, kinda unrelated, but I was wondering if you knew why my static int AGI(11) = {} variable would overflow when writing to AGI(11) = new value in a for loop? I had to extend my array to 12 to solve the problem, but I have other variables write no problem to the last element in the array. Arrays start from arr(0) don't they, but for some reason doing this overflows it.
for(i=0; i<8; i++)
AGI(i+4) = new value
//This one line overflows the variable when "i" is equal to 7 and I have tried using just AGI(11) to confirm it.

It wasn't until I tried compiling with AGI(11) instead of AGI(i+4) that my compiler told me about an overflow. Also I am using the correct syntax in my code, but rpgmaker.net won't allow me to use brackets to show my code accurately.

No worries, this stuff is tricky, especially if you learned programming via another language (more common than not these days). There are assumptions which don't always carry over from one language to another, especially the older ones.

If you take a look at the documentation page for the Image class, you might notice that there's no public member function called "Image" for declaring a new object of that type (the constructor). The constructor does exist, but it's private, so that only the the class itself can call it. Instead, it has several variants of "create" and a "destroy" function. This is a programming pattern called "object factory", where a class has specialized functions for creating objects of itself rather than allowing use of the constructor. It allows the class to set various things up and prevent other code from doing potentially bad stuff. Don't worry too much if this goes over your head, I'm just explaining so you know there's a reason for it.

The DynRPG Getting Started page has an example project which includes using Images, although it's a bit obscured by the fact that they're held in a std::map data structure. The basic idea is that you declare a variable that's a pointer to an Image (not an Image directly), and set that equal to the result of the create function. Then you can use that pointer to manipulate the Image.

For the arrays question, when you declare an array in C++, the number isn't the highest index, it's the SIZE of the array. It does start at 0, so the highest index is 1 less than the size -- from 0 to 10 in the example you gave with size 11. Some other languages give you 0 to 11 just to be safe, or even automatically increase the size of the array for you if you use an overflow index.
Okay, so I understand how Image classes work now, but they don't work... I am able to load the images, but they're always invisible. Every line of code runs with no errors, but for some reason my image is invisible, I think. Here is the code I used.
RPG::Image* myImage = RPG::Image::create();
myImage->useMaskColor = false;
myImage->alpha = 255;
std::string pathName;
pathName = "Picture\\Monster1.png";
myImage->loadFromFile(pathName, true);
RPG::screen->canvas->draw(160, 120, myImage);

I more or less did the same thing the tutorial does, but without the loops and multiple images. I ran a debugger to make sure every line executed properly and it seemingly did, but no Image appears afterwards.

I have been reading the Image header and other header files of DynRPG to try and better understand how to call these functions, but still can't understand the Window functions, but I will continue to experiment.

I thought an array's size was how many bytes the array variable is. So if I am to understand correctly an array index is equal to the Index minus 1? For example int arr(5) would begin at index arr(0) and end at index arr(4), for a total length of 5 and size of 4? It is weird that I have never ran into an issue before by using arrays that were too small in my code till now. I guess I just got lucky with my compiler.

Edit: So I got it to work in battle, but not overworld, still comes up invisible. I used the same code on both.