<< Back to Code Snippet & Analysis #001
Code Snippet #001
///ULTIMATE TRINITY SCRIPT
//this fills txtLinesWBreaks[w] & txtULBlanks[w] && gets position for underlining (AND DOES SO FOR NO-SPACES AND FOR LARGE FONT WITHOUT CRASHING)
//and it accommodates the new Titles-With-Blanks Engine ™
var i, w, pos_space, pos_current, text_current, text_output, text_full, text_full2, fat_storage, num_of_spaces, num_of_spaces2, pos_space2, pos_current2, p, txtULBlanksSpacelessTest, pos_currentBlankCheck;
pos_space = -1;
pos_current = 1;
w = 1;
text_full = “”;
text_full2 = “”;
fat_storage = “”;
num_of_spaces = 0;
num_of_spaces2 = 0;
pos_space2 = -1;
pos_current2 = 1;
p = 0;
txtULBlanksSpacelessTest = “”;
pos_currentBlankCheck = 0;
if textUpdated = 1
{
instance_destroy(obj_assembledBlank);
maxStringHeight = string_height(global.stringForHeight)*global.fontScaleReadLib;
//numReadLibLinesDisplayed
//imposedBreakLineMax (not global)
//scrolledPageReadLib
//maxPageScrollReadLib
///10-15-19///SPECIAL NEW: TITLE, EQUIPPED FOR BLANKS
//All I did was change i=1 to i=0 for the main for loop below here.
/////…That was wonky. Let’s try it anyway.
//Here goes.
//These are all being declared here for the first time. No expected issued with that yet.
txtTitleReadLib = string_replace_all(txtLinesAll[0], “=========”, “”);
txtTitleReadLib = string_replace_all(txtTitleReadLib, “+++++++++”, “”);
txtTitleReadLibOG = txtTitleReadLib;
txtTitleReadLib2 = “”;
txtULTitle = txtLinesAll[0];
fontScaleReadLibNarrow = 1;
posCurrentTitle = 1;
posSpaceTitle[0] = -1;
sizeDifference[0] = 0;
isSpaceTitle = 0;
numSpacesTitle = 0;
leastPositiveDifference = string_width(txtTitleReadLib)*global.fontScaleReadLibTitle;
leastNegativeDifference = string_width(txtTitleReadLib)*global.fontScaleReadLibTitle;
if string_width(txtTitleReadLib)*global.fontScaleReadLibTitle > global.readLibTitleBoxWidth //if it does NOT just plain fit, then…
{
//Plan A:
//We squash it until a certain ratio
//If this does not work…
while string_width(txtTitleReadLib)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth && fontScaleReadLibNarrow >= 0.72
{
fontScaleReadLibNarrow -= 0.02;
}
//Plan B REDO: (This IF contains Plans B, C, and D)
//We UNSQUASH it and linebreak at the halfway point, favoring bottom-as-longer
//First: Go through and find all positions of spaces
//Second: Break at the different spaces to find leastPositive and leastNegative
//Third: Use leastPositive UNLESS it is a certain ratio bigger than leastNegative
if string_width(txtTitleReadLib)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth // && if the ratios work out to permit 2 lines in title
{
fontScaleReadLibNarrow = 1;
//This while loop: Get position of all spaces in txtTitleReadLib
while (string_length(txtTitleReadLib) >= posCurrentTitle)
{
if (string_char_at(txtTitleReadLib,posCurrentTitle) == ” “)
{
posSpaceTitle[numSpacesTitle] = posCurrentTitle;
numSpacesTitle += 1;
isSpaceTitle = 1;
}
posCurrentTitle += 1;
}
//first, here’s what we’ll do if there were no spaces: (READ COMMENTS BELOW — SPACELESS SEEMS INCOMPLETE)
var gonnaUseSpaceless = 0;
if isSpaceTitle == 0
{
//go character by character, looking for the closest ratio. cut when it starts to get bigger.
var spacelessRatio = 0;
for (i = 1; i <= string_length(txtTitleReadLib); i++)
{
txtSpacelessTop = string_copy(txtTitleReadLib, 1, i) + “-“;
txtSpacelessBottom = string_delete(txtTitleReadLib, 1, i);
spacelessRatio = (string_width(txtSpacelessBottom)*global.fontScaleReadLibTitle)/(string_width(txtSpacelessTop)*global.fontScaleReadLibTitle);
if spacelessRatio < 1
{
//now we check: if both lines don’t fit! (then we know the whole thing is TOO LONG to fit)
if string_width(txtSpacelessBottom)*global.fontScaleReadLibTitle > global.readLibTitleBoxWidth && string_width(txtSpacelessTop)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth
{
while fontScaleReadLibNarrow >= 0.72 && string_width(txtSpacelessBottom)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth && string_width(txtSpacelessTop)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth
{
fontScaleReadLibNarrow -= 0.02;
}
//if it still doesn’t fit after full narrowing (0.7)
if string_width(txtSpacelessBottom)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth && string_width(txtSpacelessTop)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth //aka it didn’t fit
{
//we’re gonna have to manually max the topline + “-” and the bottom line + “…”
var q = 1;
while (q <= string_length(txtTitleReadLibOG)) && gonnaUseSpaceless == 0
{
txtSpacelessTop = string_copy(txtTitleReadLibOG, 1, q);
if string_width(txtSpacelessTop)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow + string_width(“-“)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth && q >= 2
{
gonnaUseSpaceless = 1;
txtTitleReadLib = string_copy(txtTitleReadLibOG, 1, q-1) + “-“;
txtTitleReadLib2 = string_delete(txtTitleReadLibOG, 1, string_length(txtTitleReadLib));
if string_width(txtTitleReadLib2)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth
{
var k = 1, bottomTrulyFilled = 0;
while (k <= string_length(txtTitleReadLib2) && bottomTrulyFilled == 0)
{
txtSpacelessBottom = string_copy(txtTitleReadLib2, 1, k);
if string_width(txtSpacelessBottom)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow + string_width(“…”)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth && k >= 2
{
bottomTrulyFilled = 1;
txtTitleReadLib2 = string_copy(txtTitleReadLib2, 1, k-1) + “…”;
}
else if k == string_length(txtTitleReadLib2) //just a strange failsafe to fill txtTitleReadLib. Logically, this should be an impossible scenario
{
txtTitleReadLib2 = “”;
}
k++;
}
}
}
else if q == string_length(txtTitleReadLibOG) //just a strange failsafe to fill txtTitleReadLib. Logically, this should be an impossible scenario
{
txtTitleReadLib = txtTitleReadLibOG;
txtTitleReadLib2 = “”;
}
q++;
}
break;
}
else //aka it did fit at some point in the Narrowing (technically including Narrow == 1, but logically only Narrow == 0.98)
{
txtTitleReadLib = txtSpacelessTop;
txtTitleReadLib2 = txtSpacelessBottom;
gonnaUseSpaceless = 1;
break;
}
}
else //AKA, if string_width(txtSpacelessBottom)*global.fontScaleReadLibTitle <= global.readLibTitleBoxWidth
{
txtTitleReadLib = txtSpacelessTop;
txtTitleReadLib2 = txtSpacelessBottom;
gonnaUseSpaceless = 1;
break;
}
}
else if i == string_length(txtTitleReadLib)
{
gonnaUseSpaceless = 0;
//don’t actually have to do anything here, I think. I bet I could delete this “if” and nothing would break ever.
//this only occurs in a case where there are no spaces, and the bottom can never be longer than the top.
//which i believe would only happen if the name was two characters or fewer, and in that case,
//txtReadLib would stay what it is already set to be.
}
}
//******************************************************
//something here looks wrong to me. Should the below “while” function on an || between ReadLib 1 and 2?
//And what if a spaceless lib is just too long? like imagine way too long? this doesn’t work. It’d have to narrow
//the whole thing (which it does here?), and then if that failed, do the top-line, already-narrow method
while string_width(txtTitleReadLib)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth && string_width(txtTitleReadLib)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth && fontScaleReadLibNarrow >= 0.72
{
fontScaleReadLibNarrow -= 0.02;
}
}
//This big while loop: Investigates the spaces. Concludes with the positions of spaces
//for leastPositive (bottom is bigger) and leastNegative (top is bigger)
//Also has the values for these “leasts” to see how disparate the lines are in length
var i = 0;
while isSpaceTitle == 1 && (i < numSpacesTitle) && (leastNegativeDifference >= string_width(txtTitleReadLib)*global.fontScaleReadLibTitle)
{
testTopString = string_copy(txtTitleReadLib,1,posSpaceTitle[i]);
testBottomString = string_copy(txtTitleReadLib,posSpaceTitle[i],string_length(txtTitleReadLib)-posSpaceTitle[i]);
sizeDifference[i] = (string_width(testBottomString)*global.fontScaleReadLibTitle)-(string_width(testTopString)*global.fontScaleReadLibTitle);
if i == 0
{
leastDifference = sizeDifference[i];
//this conditional below covers the situation of only ONE space in the title. Is it well-formed?
if numSpacesTitle == 1
{
if leastDifference >= 0
{
leastPositiveDifference = leastDifference;
posLeastPositiveDifference = posSpaceTitle[0];
}
else if leastDifference < 0
{
leastNegativeDifference = leastDifference;
posLeastNegativeDifference = posSpaceTitle[0];
}
}
}
else if i == 1 //meaning, if there are 2 spaces in the string
{
if leastDifference >= 0
{
if sizeDifference[i] >= 0
{
leastPositiveDifference = sizeDifference[i];
posLeastPositiveDifference = posSpaceTitle[i];
}
else if sizeDifference[i] < 0
{
leastPositiveDifference = leastDifference;
posLeastPositiveDifference = posSpaceTitle[0];
//debug attempt vv untested results as of 10-16-19
leastNegativeDifference = sizeDifference[i];
posLeastNegativeDifference = posSpaceTitle[i];
}
}
else if leastDifference < 0
{
leastNegativeDifference = leastDifference;
posLeastNegativeDifference = posSpaceTitle[0];
}
}
else if i >= 2 //meaning, if there are 3 or more spaces in the string
{
if sizeDifference[i] >= 0
{
leastPositiveDifference = sizeDifference[i];
posLeastPositiveDifference = posSpaceTitle[i];
}
else if sizeDifference[i] < 0
{
leastNegativeDifference = sizeDifference[i];
posLeastNegativeDifference = posSpaceTitle[i];
}
}
i++;
}
//Now we have our info about line widths… Time to see if we’re gonna use them
//THE BELOW LOGIC SEEMS REALLY GOOD AND CLEAN TO ME
var gonnaUse = -1, posRatio = 0, negRatio = 0;
if isSpaceTitle == 1
{
if leastPositiveDifference < string_width(txtTitleReadLib)*global.fontScaleReadLibTitle
{
testPosLinesTopString = string_copy(txtTitleReadLib,1,posLeastPositiveDifference);
testPosLinesBottomString = string_copy(txtTitleReadLib,posLeastPositiveDifference,string_length(txtTitleReadLib)-posLeastPositiveDifference);
//bottom is equal to or longer than top, so top/bottom is LESS THAN (or equal to) ONE (aka this value is less (or equal to) than one)
posRatio = (string_width(testPosLinesTopString)*global.fontScaleReadLibTitle)/(string_width(testPosLinesBottomString)*global.fontScaleReadLibTitle);
//so posRatio IS the ratio of bottom:top when bottom is longer
//negRatio IS the ratio of top:bottom when top is longer
//so we want to use posRatio when possible, and make the bottom longer
//but we’ll use negRatio if it’s just a lot better in terms of equal line-lengths (aka it’s much closer to 1)
}
if leastNegativeDifference < string_width(txtTitleReadLib)*global.fontScaleReadLibTitle
//if leastNegativeDifference <
{
testNegLinesTopString = string_copy(txtTitleReadLib,1,posLeastNegativeDifference);
testNegLinesBottomString = string_copy(txtTitleReadLib,posLeastNegativeDifference,string_length(txtTitleReadLib)-posLeastNegativeDifference);
//top is longer than bottom, so bottom/top is LESS THAN ONE (aka this value is less than one)
negRatio = (string_width(testNegLinesBottomString)*global.fontScaleReadLibTitle)/(string_width(testNegLinesTopString)*global.fontScaleReadLibTitle);
}
if negRatio == 0 //if the top line was never longer than the bottom…how would this event happen?
{
if string_width(testPosLinesBottomString)*global.fontScaleReadLibTitle <= global.readLibTitleBoxWidth
{
txtTitleReadLib = testPosLinesTopString;
txtTitleReadLib2 = testPosLinesBottomString;
gonnaUse = 1;
}
else {gonnaUse = 0} // redundant code? bad even? might cover fringe cases of stuff
}
else if posRatio == 0 //if the bottom line was never equal to or longer than the top
{
if string_width(testNegLinesTopString)*global.fontScaleReadLibTitle <= global.readLibTitleBoxWidth
{
txtTitleReadLib = testNegLinesTopString;
txtTitleReadLib2 = testNegLinesBottomString;
gonnaUse = 1;
}
else {gonnaUse = 0} // redundant code? bad even? might cover fringe cases of stuff
}
else if posRatio >= (negRatio + (1-negRatio)/2)
{
if string_width(testPosLinesBottomString)*global.fontScaleReadLibTitle <= global.readLibTitleBoxWidth
{
txtTitleReadLib = testPosLinesTopString;
txtTitleReadLib2 = testPosLinesBottomString;
gonnaUse = 1;
}
else if string_width(testNegLinesTopString)*global.fontScaleReadLibTitle <= global.readLibTitleBoxWidth
{
txtTitleReadLib = testNegLinesTopString;
txtTitleReadLib2 = testNegLinesBottomString;
gonnaUse = 1;
}
else {gonnaUse = 0} // redundant code? bad even? might cover fringe cases of stuff
}
else if (negRatio + (1-negRatio)/2) > posRatio
{
if string_width(testNegLinesTopString)*global.fontScaleReadLibTitle <= global.readLibTitleBoxWidth
{
txtTitleReadLib = testNegLinesTopString;
txtTitleReadLib2 = testNegLinesBottomString;
gonnaUse = 1;
}
else if string_width(testPosLinesBottomString)*global.fontScaleReadLibTitle <= global.readLibTitleBoxWidth
{
txtTitleReadLib = testPosLinesTopString;
txtTitleReadLib2 = testPosLinesBottomString;
gonnaUse = 1;
}
else {gonnaUse = 0} // redundant code? bad even? might cover fringe cases of stuff
}
else {gonnaUse = 0}
} //end Plan B & C
///COMBTHROUGH AT THE END OF THE DAY, 10-15-19 to 10-16-19 (5:43am)
///I really think the logic down to this point works!!!
///Except for SPACELESS. I need to refine that.
///And maybe double-check scenarios in my head (e.g., one space, two space, very asymmetrical spaces)
///But I think this is all really good…
///Flaws must be below.
//Plan D Lite: (original Plan D too daunting; in comments below)
//Loop:
//We squash it one iota, then linebreak at the halfway point (to be redetermined)
//Then we check if it worked. If it did not work, round the linebreak the other direction.
//If that did not work…
//We UNbreak it, squash it another iota, then repeat — redetermining the linebreak each time (unless I realize that’s dumb)
//We do this until a certain ratio
//:End Loop
//If this does not work…
while isSpaceTitle == 1 && gonnaUse == 0 && fontScaleReadLibNarrow >= .72
{
fontScaleReadLibNarrow -= .02;
if negRatio == 0
{
if string_width(testPosLinesBottomString)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow <= global.readLibTitleBoxWidth
{
txtTitleReadLib = testPosLinesTopString;
txtTitleReadLib2 = testPosLinesBottomString;
gonnaUse = 1;
}
}
else if posRatio == 0
{
if string_width(testNegLinesTopString)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow <= global.readLibTitleBoxWidth
{
txtTitleReadLib = testNegLinesTopString;
txtTitleReadLib2 = testNegLinesBottomString;
gonnaUse = 1;
}
}
else if posRatio >= (negRatio + (1-negRatio)/2)
{
if string_width(testPosLinesBottomString)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow <= global.readLibTitleBoxWidth
{
txtTitleReadLib = testPosLinesTopString;
txtTitleReadLib2 = testPosLinesBottomString;
gonnaUse = 1;
}
else if string_width(testNegLinesTopString)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow <= global.readLibTitleBoxWidth
{
txtTitleReadLib = testNegLinesTopString;
txtTitleReadLib2 = testNegLinesBottomString;
gonnaUse = 1;
}
}
else if (negRatio + (1-negRatio)/2) > posRatio
{
if string_width(testNegLinesTopString)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow <= global.readLibTitleBoxWidth
{
txtTitleReadLib = testNegLinesTopString;
txtTitleReadLib2 = testNegLinesBottomString;
gonnaUse = 1;
}
else if string_width(testPosLinesBottomString)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow <= global.readLibTitleBoxWidth
{
txtTitleReadLib = testPosLinesTopString;
txtTitleReadLib2 = testPosLinesBottomString;
gonnaUse = 1;
}
}
//else {gonnaUse = 0} unnecessary line; it’d already be 0 in this case
////////////////////
//This looks good to me! I can’t see the problem thus far.
//Problems must be below…
/////////////////
} //if this STILL doesn’t work, then we have to pick whichever space location makes top line as long as possible at .72 without leaving boundaries.
//this will find the longest top line possible, bottom will be what remains after that, and then “…” as is presumably needed.
var j = 0;
while isSpaceTitle == 1 && gonnaUse == 0 && (j < numSpacesTitle) // && fontScaleReadLibNarrow == .7
{
testTopString = string_copy(txtTitleReadLibOG,1,posSpaceTitle[j]);
//This entire if: If the first space in the title occurs so late that the top line overflows to the next line before reaching it
//Frankly this must be an impossible situation, but I’m not sure yet. (maybe i should test it with a long-before-space title)
if string_width(testTopString)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth && j == 0
{
//break it at the furthest character possible (maybe insert hyphen)
var i = 1;
while (i <= string_length(txtTitleReadLibOG)) && gonnaUse == 0
{
txtSpacelessTop = string_copy(txtTitleReadLibOG, 1, i);
if string_width(txtSpacelessTop)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow + string_width(“-“)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth && i >= 2
{
gonnaUse = 1;
txtTitleReadLib = string_copy(txtTitleReadLibOG, 1, i-1) + “-“;
txtTitleReadLib2 = string_delete(txtTitleReadLibOG, 1, string_length(txtTitleReadLib));
if string_width(txtTitleReadLib2)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth
{
var k = 1, bottomTrulyFilled = 0;
while (k <= string_length(txtTitleReadLib2) && bottomTrulyFilled == 0)
{
txtSpacelessBottom = string_copy(txtTitleReadLib2, 1, k);
if string_width(txtSpacelessBottom)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow + string_width(“…”)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth && k >= 2
{
bottomTrulyFilled = 1;
txtTitleReadLib2 = string_copy(txtTitleReadLib2, 1, k-1) + “…”;
}
else if k == string_length(txtTitleReadLib2) //just a strange failsafe to fill txtTitleReadLib. Logicaly, this should be an impossible scenario
{
txtTitleReadLib2 = “”;
}
k++;
}
}
}
else if i == string_length(txtTitleReadLibOG) //just a strange failsafe to fill txtTitleReadLib. Logicaly, this should be an impossible scenario
{
txtTitleReadLib = txtTitleReadLibOG;
txtTitleReadLib2 = “”;
}
i++;
}
}
//if the first space in the title does not occur too late, but a LATER SPACE DOES cause top to overflow
else if string_width(testTopString)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth && j >= 1
{
//break it at the space previous to this one
gonnaUse = 1;
txtTitleReadLib = string_copy(txtTitleReadLibOG, 1, posSpaceTitle[j-1]);
txtTitleReadLib2 = string_delete(txtTitleReadLibOG, 1, string_length(txtTitleReadLib));
if string_width(txtTitleReadLib2)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth
{
var k = 1, bottomTrulyFilled = 0;
while (k <= string_length(txtTitleReadLib2) && bottomTrulyFilled == 0) // this loops until we went through
{
txtSpacedBottom = string_copy(txtTitleReadLib2, 1, k);
if string_width(txtSpacedBottom)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow + string_width(“…”)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth && k >= 2
{
bottomTrulyFilled = 1;
txtTitleReadLib2 = string_copy(txtTitleReadLib2, 1, k-1) + “…”;
}
else if k == string_length(txtTitleReadLib2) //just a strange failsafe to fill txtTitleReadLib. Logicaly, this should be an impossible scenario
{
txtTitleReadLib2 = “”;
}
k++;
}
}
}
//at this point, the only thing that fits this criteria is a title with at least one space, the last space
//of which would STILL appear on the top line (as there is no negative ratio)
else if j == numSpacesTitle – 1
{
gonnaUse = 1;
txtTitleReadLib = string_copy(txtTitleReadLibOG, 1, posSpaceTitle[j]);
txtTitleReadLib2 = string_delete(txtTitleReadLibOG, 1, string_length(txtTitleReadLib));
if string_width(txtTitleReadLib2)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth
{
var fina = 1, bottomTrulyFilled = 0;
while (fina <= string_length(txtTitleReadLib2) && bottomTrulyFilled == 0) // this loops until we went through
{
txtSpacedBottom = string_copy(txtTitleReadLib2, 1, fina);
if string_width(txtSpacedBottom)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow + string_width(“…”)*global.fontScaleReadLibTitle*fontScaleReadLibNarrow > global.readLibTitleBoxWidth && fina >= 2
{
bottomTrulyFilled = 1;
txtTitleReadLib2 = string_copy(txtTitleReadLib2, 1, fina-1) + “…”;
}
else if fina == string_length(txtTitleReadLib2) //just a strange failsafe to fill txtTitleReadLib. Logicaly, this should be an impossible scenario
{
txtTitleReadLib2 = “”;
}
fina++;
}
}
}
j++;
}
}//ends all the 2-line checks, Plans B-D, and even ends the “…”-adding, which would be Plan E
}
///////////////////////////////////////////////////
///////////////////////////////////////////////////
///////////////////////////////////////////////////
for (i = 1; i <= lineMax; i+= 1)
{
txtLinesWBreaks[w] = txtLinesAll[i];
txtLinesWBreaks[w] = string_replace_all(txtLinesWBreaks[w],”=========”,””);
txtLinesWBreaks[w] = string_replace_all(txtLinesWBreaks[w],”+++++++++”,””);
txtULBlanks[w] = txtLinesAll[i];
while (string_length(txtLinesWBreaks[w]) >= pos_current)
{
if ((string_width(string_copy(txtLinesWBreaks[w],1,pos_current))*global.fontScaleReadLib) > global.readLibBoundingBoxWidth)
{
if (pos_space != -1)
{
text_full = txtLinesWBreaks[w];
txtLinesWBreaks[w] = string_copy(txtLinesWBreaks[w],1,pos_space);
//do this below after incrementing w
//txtLinesWBreaks[w+1] = string_copy(text_full,pos_space+1,string_length(text_full)-(pos_space));
//THE BELOW “IF” STATEMENT CRASHES CODE WHEN FONT IS TOO BIG. BECAUSE NO SPACE??? It tried to index txtULBlanks[0,22] when it’s only [1,22]
//(new) here, we will break the “blanked” line at the same place as the unblanked line
if (string_pos(“=========”, txtULBlanks[w]) != 0 || string_pos(“+++++++++”, txtULBlanks[w]) != 0)
{
while (num_of_spaces != num_of_spaces2)
{
if (string_char_at(txtULBlanks[w],pos_current2) == ” “)
{
pos_space2 = pos_current2;
num_of_spaces2 += 1;
}
pos_current2 += 1;
}
text_full2 = txtULBlanks[w];
txtULBlanks[w] = string_copy(txtULBlanks[w],1,pos_space2);
//////////////// trying… nah not going with this for now. didn’t seem to help
//txtULBlanks[w+1] = string_copy(text_full2,pos_space2+1,string_length(text_full2)-(pos_space2));
////////////////
}
else
{
txtULBlanks[w] = txtLinesWBreaks[w];
text_full2 = txtULBlanks[w];
/////
//txtULBlanks[w+1] = txtLinesWBreaks[w+1];
/////
}
// (end new)
w += 1;
txtLinesWBreaks[w] = string_copy(text_full,pos_space+1,string_length(text_full)-(pos_space));
//the above line: removes the text we just looked at from the current text string
////(new) here, we will create the new line by removing the text we just saved as the previous line
////////////////////////////
///THIS HAS BEEN GOOD FOR ME IN THE PAST, BUT I’M TINKERING WITH IT NOW (9-24-19)
if (string_pos(“=========”, text_full2) != 0 || string_pos(“+++++++++”, text_full2) != 0)
{
txtULBlanks[w] = string_copy(text_full2,pos_space2+1,string_length(text_full2)-(pos_space2));
}
else {txtULBlanks[w] = txtLinesWBreaks[w]};
//////////////////////////////////////////////////////////////////////
// (end new)
pos_current = 1;
pos_space = -1;
//(new)
pos_current2 = 1;
pos_space2 = -1;
num_of_spaces = 0;
num_of_spaces2 = 0;
// (end new)
}
//Still need to code UNDERLINE PREPPING in this case — that there is no space in the line
//
//
/////////////////////////////////////////////////////////////////////////////////////////////
// LET’S MAKE IT HAPPEN!
else if (pos_space == -1)
{
//if not, we can force line breaks
text_full = txtLinesWBreaks[w];
//remove the text we just looked at from the current text string
txtLinesWBreaks[w] = string_copy(txtLinesWBreaks[w],1,pos_current-1);
///here fucking goes. ULBlanks time…
//Make these variables exist up top. haven’t initialized em yet
ULBlankLengthCheck = string_length(txtLinesWBreaks[w]) + string_length(“=========”);
txtULBlanksSpacelessTest = string_copy(txtULBlanks[w],1,ULBlankLengthCheck);
pos_currentBlankCheck = pos_current-1;
while string_pos(“=========”,txtULBlanksSpacelessTest) > 0
{
txtULBlanksSpacelessTest = string_replace(txtULBlanksSpacelessTest,”=========”,””);
pos_currentBlankCheck = pos_currentBlankCheck + string_length(“=========”);
}
while string_pos(“+++++++++”,txtULBlanksSpacelessTest) > 0
{
txtULBlanksSpacelessTest = string_replace(txtULBlanksSpacelessTest,”+++++++++”,””);
pos_currentBlankCheck = pos_currentBlankCheck + string_length(“=========”);
}
text_full2 = txtULBlanks[w];
txtULBlanks[w] = string_copy(txtULBlanks[w],1,pos_currentBlankCheck);
///end of crazy experiment 9-23-19
w += 1;
txtLinesWBreaks[w] = string_copy(text_full,pos_current,string_length(text_full)-(pos_current-1));
//crazy experiment again
txtULBlanks[w] = string_copy(text_full2,pos_currentBlankCheck+1,string_length(text_full2)-(pos_currentBlankCheck));
pos_current = 1;
pos_space = -1;
num_of_spaces = 0;
}
}
if (string_char_at(txtLinesWBreaks[w],pos_current) == ” “)
{
pos_space = pos_current;
num_of_spaces += 1;
}
/* nah this was dumb shit. delete it
else if (string_char_at(txtLinesWBreaks[w],pos_current) == “=”)
{
consec_equals += 1;
}
else if (string_char_at(txtLinesWBreaks[w],pos_current) == “+”)
{
consec_pluses += 1;
}
*/
pos_current += 1;
}
if (string_length(txtLinesWBreaks[w]) > 0) w += 1;
breakLineMax = w;
//Gotta make page scroll now. it’s based on breakLineMax, hence we do it here
maxPageScrollReadLib = breakLineMax/numReadLibLinesDisplayed;
//9-24-19 will this solve it…
pos_current = 1;
pos_space = -1;
//(new)
pos_current2 = 1;
pos_space2 = -1;
num_of_spaces = 0;
num_of_spaces2 = 0;
}
//GOD NEW, ALL BELOW THIS POINT
/*
var q = 0;
var storage = “”;
var storage2 = “”;
var d_at = 0
var d_at2 = 0
for (i = 1; i < breakLineMax; i++)
{
q = 1;
stringsInLine[i] = q;
blankLocater[i,q] = txtULBlanks[i];
d_at = string_pos(“=========”, blankLocater[i,q]);
while(d_at > 0)
{
storage = blankLocater[i,q];
blankLocater[i,q] = string_delete(blankLocater[i,q], d_at, string_length(blankLocater[i,q]));
if blankLocater[i,q] != “” q += 1; // this “IF” is dubious but seems critical perhaps
blankLocater[i,q] = string_delete(storage, 1, d_at-1);
storage3 = string_delete(storage, 1, d_at + string_length(“=========”));
d_at2 = string_pos(“+++++++++”, blankLocater[i,q]);
if d_at2 != 0
{
storage2 = blankLocater[i,q];
blankLocater[i,q] = string_delete(blankLocater[i,q], d_at2 + string_length(“+++++++++”), string_length(blankLocater[i,q]));
q += 1;
storage2 = string_delete(storage2, 1, d_at2-1 + string_length(“+++++++++”));
if storage2 != “”
{
blankLocater[i,q] = storage2;
}
}
else
{
//q += 1;
break
}
//d_at = string_pos(“=========”, blankLocater[i,q]);
d_at = string_pos(“=========”, blankLocater[i,q]); //used to check storage3 which failed. but wouldn’t this way create an infinite loop…?
//d_at2 = 0; //useless line?
stringsInLine[i] = q;
}
} */
//THIS TRY IS FOR THE MARBLES.
//The above one used to get stuck in a while loop when the last blank had === but not +++. janky fix above wasn’t quite right. so we start fresh here.
var q = 0;
var storage = “”;
var storage2 = “”;
var storageForCounting = “”;
var d_atEquals = 0;
var d_atPluses = 0;
var d_atEqualsCount = 0;
var d_atPlusesCount = 0;
for (i = 1; i < breakLineMax; i++)
{
q = 1;
stringsInLine[i] = q;
blankLocater[i,q] = txtULBlanks[i];
d_atEquals = string_pos(“=========”, blankLocater[i,q]);
d_atPluses = string_pos(“+++++++++”, blankLocater[i,q]);
storageForCounting = blankLocater[i,q];
d_atEqualsCount = 0;
d_atPlusesCount = 0;
while d_atEquals != 0
{
d_atEqualsCount += 1;
storageForCounting = string_replace(storageForCounting,”=========”,””);
d_atEquals = string_pos(“=========”, storageForCounting);
}
while d_atPluses != 0
{
d_atPlusesCount += 1;
storageForCounting = string_replace(storageForCounting,”+++++++++”,””)
d_atPluses = string_pos(“+++++++++”,storageForCounting);
}
d_atEquals = string_pos(“=========”, blankLocater[i,q]);
d_atPluses = string_pos(“+++++++++”, blankLocater[i,q]);
if d_atPlusesCount > d_atEqualsCount
{
while(d_atPluses > 0)
{
storage = blankLocater[i,q];
blankLocater[i,q] = string_delete(blankLocater[i,q], d_atPluses + string_length(“+++++++++”), string_length(blankLocater[i,q]));
if blankLocater[i,q] != “” q += 1; // this “IF” is dubious but seems critical perhaps
blankLocater[i,q] = string_delete(storage, 1, d_atPluses-1 + string_length(“+++++++++”));
//storage3 = string_delete(storage, 1, d_atPluses + string_length(“=========”));
d_atEquals = string_pos(“=========”, blankLocater[i,q]);
if d_atEquals != 0
{
storage2 = blankLocater[i,q];
blankLocater[i,q] = string_delete(blankLocater[i,q], d_atEquals, string_length(blankLocater[i,q]));
q += 1;
storage2 = string_delete(storage2, 1, d_atEquals-1);
if storage2 != “”
{
blankLocater[i,q] = storage2;
}
}
d_atPluses = string_pos(“+++++++++”, blankLocater[i,q]); //used to check storage3 which failed. but wouldn’t this way create an infinite loop…?
d_atEquals = string_pos(“=========”, blankLocater[i,q]); //useless line?
stringsInLine[i] = q;
}
}
else if d_atEqualsCount >= d_atPlusesCount
{
while(d_atEquals > 0)
{
storage = blankLocater[i,q];
blankLocater[i,q] = string_delete(blankLocater[i,q], d_atEquals, string_length(blankLocater[i,q]));
if blankLocater[i,q] != “” q += 1; // this “IF” is dubious but seems critical perhaps
blankLocater[i,q] = string_delete(storage, 1, d_atEquals-1);
//storage3 = string_delete(storage, 1, d_at + string_length(“=========”));
d_atPluses = string_pos(“+++++++++”, blankLocater[i,q]);
if d_atPluses != 0
{
storage2 = blankLocater[i,q];
blankLocater[i,q] = string_delete(blankLocater[i,q], d_atPluses + string_length(“+++++++++”), string_length(blankLocater[i,q]));
q += 1;
storage2 = string_delete(storage2, 1, d_atPluses-1 + string_length(“+++++++++”));
if storage2 != “”
{
blankLocater[i,q] = storage2;
}
}
else
{
d_atEquals = string_pos(“=========”, blankLocater[i,q]);
d_atPluses = string_pos(“+++++++++”, blankLocater[i,q]);
stringsInLine[i] = q;
if string_char_at(blankLocater[i,q],string_length(blankLocater[i,q])) == ” “
{
blankLocater[i,q] = string_delete(blankLocater[i,q],string_length(blankLocater[i,q]),1);
}
break
}
d_atEquals = string_pos(“=========”, blankLocater[i,q]); //used to check storage3 which failed. but wouldn’t this way create an infinite loop…?
d_atPluses = string_pos(“+++++++++”, blankLocater[i,q]);
stringsInLine[i] = q;
}
}
/*
else if d_atEquals > 0 && d_atPluses == 0 // there are only equals
{
while(d_atEquals > 0)
{
storage = blankLocater[i,q];
blankLocater[i,q] = string_delete(blankLocater[i,q], d_atEquals, string_length(blankLocater[i,q]));
if blankLocater[i,q] != “” q += 1; // this “IF” is dubious but seems critical perhaps
blankLocater[i,q] = string_delete(storage, 1, d_atEquals-1);
//storage3 = string_delete(storage, 1, d_atEquals + string_length(“=========”));
d_atPluses = string_pos(“+++++++++”, blankLocater[i,q]);
if d_atPluses != 0
{
storage2 = blankLocater[i,q];
blankLocater[i,q] = string_delete(blankLocater[i,q], d_atPluses + string_length(“+++++++++”), string_length(blankLocater[i,q]));
q += 1;
storage2 = string_delete(storage2, 1, d_atPluses-1 + string_length(“+++++++++”));
if storage2 != “”
{
blankLocater[i,q] = storage2;
}
}
d_atEquals = string_pos(“=========”, blankLocater[i,q]); //used to check storage3 which failed. but wouldn’t this way create an infinite loop…?
d_atPluses = string_pos(“+++++++++”, blankLocater[i,q]);
stringsInLine[i] = q;
}
}
*/
/* don’t even need to code this situation, I think…
else if d_atEquals == 0 && d_atPluses == 0
{
}
*/
}
}
//
//(GOD new)
/*
for (i = 1; i <= breakLineMax; i+= 1)
{
txtTestList[i] = “”;
list1 = string_split(txtULBlanks[3], “=========”, true);
//for (list1) list2 = string_split(list1
var listSize = ds_list_size(list1);
var index;
for (index = 0; index < listSize; index++)
{txtTestList[i] += list1[| index]}
}
}