Project

General

Profile

« Previous | Next » 

Revision 27a70eae

Added by Leszek Koltunski about 4 years ago

Make RubikCube and RubikCubeMovement generic and not visible outside of their package.

View differences:

src/main/java/org/distorted/effect/sizechange/SizeChangeEffect.java
24 24 
import org.distorted.library.main.DistortedEffects;
25 25 
import org.distorted.library.main.DistortedScreen;
26 26 
import org.distorted.library.message.EffectListener;
27 
import org.distorted.object.RubikCube;
28 27 
import org.distorted.magic.RubikRenderer;
28 
import org.distorted.object.RubikObject;
29 29 

  		




  30
  30
  
    
import java.lang.reflect.Method;


  		




  31
  31
  
    

  		




  ......




  72
  72
  
    
  private int[] mCubeEffectNumber, mNodeEffectNumber;


  		




  73
  73
  
    
  private int[] mEffectFinished;


  		




  74
  74
  
    
  private boolean[] mPhaseActive;


  		




  75
  
  
    
  private RubikCube[] mCube;


  		




  
  75
  
    
  private RubikObject[] mObject;


  		




  76
  76
  
    

  		




  77
  77
  
    
  DistortedScreen mScreen;


  		




  78
  78
  
    
  Effect[][] mCubeEffects;


  		




  ......




  93
  93
  
    
    mNodeEffectPosition = new int[NUM_PHASES][];


  		




  94
  94
  
    
    mCubeEffects        = new Effect[NUM_PHASES][];


  		




  95
  95
  
    
    mNodeEffects        = new Effect[NUM_PHASES][];


  		




  96
  
  
    
    mCube               = new RubikCube[NUM_PHASES];


  		




  
  96
  
    
    mObject             = new RubikObject[NUM_PHASES];


  		




  97
  97
  
    
    }


  		




  98
  98
  
    

  		




  99
  99
  
    
///////////////////////////////////////////////////////////////////////////////////////////////////


  		




  ......




  112
  112
  
    
      if( effectID == id )


  		




  113
  113
  
    
        {


  		




  114
  114
  
    
        effectReturned(phase);


  		




  115
  
  
    
        mCube[phase].remove(id);


  		




  
  115
  
    
        mObject[phase].remove(id);


  		




  116
  116
  
    
        return;


  		




  117
  117
  
    
        }


  		




  118
  118
  
    
      }


  		




  ......




  123
  123
  
    
      if( effectID == id )


  		




  124
  124
  
    
        {


  		




  125
  125
  
    
        effectReturned(phase);


  		




  126
  
  
    
        mCube[phase].getEffects().abortById(id);


  		




  
  126
  
    
        mObject[phase].getEffects().abortById(id);


  		




  127
  127
  
    
        return;


  		




  128
  128
  
    
        }


  		




  129
  129
  
    
      }


  		




  ......




  142
  142
  
    
        case 0: mPhaseActive[1] = true;


  		




  143
  143
  
    
                mEffectFinished[1] = createEffectsPhase1(mDuration);


  		




  144
  144
  
    
                assignEffects(1);


  		




  145
  
  
    
                mScreen.attach(mCube[1]);


  		




  
  145
  
    
                mScreen.attach(mObject[1]);


  		




  146
  146
  
    
                break;


  		




  147
  147
  
    
        case 1: mListener.effectFinished(FAKE_EFFECT_ID);


  		




  148
  148
  
    
                break;


  		




  ......




  153
  153
  
    
      switch(phase)


  		




  154
  154
  
    
        {


  		




  155
  155
  
    
        case 0: mPhaseActive[0] = false;


  		




  156
  
  
    
                mScreen.detach(mCube[0]);


  		




  
  156
  
    
                mScreen.detach(mObject[0]);


  		




  157
  157
  
    
                break;


  		




  158
  158
  
    
        case 1: mPhaseActive[1] = false;


  		




  159
  159
  
    
                break;


  		




  ......




  175
  175
  
    

  		




  176
  176
  
    
    for(int i=0; i<mCubeEffectNumber[phase]; i++)


  		




  177
  177
  
    
      {


  		




  178
  
  
    
      mCube[phase].apply(mCubeEffects[phase][i],mCubeEffectPosition[phase][i]);


  		




  
  178
  
    
      mObject[phase].apply(mCubeEffects[phase][i],mCubeEffectPosition[phase][i]);


  		




  179
  179
  
    
      mCubeEffects[phase][i].notifyWhenFinished(this);


  		




  180
  180
  
    
      }


  		




  181
  181
  
    

  		




  182
  
  
    
    DistortedEffects nodeEffects = mCube[phase].getEffects();


  		




  
  182
  
    
    DistortedEffects nodeEffects = mObject[phase].getEffects();


  		




  183
  183
  
    

  		




  184
  184
  
    
    for(int i=0; i<mNodeEffectNumber[phase]; i++)


  		




  185
  185
  
    
      {


  		




  ......




  227
  227
  
    
  public long start(int duration, RubikRenderer renderer)


  		




  228
  228
  
    
    {


  		




  229
  229
  
    
    mScreen   = renderer.getScreen();


  		




  230
  
  
    
    mCube[0]  = renderer.getOldCube();


  		




  231
  
  
    
    mCube[1]  = renderer.getCube();


  		




  
  230
  
    
    mObject[0]= renderer.getOldObject();


  		




  
  231
  
    
    mObject[1]= renderer.getObject();


  		




  232
  232
  
    
    mListener = renderer;


  		




  233
  233
  
    
    mDuration = duration;


  		




  234
  234
  
    

  		




  235
  
  
    
    if( mCube[0]!=null )


  		




  
  235
  
    
    if( mObject[0]!=null )


  		




  236
  236
  
    
      {


  		




  237
  237
  
    
      mPhaseActive[0] = true;


  		




  238
  238
  
    
      mEffectFinished[0] = createEffectsPhase0(mDuration);


  		




  ......




  243
  243
  
    
      mPhaseActive[1] = true;


  		




  244
  244
  
    
      mEffectFinished[1] = createEffectsPhase1(mDuration);


  		




  245
  245
  
    
      assignEffects(1);


  		




  246
  
  
    
      mScreen.attach(mCube[1]);


  		




  
  246
  
    
      mScreen.attach(mObject[1]);


  		




  247
  247
  
    
      }


  		




  248
  248
  
    

  		




  249
  249
  
    
    return FAKE_EFFECT_ID;


  		












Also available in:  Unified diff