public override void InsertBetween(DynShelterModule prev, DynShelterModule next)
{
if(next == null && prev == null)
return;
if(next == null) // la facade est le dernier module
{
// Debug.Log("dernier module");
//Retourne la facade
// Vector3 flip = new Vector3(0,180,0);
// Quaternion flipQuat = new Quaternion(0,0,0,0);
// flipQuat.eulerAngles = flip;
// _moduleGameObj.transform.localRotation = flipQuat;
foreach(Transform t in _moduleGameObj.transform)
{
Vector3 pos = t.localPosition;
pos.z = -pos.z;
t.localPosition = pos;
// Debug.Log("pos : "+pos);
}
prev.SetNextModule(this);
this.SetPrevModule(prev);
}
/*else*/ //prev = null, la facade est le premier module
if(prev == null)
{
// Debug.Log("premier module");
next.SetPrevModule(this);
this.SetNextModule(next);
}
}
public override void InsertBetween(DynShelterModule prev, DynShelterModule next)
{
if(next == null) // la facade est le dernier module
{
SetPos(false,prev.GetExtPos(AR).z);
prev.SetNextModule(this);
this.SetPrevModule(prev);
}
else //prev = null, la facade est le premier module
{
SetPos(false,next.GetExtPos(AV).z);
next.SetPrevModule(this);
this.SetNextModule(next);
}
}
//CONSTRUCTOR---
public DynShelterModule(int size,string style,FunctionConf_Dynshelter.ModuleType type,Color32 color,FunctionConf_Dynshelter parent)
{
_size = size;
_style = style;
_type = type;
_color = color;
_parentConf = parent;
//--------------------------------------------
_tag = _type.ToString()+"_t"+_size+"_"+_style;
_canMoveNext = true;
_canMovePrev = true;
_lockNext = true;
_lockPrev = true;
_isAnchored = false;
_nextModule = null;
_prevModule = null;
_transparent = new Material(Shader.Find("Transparent/Diffuse"));
_transparent.color = new Color(1,1,1,0.25f);
_backUpMaterials = new ArrayList();
}
public override bool MoveModuleV2(float delta, DynShelterModule startPoint,bool actOnPrevs=true,bool actOnNexts=true)
{
// Debug.Log ("delta : "+delta+", actOnPrevs : "+actOnPrevs+", actOnNexts : "+actOnNexts);
if(_nextModule != null)
{
// Debug.Log ("next module");
if(startPoint != _nextModule)
{
// Debug.Log ("startPoint != _nextModule");
return _nextModule.MoveModuleV2(delta,null);
}
else
{
// Debug.Log ("false startPoint != _nextModule");
SetPos(false,GetMyPos(false));
return true;
}
}
else if(_prevModule != null)
{
// Debug.Log ("prev module");
if(startPoint != _prevModule)
{
// Debug.Log ("startPoint != _nextModule");
return _prevModule.MoveModuleV2(delta,null);
}
else
{
// Debug.Log ("false startPoint != _nextModule");
SetPos(false,GetMyPos(true));
return true;
}
}
else
return false;
}
//Mets a jours le module courant
public void UpdateCurrentModule()
{
//Debug.Log("selectedIndex : "+_selectedIndex+" count : "+_modules.Count );
if(_modules.Count > 0)
{
/*if(_selectedIndex==-1)
_selectedIndex = 0;
if(_selectedIndex>=_modules.Count)
_selectedIndex =_modules.Count-1;*/
if(_selectedIndex==-1)
return;
if(_selectedIndex>=_modules.Count)
return;
_currentModule = (DynShelterModule) _modules[_selectedIndex];
_tmpStylesNames = _dsMdl.GetStylesNameOfSize(_currentModule.GetSize(),_currentModule.GetModuleType());
_tmpStylesThumbs = _dsMdl.GetStylesThumbsOfSize(_tmpStylesNames);
_currentType = _currentModule.GetType().ToString();//_currentModule.GetModuleType().ToString();
for(int i=0;i<_tmpStylesNames.Length;i++)
{
if(_tmpStylesNames[i] == _currentModule.GetStyle())
{
_currentStyle = i;
}
}
UpdateRules();
//Locks -------------------------
_isLockedNext = _currentModule.GetNextLock();
_isLockedPrev = _currentModule.GetPrevLock();
//Mods
_modManager.UpdateLocalMods(_currentModule.GetGameObj());
}
else
{
//CAS OU PLUS DE MODULES
_currentModule = null;
}
UI.SetSelectedItem(_selectedIndex);
UI.SetSelectedLocks(_isLockedPrev,_isLockedNext);
if(szbrand == "PoolCover")
{
UpdateVisibility();
}
}
//--vv--FCN's spécifiques--vv--------
private bool Push(bool prev,float delta,DynShelterModule comp)
{
if(prev)
{
if(Mathf.Sign((comp.GetExtPos(AR)-(GetExtPos(AV) + new Vector3(0,0,delta))).z)<0)
return true;
else
return false;
}
else
{
if(Mathf.Sign((comp.GetExtPos(AV) - (GetExtPos(AR) + new Vector3(0,0,delta))).z)>0)
return true;
else
return false;
}
}
public override bool MoveModuleV2(float delta, DynShelterModule startPoint,bool actOnPrevs=true,bool actOnNexts=true)
{
bool outPut = true;
outPut = MoveMulti(delta,this,actOnPrevs,actOnNexts); // Test déplacement de tout l'ensemble
if(_nextModule != null && outPut)
{
if(_nextModule.GetType() == GetType() && _nextModule.GetSize() == GetSize()) // propagation du mouvement aux nexts
{
((DynShelterMultiBloc) _nextModule).MoveModuleLocal(delta,false,false,true);
}
}
if(_prevModule != null && outPut)
{
if(_prevModule.GetType() == GetType() && _prevModule.GetSize() == GetSize()) // propagation du mouvement aux prevs
{
((DynShelterMultiBloc) _prevModule).MoveModuleLocal(delta,false,true,false);
}
}
return outPut;
}
public override void InsertBetween(DynShelterModule prev, DynShelterModule next)
{
int nxtSize = next!=null? next.GetSize() : -1;
int prvSize = prev!=null? prev.GetSize() : -1;
float newPos = 0.0f;
float off7 = 0.0f;
if(next != null && prev != null) //Cas d'ajout entre deux modules
{
//--vv--configuration des modules--vv--
if(next.GetModuleType() != FunctionConf_Dynshelter.ModuleType.bloc)
{
_last = this;
}
next.SetPrevModule(this);
if(prev.GetModuleType() != FunctionConf_Dynshelter.ModuleType.bloc)
{
_first = this;
}
prev.SetNextModule(this);
// SetNextPrevModule(prev,next);
SetPrevModule(prev);
SetNextModule(next);
WhoIs(true);
WhoIs(false);
//--vv--Placement--vv--
if(_size == nxtSize && (_size != prvSize || prev.GetModuleType() != FunctionConf_Dynshelter.ModuleType.bloc)) //Le suivant est de la mm taille mais pas le précedent
{
//Add collé au next
newPos = next.GetPos().z;
off7 = -_length;
if(next.GetType() == GetType())
off7 += _AvArSize;//TAILLE DU MONTANT
DynShelterModule nxt = next;
while(nxt != null)
{
nxt.SetPos(true,off7);
nxt = nxt.GetNextModule();
}
}
else if(_size == prvSize && (_size != nxtSize || next.GetModuleType() != FunctionConf_Dynshelter.ModuleType.bloc)) //le précedent est de la meme taille mais pas le suivant
{
//Add collé au prev
newPos = prev.GetPos().z;
off7 = _length;
if(prev.GetType() == GetType())
off7 -= ((DynShelterMultiBloc)prev).GetAvArSize();//TAILLE DU MONTANT
DynShelterModule prv = prev;
while(prv != null)
{
prv.SetPos(true,off7);
prv = prv.GetPrevModule();
}
}
else //if(_size == nxtSize && _size == prvSize) // le precedent et le suivant ont la meme taille que le courant
{
DynShelterModule nxt = next;
off7 = -_length;
if(next.GetType() == GetType())
off7 += _AvArSize;//TAILLE DU MONTANT
while(nxt != null)
{
nxt.SetPos(true,off7/2);
nxt = nxt.GetNextModule();
}
off7 = _length;
if(prev.GetType() == GetType())
off7 -= ((DynShelterMultiBloc)prev).GetAvArSize();//TAILLE DU MONTANT
DynShelterModule prv = prev;
while(prv != null)
{
prv.SetPos(true,off7/2);
prv = prv.GetPrevModule();
}
newPos = (next.GetPos()+prev.GetPos()).z/2;
}
// else // le precedent et le suivant ont une taille différente du courant
// {
// DynShelterModule nxt = next;
// while(nxt != null)
// {
// nxt.SetPos(true,-_length/2);
// nxt = nxt.GetNextModule();
// }
//
// DynShelterModule prv = prev;
// while(prv != null)
// {
// prv.SetPos(true,_length/2);
// prv = prv.GetPrevModule();
// }
//
// newPos = (next.GetPos()+prev.GetPos()).z/2;
// }
}
else //(next == null || prev == null) // Cas d'ajout aux extremites (1er ou dernier)
{
if(next !=null) // this est le 1er module
{
next.SetPrevModule(this);
SetNextModule(next);
WhoIs(true);
WhoIs(false);
if(_size == nxtSize)
{
//Add collé au next
newPos = next.GetPos().z + (_length/2 + next.GetIntOffSet()/*next.GetLength()/2*/);
}
else
{
//Add collé au next ou a cheval si pas la place
newPos = next.GetExtPos(AV).z;
}
}
else//(prev != null) // this est le dernier module
{
prev.SetNextModule(this);
SetPrevModule(prev);
WhoIs(true);
WhoIs(false);
if(_size == prvSize)
{
//Add collé au prev
newPos = prev.GetPos().z - (_length/2 + prev.GetIntOffSet() /*prev.GetLength()/2*/);
}
else
{
//Add collé au prev ou a cheval si pas la place
newPos = prev.GetExtPos(AR).z;
}
}
}
//Applying Position
SetPos(false,newPos);
}
private bool CheckCollisionPossibilityF(float delta,bool checkNext,DynShelterModule cmp)
{
if(checkNext)//Checks with nexts
{
if(_size >= cmp.GetSize())//Meme taille
{
return Contact(delta,AR,true,AV,true,cmp,checkNext);
}
else return false;
}
else//Checks with prevs
{
if(_size >= cmp.GetSize())//Meme taille
{
return Contact(delta,AV,true,AR,true,cmp,checkNext);
}
else return false;
}
}
//Next/Prev Module
public virtual void SetPrevModule(DynShelterModule prev)
{
_prevModule = prev;
}
public override void SetNextModule(DynShelterModule next)
{
if(next != null && next.GetType() == GetType() && _size == next.GetSize())
{
ARSubObj.SetActive(false);
}
else
{
ARSubObj.SetActive(true);
}
_nextModule = next;
}
public virtual void InsertBetween(DynShelterModule prev, DynShelterModule next)
{
//A implémenter dans les classes filles
}
public virtual void SetNextModule(DynShelterModule next)
{
_nextModule = next;
}
private bool CheckCollisionPossibility(float delta,bool checkNext,DynShelterModule cmp)
{
if(checkNext)//Checks with nexts
{
if(cmp == _nextModule && _lockNext)
return false;
if(_size == cmp.GetSize())//Meme taille
{
return Contact(delta,AR,true,AV,true,cmp,checkNext);
}
else if(cmp.GetSize() >= _size && cmp.IsLastEnd() )
{
return Contact(delta,AR,true,AR,false,cmp,checkNext);
}
else
return false;
}
else//Checks with prevs
{
if(cmp == _prevModule && _lockPrev)
return false;
if(_size == cmp.GetSize() /*|| (cmp.GetModuleType() != FunctionConf_Dynshelter.ModuleType.bloc && _size <= cmp.GetSize())*/)//Meme taille
{
return Contact(delta,AV,true,AR,true,cmp,checkNext);
}
else if(cmp.GetSize() >= _size && cmp.IsFirstEnd())
{
return Contact(delta,AV,true,AV,false,cmp,checkNext);
}
else//--------------------//pas meme taille
{
return false;
}
}
}
public override bool MoveModuleV2(float delta, DynShelterModule startPoint,bool actOnPrevs=true,bool actOnNexts=true)
{
//test des limites-------------------------------
bool notBlockedByLimits = CheckLimitMove(delta);
if(!notBlockedByLimits)
{
// Debug.Log(_tag + "Blocked by limits");
return false;
}
//test Ancrage du module
if(_isAnchored)
{
return false;
}
//test déplacement telescopique-------------------------------
bool notBlockedByNext = true;
bool notBlockedByPrev = true;
if(delta > 0)
{
//Test PushPrev
if(_prevModule != null && actOnPrevs && _prevModule != startPoint && _lockPrev)
if(CheckTelescopicMove(delta,false))
notBlockedByPrev = _prevModule.MoveModuleV2(delta,this,true,false);//true,true
//SI pushPrev > test PullNext
if(notBlockedByPrev)
if(_nextModule != null && actOnNexts && _nextModule != startPoint && _lockNext)
if(CheckTelescopicMove(delta,true))
notBlockedByNext = _nextModule.MoveModuleV2(delta,this,false,true);//true,true
}
else //delta <0
{
//Test PushNext
if(_nextModule != null && actOnNexts && _nextModule != startPoint && _lockNext)
if(CheckTelescopicMove(delta,true))
notBlockedByNext = _nextModule.MoveModuleV2(delta,this,false,true);//true,true
//SI PushNext > test PullPrev
if(notBlockedByNext)
if(_prevModule != null && actOnPrevs && _prevModule != startPoint && _lockPrev)
if(CheckTelescopicMove(delta,false))
notBlockedByPrev = _prevModule.MoveModuleV2(delta,this,true,false);//true,true
}
if(!notBlockedByNext || !notBlockedByPrev)
{
return false;
}
//test éventuelles collision-------------------------------
if(delta>0) //test with prevs
{
DynShelterModule prev;
if(_prevModule != null)
{
if(_prevModule.GetModuleType() == FunctionConf_Dynshelter.ModuleType.bloc)
prev = (DynShelterModule)_prevModule;
else
prev = null;
}
else prev = null;
while(prev != null)
{
if(CheckCollisionPossibility(delta,false,prev))
{
if(!prev.MoveModuleV2(delta,this))
return false;
}
if(prev.GetPrevModule() != null)
{
if(prev.GetPrevModule().GetModuleType() == FunctionConf_Dynshelter.ModuleType.bloc)
prev = (DynShelterModule)prev.GetPrevModule();
else
prev = null;
}
else
prev = null;
}
}
else //test with nexts
{
DynShelterModule next;
if(_nextModule != null)
{
if(_nextModule.GetModuleType() == FunctionConf_Dynshelter.ModuleType.bloc)
next = (DynShelterModule)_nextModule;
else
next = null;
}
else next = null;
while(next != null)
{
if(CheckCollisionPossibility(delta,true,next))
{
if(!next.MoveModuleV2(delta,this))
return false;
}
if(next.GetNextModule() != null)
{
if(next.GetNextModule().GetModuleType() == FunctionConf_Dynshelter.ModuleType.bloc)
next = (DynShelterModule) next.GetNextModule();
else
next = null;
}
else
next = null;
}
}
//IF CAN MOVE -----
SetPos(true,delta);
if(_isFirstEnd)
{
_prevModule.MoveModuleV2(delta,this);
}
if(_isLastEnd)
{
_nextModule.MoveModuleV2(delta,this);
}
return true;
}
public override void InsertBetween(DynShelterModule prev, DynShelterModule next)
{
int nxtSize = next!=null? next.GetSize() : -1;
int prvSize = prev!=null? prev.GetSize() : -1;
float newPos = 0.0f;
if(next != null && prev != null) //Cas d'ajout entre deux modules
{
next.SetPrevModule(this);
prev.SetNextModule(this);
SetNextPrevModule(prev,next);
if(_size == nxtSize && next.GetModuleType() == FunctionConf_Dynshelter.ModuleType.bloc)
{
//Add collé au next
next.MoveModuleV2(-_length/2,next);
prev.MoveModuleV2(_length/2,prev);
newPos = next.GetPos().z + (_length/2+next.GetLength()/2);
}
if(_size == prvSize && prev.GetModuleType() == FunctionConf_Dynshelter.ModuleType.bloc)
{
//Add collé au prev
if(_size != nxtSize)
{
next.MoveModuleV2(-_length/2,next);
prev.MoveModuleV2(_length/2,prev);
}
newPos = prev.GetPos().z - (_length/2+prev.GetLength()/2);
}
if(_size != nxtSize && _size != prvSize)
{
//add a cheval
float space = Vector3.Distance(prev.GetPos(),next.GetPos());
if(space > _length)
{
newPos = ((prev.GetPos() + next.GetPos()).z)/2;
}
else
{
float off7 = (_length - space)/2;
next.MoveModuleV2(-off7,next);
prev.MoveModuleV2(off7,prev);
newPos = (prev.GetPos().z + next.GetPos().z)/2;
}
}
}
else //(next == null || prev == null) // Cas d'ajout aux extremites (1er ou dernier)
{
if(next !=null)
{
next.SetPrevModule(this);
SetNextModule(next);
if(_size == nxtSize)
{
//Add collé au next
newPos = next.GetPos().z + (_length/2 + next.GetLength()/2);
}
else
{
//Add collé au next ou a cheval si pas la place
// newPos = next.GetExtPos(AV).z;
newPos = /*next.GetPos().z + */next.GetIntPos(AV).z - GetIntPos(AR).z;
}
}
else//(prev != null)
{
prev.SetNextModule(this);
SetPrevModule(prev);
if(_size == prvSize)
{
//Add collé au prev
newPos = prev.GetPos().z - (_length/2 + prev.GetLength()/2);
}
else
{
//Add collé au prev ou a cheval si pas la place
// newPos = prev.GetExtPos(AR).z;
newPos = /*prev.GetPos().z + */prev.GetIntPos(AR).z - GetIntPos(AV).z;
}
}
}
//Applying
SetPos(false,newPos);
}
//-------------------------vv--FCNS--vv------------------------------------------------------
private bool MoveMulti(float delta, DynShelterModule startPoint,bool actOnPrevs=true,bool actOnNexts=true)
{
_canMoveNext = true;
_canMovePrev = true;
DynShelterModule multiNext = _last.GetNextModule(); //multiNext equivalent du _nextModule
DynShelterModule multiPrev = _first.GetPrevModule();//multiPrev equivalent du _prevModule
//test des limites-------------------------------
bool notBlockedByLimits = CheckLimitMove(delta);
if( (!notBlockedByLimits) && !_parentConf.IsAbrifixe())
{
Debug.Log(_tag + "Blocked by limits");
return false;
}
//test Ancrage du module
bool test = true;
DynShelterModule testModule = _first;
while(testModule != _last && test)
{
if(testModule.IsAnchored())
{
test = false;
}
else
{
testModule = testModule.GetNextModule();
}
}
if(!test)
{
Debug.Log("Anchored");
return false;
}
//test déplacement telescopique-------------------------------
bool notBlockedByNext = true;
bool notBlockedByPrev = true;
if(delta > 0)
{
//Test PushPrev
if(multiPrev != null && actOnPrevs && multiPrev != startPoint && _lockPrev)
if(CheckTelescopicMove(delta,false,multiNext,multiPrev))
notBlockedByPrev = multiPrev.MoveModuleV2(delta,this,true,false);//true,true
//SI pushPrev > test PullNext
if(notBlockedByPrev)
if(multiNext != null && actOnNexts && multiNext != startPoint && _lockNext)
if(CheckTelescopicMove(delta,true,multiNext,multiPrev))
notBlockedByNext = multiNext.MoveModuleV2(delta,this,false,true);//true,true
}
else //delta <0
{
//Test PushNext
if(multiNext != null && actOnNexts && multiNext != startPoint && _lockNext)
if(CheckTelescopicMove(delta,true,multiNext,multiPrev))
notBlockedByNext = multiNext.MoveModuleV2(delta,this,false,true);//true,true
//SI PushNext > test PullPrev
if(notBlockedByNext)
if(multiPrev != null && actOnPrevs && multiPrev != startPoint && _lockPrev)
if(CheckTelescopicMove(delta,false,multiNext,multiPrev))
notBlockedByPrev = multiPrev.MoveModuleV2(delta,this,true,false);//true,true
}
if(!notBlockedByNext || !notBlockedByPrev)
{
Debug.Log("Blockedbynextprev");
return false;
}
//test éventuelles collision-------------------------------
if(delta>0) //test with prevs
{
DynShelterModule prev;
if(multiPrev != null)
{
if(multiPrev.GetModuleType() == FunctionConf_Dynshelter.ModuleType.bloc)
prev = (DynShelterModule)multiPrev;
else
prev = null;
}
else prev = null;
while(prev != null)
{
if(CheckCollisionPossibility(delta,false,prev))
{
if(!prev.MoveModuleV2(delta,this))
return false;
}
if(prev.GetPrevModule() != null)
{
if(prev.GetPrevModule().GetModuleType() == FunctionConf_Dynshelter.ModuleType.bloc)
prev = (DynShelterModule)prev.GetPrevModule();
else
prev = null;
}
else
prev = null;
}
}
else //test with nexts
{
DynShelterModule next;
if(multiNext != null)
{
if(multiNext.GetModuleType() == FunctionConf_Dynshelter.ModuleType.bloc)
next = (DynShelterModule)multiNext;
else
next = null;
}
else next = null;
while(next != null)
{
if(CheckCollisionPossibility(delta,true,next))
{
if(!next.MoveModuleV2(delta,this))
return false;
}
if(next.GetNextModule() != null)
{
if(next.GetNextModule().GetModuleType() == FunctionConf_Dynshelter.ModuleType.bloc)
next = (DynShelterModule) next.GetNextModule();
else
next = null;
}
else
next = null;
}
}
//IF CAN MOVE -----
SetPos(true,delta);
if(_isFirstEnd)
{
multiPrev.MoveModuleV2(delta,this);
}
/*else
{
if(GetPrevModule()!=null)
if(GetPrevModule().GetType()==typeof(DynShelterFacade))
multiPrev.MoveModuleV2(delta,this);
}*/
if(_isLastEnd)
{
multiNext.MoveModuleV2(delta,this);
}
/*else
{
if(GetNextModule()!=null)
if(GetNextModule().GetType()==typeof(DynShelterFacade))
multiPrev.MoveModuleV2(delta,this);
}*/
return true;
}
//Déplacement tests
private bool CheckTelescopicMove(float delta,bool checkNext,DynShelterModule nxt,DynShelterModule prv)
{
bool pushNext = false;
bool pullNext = false;
bool pushPrev = false;
bool pullPrev = false;
if(delta <0)//---------------------------------------------------------------------dep Z-
{
if(nxt != null && _lockNext && checkNext)
{
if(nxt.GetSize()!=GetSize())//---Si c'est un bloc
{
if(Push(false,delta))
{
pushNext = true;
}
}
else//-------------------------------------------------------------------------Si c'est un bloc de mm taille
{
pushNext = true;
}
}
if(prv != null && _lockPrev && !checkNext)
{
if(prv.GetSize()!=GetSize())//---Si c'est un bloc
{
if(Pull(true,delta))
{
pullPrev = true;
}
}
else//-------------------------------------------------------------------------Si c'est une facade ou une extremité ou un bloc de mm taille
{
pullPrev = true;
if(Contact(delta,AV,true,AR,true,prv,false))
pullPrev = false;
}
}
}
else if(delta >0)//-----------------------------------------------------------------------------dep Z+
{
if(nxt != null && _lockNext && checkNext)
{
if(nxt.GetSize()!=GetSize())//---Si c'est un bloc
{
if(Pull(false,delta))
{
pullNext = true;
}
}
else//-------------------------------------------------------------------------Si c'est une facade ou une extremité ou un bloc de mm taille
{
pullNext = true;
if(Contact(delta,AR,true,AV,true,nxt,true))
pullNext = false;
}
}
if(prv != null && _lockPrev && !checkNext)
{
if(prv.GetSize()!=GetSize())//---Si c'est un bloc
{
if(Push(true,delta))
{
pushPrev = true;
}
}
else//-------------------------------------------------------------------------Si c'est un bloc de mm taille
{
pushPrev = true;
}
}
}
if(checkNext)
{
if((pushNext||pullNext))
return true;
else
return false;
}
else
{
if((pushPrev||pullPrev))
return true;
else
return false;
}
}
public virtual bool MoveModuleV2(float delta, DynShelterModule startPoint,bool actOnPrevs=true,bool actOnNexts=true)
{
return true;
}
public IEnumerator AddModule(int size,string style,ModuleType typ,Color32 color,bool fromInit=false, bool bsensfacade=false)
{
//Debug.Log("t : "+size+", styl : "+style+",ModuleType : "+ typ.ToString()+", bool "+fromInit);
bool noNeedLimitToBeRecalculate = fromInit;
_isBuilding = true;
//-------vv-Récupération du mesh-vv------------
DynShelterModule newModule = null;
string newStyle= string.Copy(style);
string tag = CheckAndCreateTag(size,style,typ,out newStyle);
style = string.Copy(newStyle);
GameObject go = null;
bool bextrem = false;
//--vv--Si il na pas deja été créé, ben tant pis on ouvre--vv--
if(go == null)
{
// OSLib libObj = GetComponent<ObjData>().GetObjectModel().GetLibrary();
WWW www = WWW.LoadFromCacheOrDownload (_lib.GetAssetBundlePath (), _lib.GetVersion ());
yield return www;
if (www.error != null)
{
Debug.Log ("AssetBundle ERROR" + www.error);
}
else
{
_assetBundle = www.assetBundle;
if (_assetBundle != null)
{
string sz = _assetBundle.name;
if(sz.Contains("extrem"))
{
bextrem = true;
}
// Debug.Log("assetBundle.load : "+tag);
Object original = _assetBundle.LoadAsset (tag, typeof(GameObject));
if(original!=null){
go = (GameObject) Instantiate (original);
}
/*else
{
_assetBundle.Unload (false);
www.Dispose();
}*/
}
_assetBundle.Unload (false);
}
www.Dispose();
}
//-------vv-Création du module-vv---------------
switch(typ)
{
case ModuleType.bloc:
newModule = new DynShelterBloc(size,style,typ,color,this);
break;
case ModuleType.facade:
noNeedLimitToBeRecalculate=true;
newModule = new DynShelterFacade(size,style,typ,color,this);
m_icounterFacade++;
break;
case ModuleType.extremite:
newModule = new DynShelterExtrem(size,style,typ,color,this);
break;
case ModuleType.multiBloc:
newModule = new DynShelterMultiBloc(size,style,ModuleType.bloc,color,this);
if(_currentModule==null)
{
break;
}
if(_currentModule.GetType() == typeof(DynShelterBloc))
{
DynShelterMultiBloc newCurrent = new DynShelterMultiBloc((DynShelterBloc)_currentModule);
foreach(DynShelterModule dm in _modules)
{
if(dm.GetPrevModule() == _currentModule)
dm.SetPrevModule(newCurrent);
if(dm.GetNextModule() == _currentModule)
dm.SetNextModule(newCurrent);
}
_currentModule = newCurrent;
_modules[_selectedIndex] = _currentModule;
}
else
{
if(_currentModule.GetPrevModule() != null)
{
if(_currentModule.GetPrevModule().GetSize() == size && _currentModule.GetPrevModule().GetType() == typeof(DynShelterBloc))
{
Debug.Log("Modifying Prev");
DynShelterMultiBloc newPrev = new DynShelterMultiBloc((DynShelterBloc)_currentModule.GetPrevModule());
int idx = _modules.IndexOf(_currentModule.GetPrevModule());
_modules[idx] = newPrev;
_currentModule.SetNextModule(newPrev);
}
}
if(_currentModule.GetNextModule() != null)
{
Debug.Log("Modifying Next");
if(_currentModule.GetNextModule().GetSize() == size && _currentModule.GetNextModule().GetType() == typeof(DynShelterBloc))
{
DynShelterMultiBloc newNext = new DynShelterMultiBloc((DynShelterBloc)_currentModule.GetNextModule());
int idx = _modules.IndexOf(_currentModule.GetNextModule());
_modules[idx] = newNext;
_currentModule.SetNextModule(newNext);
}
}
}
break;
}
SaveTransform();
go.transform.parent = transform;
go.transform.localPosition = Vector3.zero;
if(_currentModule != null)
{
if(bsensfacade && bextrem)
{
_currentModule.bextrem = true;
go.transform.Rotate(0.0f, 180.0f, 0.0f);
}
else
{
_currentModule.bextrem = false;
}
}
newModule.SetGameObject(go);
_modManager.TestModuleForGlobalMods(go);
//-------vv-Placement-vv-----------------------
if(_currentModule != null)
{
// Debug.Log(" _currentModule not null");
if(_nextInsertion)
{
// Debug.Log(" _nextInsertion");
newModule.InsertBetween(_currentModule,_currentModule.GetNextModule());
print ("_selectedIndex :"+ _selectedIndex );
if( _selectedIndex+1 <= _modules.Count)
{
_modules.Insert(_selectedIndex+1,newModule);
_selectedIndex++;
}
}
else
{
// Debug.Log("Not _nextInsertion");
/* if(_currentModule.GetType() == typeof(DynShelterMultiBloc)
&& newModule.GetType() == typeof(DynShelterMultiBloc)
&& _currentModule.GetPrevModule().GetType() == typeof(DynShelterFacade))
{
newModule.InsertBetween(_currentModule,_currentModule.GetNextModule());
_modules.Insert(_selectedIndex+1,newModule);
}
else*/
{
newModule.InsertBetween(_currentModule.GetPrevModule(),_currentModule);
_modules.Insert(_selectedIndex,newModule);
}
}
//Déplacement Immobile ^^ QUICKFIX placement des facades a l'ajout de celles-ci
_currentModule.MoveModuleV2(0,_currentModule,true,true);
}
else
{
// Debug.Log(" _currentModule null");
newModule.SetPos(false,0);
newModule.SetNextPrevModule(null,null);
newModule.SetNextPrevLocks(true,true);
_modules.Add(newModule);
//_selectedIndex = 0;
}
UI.SetItemsNb(_modules.Count);
UpdateCurrentModule();
_removeModule = false;
ChangeModuleColor(_currentColor);
UpdateLimits(noNeedLimitToBeRecalculate);
ReapplyTransform();
if(szbrand == "PoolCover")
{
UpdateBoxCollider();
UpdateVisibility();
}
//CenterDeployAndFeetLimit();
yield return new WaitForEndOfFrame();
_isBuilding = false;
}
public void SetNextPrevModule(DynShelterModule prev,DynShelterModule next)
{
_prevModule = prev;
_nextModule = next;
}
/* LoadShelter()
* Chargement de la configuration d'abri lors du chargement de montage
**/
private IEnumerator LoadShelter(ArrayList CustomConf = null,ArrayList PosConf = null)
{
while(_isBuilding)
yield return null;
foreach(DynShelterModule m in _modules)
{
m.RemoveModule();
}
_modules.Clear();
_modManager.ClearManager();
_currentModule = null;
_selectedIndex = 0;
yield return null;
_isBuilding = true;
//Attend que le objdata soit configuré
while(gameObject.GetComponent<ObjData>().GetObjectModel() == null)
{
yield return new WaitForEndOfFrame();
}
//Création de l'abri par default
ArrayList stConf = CustomConf;
if(stConf.Count > 0)
{
Color32 c = new Color32(255,255,255,255);
// SaveTransform();
for(int i=0;i<stConf.Count-2;i=i+8)
{
ModuleType typ = ModuleType.bloc;
switch ((string)stConf[i]) //TYP >0
{
case "facade":
typ = ModuleType.facade;
break;
case "bloc":
typ = ModuleType.bloc;
break;
case "extremite":
typ = ModuleType.extremite;
break;
}
int t = (int) stConf[i+1]; //TAILLE >1
string styl = (string) stConf[i+2]; //STYLE >2
_nextInsertion = true;
_decalZ = 0.0f;
yield return StartCoroutine(AddModule(t,styl,typ,_currentColor));
c = (Color32)stConf[i+3]; //color > 3
_currentModule.SetColor(c);
_currentModule.SetNextLocks((bool)stConf[i+4]);//NLock> 4
_currentModule.SetPrevLocks((bool)stConf[i+5]);//PLock> 5
_currentModule.SetAnchor((bool)stConf[i+6]); //Anchor > 6
yield return new WaitForEndOfFrame();
_modManager.UpdateLocalMods(_currentModule.GetGameObj(),true);
_modManager.ApplyLoadConf((string[])stConf[i+7]); //ModConf>7
}
ChangeModuleColor(c);
_isBuilding = false;
}
_selectedIndex = 0;
UpdateCurrentModule();
for(int i=0;i<_modules.Count;i++)
{
((DynShelterModule)_modules[i]).SetPos(false,(float)PosConf[i]);
}
UpdateBoxCollider();
enabled = false;
ShowArrows(false);
CenterDeployAndFeetLimit();
yield return null;
}
//Créé un vecteur "test" entre avant/arriere intérieur/exterieur entre le current et le cmp(comparé)
//renvoie true si avec le déplacement delta il y a contact
protected bool Contact(float delta,bool curAvt,bool curExt, bool cmpAvt,bool cmpExt,DynShelterModule cmp,bool cmpIsNext)
{
Vector3 toTest;
if(cmpExt)
{
toTest = cmp.GetExtPos(cmpAvt);
}
else//int
{
toTest = cmp.GetIntPos(cmpAvt);
}
if(curExt)
{
toTest = toTest - (GetExtPos(curAvt)+ new Vector3(0,0,delta));
}
else//int
{
toTest = toTest - (GetIntPos(curAvt)+ new Vector3(0,0,delta));
}
if(cmpIsNext)
{
if(toTest.z >= 0) //>=
return true;
else
return false;
}
else
{
if(toTest.z <= 0)//<=
return true;
else
return false;
}
}
public override void SetNextModule(DynShelterModule next)
{
_nextModule = next;
if(next == null)
return;
((DynShelterModule) next).SetIsFirstEnd(true);
SetPos(false,GetMyPos(false));
}
public override void SetPrevModule(DynShelterModule prev)
{
_prevModule = prev;
if(prev == null)
return;
((DynShelterModule) prev).SetIsLastEnd(true);
SetPos(false,GetMyPos(true));
}
public void IAm(bool first,DynShelterMultiBloc bloc)
{
if(first)
{
_first = bloc;
if(_nextModule != null)
{
if(_nextModule.GetType() == GetType() && _nextModule.GetSize()==GetSize())
{
((DynShelterMultiBloc) _nextModule).IAm(first,bloc);//Propagation de la réponse aux suivants
}
}
}
else
{
_last = bloc;
if(_prevModule != null)
{
if(_prevModule.GetType() == GetType() && _prevModule.GetSize()==GetSize())
{
((DynShelterMultiBloc) _prevModule).IAm(first,bloc);//Propagation de la reponse aux précedants
}
}
}
}
