API tools faq
paste
TimTimTimTim

Untitled

TimTimTimTim
May 17th, 2012
66
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
UnrealScript 27.47 KB | None | 0 0
raw download clone embed print report
  1. // ============================================================================
  2. // Screen
  3. // Copyright 2001 by Mychaeel <[email protected]>
  4. //
  5. // Provides an implementation of a ClientScriptedTexture that is able to
  6. // display slides of type ScreenSlide and its subclasses.
  7. // ============================================================================
  8.  
  9.  
  10. class Screen extends ClientScriptedTexture config(Screen);
  11.  
  12.  
  13. // ============================================================================
  14. // Compiler Directives
  15. // ============================================================================
  16.  
  17. #exec texture import file=Textures\ActorScreen.bmp mips=off flags=2
  18.  
  19.  
  20. // ============================================================================
  21. // Replication
  22. // ============================================================================
  23.  
  24. replication {
  25.  
  26.   reliable if (Role == ROLE_Authority)
  27.     VersionServer, GetClientWidthTotal, GetClientHeightTotal, RenderTexture, Tile, VersionCheck, AddSlide;
  28.   reliable if (Role == ROLE_Authority && SwitchTriggered.SlideSwitch != None)
  29.     SwitchTriggered;
  30.   }
  31.  
  32.  
  33. // ============================================================================
  34. // Types
  35. // ============================================================================
  36.  
  37. enum EnumSlideAction {
  38.  
  39.   SlideAction_None,
  40.   SlideAction_Entering,
  41.   SlideAction_Scrolling,
  42.   SlideAction_Exiting,
  43.   };
  44.  
  45.  
  46. enum EnumConfigNetwork {
  47.  
  48.   ConfigNetwork_Always,
  49.   ConfigNetwork_Network,
  50.   ConfigNetwork_Never,
  51.   };
  52.  
  53.  
  54. struct StructSwitch {
  55.  
  56.   var ScreenSlide SlideSwitch;
  57.   var int Update;
  58.   };
  59.  
  60.  
  61. // ============================================================================
  62. // Configuration
  63. // ============================================================================
  64.  
  65. var config EnumConfigNetwork Network;
  66. var config int VersionLatest;
  67.  
  68.  
  69. // ============================================================================
  70. // Properties
  71. // ============================================================================
  72.  
  73. var() editconst int Version;
  74.  
  75. var() ScreenSlide SlideCurrent;
  76. var() Texture ScreenBackground;
  77. var() Texture ScreenForeground;
  78.  
  79. var() int Top;
  80. var() int Left;
  81. var() int Width;
  82. var() int Height;
  83.  
  84. var() int TileTop;
  85. var() int TileLeft;
  86. var() Screen TileMaster;
  87.  
  88.  
  89. // ============================================================================
  90. // Variables
  91. // ============================================================================
  92.  
  93. var int VersionServer;
  94. var bool FlagVersionAck;
  95.  
  96. var ScreenMutator MutatorScreen;
  97.  
  98. var ScreenSlide SlideCurrentAck;
  99. var StructSwitch SwitchTriggered;
  100. var Palette PaletteOriginal;
  101.  
  102. var EnumSlideAction Action;
  103. var int DirectionHorz;
  104. var int DirectionVert;
  105.  
  106. var int CountSlides;
  107. var int OffsetTopSlide[32];
  108. var int OffsetLeftSlide[32];
  109.  
  110. var float TimeDisplayed;
  111.  
  112. var float Fade;
  113. var float OffsetTop;
  114. var float OffsetLeft;
  115.  
  116.  
  117. // ============================================================================
  118. // Constants
  119. // ============================================================================
  120.  
  121. const FlagDebug = false;
  122.  
  123.  
  124. // ============================================================================
  125. // PreBeginPlay
  126. // ============================================================================
  127.  
  128. simulated function PreBeginPlay() {
  129.  
  130.   local GameInfo ThisGame;
  131.  
  132.   Super.PreBeginPlay();
  133.  
  134.   if (PaletteOriginal == None)
  135.     PaletteOriginal = ScriptedTexture.Palette;
  136.  
  137.   if (Level.NetMode != NM_Client)
  138.     VersionServer = Version;
  139.  
  140.   foreach AllActors(class 'ScreenMutator', MutatorScreen)
  141.     break;
  142.  
  143.   if (MutatorScreen == None) {
  144.     MutatorScreen = Spawn(class 'ScreenMutator');
  145.  
  146.     foreach AllActors(class 'GameInfo', ThisGame)
  147.       break;
  148.     if (ThisGame != None) {
  149.       ThisGame.BaseMutator.AddMutator(MutatorScreen);
  150.       ThisGame.RegisterMessageMutator(MutatorScreen);
  151.       }
  152.     }
  153.   }
  154.  
  155.  
  156. // ============================================================================
  157. // Tick
  158. // ============================================================================
  159.  
  160. simulated function Tick(float TimeDelta) {
  161.  
  162.   local ScriptedTexture TextureCanvas;
  163.   local bool FlagCompleted;
  164.   local bool FlagCompletedHorz;
  165.   local bool FlagCompletedVert;
  166.   local int IndexSlide;
  167.   local int ClientWidthTotal;
  168.   local int ClientHeightTotal;
  169.   local int ClientWidthDisplayed;
  170.   local int ClientHeightDisplayed;
  171.   local int OffsetTopTarget;
  172.   local int OffsetLeftTarget;
  173.   local int OffsetTopDisplayed;
  174.   local int OffsetLeftDisplayed;
  175.   local int OffsetTopTotal;
  176.   local int OffsetLeftTotal;
  177.   local int OffsetRightTotal;
  178.   local int OffsetBottomTotal;
  179.   local int DirectionVertPrev;
  180.   local int DirectionHorzPrev;
  181.   local int ThisOffsetTop;
  182.   local int ThisOffsetLeft;
  183.   local ScreenSlide ThisSlide;
  184.   local ScreenSlide ThisSlidePrev;
  185.   local EnumSlideAction ActionPrev;
  186.  
  187.   VersionCheck();
  188.  
  189.   if (Level.NetMode == NM_DedicatedServer)
  190.     return;
  191.  
  192.   if (TileMaster != None)
  193.     return;
  194.  
  195.   TextureCanvas = ScriptedTexture(ScriptedTexture);
  196.   if (TextureCanvas == None)
  197.     return;
  198.  
  199.  
  200.   // ================================================================
  201.   // Slides Switched
  202.   // ================================================================
  203.  
  204.   ActionPrev = Action;
  205.  
  206.   if (SlideCurrent == None) {
  207.     if (SwitchTriggered.SlideSwitch == None)
  208.       return;
  209.  
  210.     SlideCurrent = SwitchTriggered.SlideSwitch;
  211.     SlideCurrentAck = None;
  212.     SwitchTriggered.SlideSwitch = None;
  213.     }
  214.  
  215.   if (SwitchTriggered.SlideSwitch == SlideCurrent && Action != SlideAction_Exiting)
  216.     SwitchTriggered.SlideSwitch = None;
  217.  
  218.   if (SlideCurrentAck != SlideCurrent) {
  219.     Action = SlideAction_Entering;
  220.     ActionPrev = SlideAction_None;
  221.    
  222.     SlideCurrentAck = SlideCurrent;
  223.     }
  224.  
  225.  
  226.   // ================================================================
  227.   // Calculate Animation
  228.   // ================================================================
  229.  
  230.   if (SlideCurrent != None) {
  231.  
  232.     // ====================================================
  233.     // Prepare Slide
  234.     // ====================================================
  235.  
  236.     SlideCurrent.Prepare(TextureCanvas);
  237.  
  238.     OffsetTopTotal    = -GetClientHeightTotal(SlideCurrent) / 2;
  239.     OffsetLeftTotal   = -GetClientWidthTotal (SlideCurrent) / 2;
  240.     OffsetRightTotal  =  OffsetLeftTotal + GetClientWidthTotal (SlideCurrent);
  241.     OffsetBottomTotal =  OffsetTopTotal  + GetClientHeightTotal(SlideCurrent);
  242.  
  243.     ThisOffsetTop  = OffsetTopTotal;
  244.     ThisOffsetLeft = OffsetLeftTotal;
  245.  
  246.     CountSlides = 1;
  247.     OffsetTopSlide [0] = ThisOffsetTop;
  248.     OffsetLeftSlide[0] = ThisOffsetLeft;
  249.  
  250.     ThisSlidePrev = SlideCurrent;
  251.     for (ThisSlide = SlideCurrent.SlideOverlay; ThisSlide != None; ThisSlide = ThisSlide.SlideOverlay) {
  252.       if (CountSlides == ArrayCount(OffsetLeftSlide) - 1) {
  253.         Log("Screen: Too many layered slides, starting with slide" @ SlideCurrent.Name);
  254.         break;
  255.         }
  256.      
  257.       ThisSlide.Prepare(TextureCanvas);
  258.  
  259.       switch (ThisSlide.AlignHorz) {
  260.         case SlideAlignHorz_Left:
  261.           OffsetRightTotal = Max(OffsetRightTotal, ThisOffsetLeft + GetClientWidthTotal(ThisSlide));
  262.           break;
  263.        
  264.         case SlideAlignHorz_LeftAdjacent:
  265.           ThisOffsetLeft -= GetClientWidthTotal(ThisSlide);
  266.           OffsetLeftTotal = Min(OffsetLeftTotal, ThisOffsetLeft);
  267.           break;
  268.        
  269.         case SlideAlignHorz_Center:
  270.           ThisOffsetLeft += (GetClientWidthTotal(ThisSlidePrev) - GetClientWidthTotal(ThisSlide)) / 2;
  271.           OffsetLeftTotal  = Min(OffsetLeftTotal,  ThisOffsetLeft);
  272.           OffsetRightTotal = Max(OffsetRightTotal, ThisOffsetLeft + GetClientWidthTotal(ThisSlide));
  273.           break;
  274.        
  275.         case SlideAlignHorz_Right:
  276.           ThisOffsetLeft += GetClientWidthTotal(ThisSlidePrev) - GetClientWidthTotal(ThisSlide);
  277.           OffsetLeftTotal = Min(OffsetLeftTotal, ThisOffsetLeft);
  278.           break;
  279.        
  280.         case SlideAlignHorz_RightAdjacent:
  281.           ThisOffsetLeft += GetClientWidthTotal(ThisSlidePrev);
  282.           OffsetRightTotal = Max(OffsetRightTotal, ThisOffsetLeft + GetClientWidthTotal(ThisSlide));
  283.           break;
  284.         }
  285.  
  286.       switch (ThisSlide.AlignVert) {
  287.         case SlideAlignVert_Top:
  288.           OffsetBottomTotal = Max(OffsetBottomTotal, ThisOffsetTop + GetClientHeightTotal(ThisSlide));
  289.           break;
  290.        
  291.         case SlideAlignVert_TopAdjacent:
  292.           ThisOffsetTop -= GetClientHeightTotal(ThisSlide);
  293.           OffsetTopTotal = Min(OffsetTopTotal, ThisOffsetTop);
  294.           break;
  295.        
  296.         case SlideAlignVert_Middle:
  297.           ThisOffsetTop += (GetClientHeightTotal(ThisSlidePrev) - GetClientHeightTotal(ThisSlide)) / 2;
  298.           OffsetTopTotal    = Min(OffsetTopTotal,    ThisOffsetTop);
  299.           OffsetBottomTotal = Max(OffsetBottomTotal, ThisOffsetTop + GetClientHeightTotal(ThisSlide));
  300.           break;
  301.        
  302.         case SlideAlignVert_Bottom:
  303.           ThisOffsetTop += GetClientHeightTotal(ThisSlidePrev) - GetClientHeightTotal(ThisSlide);
  304.           OffsetTopTotal = Min(OffsetTopTotal, ThisOffsetTop);
  305.           break;
  306.        
  307.         case SlideAlignVert_BottomAdjacent:
  308.           ThisOffsetTop += GetClientHeightTotal(ThisSlidePrev);
  309.           OffsetBottomTotal = Max(OffsetBottomTotal, ThisOffsetTop + GetClientHeightTotal(ThisSlide));
  310.           break;
  311.         }
  312.  
  313.       OffsetTopSlide [CountSlides] = ThisOffsetTop;
  314.       OffsetLeftSlide[CountSlides] = ThisOffsetLeft;
  315.       CountSlides++;
  316.  
  317.       ThisSlidePrev = ThisSlide;
  318.       }
  319.  
  320.     for (IndexSlide = 0; IndexSlide < CountSlides; IndexSlide++) {
  321.       OffsetTopSlide [IndexSlide] -= OffsetTopTotal;
  322.       OffsetLeftSlide[IndexSlide] -= OffsetLeftTotal;
  323.       }
  324.  
  325.     ClientWidthTotal  = OffsetRightTotal  - OffsetLeftTotal;
  326.     ClientHeightTotal = OffsetBottomTotal - OffsetTopTotal;
  327.     ClientWidthDisplayed  = Clamp(ClientWidthTotal,  0, Width);
  328.     ClientHeightDisplayed = Clamp(ClientHeightTotal, 0, Height);
  329.    
  330.     switch (SlideCurrent.AlignHorz) {
  331.       case SlideAlignHorz_Left:
  332.       case SlideAlignHorz_LeftAdjacent:  OffsetLeftTarget = 0;                           break;
  333.       case SlideAlignHorz_Center:        OffsetLeftTarget = Width / 2 + OffsetLeftTotal; break;
  334.       case SlideAlignHorz_Right:
  335.       case SlideAlignHorz_RightAdjacent: OffsetLeftTarget = Width - ClientWidthTotal;    break;
  336.       }
  337.  
  338.     switch (SlideCurrent.AlignVert) {
  339.       case SlideAlignVert_Top:
  340.       case SlideAlignVert_TopAdjacent:    OffsetTopTarget = 0;                            break;
  341.       case SlideAlignVert_Middle:         OffsetTopTarget = Height / 2 + OffsetTopTotal;  break;
  342.       case SlideAlignVert_Bottom:
  343.       case SlideAlignVert_BottomAdjacent: OffsetTopTarget = Height - ClientHeightTotal;   break;
  344.       }
  345.  
  346.     OffsetTopDisplayed  = Clamp(OffsetTopTarget,  0, Height);
  347.     OffsetLeftDisplayed = Clamp(OffsetLeftTarget, 0, Width);
  348.    
  349.     TimeDisplayed += TimeDelta;
  350.  
  351.  
  352.     // ====================================================
  353.     // Scroll Slide
  354.     // ====================================================
  355.  
  356.     do {
  357.       if (Action != ActionPrev) {
  358.         switch (Action) {
  359.           case SlideAction_Entering:
  360.             Fade = 1.0;
  361.             OffsetLeft = OffsetLeftTarget;
  362.             OffsetTop  = OffsetTopTarget;
  363.            
  364.             switch (SlideCurrent.EffectEntry) {
  365.               case SlideEffect_Replace:                                      break;
  366.               case SlideEffect_SlideTop:    OffsetTop  =  Height;            break;
  367.               case SlideEffect_SlideLeft:   OffsetLeft =  Width;             break;
  368.               case SlideEffect_SlideRight:  OffsetLeft = -ClientWidthTotal;  break;
  369.               case SlideEffect_SlideBottom: OffsetTop  = -ClientHeightTotal; break;
  370.               case SlideEffect_Fade:        Fade = 0.0;                      break;
  371.               }
  372.            
  373.             break;
  374.          
  375.           case SlideAction_Scrolling:
  376.             TimeDisplayed = 0.0;
  377.             DirectionHorz = 1;
  378.             DirectionVert = 1;
  379.             break;
  380.           }
  381.  
  382.         ActionPrev = Action;
  383.         }
  384.    
  385.       switch (Action) {
  386.  
  387.         // ================================================
  388.         // Entry Animation
  389.  
  390.         case SlideAction_Entering:
  391.           switch (SlideCurrent.EffectEntry) {
  392.             case SlideEffect_Replace:
  393.               FlagCompleted = true;
  394.               break;
  395.            
  396.             case SlideEffect_SlideTop:
  397.               OffsetTop -= SlideCurrent.EffectEntrySpeed * TimeDelta;
  398.               OffsetTop = FMax(OffsetTop, OffsetTopTarget);
  399.               FlagCompleted = (OffsetTop <= OffsetTopTarget);
  400.               break;
  401.            
  402.             case SlideEffect_SlideLeft:
  403.               OffsetLeft -= SlideCurrent.EffectEntrySpeed * TimeDelta;
  404.               OffsetLeft = FMax(OffsetLeft, OffsetLeftTarget);
  405.               FlagCompleted = (OffsetLeft <= OffsetLeftTarget);
  406.               break;
  407.            
  408.             case SlideEffect_SlideRight:
  409.               OffsetLeft += SlideCurrent.EffectEntrySpeed * TimeDelta;
  410.               OffsetLeft = FMin(OffsetLeft, OffsetLeftTarget);
  411.               FlagCompleted = (OffsetLeft >= OffsetLeftTarget);
  412.               break;
  413.            
  414.             case SlideEffect_SlideBottom:
  415.               OffsetTop += SlideCurrent.EffectEntrySpeed * TimeDelta;
  416.               OffsetTop = FMin(OffsetTop, OffsetTopTarget);
  417.               FlagCompleted = (OffsetTop >= OffsetTopTarget);
  418.               break;
  419.            
  420.             case SlideEffect_Fade:
  421.               Fade += SlideCurrent.EffectEntrySpeed / 100.0 * TimeDelta;
  422.               Fade = FClamp(Fade, 0.0, 1.0);
  423.               FlagCompleted = (Fade == 1.0);
  424.               break;
  425.             }
  426.  
  427.           if (FlagCompleted) {
  428.             OffsetTop  = OffsetTopTarget;
  429.             OffsetLeft = OffsetLeftTarget;
  430.             Action = SlideAction_Scrolling;
  431.             }
  432.            
  433.           break;
  434.  
  435.  
  436.         // ================================================
  437.         // Scrolling
  438.  
  439.         case SlideAction_Scrolling:
  440.           switch (SlideCurrent.ScrollVert) {
  441.             case SlideScroll_None:
  442.               OffsetTop = OffsetTopTarget;
  443.               FlagCompletedVert = true;
  444.               break;
  445.            
  446.             case SlideScroll_Wrap:
  447.               FlagCompletedVert = (ClientHeightTotal <= Height && OffsetTop == OffsetTopTarget);
  448.  
  449.               if (!FlagCompletedVert) {
  450.                 if (OffsetTop + ClientHeightTotal <= 0)
  451.                   OffsetTop = Height;
  452.                 OffsetTop -= SlideCurrent.ScrollVertSpeed * TimeDelta;
  453.                 OffsetTop = FMax(OffsetTop, -ClientHeightTotal);
  454.  
  455.                 FlagCompletedVert = (OffsetTop + ClientHeightTotal <= 0);
  456.                 }
  457.  
  458.               break;  
  459.            
  460.             case SlideScroll_Bounce:
  461.               DirectionVertPrev = DirectionVert;
  462.  
  463.               FlagCompletedVert = (ClientHeightTotal <= Height && OffsetTop == OffsetTopTarget);
  464.               if (!FlagCompletedVert) {
  465.                 if (DirectionVert == 1 && OffsetTop + ClientHeightTotal <= OffsetTopDisplayed + ClientHeightDisplayed)
  466.                   DirectionVert = -1;
  467.                 else if (DirectionVert == -1 && OffsetTop >= OffsetTopDisplayed)
  468.                   DirectionVert = 1;
  469.                 else
  470.                   if (DirectionVert == 1)
  471.                     OffsetTop -= SlideCurrent.ScrollVertSpeed * TimeDelta;
  472.                   else
  473.                     OffsetTop += SlideCurrent.ScrollVertSpeed * TimeDelta;
  474.  
  475.                 OffsetTop = FClamp(OffsetTop, OffsetTopDisplayed + ClientHeightDisplayed - ClientHeightTotal,
  476.                                               OffsetTopDisplayed);
  477.  
  478.                 FlagCompletedVert = (DirectionVert != DirectionVertPrev);
  479.                 }
  480.  
  481.               break;
  482.             }
  483.  
  484.           switch (SlideCurrent.ScrollHorz) {
  485.             case SlideScroll_None:
  486.               OffsetLeft = OffsetLeftTarget;
  487.               FlagCompletedHorz = true;
  488.               break;
  489.            
  490.             case SlideScroll_Wrap:
  491.               FlagCompletedHorz = (ClientWidthTotal <= Width && OffsetLeft == OffsetLeftTarget);
  492.  
  493.               if (!FlagCompletedHorz) {
  494.                 if (OffsetLeft + ClientWidthTotal <= 0)
  495.                   OffsetLeft = Width;
  496.                 OffsetLeft -= SlideCurrent.ScrollHorzSpeed * TimeDelta;
  497.                 OffsetLeft = FMax(OffsetLeft, -ClientWidthTotal);
  498.  
  499.                 FlagCompletedHorz = (OffsetLeft + ClientWidthTotal <= 0);
  500.                 }
  501.                
  502.               break;  
  503.            
  504.             case SlideScroll_Bounce:
  505.               DirectionHorzPrev = DirectionHorz;
  506.  
  507.               FlagCompletedHorz = (ClientWidthTotal <= Width && OffsetLeft == OffsetLeftTarget);
  508.               if (!FlagCompletedHorz) {
  509.                 if (DirectionHorz == 1 && OffsetLeft + ClientWidthTotal <= OffsetLeftDisplayed + ClientWidthDisplayed)
  510.                   DirectionHorz = -1;
  511.                 else if (DirectionHorz == -1 && OffsetLeft >= OffsetLeftDisplayed)
  512.                   DirectionHorz =  1;
  513.                 else
  514.                   if (DirectionHorz == 1)
  515.                     OffsetLeft -= SlideCurrent.ScrollHorzSpeed * TimeDelta;
  516.                   else
  517.                     OffsetLeft += SlideCurrent.ScrollHorzSpeed * TimeDelta;
  518.  
  519.                 OffsetLeft = FClamp(OffsetLeft, OffsetLeftDisplayed + ClientWidthDisplayed - ClientWidthTotal,
  520.                                                 OffsetLeftDisplayed);
  521.  
  522.                 FlagCompletedHorz = (DirectionHorz != DirectionHorzPrev);
  523.                 }
  524.  
  525.               break;
  526.             }
  527.  
  528.           FlagCompleted = FlagCompletedHorz && FlagCompletedVert;
  529.           if (FlagCompleted && ((TimeDisplayed >= SlideCurrent.Time && SlideCurrent.SlideNext != None) ||
  530.                                 SwitchTriggered.SlideSwitch != None))
  531.             Action = SlideAction_Exiting;
  532.           break;
  533.  
  534.  
  535.         // ================================================
  536.         // Exit Animation
  537.  
  538.         case SlideAction_Exiting:
  539.           switch (SlideCurrent.EffectExit) {
  540.             case SlideEffect_Replace:
  541.               FlagCompleted = true;
  542.               break;
  543.            
  544.             case SlideEffect_SlideTop:
  545.               OffsetTop -= SlideCurrent.EffectExitSpeed * TimeDelta;
  546.               FlagCompleted = (OffsetTop + ClientHeightTotal <= 0);
  547.               break;
  548.            
  549.             case SlideEffect_SlideLeft:
  550.               OffsetLeft -= SlideCurrent.EffectExitSpeed * TimeDelta;
  551.               FlagCompleted = (OffsetLeft + ClientWidthTotal <= 0);
  552.               break;
  553.            
  554.             case SlideEffect_SlideRight:
  555.               OffsetLeft += SlideCurrent.EffectExitSpeed * TimeDelta;
  556.               FlagCompleted = (OffsetLeft >= Width);
  557.               break;
  558.            
  559.             case SlideEffect_SlideBottom:
  560.               OffsetTop += SlideCurrent.EffectExitSpeed * TimeDelta;
  561.               FlagCompleted = (OffsetTop >= Height);
  562.               break;
  563.            
  564.             case SlideEffect_Fade:
  565.               Fade -= SlideCurrent.EffectExitSpeed / 100.0 * TimeDelta;
  566.               Fade = FClamp(Fade, 0.0, 1.0);
  567.               FlagCompleted = (Fade == 0.0);
  568.               break;
  569.             }
  570.            
  571.           break;
  572.         }
  573.  
  574.       } until (Action == ActionPrev);
  575.  
  576.  
  577.     // ====================================================
  578.     // Switch Slides
  579.     // ====================================================
  580.  
  581.     if (Action == SlideAction_Exiting && FlagCompleted) {
  582.       if (SwitchTriggered.SlideSwitch == None)
  583.         SwitchTriggered.SlideSwitch = SlideCurrent.SlideNext;
  584.  
  585.       SlideCurrent = None;
  586.  
  587.       if (FlagDebug)
  588.         Log("Switching to slide" @ SwitchTriggered.SlideSwitch.Name);
  589.       }
  590.     }
  591.   }
  592.  
  593.  
  594. // ============================================================================
  595. // GetClientWidthTotal
  596. //
  597. // Calculates and returns the total client width of a slide.
  598. // ============================================================================
  599.  
  600. simulated function int GetClientWidthTotal(ScreenSlide Slide) {
  601.  
  602.   return Slide.ClientPaddingLeft +
  603.          Slide.ClientWidth +
  604.          Slide.ClientPaddingRight;
  605.   }
  606.  
  607.  
  608. // ============================================================================
  609. // GetClientHeightTotal
  610. //
  611. // Calculates and returns the total client height of a slide.
  612. // ============================================================================
  613.  
  614. simulated function int GetClientHeightTotal(ScreenSlide Slide) {
  615.  
  616.   return Slide.ClientPaddingTop +
  617.          Slide.ClientHeight +
  618.          Slide.ClientPaddingBottom;
  619.   }
  620.  
  621.  
  622. // ============================================================================
  623. // RenderTexture
  624. // ============================================================================
  625.  
  626. simulated event RenderTexture(ScriptedTexture TextureCanvas) {
  627.  
  628.   local Color ColorDebug;
  629.   local Screen ScreenMaster;
  630.   local ScreenSlide ThisSlide;
  631.   local int IndexSlide;
  632.  
  633.   ScreenMaster = TileMaster;
  634.   if (ScreenMaster == None)
  635.     ScreenMaster = Self;
  636.  
  637.   if (ScreenMaster.SlideCurrentAck == None)
  638.     return;
  639.  
  640.   if (ScreenMaster.SlideCurrentAck.Palette != None)
  641.     TextureCanvas.Palette = ScreenMaster.SlideCurrentAck.Palette.Palette;
  642.   else
  643.     TextureCanvas.Palette = PaletteOriginal;
  644.  
  645.  
  646.   // ================================================================
  647.   // Screen Background
  648.   // ================================================================
  649.  
  650.   if (ScreenMaster.ScreenBackground != None)
  651.     TextureCanvas.DrawTile(Left - TileLeft,
  652.                            Top  - TileTop,
  653.                            ScreenMaster.Width,
  654.                            ScreenMaster.Height,
  655.                            0, 0,
  656.                            ScreenMaster.ScreenBackground.USize,
  657.                            ScreenMaster.ScreenBackground.VSize,
  658.                            ScreenMaster.ScreenBackground,
  659.                            ScreenMaster.ScreenBackground.bMasked);
  660.  
  661.  
  662.   // ================================================================
  663.   // Slides
  664.   // ================================================================
  665.  
  666.   for (ThisSlide = ScreenMaster.SlideCurrentAck; ThisSlide != None; ThisSlide = ThisSlide.SlideOverlay) {
  667.     if (ThisSlide.Background != None)
  668.       if (ThisSlide.BackgroundScroll)
  669.         Tile(TextureCanvas,
  670.              ThisSlide.Background,
  671.              Left - TileLeft + ScreenMaster.OffsetLeftSlide[IndexSlide] + int(ScreenMaster.OffsetLeft),
  672.              Top  - TileTop  + ScreenMaster.OffsetTopSlide [IndexSlide] + int(ScreenMaster.OffsetTop),
  673.              ThisSlide.BackgroundTile);
  674.       else
  675.         Tile(TextureCanvas,
  676.              ThisSlide.Background,
  677.              Left - TileLeft + ScreenMaster.OffsetLeftSlide[IndexSlide],
  678.              Top  - TileTop  + ScreenMaster.OffsetTopSlide [IndexSlide],
  679.              ThisSlide.BackgroundTile);
  680.  
  681.     ThisSlide.Draw(TextureCanvas,
  682.       Left - TileLeft + ScreenMaster.OffsetLeftSlide[IndexSlide] +
  683.         int(ScreenMaster.OffsetLeft) + ThisSlide.ClientPaddingLeft,
  684.       Top  - TileTop  + ScreenMaster.OffsetTopSlide [IndexSlide] +
  685.         int(ScreenMaster.OffsetTop)  + ThisSlide.ClientPaddingTop,
  686.       ScreenMaster.Fade);
  687.  
  688.     IndexSlide++;
  689.     if (IndexSlide == ArrayCount(OffsetLeftSlide))
  690.       break;
  691.     }
  692.  
  693.  
  694.   // ================================================================
  695.   // Screen Foreground
  696.   // ================================================================
  697.  
  698.   if (ScreenMaster.ScreenForeground != None)
  699.     TextureCanvas.DrawTile(Left - TileLeft,
  700.                            Top  - TileTop,
  701.                            ScreenMaster.Width,
  702.                            ScreenMaster.Height,
  703.                            0, 0,
  704.                            ScreenMaster.ScreenForeground.USize,
  705.                            ScreenMaster.ScreenForeground.VSize,
  706.                            ScreenMaster.ScreenForeground,
  707.                            ScreenMaster.ScreenForeground.bMasked);
  708.  
  709.   if (FlagDebug) {
  710.     ColorDebug.R = 255;
  711.     ColorDebug.G =   0;
  712.     ColorDebug.B =   0;
  713.  
  714.     TextureCanvas.DrawColoredText(Left, Top,
  715.       int(Left - TileLeft + ScreenMaster.OffsetLeft + ScreenMaster.SlideCurrentAck.ClientPaddingLeft) @ "x" @
  716.       int(Top  - TileTop  + ScreenMaster.OffsetTop  + ScreenMaster.SlideCurrentAck.ClientPaddingTop),
  717.       Font 'Engine.SmallFont', ColorDebug);
  718.     }
  719.   }
  720.  
  721.  
  722. // ============================================================================
  723. // Tile
  724. //
  725. // Draws a texture repeatedly onto another texture, starting at the given
  726. // offset.
  727. // ============================================================================
  728.  
  729. simulated function Tile(ScriptedTexture TextureCanvas, Texture TextureTile,
  730.                         int OffsetLeft, int OffsetTop, bool FlagTiled) {
  731.  
  732.   local int OffsetTopTexture;
  733.   local int OffsetLeftTexture;
  734.  
  735.   for (OffsetLeftTexture = OffsetLeft; OffsetLeftTexture < TextureCanvas.USize; OffsetLeftTexture += TextureTile.USize) {
  736.     if (OffsetLeftTexture + TextureTile.USize > 0)
  737.       for (OffsetTopTexture = OffsetTop; OffsetTopTexture < TextureCanvas.VSize; OffsetTopTexture += TextureTile.VSize) {
  738.         if (OffsetTopTexture + TextureTile.VSize > 0)
  739.           TextureCanvas.DrawTile(OffsetLeftTexture, OffsetTopTexture, TextureTile.USize, TextureTile.VSize,
  740.                                  0, 0, TextureTile.USize, TextureTile.VSize, TextureTile, TextureTile.bMasked);
  741.         if (!FlagTiled) break;
  742.         }
  743.  
  744.     if (!FlagTiled) break;
  745.     }
  746.   }
  747.  
  748.  
  749. // ============================================================================
  750. // VersionCheck
  751. //
  752. // Compares this client's Screen version with the version running on the
  753. // server and notifies the user of updates.
  754. // ============================================================================
  755.  
  756. simulated function VersionCheck() {
  757.  
  758.   local ScreenMutator ThisScreenMutator;
  759.   local Mutator ThisMutator;
  760.  
  761.   if (FlagVersionAck)
  762.     return;
  763.  
  764.   FlagVersionAck = (VersionServer > 0);
  765.  
  766.   if (VersionServer > Version)
  767.     MutatorScreen.DisplayVersion(Version, VersionServer);
  768.  
  769.   VersionLatest = Max(VersionLatest, VersionServer);
  770.   SaveConfig();
  771.   }
  772.  
  773.  
  774. // ============================================================================
  775. // AddSlide
  776. //
  777. // Adds a slide to the end of the Screen's current slide list. If the current
  778. // last slide wraps around to a previous slide, so will the appended slide.
  779. // ============================================================================
  780.  
  781. simulated function AddSlide(ScreenSlide NewSlide) {
  782.  
  783.   local ScreenSlide ThisSlide;
  784.   local ScreenSlide SlidePrevious;
  785.  
  786.   SlidePrevious = None;
  787.  
  788.   for (ThisSlide = SlideCurrent; ThisSlide != None && !ThisSlide.FlagSeen; ThisSlide = ThisSlide.SlideNext) {
  789.     ThisSlide.FlagSeen = true;
  790.     SlidePrevious = ThisSlide;
  791.     }
  792.  
  793.   if (SlidePrevious == None) {
  794.     NewSlide.SlideNext = SlideCurrent;
  795.     SlideCurrent = NewSlide;
  796.     }
  797.  
  798.   else {
  799.     NewSlide.SlideNext = ThisSlide;
  800.     SlidePrevious.SlideNext = NewSlide;
  801.     }
  802.  
  803.   NewSlide.FlagSeen = true;
  804.   for (ThisSlide = SlideCurrent; ThisSlide != None && ThisSlide.FlagSeen; ThisSlide = ThisSlide.SlideNext)
  805.     ThisSlide.FlagSeen = false;
  806.   }
  807.  
  808.  
  809. // ============================================================================
  810. // Default Properties
  811. // ============================================================================
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!