1501 lines
36 KiB
Plaintext
1501 lines
36 KiB
Plaintext
//::///////////////////////////////////////////////
|
|
//:: Shape maker and letters of fire
|
|
//:: shp_include
|
|
//::
|
|
//:://////////////////////////////////////////////
|
|
/*
|
|
This file contains all the functions necessary to create
|
|
shapes
|
|
|
|
*/
|
|
//:://////////////////////////////////////////////
|
|
//:: Created By: Craig Graff
|
|
//:: Created On: 7/15/02 - 8/15/02 (give me a break.. it's my first script ever.)
|
|
//:://////////////////////////////////////////////
|
|
|
|
|
|
//-------------variables & constants------------------------//
|
|
|
|
|
|
int nDensity = 4; //use with arcIncrement to modify population of circle or letter
|
|
|
|
int nNumber = 8; // default number of objects to create
|
|
|
|
int nPart; //current position along segment
|
|
|
|
//use if target is an object
|
|
object oTarget = OBJECT_SELF;
|
|
|
|
//blueprint tag of object to create
|
|
string sBluePrint= "fireletter";
|
|
|
|
//Location of target (epicenter)
|
|
location lTarget = GetLocation ( oTarget );
|
|
|
|
location lCreate; //Location of created object
|
|
|
|
vector vCreate; //position of created object
|
|
|
|
//vector (position) of lTarget
|
|
vector vTarget = GetPositionFromLocation ( lTarget );
|
|
|
|
//default starting vector for segment
|
|
vector vStartSegment = Vector(vTarget.x - 5.0f, vTarget.y + 5.0f, vTarget.z);
|
|
|
|
//default ending vector for segment
|
|
vector vEndSegment = Vector(vTarget.x + 5.0f, vTarget.y + 5.0f, vTarget.z);
|
|
|
|
//for scaling letters or shapes
|
|
float fScale = 1.0f;
|
|
float fXScale = 1.0f;
|
|
float fYScale = 1.0f;
|
|
float fZScale = 1.0f;
|
|
|
|
float fFace; //Facing of created object
|
|
|
|
float fRadius = 5.0f; //default radius of circle
|
|
|
|
//distance from vTarget
|
|
float fXDist;
|
|
float fYDist;
|
|
float fZDist;
|
|
|
|
//additional distance from vTarget (for use in placement of shapes relative to one another)
|
|
float fXOffset;
|
|
float fYOffset;
|
|
float fZOffset;
|
|
|
|
//relative coordinates for start of segment
|
|
float fX1;
|
|
float fY1;
|
|
float fZ1;
|
|
|
|
//relative coordinates for end of segment
|
|
float fX2;
|
|
float fY2;
|
|
float fZ2;
|
|
|
|
float fAngle; // 0.0f < fAngle <= 360.0f
|
|
|
|
float fSlice; // degree of seperation between arc objects
|
|
|
|
//float fDelay = 7.0; //not currently in use
|
|
string sCreateType = "PLACEABLE";
|
|
int nDuration = DURATION_TYPE_INSTANT;
|
|
int nEffect = VFX_IMP_PULSE_FIRE;
|
|
|
|
|
|
string sMessage = GetStringUpperCase("Message here");
|
|
string sLine;
|
|
string sLetterToPrint;
|
|
string sLetter;
|
|
int nMessageLength;
|
|
int bLowerCase;
|
|
int nMessageType = 2;
|
|
float fSpacing;
|
|
|
|
//-----------------------------declaring functions---------------------------------------//
|
|
|
|
|
|
//------------base funtions----------------//
|
|
|
|
//Returns nNumber - makes sure circle is well populated -- not in use at this time
|
|
//int arcIncrement(float fRadius);
|
|
|
|
//Determines x-coordinate for vector
|
|
//returns values for fXDist
|
|
float arcCreateX(float fAngle, float fRadius);
|
|
|
|
//Determines y-coordinate for vector
|
|
//Arc function - returns values for fYDist
|
|
float arcCreateY(float fAngle, float fRadius);
|
|
|
|
//Determines z-coordinate for vector
|
|
//Arc function - returns values for fZDist
|
|
float arcCreateZ(float fAngle, float fRadius);
|
|
|
|
//Arc function - compute angle for sin & cos
|
|
float ArcComputeAngle(float fAngle);
|
|
|
|
//returns facing of created object
|
|
//returns fFace
|
|
float arcFacing(float fAngle);
|
|
|
|
//Determines x-coordinate for vector along segment
|
|
//returns values for fXDist
|
|
float createX(int nNumber);
|
|
|
|
//Determines y-coordinate for vector along segment
|
|
//returns values for fYDist
|
|
float createY(int nNumber);
|
|
|
|
//Determines z-coordinate for vector along segment
|
|
//returns values for fZDist
|
|
float createZ(int nNumber);
|
|
|
|
//Arc function - returns lCreate
|
|
location arcCreateLocation(float fAngle);
|
|
|
|
//Arc function - returns vCreate
|
|
vector arcCreateSpot(float fAngle);
|
|
|
|
//returns vCreate
|
|
vector createSpot(int nNumber);
|
|
|
|
//Creates object or effect named in sBlueprint or nEffect
|
|
//at fAngle
|
|
void arcCreateBluePrint(float fAngle);
|
|
|
|
//Creates object or effect named in sBlueprint or nEffect
|
|
void createBluePrint(int nNumber);
|
|
|
|
//returns location to create object
|
|
location createLocation(int nNumber);
|
|
|
|
//defines the starting point for a segment using coordinates fX1, fY1, and fZ1
|
|
vector startSegment(float fX1, float fY1, float fZ1);
|
|
//defines the end point for a segment using coordinates fX2, fY2, and fZ2
|
|
vector endSegment(float fX2, float fY2, float fZ2);
|
|
// destroys all the designated instances of sBlueprint
|
|
void destroy(string sBlueprint);
|
|
|
|
//-------functions for shapes--------------//
|
|
//
|
|
// most of these will likely be integrated into one function for later releases
|
|
//
|
|
|
|
// Creates a cirle of nNumber of objects with resref sBlueprint, with fRadius
|
|
void circle(int nNumber, float fRadius);
|
|
// Creates a hoop of nNumber of objects with resref sBlueprint, with fRadius
|
|
void hoop(int nNumber, float fRadius);
|
|
// Creates a topHalfCircle of nNumber of objects with resref sBlueprint, with fRadius
|
|
void topHalfCircle(int nNumber, float fRadius);
|
|
// Creates a bottomHalfCircle of nNumber of objects with resref sBlueprint, with fRadius
|
|
void bottomHalfCircle(int nNumber, float fRadius);
|
|
// Creates a leftHalfCircle of nNumber of objects with resref sBlueprint, with fRadius
|
|
void leftHalfCircle(int nNumber, float fRadius);
|
|
// Creates a rightHalfCircle of nNumber of objects with resref sBlueprint, with fRadius
|
|
void rightHalfCircle(int nNumber, float fRadius);
|
|
// Creates a topArch of nNumber of objects with resref sBlueprint, with fRadius
|
|
void topArch(int nNumber, float fRadius);
|
|
// Creates a bottomArch of nNumber of objects with resref sBlueprint, with fRadius
|
|
void bottomArch(int nNumber, float fRadius);
|
|
// Creates a topLeftHalfArch of nNumber of objects with resref sBlueprint, with fRadius
|
|
void topLeftHalfArch(int nNumber, float fRadius);
|
|
// Creates a topRightHalfArch of nNumber of objects with resref sBlueprint, with fRadius
|
|
void topRightHalfArch(int nNumber, float fRadius);
|
|
// Creates a bottomLeftHalfArch of nNumber of objects with resref sBlueprint, with fRadius
|
|
void bottomLeftHalfArch(int nNumber, float fRadius);
|
|
// Creates a bottomRightHalfArch of nNumber of objects with resref sBlueprint, with fRadius
|
|
void bottomRightHalfArch(int nNumber, float fRadius);
|
|
// Creates a segment of a line with nNumber of objects from the point
|
|
// vStartSegment to vEndSegment. Used in conjunction with startSegment()
|
|
// and endSegment()
|
|
void doSegment(int nNumber);
|
|
|
|
//------- functions for letters-----------//
|
|
|
|
//Creates the letter
|
|
void A();
|
|
//Creates the letter
|
|
void B();
|
|
//Creates the letter
|
|
void C();
|
|
//Creates the letter
|
|
void D();
|
|
//Creates the letter
|
|
void E();
|
|
//Creates the letter
|
|
void F();
|
|
//Creates the letter
|
|
void G();
|
|
//Creates the letter
|
|
void H();
|
|
//Creates the letter
|
|
void I();
|
|
//Creates the letter
|
|
void J();
|
|
//Creates the letter
|
|
void K();
|
|
//Creates the letter
|
|
void L();
|
|
//Creates the letter
|
|
void M();
|
|
//Creates the letter
|
|
void N();
|
|
//Creates the letter
|
|
void O();
|
|
//Creates the letter
|
|
void P();
|
|
//Creates the letter
|
|
void Q();
|
|
//Creates the letter
|
|
void R();
|
|
//Creates the letter
|
|
void S();
|
|
//Creates the letter
|
|
void T();
|
|
//Creates the letter
|
|
void U();
|
|
//Creates the letter
|
|
void V();
|
|
//Creates the letter
|
|
void W();
|
|
//Creates the letter
|
|
void X();
|
|
//Creates the letter
|
|
void Y();
|
|
//Creates the letter
|
|
void Z();
|
|
// creates punctuation
|
|
void apostrophe();
|
|
// creates punctuation
|
|
void period();
|
|
// creates punctuation
|
|
void exclamation();
|
|
// creates punctuation
|
|
void questionmark();
|
|
|
|
//--------------funtions for printing----------------//
|
|
|
|
//prints sLetterToPrint in flames
|
|
void printLetter(string sLetterToPrint);
|
|
|
|
//Prints sLine in letters of fire if nDurationType = DURATION_TYPE_TEMPORARY
|
|
//the letters will fade after about 7 seconds
|
|
void printLine(string sLine);
|
|
|
|
//Takes the first 13 characters from sMessage(counts down from 13th character
|
|
//until it finds a blank character, prints them in letters
|
|
//of fire and returns the rest of sMessage
|
|
//
|
|
//Note: if any of your words is longer than 13 characters, this function cannot
|
|
//continue.
|
|
string getLine(string sMessage);
|
|
|
|
//Uses getLine to break up sMessage into readable chunks and displays these
|
|
//chunks in 7 second intervals
|
|
void printMessage(string sMessage);
|
|
|
|
//---------------------defining functions----------------------------------//
|
|
|
|
|
|
/* not in use at this time
|
|
int arcIncrement(float fRadius)
|
|
{
|
|
nNumber = (FloatToInt(0.5f * fRadius * PI) + 1) * nDensity;
|
|
return nNumber;
|
|
}
|
|
*/
|
|
|
|
float arcCreateX(float fAngle, float fRadius)
|
|
{
|
|
fXDist = fRadius * cos(fAngle) * fXScale;
|
|
return fXDist;
|
|
}
|
|
|
|
float arcCreateY(float fAngle, float fRadius)
|
|
{
|
|
fYDist = fRadius * sin(fAngle) * fYScale;
|
|
return fYDist;
|
|
}
|
|
|
|
float arcCreateZ(float fAngle, float fRadius)
|
|
{
|
|
fZDist = fRadius * sin(fAngle) * fZScale;
|
|
return fZDist;
|
|
}
|
|
|
|
/*
|
|
returns vector to compute location to create object
|
|
*/
|
|
vector arcCreateSpot(float fAngle)
|
|
{
|
|
vCreate = Vector(vTarget.x + (fXDist + fXOffset), vTarget.y + fYDist
|
|
+ fYOffset, vTarget.z + fZDist + fZOffset);
|
|
return vCreate;
|
|
}
|
|
|
|
/*
|
|
returns location to create object
|
|
*/
|
|
location arcCreateLocation(float fAngle)
|
|
{
|
|
lCreate = Location(GetArea(oTarget), arcCreateSpot(fAngle), arcFacing(fAngle));
|
|
return lCreate;
|
|
}
|
|
|
|
/*
|
|
returns facing of created object
|
|
*/
|
|
float arcFacing(float fAngle)
|
|
{
|
|
fFace = fAngle;
|
|
while (fFace > 360.0f)
|
|
{
|
|
fFace = fFace - 360.0f;
|
|
}
|
|
return fFace;
|
|
}
|
|
|
|
/*
|
|
Creates object or effect named in sBlueprint or nEffect
|
|
*/
|
|
void arcCreateBluePrint(float fAngle)
|
|
{
|
|
object oCreated;
|
|
if (sCreateType == "EFFECT")
|
|
{
|
|
ApplyEffectAtLocation(nDuration, EffectVisualEffect(nEffect, FALSE), arcCreateLocation(fAngle));
|
|
}
|
|
|
|
else
|
|
{
|
|
if (sCreateType == "PLACEABLE")
|
|
{
|
|
oCreated = CreateObject(OBJECT_TYPE_PLACEABLE, sBluePrint, arcCreateLocation(fAngle), FALSE);
|
|
}
|
|
|
|
if (sCreateType == "CREATURE")
|
|
{
|
|
oCreated = CreateObject(OBJECT_TYPE_CREATURE, sBluePrint, arcCreateLocation(fAngle), FALSE);
|
|
}
|
|
|
|
if (sCreateType == "ITEM")
|
|
{
|
|
oCreated = CreateObject(OBJECT_TYPE_ITEM, sBluePrint, arcCreateLocation(fAngle), FALSE);
|
|
}
|
|
|
|
if (sCreateType == "STORE")
|
|
{
|
|
oCreated = CreateObject(OBJECT_TYPE_STORE, sBluePrint, arcCreateLocation(fAngle), FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
location createLocation(int nNumber)
|
|
{
|
|
lCreate = Location(GetArea(oTarget), createSpot(nNumber), arcFacing(fAngle));
|
|
return lCreate;
|
|
}
|
|
|
|
void createBluePrint(int nNumber)
|
|
{
|
|
if (sCreateType == "EFFECT") //not fully or properly implemented
|
|
{
|
|
ApplyEffectAtLocation(nDuration, EffectVisualEffect(nEffect, FALSE),
|
|
createLocation(nNumber));
|
|
}
|
|
else
|
|
{
|
|
if (sCreateType == "PLACEABLE")
|
|
{
|
|
CreateObject(OBJECT_TYPE_PLACEABLE, sBluePrint, createLocation(nNumber), FALSE);
|
|
}
|
|
if (sCreateType == "CREATURE")
|
|
{
|
|
CreateObject(OBJECT_TYPE_CREATURE, sBluePrint, createLocation(nNumber), FALSE);
|
|
}
|
|
if (sCreateType == "ITEM")
|
|
{
|
|
CreateObject(OBJECT_TYPE_ITEM, sBluePrint, createLocation(nNumber), FALSE);
|
|
}
|
|
if (sCreateType == "STORE")//why not...
|
|
{
|
|
CreateObject(OBJECT_TYPE_STORE, sBluePrint, createLocation(nNumber), FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
vector startSegment(float fX1, float fY1, float fZ1)
|
|
{
|
|
vStartSegment = Vector(vTarget.x + fX1 * fXScale + fXOffset,
|
|
vTarget.y + fY1 * fYScale + fYOffset, vTarget.z + fZ1 * fZScale +fZOffset);
|
|
return vStartSegment;
|
|
}
|
|
|
|
vector endSegment(float fX2, float fY2, float fZ2)
|
|
{
|
|
vEndSegment = Vector(vTarget.x + fX2 * fXScale + fXOffset,
|
|
vTarget.y + fY2 * fYScale + fYOffset, vTarget.z + fZ2 * fZScale + fZOffset);
|
|
return vEndSegment;
|
|
}
|
|
|
|
vector createSpot(int nNumber)
|
|
{
|
|
if (nNumber > 0)
|
|
{
|
|
vCreate = Vector(vStartSegment.x + createX(nNumber),
|
|
vStartSegment.y + createY(nNumber),
|
|
vStartSegment.z + createZ(nNumber));
|
|
}
|
|
else
|
|
{
|
|
vCreate = Vector((vStartSegment.x + vEndSegment.x) / 2,
|
|
(vStartSegment.y + vEndSegment.y) / 2,
|
|
(vStartSegment.z + vEndSegment.z) / 2);
|
|
}
|
|
return vCreate;
|
|
}
|
|
|
|
float createX(int nNumber)
|
|
{
|
|
fXDist = (( vEndSegment.x - vStartSegment.x ) / nNumber) * nPart;
|
|
return fXDist;
|
|
}
|
|
|
|
float createY(int nNumber)
|
|
{
|
|
fYDist = (( vEndSegment.y - vStartSegment.y ) / nNumber) * nPart;
|
|
return fYDist;
|
|
}
|
|
|
|
float createZ(int nNumber)
|
|
{
|
|
fZDist = (( vEndSegment.z - vStartSegment.z ) / nNumber) * nPart;
|
|
return fZDist;
|
|
}
|
|
|
|
void destroy(string sBlueprint)
|
|
{
|
|
int nDestroy = 0;
|
|
object oObjectToDestroy = GetObjectByTag(sBluePrint,nDestroy++);
|
|
while ( oObjectToDestroy != OBJECT_INVALID)
|
|
{
|
|
DestroyObject( oObjectToDestroy );
|
|
oObjectToDestroy = GetObjectByTag(sBluePrint, nDestroy++);
|
|
}
|
|
}
|
|
|
|
|
|
//create various types of shapes - almost entirely circles at this point
|
|
//future releases will probably combine all of these into one function
|
|
//with different inputs
|
|
|
|
|
|
void circle(int nNumber, float fRadius)
|
|
{
|
|
fSlice = 360.0f / nNumber;
|
|
fAngle = 0.0f;
|
|
while (fAngle <= 360.0f)
|
|
{
|
|
|
|
arcCreateX(fAngle, fRadius);
|
|
arcCreateY(fAngle, fRadius);
|
|
arcCreateZ(fAngle, fRadius);
|
|
fAngle = fAngle + fSlice;
|
|
arcCreateBluePrint(fAngle);
|
|
}
|
|
|
|
}
|
|
void hoop(int nNumber, float fRadius)
|
|
{
|
|
fSlice = 360.0f / nNumber;
|
|
fAngle = 0.0f;
|
|
while (fAngle <= 360.0f)
|
|
{
|
|
arcCreateX(fAngle, fRadius);
|
|
arcCreateY(fAngle, fRadius);
|
|
arcCreateZ(fAngle, fRadius);
|
|
fAngle = fAngle + fSlice;
|
|
arcCreateBluePrint(fAngle);
|
|
}
|
|
|
|
}
|
|
|
|
void topHalfCircle(int nNumber, float fRadius)
|
|
{
|
|
fSlice = 180.0f / nNumber;
|
|
fAngle = 0.0f;
|
|
while (fAngle <= 180.0f)
|
|
{
|
|
arcCreateX(fAngle, fRadius);
|
|
arcCreateY(fAngle, fRadius);
|
|
arcCreateZ(fAngle, fRadius);
|
|
arcCreateBluePrint(fAngle);
|
|
fAngle = fAngle + fSlice;
|
|
}
|
|
|
|
}
|
|
|
|
void bottomHalfCircle(int nNumber, float fRadius)
|
|
{
|
|
fSlice = 180.0f / nNumber;
|
|
fAngle = 180.0f;
|
|
while (fAngle <= 360.0f)
|
|
{
|
|
arcCreateX(fAngle, fRadius);
|
|
arcCreateY(fAngle, fRadius);
|
|
arcCreateZ(fAngle, fRadius);
|
|
arcCreateBluePrint(fAngle);
|
|
fAngle = fAngle + fSlice;
|
|
}
|
|
}
|
|
|
|
void leftHalfCircle(int nNumber, float fRadius)
|
|
{
|
|
fSlice = 180.0f / nNumber;
|
|
fAngle = 90.0f;
|
|
while (fAngle <= 270.0f)
|
|
{
|
|
arcCreateX(fAngle, fRadius);
|
|
arcCreateY(fAngle, fRadius);
|
|
arcCreateZ(fAngle, fRadius);
|
|
arcCreateBluePrint(fAngle);
|
|
fAngle = fAngle + fSlice;
|
|
}
|
|
}
|
|
|
|
void rightHalfCircle(int nNumber, float fRadius)
|
|
{
|
|
fSlice = 180.0f / nNumber;
|
|
fAngle = 270.0f;
|
|
|
|
while (fAngle <= 450.0f)
|
|
{
|
|
arcCreateX(fAngle, fRadius);
|
|
arcCreateY(fAngle, fRadius);
|
|
arcCreateZ(fAngle, fRadius);
|
|
arcCreateBluePrint(fAngle);
|
|
fAngle = fAngle + fSlice;
|
|
}
|
|
}
|
|
|
|
void topArch(int nNumber, float fRadius)
|
|
{
|
|
fSlice = 180.0f / nNumber;
|
|
fAngle = 0.0f;
|
|
while (fAngle <= 180.0f)
|
|
{
|
|
arcCreateX(fAngle, fRadius);
|
|
arcCreateY(fAngle, fRadius);
|
|
arcCreateZ(fAngle, fRadius);
|
|
arcCreateBluePrint(fAngle);
|
|
fAngle = fAngle + fSlice;
|
|
}
|
|
|
|
}
|
|
|
|
void bottomArch(int nNumber, float fRadius)
|
|
{
|
|
fSlice = 180.0f / nNumber;
|
|
fAngle = 180.0f;
|
|
while (fAngle <= 360.0f)
|
|
{
|
|
arcCreateX(fAngle, fRadius);
|
|
arcCreateY(fAngle, fRadius);
|
|
arcCreateZ(fAngle, fRadius);
|
|
arcCreateBluePrint(fAngle);
|
|
fAngle = fAngle + fSlice;
|
|
}
|
|
|
|
}
|
|
|
|
void topLeftHalfArch(int nNumber, float fRadius)
|
|
{
|
|
fSlice = 90.0f / nNumber;
|
|
fAngle = 90.0f;
|
|
while (fAngle <= 180.0f)
|
|
{
|
|
|
|
arcCreateX(fAngle, fRadius);
|
|
arcCreateY(fAngle, fRadius);
|
|
arcCreateZ(fAngle, fRadius);
|
|
arcCreateBluePrint(fAngle);
|
|
fAngle = fAngle + fSlice;
|
|
}
|
|
}
|
|
|
|
void topRightHalfArch(int nNumber, float fRadius)
|
|
{
|
|
fSlice = 90.0f / nNumber;
|
|
fAngle = 0.0f;
|
|
while (fAngle <= 90.0f)
|
|
{
|
|
arcCreateX(fAngle, fRadius);
|
|
arcCreateY(fAngle, fRadius);
|
|
arcCreateZ(fAngle, fRadius);
|
|
arcCreateBluePrint(fAngle);
|
|
fAngle = fAngle + fSlice;
|
|
}
|
|
|
|
}
|
|
|
|
void bottomRightHalfArch(int nNumber, float fRadius)
|
|
{
|
|
fSlice = 90.0f / nNumber;
|
|
fAngle = 270.0f;
|
|
while (fAngle <= 360.0f)
|
|
{
|
|
arcCreateX(fAngle, fRadius);
|
|
arcCreateY(fAngle, fRadius);
|
|
arcCreateZ(fAngle, fRadius);
|
|
arcCreateBluePrint(fAngle);
|
|
fAngle = fAngle + fSlice;
|
|
}
|
|
|
|
}
|
|
|
|
void bottomLeftHalfArch(int nNumber, float fRadius)
|
|
{
|
|
fSlice = 90.0f / nNumber;
|
|
fAngle = 180.0f;
|
|
while (fAngle <= 270.0f)
|
|
{
|
|
arcCreateX(fAngle, fRadius);
|
|
arcCreateY(fAngle, fRadius);
|
|
arcCreateZ(fAngle, fRadius);
|
|
arcCreateBluePrint(fAngle);
|
|
fAngle = fAngle + fSlice;
|
|
}
|
|
}
|
|
|
|
void doSegment(int nNumber)
|
|
{
|
|
nPart = 0;
|
|
while (nPart <= nNumber)
|
|
{
|
|
createBluePrint(nNumber);
|
|
nPart++;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
//Functions for letters
|
|
|
|
void A()
|
|
{
|
|
startSegment(-1.05f, 0.0f, 0.0f);
|
|
endSegment(-0.15f, 4.0f, 4.0f);
|
|
doSegment(5 * nDensity / 4);
|
|
|
|
startSegment(1.05f, 0.0f, 0.0f);
|
|
endSegment(0.15f, 4.0f, 4.0f);
|
|
doSegment(5 * nDensity / 4);
|
|
|
|
startSegment(-0.225f, 0.8f, 0.8f);
|
|
endSegment(0.225f, 0.8f, 0.8f);
|
|
doSegment(1);
|
|
}
|
|
|
|
void B()
|
|
{
|
|
startSegment(-1.05f, 0.0f, 0.0f);
|
|
endSegment(-1.05f, 4.0f, 4.0f);
|
|
doSegment(8 * nDensity / 4);
|
|
|
|
startSegment(-0.9f, 4.0f, 4.0f);
|
|
endSegment(-0.65f, 4.0f, 4.0f);
|
|
doSegment(0);
|
|
|
|
startSegment(-0.9f, 2.0f, 2.0f);
|
|
endSegment(-0.65f, 2.0f, 2.0f);
|
|
doSegment(0);
|
|
|
|
startSegment(-0.9f, 0.0f, 0.0f);
|
|
endSegment(-0.4f, 0.0f, 0.0f);
|
|
doSegment(1 * nDensity / 4);
|
|
|
|
|
|
fXOffset = fXOffset - 0.15 * fXScale;
|
|
fYOffset = fYOffset + 3 * fYScale;
|
|
fZOffset = fZOffset + 3 * fZScale;
|
|
rightHalfCircle(5 * nDensity / 4, 1.0);
|
|
|
|
|
|
fXOffset = fXOffset + 0.25 * fXScale;
|
|
fYOffset = fYOffset - 2.0 * fYScale;
|
|
fZOffset = fZOffset - 2.0 * fZScale;
|
|
rightHalfCircle(5 * nDensity / 4, 1.0);
|
|
|
|
//restoring offsets to relative zero values
|
|
|
|
fXOffset = fXOffset - 0.10 * fXScale;
|
|
fYOffset = fYOffset - 1.0 * fYScale;
|
|
fZOffset = fZOffset - 1.0 * fZScale;
|
|
}
|
|
|
|
void C()
|
|
{
|
|
fYOffset = fYOffset + 2.0 * fYScale;
|
|
fZOffset = fZOffset + 2.0 * fZScale;
|
|
leftHalfCircle(11 * nDensity / 4, 2.0);
|
|
|
|
fYOffset = fYOffset + 1.0 * fYScale;
|
|
fZOffset = fZOffset + 1.0 * fZScale;
|
|
topRightHalfArch(3 * nDensity / 4, 1.0);
|
|
|
|
fYOffset = fYOffset - 2.0 * fYScale;
|
|
fZOffset = fZOffset - 2.0 * fZScale;
|
|
bottomRightHalfArch(3 * nDensity / 4, 1.0);
|
|
|
|
//restoring offsets to relative zero values
|
|
fYOffset = fYOffset - 1.0 * fYScale;
|
|
fZOffset = fZOffset - 1.0 * fZScale;
|
|
}
|
|
|
|
void D()
|
|
{
|
|
startSegment(-1.3, 0.0, 0.0);
|
|
endSegment(-1.3, 4.0, 4.0);
|
|
doSegment(8 * nDensity / 4);
|
|
|
|
startSegment(-1.1, 4.0, 4.0);
|
|
endSegment(-0.8, 4.0, 4.0);
|
|
doSegment(0 * nDensity / 4);
|
|
|
|
startSegment(-1.1, 0.0, 0.0);
|
|
endSegment(-0.8, 0.0, 0.0);
|
|
doSegment(0 * nDensity / 4);
|
|
|
|
fXOffset = fXOffset - 0.6 * fXScale;
|
|
fYOffset = fYOffset + 2.0 * fYScale;
|
|
fZOffset = fZOffset + 2.0 * fZScale;
|
|
rightHalfCircle(10 * nDensity / 4, 2.0);
|
|
|
|
//restoring offsets to relative zero values
|
|
fXOffset = fXOffset + 0.6 * fXScale;
|
|
fYOffset = fYOffset - 2.0 * fYScale;
|
|
fZOffset = fZOffset - 2.0 * fZScale;
|
|
}
|
|
|
|
void E()
|
|
{
|
|
startSegment(-1.4, 0.0, 0.0);
|
|
endSegment(-1.4, 4.0, 4.0);
|
|
doSegment(8 * nDensity / 4);
|
|
|
|
startSegment(-1.0, 4.0, 4.0);
|
|
endSegment(1.2, 4.0, 4.0);
|
|
doSegment(4 * nDensity / 4);
|
|
|
|
startSegment(-1.0, 2.0, 2.0);
|
|
endSegment(0.0, 2.0, 2.0);
|
|
doSegment(2 * nDensity / 4);
|
|
|
|
startSegment(-1.0, 0.0, 0.0);
|
|
endSegment(1.2, 0.0, 0.0);
|
|
doSegment(4 * nDensity / 4);
|
|
}
|
|
|
|
void F()
|
|
{
|
|
startSegment(-1.3, 0.0, 0.0);
|
|
endSegment(-1.3, 4.0, 4.0);
|
|
doSegment(8 * nDensity / 4);
|
|
|
|
startSegment(-0.8, 4.0, 4.0);
|
|
endSegment(1.3, 4.0, 4.0);
|
|
doSegment(4 * nDensity / 4);
|
|
|
|
startSegment(-0.8, 2.0, 2.0);
|
|
endSegment(0.1, 2.0, 2.0);
|
|
doSegment(2 * nDensity / 4);
|
|
}
|
|
|
|
void G()
|
|
{
|
|
fYOffset = fYOffset + 2.0 * fYScale;
|
|
fZOffset = fZOffset + 2.0 * fZScale;
|
|
leftHalfCircle(11 * nDensity / 4, 2.0);
|
|
|
|
fYOffset = fYOffset + 1.0 * fYScale;
|
|
fZOffset = fZOffset + 1.0 * fZScale;
|
|
topRightHalfArch(3 * nDensity / 4, 1.0);
|
|
|
|
fYOffset = fYOffset - 2.0 * fYScale;
|
|
fZOffset = fZOffset - 2.0 * fZScale;
|
|
bottomRightHalfArch(3 * nDensity / 4, 1.0);
|
|
|
|
//restoring offsets to relative zero values
|
|
fYOffset = fYOffset - 1.0 * fYScale;
|
|
fZOffset = fZOffset - 1.0 * fZScale;
|
|
|
|
|
|
startSegment(0.0, 1.5, 1.5);
|
|
endSegment(1.0, 1.5, 1.5);
|
|
doSegment(2 * nDensity / 4);
|
|
|
|
}
|
|
|
|
void H()
|
|
{
|
|
startSegment(-1.4, 0.0, 0.0);
|
|
endSegment(-1.4, 4.0, 4.0);
|
|
doSegment(8 * nDensity / 4);
|
|
|
|
startSegment(-1.0, 2.0, 2.0);
|
|
endSegment(1.0, 2.0, 2.0);
|
|
doSegment(4 * nDensity / 4);
|
|
|
|
startSegment(1.4, 0.0, 0.0);
|
|
endSegment(1.4, 4.0, 4.0);
|
|
doSegment(8 * nDensity / 4);
|
|
}
|
|
|
|
void I()
|
|
{
|
|
startSegment(0.0, 0.0, 0.0);
|
|
endSegment(0.0, 4.0, 4.0);
|
|
doSegment(8 * nDensity / 4);
|
|
|
|
startSegment(-1.2, 4.0, 4.0);
|
|
endSegment(1.2, 4.0, 4.0);
|
|
doSegment(4 * nDensity / 4);
|
|
|
|
startSegment(-1.2, 0.0, 0.0);
|
|
endSegment(1.2, 0.0, 0.0);
|
|
doSegment(4 * nDensity / 4);
|
|
}
|
|
|
|
void J()
|
|
{
|
|
startSegment(1.0, 1.25, 1.25);
|
|
endSegment(1.0, 4.0, 4.0);
|
|
doSegment(6 * nDensity / 4);
|
|
|
|
fXOffset = fXOffset - 0.25 * fXScale;
|
|
|
|
fYOffset = fYOffset + 1.25 * fYScale;
|
|
fZOffset = fZOffset + 1.25 * fZScale;
|
|
bottomHalfCircle(6 * nDensity / 4, 1.25);
|
|
|
|
//restoring offsets to relative zero values
|
|
fXOffset = fXOffset + 0.25 * fXScale;
|
|
fYOffset = fYOffset - 1.25 * fYScale;
|
|
fZOffset = fZOffset - 1.25 * fZScale;
|
|
}
|
|
|
|
void K()
|
|
{
|
|
startSegment(-1.3, 0.0, 0.0);
|
|
endSegment(-1.3, 4.0, 4.0);
|
|
doSegment(8 * nDensity / 4);
|
|
|
|
startSegment(-1.3, 2.0, 2.0);
|
|
endSegment(1.3, 4.0, 4.0);
|
|
doSegment(5 * nDensity / 4);
|
|
|
|
startSegment(-1.3, 2.0, 2.0);
|
|
endSegment(1.3, 0.0, 0.0);
|
|
doSegment(5 * nDensity / 4);
|
|
|
|
}
|
|
|
|
|
|
void L()
|
|
{
|
|
startSegment(-1.3, 0.0, 0.0);
|
|
endSegment(-1.3, 4.0, 4.0);
|
|
doSegment(8 * nDensity / 4);
|
|
|
|
startSegment(-0.9, 0.0, 0.0);
|
|
endSegment(1.3, 0.0, 0.0);
|
|
doSegment(4 * nDensity / 4);
|
|
}
|
|
|
|
void M()
|
|
{
|
|
startSegment(-1.3, 0.0, 0.0);
|
|
endSegment(-1.3, 4.0, 4.0);
|
|
doSegment(8 * nDensity / 4);
|
|
|
|
startSegment(1.3, 0.0, 0.0);
|
|
endSegment(1.3, 4.0, 4.0);
|
|
doSegment(8 * nDensity / 4);
|
|
|
|
startSegment(-1.1, 4.0, 4.0);
|
|
endSegment(0.0, 2.0, 2.0);
|
|
doSegment(4 * nDensity / 4);
|
|
|
|
startSegment(0.0, 2.0, 2.0);
|
|
endSegment(1.1, 4.0, 4.0);
|
|
doSegment(4 * nDensity / 4);
|
|
}
|
|
|
|
void N()
|
|
{
|
|
startSegment(-1.1, 0.0, 0.0);
|
|
endSegment(-1.1, 4.0, 4.0);
|
|
doSegment(8 * nDensity / 4);
|
|
|
|
startSegment(-1.1, 4.0, 4.0);
|
|
endSegment(1.1, 0.0, 0.0);
|
|
doSegment(8 * nDensity / 4);
|
|
|
|
startSegment(1.1, 0.0, 0.0);
|
|
endSegment(1.1, 4.0, 4.0);
|
|
doSegment(8 * nDensity / 4);
|
|
}
|
|
|
|
void O()
|
|
{
|
|
|
|
|
|
startSegment(-1.3f, 1.6f, 1.6f);
|
|
endSegment(1.3f, 1.6, 1.6f);
|
|
doSegment(1);
|
|
|
|
startSegment(-1.3f, 2.0f, 2.0f);
|
|
endSegment(1.3f, 2.0f, 2.0f);
|
|
doSegment(1);
|
|
|
|
startSegment(-1.3f, 2.4f, 2.4f);
|
|
endSegment(1.3f, 2.4f, 2.4f);
|
|
doSegment(1);
|
|
|
|
fYOffset = fYOffset + 1.3f * fYScale;
|
|
fZOffset = fZOffset + 1.3f * fZScale;
|
|
bottomHalfCircle(10 * nDensity / 4, 1.3);//);
|
|
|
|
fYOffset = fYOffset + 1.4f * fYScale;
|
|
fZOffset = fZOffset + 1.4f * fZScale;
|
|
|
|
topHalfCircle(10 * nDensity / 4, 1.3);//);
|
|
|
|
//restoring offsets to relative zero values
|
|
fYOffset = fYOffset - 2.7f * fYScale;
|
|
fZOffset = fZOffset - 2.7f * fZScale;
|
|
}
|
|
|
|
|
|
void P()
|
|
{
|
|
startSegment(-1.4, 0.0, 0.0);
|
|
endSegment(-1.4, 4.0, 4.0);
|
|
doSegment(8 * nDensity / 4);
|
|
|
|
startSegment(-0.9, 4.0, 4.0);
|
|
endSegment(-0.65, 4.0, 4.0);
|
|
doSegment(0 * nDensity / 4);
|
|
|
|
startSegment(-0.9, 2.0, 2.0);
|
|
endSegment(-0.65, 2.0, 2.0);
|
|
doSegment(0 * nDensity / 4);
|
|
|
|
fXOffset = fXOffset - 0.15 * fXScale;
|
|
fYOffset = fYOffset + 3.0 * fYScale;
|
|
fZOffset = fZOffset + 3.0 * fZScale;
|
|
rightHalfCircle(5 * nDensity / 4, 1.0);
|
|
|
|
//restoring offsets to relative zero values
|
|
fXOffset = fXOffset + 0.15 * fXScale;
|
|
fYOffset = fYOffset - 3.0 * fYScale;
|
|
fZOffset = fZOffset - 3.0 * fZScale;
|
|
}
|
|
|
|
void Q()
|
|
{
|
|
startSegment(-1.2, 1.6, 1.6);
|
|
endSegment(1.2, 1.6, 1.6);
|
|
doSegment(1);
|
|
|
|
startSegment(-1.2, 2.0, 2.0);
|
|
endSegment(1.2, 2.0, 2.0);
|
|
doSegment(1);
|
|
|
|
startSegment(-1.2, 2.4, 2.4);
|
|
endSegment(1.2, 2.4, 2.4);
|
|
doSegment(1);
|
|
|
|
startSegment(0.2, 1.1, 1.1);
|
|
endSegment(1.2, 0.0, 0.0);
|
|
doSegment(3 * nDensity / 4);
|
|
|
|
fYOffset = fYOffset + 1.3 * fYScale;
|
|
fZOffset = fZOffset + 1.3 * fZScale;
|
|
bottomHalfCircle(10 * nDensity / 4, 1.3);
|
|
|
|
fYOffset = fYOffset + 1.4 * fYScale;
|
|
fZOffset = fZOffset + 1.4 * fZScale;
|
|
topHalfCircle(10 * nDensity / 4, 1.3);
|
|
|
|
//restoring offsets to relative zero values
|
|
fYOffset = fYOffset - 2.7 * fYScale;
|
|
fZOffset = fZOffset - 2.7 * fZScale;
|
|
}
|
|
|
|
void R()
|
|
{
|
|
startSegment(-1.4, 0.0, 0.0);
|
|
endSegment(-1.4, 4.0, 4.0);
|
|
doSegment(8 * nDensity / 4);
|
|
|
|
startSegment(-0.9, 4.0, 4.0);
|
|
endSegment(-0.65, 4.0, 4.0);
|
|
doSegment(0);
|
|
|
|
startSegment(-0.9, 2.0, 2.0);
|
|
endSegment(-0.65, 2.0, 2.0);
|
|
doSegment(0);
|
|
|
|
|
|
startSegment(-0.9, 2.0, 2.0);
|
|
endSegment(0.85, 0.0, 0.0);
|
|
doSegment(3 * nDensity);
|
|
|
|
fXOffset = fXOffset - 0.15 * fXScale;
|
|
fYOffset = fYOffset + 3.0 * fYScale;
|
|
fZOffset = fZOffset + 3.0 * fZScale;
|
|
rightHalfCircle(5 * nDensity / 4, 1.0);
|
|
|
|
//restoring offsets to relative zero values
|
|
fXOffset = fXOffset + 0.15 * fXScale;
|
|
fYOffset = fYOffset - 3.0 * fYScale;
|
|
fZOffset = fZOffset - 3.0 * fZScale;
|
|
}
|
|
|
|
void S()
|
|
{
|
|
startSegment(0.0, 0.0, 0.0);
|
|
endSegment(0.0, 4.0, 4.0);
|
|
doSegment(2);
|
|
|
|
fXOffset = fXOffset - 0.5 * fXScale;
|
|
fYOffset = fYOffset + 3.0 * fYScale;
|
|
fZOffset = fZOffset + 3.0 * fZScale;
|
|
leftHalfCircle(6 * nDensity / 4, 1.0);
|
|
|
|
fXOffset = fXOffset + 1.0 * fXScale;
|
|
topRightHalfArch(3 * nDensity / 4, 1.0);
|
|
|
|
fYOffset = fYOffset - 2.0 * fYScale;
|
|
fZOffset = fZOffset - 2.0 * fZScale;
|
|
rightHalfCircle(6 * nDensity / 4, 1.0);
|
|
|
|
fXOffset = fXOffset - 1.0 * fXScale;
|
|
bottomLeftHalfArch(3 * nDensity / 4, 1.0);
|
|
|
|
//restoring offsets to relative zero values
|
|
fXOffset = fXOffset + 0.5 * fXScale;
|
|
fYOffset = fYOffset - 1.0 * fYScale;
|
|
fZOffset = fZOffset - 1.0 * fZScale;
|
|
}
|
|
|
|
void T()
|
|
{
|
|
startSegment(0.0, 0.0, 0.0);
|
|
endSegment(0.0, 4.0, 4.0);
|
|
doSegment(8 * nDensity / 4);
|
|
|
|
startSegment(-1.3, 4.0, 4.0);
|
|
endSegment(1.3, 4.0, 4.0);
|
|
doSegment(6 * nDensity / 4);
|
|
}
|
|
|
|
void U()
|
|
{
|
|
startSegment(1.25, 1.25, 1.25);
|
|
endSegment(1.25, 4.0, 4.0);
|
|
doSegment(6 * nDensity / 4);
|
|
|
|
startSegment(-1.25, 1.25, 1.25);
|
|
endSegment(-1.25, 4.0, 4.0);
|
|
doSegment(6 * nDensity / 4);
|
|
|
|
fYOffset = fYOffset + 1.25 * fYScale;
|
|
fZOffset = fZOffset + 1.25 * fZScale;
|
|
|
|
bottomHalfCircle(6 * nDensity / 4, 1.25);
|
|
|
|
//restoring offsets to relative zero values
|
|
fYOffset = fYOffset - 1.25 * fYScale;
|
|
fZOffset = fZOffset - 1.25 * fZScale;
|
|
}
|
|
|
|
void V()
|
|
{
|
|
startSegment(-1.2, 4.0, 4.0);
|
|
endSegment(0.0, 0.0, 0.0);
|
|
doSegment(8 * nDensity / 4);
|
|
|
|
startSegment(1.2, 4.0, 4.0);
|
|
endSegment(0.0, 0.0, 0.0);
|
|
doSegment(8 * nDensity / 4);
|
|
}
|
|
|
|
void W()
|
|
{
|
|
startSegment(-1.4, 4.0, 4.0);
|
|
endSegment(-0.7, 0.0, 0.0);
|
|
doSegment(6 * nDensity / 4);
|
|
|
|
startSegment(-0.7, 0.0, 0.0);
|
|
endSegment(0.0, 2.0, 2.0);
|
|
doSegment(3 * nDensity / 4);
|
|
|
|
startSegment(0.0, 2.0, 2.0);
|
|
endSegment(0.7, 0.0, 0.0);
|
|
doSegment(3 * nDensity / 4);
|
|
|
|
startSegment(1.4, 4.0, 4.0);
|
|
endSegment(0.7, 0.0, 0.0);
|
|
doSegment(6 * nDensity / 4);
|
|
}
|
|
|
|
void X()
|
|
{
|
|
startSegment(-1.3, 0.0, 0.0);
|
|
endSegment(1.3, 4.0, 4.0);
|
|
doSegment(8 * nDensity / 4);
|
|
|
|
startSegment(-1.3, 4.0, 4.0);
|
|
endSegment(1.3, 0.0, 0.0);
|
|
doSegment(8 * nDensity / 4);
|
|
}
|
|
|
|
void Y()
|
|
{
|
|
startSegment(-1.3, 4.0, 4.0);
|
|
endSegment(0.0, 2.0, 2.0);
|
|
doSegment(4 * nDensity / 4);
|
|
|
|
startSegment(0.0, 2.0, 2.0);
|
|
endSegment(1.3, 4.0, 4.0);
|
|
doSegment(4 * nDensity / 4);
|
|
|
|
startSegment(0.0, 0.0, 0.0);
|
|
endSegment(0.0, 2.0, 2.0);
|
|
doSegment(4 * nDensity / 4);
|
|
}
|
|
|
|
void Z()
|
|
{
|
|
startSegment(-1.3, 0.0, 0.0);
|
|
endSegment(1.3, 4.0, 4.0);
|
|
doSegment(8 * nDensity / 4);
|
|
|
|
startSegment(-1.3, 4.0, 4.0);
|
|
endSegment(1.3, 4.0, 4.0);
|
|
doSegment(6 * nDensity / 4);
|
|
|
|
startSegment(-1.3, 0.0, 0.0);
|
|
endSegment(1.3, 0.0, 0.0);
|
|
doSegment(6 * nDensity / 4);
|
|
}
|
|
|
|
void apostrophe()
|
|
{
|
|
startSegment(0.0, 3.8, 3.8);
|
|
endSegment(0.8, 3.0, 3.0);
|
|
doSegment(2);
|
|
}
|
|
|
|
void period()
|
|
{
|
|
startSegment(0.0, 0.0, 0.0);
|
|
endSegment(0.0, 0.0, 0.0);
|
|
doSegment(0);
|
|
}
|
|
|
|
void exclamation()
|
|
{
|
|
startSegment(0.0, 0.0, 0.0);
|
|
endSegment(0.0, 0.0, 0.0);
|
|
doSegment(0);
|
|
|
|
startSegment(0.0, 1.0, 1.0);
|
|
endSegment(0.0, 4.0, 4.0);
|
|
doSegment(7 * nDensity / 4);
|
|
}
|
|
|
|
void questionmark()
|
|
{
|
|
startSegment(0.0, 0.0, 0.0);
|
|
endSegment(0.0, 0.0, 0.0);
|
|
doSegment(0);
|
|
|
|
startSegment(0.0, 1.0, 1.0);
|
|
endSegment(0.0, 2.0, 2.0);
|
|
doSegment(3 * nDensity / 4);
|
|
|
|
fYOffset = fYOffset + 3.0 * fYScale;
|
|
fZOffset = fZOffset + 3.0 * fZScale;
|
|
rightHalfCircle(8 * nDensity / 4, 1.0);
|
|
|
|
fYOffset = fYOffset + 0.5 * fYScale;
|
|
fZOffset = fZOffset + 0.5 * fZScale;
|
|
topLeftHalfArch(4 * nDensity / 4, 0.5);
|
|
|
|
//restoring offsets to relative zero values
|
|
fYOffset = fYOffset - 3.5 * fYScale;
|
|
fZOffset = fZOffset - 3.5 * fZScale;
|
|
}
|
|
|
|
void printLetter(string sLetterToPrint)
|
|
{
|
|
if (sLetterToPrint == " ")
|
|
{
|
|
fXOffset = fXOffset + 3.2 * fXScale;
|
|
}
|
|
else
|
|
{
|
|
if (bLowerCase != 1)
|
|
{
|
|
if (sLetterToPrint != GetStringUpperCase(sLetterToPrint))
|
|
{
|
|
fXScale = 2 * fXScale / 3;
|
|
fYScale = 2 * fYScale / 3;
|
|
fZScale = 2 * fZScale / 3;
|
|
nDensity = 3;
|
|
bLowerCase = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (sLetterToPrint == GetStringUpperCase(sLetterToPrint))
|
|
{
|
|
fXScale = 3 * fXScale / 2;
|
|
fYScale = 3 * fYScale / 2;
|
|
fZScale = 3 * fZScale / 2;
|
|
nDensity = 4;
|
|
bLowerCase = 0;
|
|
}
|
|
}
|
|
|
|
|
|
if (sLetterToPrint == "'")
|
|
{
|
|
fXOffset = fXOffset + 2.2 * fXScale;
|
|
apostrophe();
|
|
fXOffset = fXOffset + 0.8 * fXScale;
|
|
}
|
|
else if (sLetterToPrint == "!")
|
|
{
|
|
fXOffset = fXOffset + 2.2 * fXScale;
|
|
exclamation();
|
|
fXOffset = fXOffset + 1.4 * fXScale;
|
|
}
|
|
else if (sLetterToPrint == ".")
|
|
{
|
|
fXOffset = fXOffset + 2.2 * fXScale;
|
|
period();
|
|
fXOffset = fXOffset + 1.4 * fXScale;
|
|
}
|
|
else
|
|
{
|
|
fXOffset = fXOffset + 3.6 * fXScale;
|
|
if (bLowerCase != 1)
|
|
{
|
|
if (sLetterToPrint != GetStringUpperCase(sLetterToPrint))
|
|
{
|
|
fXScale = 2 * fXScale / 4;
|
|
fYScale = 2 * fYScale / 4;
|
|
fZScale = 2 * fZScale / 4;
|
|
nDensity = 3;
|
|
bLowerCase = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (sLetterToPrint == GetStringUpperCase(sLetterToPrint))
|
|
{
|
|
fXScale = 3 * fXScale / 2;
|
|
fYScale = 3 * fYScale / 2;
|
|
fZScale = 3 * fZScale / 2;
|
|
nDensity = 4;
|
|
bLowerCase = 0;
|
|
}
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "A")
|
|
{
|
|
A();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "B")
|
|
{
|
|
B();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "C")
|
|
{
|
|
C();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "D")
|
|
{
|
|
D();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "E")
|
|
{
|
|
E();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "F")
|
|
{
|
|
F();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "G")
|
|
{
|
|
G();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "H")
|
|
{
|
|
H();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "I")
|
|
{
|
|
I();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "J")
|
|
{
|
|
J();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "K")
|
|
{
|
|
K();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "L")
|
|
{
|
|
L();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "M")
|
|
{
|
|
M();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "N")
|
|
{
|
|
N();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "O")
|
|
{
|
|
O();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "P")
|
|
{
|
|
P();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "Q")
|
|
{
|
|
Q();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "R")
|
|
{
|
|
R();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "S")
|
|
{
|
|
S();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "T")
|
|
{
|
|
T();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "U")
|
|
{
|
|
U();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "V")
|
|
{
|
|
V();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "W")
|
|
{
|
|
W();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "X")
|
|
{
|
|
X();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "Y")
|
|
{
|
|
Y();
|
|
}
|
|
if (GetStringUpperCase(sLetterToPrint) == "Z")
|
|
{
|
|
Z();
|
|
}
|
|
if (sLetterToPrint == "?")
|
|
{
|
|
questionmark();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void printLine(string sLine)
|
|
{
|
|
ApplyEffectAtLocation(DURATION_TYPE_PERMANENT, EffectVisualEffect(VFX_FNF_FIRESTORM), lTarget);
|
|
int nLineLength = GetStringLength(sLine);
|
|
if (nMessageType = 1) //all lower case
|
|
{
|
|
fSpacing = (2.6 * fXScale) * nLineLength / 2;
|
|
}
|
|
if (nMessageType = 2) //all upper case
|
|
{
|
|
fSpacing = (3.6 * fXScale) * nLineLength / 2;
|
|
}
|
|
if (nMessageType = 3) //mixed - upper and lower case
|
|
{
|
|
fSpacing = (3.0 * fXScale) * nLineLength / 2;
|
|
}
|
|
|
|
fXOffset = fXOffset - fSpacing;
|
|
int nLetter = 0;
|
|
|
|
while (nLetter < nLineLength)
|
|
{
|
|
sLetterToPrint = GetSubString(sLine, nLetter, 1);
|
|
printLetter(sLetterToPrint);
|
|
nLetter++;
|
|
}
|
|
fXOffset = fXOffset + fSpacing;
|
|
if ( nDuration == DURATION_TYPE_TEMPORARY)
|
|
{
|
|
DelayCommand(7.0, destroy(sBluePrint));
|
|
}
|
|
}
|
|
|
|
void printMessage(string sMessage)
|
|
{
|
|
nDuration = DURATION_TYPE_TEMPORARY;
|
|
nMessageLength = GetStringLength(sMessage);
|
|
if (nMessageLength > 12)
|
|
{
|
|
while (nMessageLength > 12)
|
|
{
|
|
sMessage = getLine(sMessage);
|
|
nMessageLength = GetStringLength(sMessage);
|
|
if ( nMessageLength <= 12)
|
|
{
|
|
if (nMessageLength == -1)
|
|
break;
|
|
else
|
|
ActionDoCommand(printLine(sMessage));
|
|
}
|
|
}
|
|
}
|
|
else printLine(sMessage);
|
|
}
|
|
|
|
string getLine(string sMessage)
|
|
{
|
|
int nLetters = 12;
|
|
sLetter = "a";
|
|
while (nLetters >= 0)
|
|
{
|
|
sLetter = GetSubString(sMessage, nLetters, 1);
|
|
if (sLetter == " ")
|
|
{
|
|
ActionDoCommand(printLine(GetSubString(sMessage, 0, nLetters)));
|
|
sMessage = GetSubString(sMessage, nLetters + 1, nMessageLength - nLetters - 1);
|
|
ActionWait(8.0);
|
|
break;
|
|
}
|
|
nLetters--;
|
|
|
|
}
|
|
if (nLetters == -1)
|
|
{
|
|
SpeakString("Your words are too long.");
|
|
DelayCommand(0.8, SpeakString("I cannot understand you."));
|
|
sMessage = "";
|
|
}
|
|
return sMessage;
|
|
}
|
|
|
|
//uncomment to test
|
|
/*
|
|
void main()
|
|
{
|
|
}
|
|
*/
|