// -----------------------------------------------------------------------------
// Place some text (called from another add-on)
// -----------------------------------------------------------------------------
GSErrCode __ACENV_CALL CreateTextCommandHandler (GSHandle parHdl, GSPtr resultData, bool silentMode)
{
UNUSED_PARAMETER (resultData);
TextParams params;
TextParamsInd parHdlInd;
bool ok;
GSErrCode err = NoError;
// setup command parameters
DefaultParams (¶ms);
ProcessParams (¶ms, &parHdlInd, parHdl);
if (!silentMode) {
ok = InputParams (¶ms, &parHdlInd);
if (!ok)
return NoError;
// return parameters modified in the dialog
ModifyParams (¶ms, &parHdlInd, parHdl);
}
// do the job
err = CreateAText (¶ms);
return err;
} // CreateTextCommandHandler
static void Do_CreateAText ()
{
bool okHit;
TextParams textPars;
Int32 version = 0;
GSSize nBytes = 0;
unsigned short platformSign = GS::Act_Platform_Sign;
BNZeroMemory (&textPars, sizeof (TextParams));
ACAPI_GetPreferences_Platform (&version, &nBytes, NULL, NULL);
if (version == 1 && nBytes == sizeof (TextParams)) {
ACAPI_GetPreferences_Platform (&version, &nBytes, &textPars, &platformSign);
if (platformSign != GS::Act_Platform_Sign) {
GS::PlatformSign inplatform = (GS::PlatformSign) platformSign;
IVShort (inplatform, &textPars.pen);
IVShort (inplatform, &textPars.filler_1);
IVLong (inplatform, &textPars.filler_2);
IVDouble (inplatform, &textPars.size);
// char content [256];
}
} else
DefaultParams (&textPars);
okHit = InputParams (&textPars, NULL);
if (okHit) {
ACAPI_SetPreferences (1, sizeof (TextParams), &textPars);
CreateAText (&textPars);
}
return;
} // Do_CreateAText
void ConvertToMode4(std::map<std::string, ImageInfo>& images, std::vector<Image8Bpp>& images8)
{
DefaultParams();
std::vector<Image16Bpp> images16;
ConvertToMode3(images, images16);
Image8BppScene scene(images16, "");
for (unsigned int i = 0; i < scene.NumImages(); i++)
images8.emplace_back(scene.GetImage(i));
}
void ConvertToMode0(std::map<std::string, ImageInfo>& images, std::vector<Map>& maps, int bpp)
{
DefaultParams();
params.bpp = bpp;
std::vector<Image16Bpp> images16;
ConvertToMode3(images, images16);
MapScene scene(images16, "", bpp);
for (unsigned int i = 0; i < scene.NumImages(); i++)
maps.emplace_back(scene.GetMap(i));
}
PhysicsSpace::PhysicsSpace(const PhysicsSpace &source) :
Inherited(source)
{
_ContactJoints.resize(MAX_PHYS_CONTACTS);
_ColJointGroupId = dJointGroupCreate(0);
if(getDefaultCollisionParameters() == NULL)
{
CollisionContactParametersUnrecPtr DefaultParams(createDefaultContactParams());
setDefaultCollisionParameters(DefaultParams);
}
}
//------------------------------------------------------------------------
void CWeapon::RequestReload()
{
CActor *pActor=GetOwnerActor();
if (!gEnv->bServer && pActor && pActor->IsClient())
{
GetGameObject()->InvokeRMI(SvRequestReload(), DefaultParams(), eRMI_ToServer);
}
else if (IsServer())
{
SvSetReloadState(eNRS_StartReload);
}
}
//------------------------------------------------------------------------
void CWeapon::RequestStopFire()
{
CActor *pActor=GetOwnerActor();
if (!gEnv->bServer && pActor && pActor->IsClient())
{
GetGameObject()->InvokeRMI(CWeapon::SvRequestStopFire(), DefaultParams(), eRMI_ToServer);
}
else if (IsServer())
{
NetSetIsFiring(false);
}
}
void ConvertToSprites(std::map<std::string, ImageInfo>& images, std::vector<Sprite>& sprites, std::vector<PaletteBank>& banks, int bpp, bool for_bitmap)
{
DefaultParams();
params.bpp = bpp;
params.for_bitmap = for_bitmap;
std::vector<Image16Bpp> images16;
ConvertToMode3(images, images16);
SpriteScene scene(images16, "", false, bpp);
scene.Build();
for (unsigned int i = 0; i < scene.NumImages(); i++)
sprites.emplace_back(scene.GetSprite(i));
banks = scene.paletteBanks.banks;
}
void ConvertToMode3(std::map<std::string, ImageInfo>& images, std::vector<Image16Bpp>& images16)
{
DefaultParams();
for (const auto& filename_imageinfo : images)
{
const auto& filename = filename_imageinfo.first;
const auto& info = filename_imageinfo.second;
for (auto image : info.GetImages())
{
Magick::Geometry geom(info.GetWidth(), info.GetHeight());
geom.aspect(true);
image.resize(geom);
images16.emplace_back(Image16Bpp(Image32Bpp(image, info.GetName(), filename, image.scene(), info.IsAnimated())));
}
}
}
//-----------------------------------------------------------------------
void CWeapon::RequestCancelReload()
{
CActor *pActor=GetOwnerActor();
if (!gEnv->bServer && pActor && pActor->IsClient())
{
if(m_fm)
{
m_fm->CancelReload();
}
GetGameObject()->InvokeRMI(SvRequestCancelReload(), DefaultParams(), eRMI_ToServer);
}
else if (IsServer())
{
SvCancelReload();
}
}
int main(int argc, char* argv[]) {
Params params = DefaultParams();
ParseArguments(argc, argv, params);
PossibleHotspotsDistribution::ValidateIndexLimits(params.startIndex, params.endIndex);
StandardizeDirectoryNames(params);
printf("===============================================================\n");
#ifdef using_parallel
printf("Number of cores: %4d\n", omp_get_num_procs());
printf("Max number of OpenMP threads: %4d\n\n", omp_get_max_threads());
#endif
printf("Grid resolution: %4d\n", params.gridRes);
printf("Grid increment: %4d\n", params.increment);
printf("Abcd space chunking interval: %4d\n\n", params.interval);
std::string infile = params.dataDir + params.inputFile;
printf("Input file is \"%s\".\n", infile.c_str());
ObservedHotspots observedHotspots(infile);
if(params.deduplicateObserved){
observedHotspots.RemoveDuplicates();
}
observedHotspots.Iterate(PrintCoord, NULL);
printf("\n");
AbcdSpaceLimits limits(observedHotspots);
limits.PrintToFile(stdout);
printf("\n");
printf("Checking whether to generate a partial file, based on # of possible hotspots.\n");
PossibleHotspotsDistribution::AdjustStartEndIndices(limits, params.startIndex, params.endIndex);
bool isPartial = PossibleHotspotsDistribution::IsPartial(params.startIndex, params.endIndex);
printf("\n");
if(isPartial)
AddPartialSubdirToPath(params.outputDir, params.startIndex, params.endIndex);
if(params.outputStatus)
MakeDirectoryRecursive(params.outputDir + params.statusDir);
else
MakeDirectoryRecursive(params.outputDir);
if(isPartial) {
printf("GENERATING PARTIAL FILE\n");
printf("Start index: %4d\n", params.startIndex);
printf("End index: %4d\n\n", params.endIndex);
}
std::string outfile = params.outputDir + params.inputFile;
std::ifstream src(infile.c_str());
std::ofstream dst(outfile.c_str());
dst << src.rdbuf();
printf("Copied input file to \"%s\".\n", outfile.c_str());
limits.PrintToFile(params.outputDir + params.limitsFile);
printf("\n");
AbcdSpaceProbabilityDistribution abcdDist(observedHotspots, limits, 1, 5);
abcdDist.PrintToFile(params.outputDir + params.abcdDistFile);
printf("\n");
RegenerateMatrix* regenMat = NULL;
std::string inMfile = params.dataDir + params.mFile;
std::ifstream srcM(inMfile.c_str());
if(srcM)
{
std::string outMfile = params.outputDir + params.mFile;
std::ofstream dstM(outMfile.c_str());
dstM << srcM.rdbuf();
printf("Copied M file to \"%s\".\n", outMfile.c_str());
regenMat = new RegenerateMatrix(inMfile);
printf("\n");
}
std::string statusFullDir;
if(params.outputStatus)
statusFullDir = params.outputDir + params.statusDir;
else
statusFullDir = "/dev/null";
PossibleHotspotsDistribution possibleHotspots(observedHotspots, limits, regenMat, params.gridRes, params.increment, params.interval,
params.deduplicateObserved, statusFullDir, params.startIndex, params.endIndex);
possibleHotspots.PrintToFile(params.outputDir + params.possibleHotspotsFile);
if(!isPartial) {
printf("\nFinding nonremovable possible hotspots:\n");
PossibleHotspotsDistribution nonremovableHotspots(limits, true);
nonremovableHotspots.PrintToFile(params.outputDir + params.nonremovableHotspotsFile, false);
Double accumProb = possibleHotspots.GetTotalProbability(nonremovableHotspots);
std::string filename = params.outputDir + params.nonremovableProbFile;
FILE* file = fopen(filename.c_str(), "w");
if(!file) {
printf("Error: Could not open file for writing: \"%s\"\n", filename.c_str());
exit(EXIT_FAILURE);
}
fprintf(file, "Probability of getting a nonremovable & non-removing point next month:\n");
fprintf(file, "%.36Lg%%\n", 100*accumProb);
fprintf(file, "Probability of getting a removable & removing point next month:\n");
fprintf(file, "%.36Lg%%\n", 100*(1-accumProb));
fclose(file);
printf("\nPrinted nonremovable & removable probabilities to file: \"%s\".\n", filename.c_str());
printf("\nProbability of getting a nonremovable & non-removing point next month:\n");
printf("%.36Lg%%\n", 100*accumProb);
printf("Probability of getting a removable & removing point next month:\n");
printf("%.36Lg%%\n", 100*(1-accumProb));
}
return EXIT_SUCCESS;
}
