public void addVal(SPoint p, float m, float di, float diDist, float dm, float w)
{
vtxArr[curInd]= new AttkVtx(p, m, di, dm, w);
curInd++;
if(vCount==0){//indicates a reset
dir=0;
wgt=0;
perimeter=0;
diDist=0;
xMin = p.x;
xMax = p.x;
yMin = p.y;
yMax = p.y;
}
dir+=di;
perimeter+=1;
wgt+=w;
vCount++;
if(m>mag)
mag=m;
if(dm>dmg)
dmg=dm;
if(xMin>p.x)
xMin=p.x;
if(xMax<p.x)
xMax = p.x;
if(yMin>p.y)
yMin=p.y;
if(yMax<p.y)
yMax=p.y;
}
public void AllocateSecondIndices(int ind, int num)
{
jLength[ind] = num;
aVtx[ind] = new AttkVtx[num];
atkAng[ind] = new float[num];
pBounds[ind] = new SPoint[num];
for (int i=0; i<num; i++) {
atkAng [ind] [i] = 0;
aVtx[ind][i]=new AttkVtx();
}
}
public AttkVtx(AttkVtx a)
{
next = null;
frame = -1;
mag = a.mag;
dmg = a.dmg;
dir = a.dir;
brk = a.brk;
wgt = a.wgt;
rad = a.rad;
}
public float wgt; //weight used in the hit function
#endregion Fields
#region Constructors
public AttkVtx( )
{
dmg=0;
dir=0;
wgt=0;
mag=0;
rad=0;
pri = 0;
pos = new SPoint(0,0);
next = null;
frame = -1;
brk = false;
}
public AttkVtx(SPoint p, float m, float d, float dm, float w)
{
next = null;
frame = -1;
pos = new SPoint(p.x, p.y);
mag = m;
dmg = dm;
dir = d;
pri = 0;
brk = false;
wgt = w;
rad = 0;
}
public AttkTrack( )
{
priority = -1;//just a default
trackType=0;
aVtx=null;
hit=null;
centre = null;
polyNum=null;
noHit=false;
isRadial = false;
isVacuum = false;
atkAng=null;
}
public void CopyFrom(AttkVtx s)
{
if (this == s)
return ;
next = s.next;
frame = s.frame;
mag = s.mag;
dmg = s.dmg;
dir = s.dir;
brk = s.brk;
wgt = s.wgt;
pos = s.pos;
rad = s.rad;
}
public void AllocateFirstIndices(int num)
{
iLength = num;
jLength = new int[iLength];
hit = new bool[iLength][];
atkAng = new float[iLength][];
aVtx = new AttkVtx[iLength][];
pBounds = new SPoint[iLength][];
centre = new AttkVtx();
polyNum = new int[iLength];
for(int i = 0; i < iLength;i++){
aVtx[i]=null;
if(iLength>1)//issues with null arrays
atkAng[i]=null;
pBounds[i] = null;
jLength[i]=0;
polyNum[i]=1;
hit[i]=new bool[4];
for(int j=0;j<4;j++)
hit[i][j]=false;
}
}
protected AttkVtx InterpVert(AttkVtx vI, AttkVtx vO, Fighter plr)
{
//returns an interpolated vertec between vI (vertex inside player hitbox),
//vO(vertex outside player hitbox), where plr is the player
AttkVtx retVtx = new AttkVtx();
float itpWgt = 1.1f;
if(vO.pos.x > plr.Right()){
retVtx.pos.x=plr.Right();
itpWgt = (plr.Right() - vI.pos.x)/(vO.pos.x-vI.pos.x);
retVtx.pos.y = itpWgt*vI.pos.y + (1-itpWgt)*vO.pos.y;//solve rest
}else if(vO.pos.x < plr.Left()){
retVtx.pos.x=plr.Left();
itpWgt = (plr.Left() - vI.pos.x)/(vO.pos.x-vI.pos.x);
retVtx.pos.y = itpWgt*vI.pos.y + (1-itpWgt)*vO.pos.y;//solve rest
}
if(itpWgt>1){
if(vO.pos.y > plr.Top()){
retVtx.pos.y=plr.Top();
itpWgt = (plr.Top() - vI.pos.y)/(vO.pos.y-vI.pos.y);
retVtx.pos.x = itpWgt*vI.pos.x + (1-itpWgt)*vO.pos.x;//solve rest
}
else if(vO.pos.y > plr.Bottom()){
retVtx.pos.y=plr.Bottom();
itpWgt = (plr.Bottom() - vI.pos.y)/(vO.pos.y-vI.pos.y);
retVtx.pos.x = itpWgt*vI.pos.x + (1-itpWgt)*vO.pos.x;//solve rest
}
}
retVtx.mag = itpWgt*vI.mag + (1-itpWgt)*vO.mag;
retVtx.dir = itpWgt*vI.dir + (1-itpWgt)*vO.dir;
retVtx.dmg = itpWgt*vI.dmg + (1-itpWgt)*vO.dmg;
retVtx.wgt = itpWgt*vI.wgt + (1-itpWgt)*vO.wgt;
return retVtx;
}
public void FetchFrame(int atkInd, float aniLen, float frameInd, int tInd, SPoint loc, bool isRight, AttkTrack aTr)
{
AttkVtx vertex;
vertex = trackList[atkInd].GetVertSPointer(tInd, 0);
int atkLen;
if((vertex==null)||(vertex.frame > frameInd)){// attack not yet active
aTr.noHit=true;
return;
}
if (trackList [atkInd].trackType == 4){// for flash attacks
if (!flashAtkRdy)//leave if not ready
return;
else
flashAtkRdy=false;
}
//FetchFlashFrame (atkInd, aniLen,frameInd, tInd, loc, isRight, aTr);
AttkVtx[] rtnArr;
AttkVtx ctr=new AttkVtx();
SPoint retCtr = new SPoint();
if (trackList [atkInd].isRadial) {
aTr.AllocateFirstIndices (trackList [atkInd].GetJlength (tInd));//prepare for number of circles
aTr.AllocateSecondIndices(0, trackList[atkInd].FetchNextBreak(tInd,0, true)+1);//allocate for first poly
}else{
aTr.AllocateFirstIndices(trackList[atkInd].polyNum[tInd]);//prepare for number of sub-polygons
aTr.AllocateSecondIndices(0, trackList[atkInd].FetchNextBreak(tInd,0, true)+1);//allocate for first poly
}
float lastFrame = 0;
float firstFrame=0;
SPoint lastPt = new SPoint();
float lastDir=0, lastDmg=0, lastMag=0, lastWgt=0, lastCtrX=0, lastCtrY = 0, lastRad=0;
float frameTime=1/60.0f;
frameTime=frameTime/aniLen;
float aWgt;
float[] radArr;
int lastBk=0;
int pInd=0;//to keep track of tracks/jIndex
float diffHldr =0;
if(atkInd < numAtk){
int numVerts;
if(trackList[atkInd].isRadial);
numVerts= trackList[atkInd].jLength[tInd];
rtnArr = new AttkVtx[numVerts];
radArr = new float[numVerts];
for(int j = 0; j < numVerts; j++)
rtnArr[j]=new AttkVtx();
for(int j = 0; j < numVerts; j++){
vertex = trackList[atkInd].GetVertSPointer(tInd, j);
if(vertex.frame <0) //vertex SPointer
vertex = trackList[atkInd].GetVertSPointer(tInd, (int)vertex.pos.x);
firstFrame = vertex.frame;
ctr = trackList[atkInd].GetCtrSPointer(tInd);
while((vertex.next != null)&&(frameInd >= vertex.frame)){
lastFrame = vertex.frame;
lastPt.x = vertex.pos.x;
lastPt.y = vertex.pos.y;
lastMag = vertex.mag;
lastDir = vertex.dir;
lastDmg = vertex.dmg;
lastWgt = vertex.wgt;
lastRad = vertex.rad;
vertex = vertex.next;
lastCtrX = ctr.pos.x;
lastCtrY = ctr.pos.y;
ctr=ctr.next;
}
//end of vertlist implies the active window has ended.
//cancel the function here
diffHldr = frameInd-frameTime;
if((vertex.frame<frameInd)&&(firstFrame>frameInd-frameTime)){
//entire attack passed between last frame and this
//retrieve first vals so it is not skipped
vertex = trackList[atkInd].GetVertSPointer(tInd, j);
if(vertex.frame <0) //vertex SPointer
vertex = trackList[atkInd].GetVertSPointer(tInd, (int)vertex.pos.x);
frameInd=vertex.frame;//set to start
}
else if(vertex.frame<frameInd){
aTr.noHit=true;
return;
}
if(Mathf.Abs(lastFrame - vertex.frame) == 0)
aWgt = 0;
else
aWgt = (frameInd - lastFrame)/Mathf.Abs(lastFrame - vertex.frame); //alpha weight for interpolation
if(isRight){
rtnArr[j].pos.x = (1-aWgt)*lastPt.x + (aWgt)*vertex.pos.x + loc.x;
rtnArr[j].dir = (1-aWgt)*lastDir + (aWgt)*vertex.dir;
}
else{//INVERTED DIRS HERE
rtnArr[j].pos.x = -(1-aWgt)*lastPt.x -(aWgt)*vertex.pos.x + loc.x;
rtnArr[j].dir = (1-aWgt)*lastDir + (aWgt)*vertex.dir;
float diff = ((Mathf.PI/2)-rtnArr[j].dir)*2.0f;
rtnArr[j].dir+=diff;
}
rtnArr[j].pos.y = (1-aWgt)*lastPt.y + (aWgt)*vertex.pos.y + loc.y;
rtnArr[j].dmg = (1-aWgt)*lastDmg + (aWgt)*vertex.dmg;
rtnArr[j].mag = (1-aWgt)*lastMag + (aWgt)*vertex.mag;
rtnArr[j].wgt = (1-aWgt)*lastWgt + (aWgt)*vertex.wgt;
rtnArr[j].rad = (1-aWgt)*lastRad + (aWgt)*vertex.rad;
radArr[j] =rtnArr[j].rad;
retCtr.x = (1-aWgt)*lastCtrX + (aWgt)*ctr.pos.x;
retCtr.y = (1-aWgt)*lastCtrY + (aWgt)*ctr.pos.y;
aTr.SetCentre(retCtr.x, retCtr.y, 0, pInd);
//this attack track is ONE track
// with the polygons separated into new tracks.
//always start each poly on new track
SPoint[] spArr = new SPoint[numVerts];
for(int k=0;k<numVerts;k++){
spArr[k] = new SPoint(rtnArr[k].pos.x, rtnArr[k].pos.y);
}
SPoint[] circHolder = new SPoint[AttkTrack.CIRC_VNUM];
if((trackList[atkInd].isRadial)&&(j==numVerts-1)){
circHolder = trackList[atkInd].FetchRadialRenderingFrame(spArr, radArr);
AttkVtx radVertHolder = new AttkVtx();
for(int m = 0; m<numVerts;m++){
for(int k=0; k<AttkTrack.CIRC_VNUM;k++)
{
radVertHolder = new AttkVtx(circHolder[k+m*AttkTrack.CIRC_VNUM], rtnArr[m].mag, rtnArr[m].dir,rtnArr[m].dmg, rtnArr[m].wgt);
aTr.SetVertex(radVertHolder, m, k);
}
if(m<j){
int brkCheck=trackList[atkInd].FetchNextBreak(tInd, m, true);
aTr.AllocateSecondIndices(m+1, AttkTrack.CIRC_VNUM);
}
}
}else if((trackList[atkInd].aVtx[tInd][j].brk)||(j==numVerts-1)){//end of this polygon
//continue handling circles here
if(isRight)
for(int k = lastBk; k<=j; k++)//add rtnArr to aTr
aTr.SetVertex(rtnArr[k], pInd, k-lastBk);
else
for(int k = j; k>=lastBk; k--)//add rtnArr to aTr
aTr.SetVertex(rtnArr[k], pInd, j-k);
pInd++;
if(j<numVerts-1){//do not preemtively allocate when done
int brkCheck=trackList[atkInd].FetchNextBreak(tInd, j, true);
aTr.AllocateSecondIndices(pInd, trackList[atkInd].FetchNextBreak(tInd, j, true)-j);
}
lastBk=j+1;
}
}
//if(rtnArr!=null)
// rtnArr=null;
if(trackList[atkInd].isRadial){
for(int i=0;i<aTr.iLength;i++){
for(int j = 0; j < AttkTrack.CIRC_VNUM-1; j++){
aTr.atkAng[i][j] = Mathf.Atan2(aTr.aVtx[i][j+1].pos.y - aTr.aVtx[i][j].pos.y, aTr.aVtx[i][j+1].pos.x - aTr.aVtx[i][j].pos.x); //store angles for detection
aTr.atkAng[i][AttkTrack.CIRC_VNUM-1] = Mathf.Atan2(aTr.aVtx[i][0].pos.y - aTr.aVtx[i][AttkTrack.CIRC_VNUM-1].pos.y, aTr.aVtx[i][0].pos.x - aTr.aVtx[i][AttkTrack.CIRC_VNUM-1].pos.x);
}
}
}else{
for(int i=0;i<aTr.iLength;i++){
atkLen=aTr.GetJlength(i);
for(int j = 0; j < atkLen-1; j++)
aTr.atkAng[i][j] = Mathf.Atan2(aTr.aVtx[i][j+1].pos.y - aTr.aVtx[i][j].pos.y, aTr.aVtx[i][j+1].pos.x - aTr.aVtx[i][j].pos.x); //store angles for detection
aTr.atkAng[i][atkLen-1] = Mathf.Atan2(aTr.aVtx[i][0].pos.y - aTr.aVtx[i][atkLen-1].pos.y, aTr.aVtx[i][0].pos.x - aTr.aVtx[i][atkLen-1].pos.x);
}
}
}
AttkTrack rTr = FetchRadialFrame (aTr);
}
public void SetCentre(float x, float y, float frame, int iInd)
{
AttkVtx c = centre;
AttkVtx lC = null;
if(c==null){
c.pos = new SPoint(x, y);
c.frame = frame;
}else{
while((c != null)&&(c.frame >= 0)&&(c.frame != frame)){
lC = c;
c = c.next;
}
if(c == null){
c = new AttkVtx(lC);
c.frame = frame;
lC.next = c;
}
c.pos = new SPoint(x, y);
c.frame = frame;
}
}
protected AttkVtx InterpCorner(AttkVtx[] arrV, int arrLen, SPoint oPos)
{
AttkVtx rtnVtx = new AttkVtx();
float dist = 0;
float distSum=0;
SPoint tPos = new SPoint();
for(int i = 0; i< arrLen;i++){
tPos.x = arrV[i].pos.x-oPos.x;//tranlated for ease of calculations
tPos.y = arrV[i].pos.y-oPos.y;
dist=Mathf.Sqrt(tPos.SqDistFromOrigin());
distSum+=dist;
}//now average out verts
for(int i = 0; i< arrLen;i++){
tPos.x = arrV[i].pos.x-oPos.x;//tranlated for ease of calculations
tPos.y = arrV[i].pos.y-oPos.y;
dist=Mathf.Sqrt(tPos.SqDistFromOrigin());
rtnVtx.mag+=(dist/distSum)*arrV[i].mag;
rtnVtx.dir+=(dist/distSum)*arrV[i].dir;
rtnVtx.dmg+=(dist/distSum)*arrV[i].dmg;
rtnVtx.wgt+=(dist/distSum)*arrV[i].wgt;
}
return rtnVtx;
}
public void SetDamage(float damage, float frame, int iInd, int jInd)
{
AttkVtx vertex = GetVertSPointer(iInd, jInd);
AttkVtx lastVertex = null;
if((iInd < iLength)&&(jInd<jLength[iInd])){
while((vertex != null)&&(vertex.frame >= 0)&&(vertex.frame != frame)){
lastVertex = vertex;
vertex = vertex.next;
}
if(vertex == null){
vertex = new AttkVtx(lastVertex);
vertex.frame = frame;
lastVertex.next = vertex;
}
vertex.dmg = damage;
}
}
public void SetRadius(float rad, float frame, int iInd, int jInd)
{
AttkVtx vertex = aVtx[iInd][jInd];
AttkVtx lastVertex = null;
if((iInd < iLength)&&(jInd<jLength[iInd])){
while((vertex != null)&&(vertex.frame >= 0)&&(vertex.frame != frame)){
lastVertex = vertex;
vertex = vertex.next;
}
if(vertex == null){
vertex = new AttkVtx(lastVertex);
vertex.frame = frame;
lastVertex.next = vertex;
}
vertex.rad = rad;
}
}
public void SetVertex(float px, float py, float frame, int iInd, int jInd)
{
//sets a vertex with a given frame.
//ALL verts are meant to be input in chronological order (by frames)
//this function sets the vert values of the vert at the specified frame,
// or makes a new frame if none exists.
AttkVtx vertex = aVtx[iInd][jInd];
AttkVtx lastVertex = null;
if(frame<0){//vertex SPointer
vertex.pos = new SPoint(px, py);
vertex.frame = frame;
}else{
if((iInd < iLength)&&(jInd<jLength[iInd])){
while((vertex != null)&&(vertex.frame >= 0)&&(vertex.frame != frame)){
lastVertex = vertex;
vertex = vertex.next;
}
if(vertex == null){
vertex = new AttkVtx(lastVertex);
vertex.frame = frame;
lastVertex.next = vertex;
}
vertex.pos = new SPoint(px, py);
vertex.frame = frame;
}
}
}
public void SetVertex(AttkVtx a, int iInd, int jInd)
{
aVtx[iInd][jInd].pos.x = a.pos.x;
aVtx[iInd][jInd].pos.y = a.pos.y;
aVtx[iInd][jInd].mag = a.mag;
aVtx[iInd][jInd].dmg = a.dmg;
aVtx[iInd][jInd].dir = a.dir;
aVtx[iInd][jInd].wgt = a.wgt;
}
public void SetWeight(float weight, float frame, int iInd, int jInd)
{
AttkVtx vertex = aVtx[iInd][jInd];
AttkVtx lastVertex = null;
if((iInd < iLength)&&(jInd<jLength[iInd])){
while((vertex != null)&&(vertex.frame >= 0)&&(vertex.frame != frame)){
lastVertex = vertex;
vertex = vertex.next;
}
if(vertex == null){
vertex = new AttkVtx(lastVertex);
vertex.frame = frame;
}
vertex.wgt = weight;
}
}
