ocrm.bsky.social
the game where you go into mines and start crafting! but for consoles (forked directly from smartcmd's github)
1#include "stdafx.h"
2#include "XUI_SkinSelect.h"
3#include "XUI_Ctrl_MinecraftSkinPreview.h"
4
5#define SKIN_SELECT_PACK_DEFAULT 0
6#define SKIN_SELECT_PACK_FAVORITES 1
7//#define SKIN_SELECT_PACK_PLAYER_CUSTOM 1
8#define SKIN_SELECT_MAX_DEFAULTS 2
9
10WCHAR *CScene_SkinSelect::wchDefaultNamesA[]=
11{
12 L"USE LOCALISED VERSION", // Server selected
13 L"Steve",
14 L"Tennis Steve",
15 L"Tuxedo Steve",
16 L"Athlete Steve",
17 L"Scottish Steve",
18 L"Prisoner Steve",
19 L"Cyclist Steve",
20 L"Boxer Steve",
21};
22
23
24//----------------------------------------------------------------------------------
25// Performs initialization tasks - retrieves controls.
26//----------------------------------------------------------------------------------
27HRESULT CScene_SkinSelect::OnInit( XUIMessageInit* pInitData, BOOL& bHandled )
28{
29 m_iPad=*(int *)pInitData->pvInitData;
30 // if we're not in the game, we need to use basescene 0
31 bool bNotInGame=(Minecraft::GetInstance()->level==NULL);
32 m_bIgnoreInput=false;
33
34 // 4J Stu - Added this so that we have skins loaded
35 // 4J-PB - Need to check for installed DLC
36 //if( (!app.DLCInstalled() || app.m_dlcManager.NeedsUpdated()) && !app.DLCInstallPending()) app.StartInstallDLCProcess(m_iPad);
37
38 // StartInstallDLCProcess will check for all conditions within the call
39 MapChildControls();
40
41 m_selectedText.SetText( app.GetString( IDS_SELECTED ) );
42
43 updateClipping();
44
45 m_packIndex = SKIN_SELECT_PACK_DEFAULT;
46 m_skinIndex = 0;
47 m_currentSkinPath = app.GetPlayerSkinName(m_iPad);
48 m_originalSkinId = app.GetPlayerSkinId(m_iPad);
49 m_currentPack = NULL;
50 m_bSlidingSkins = false;
51 m_bAnimatingMove = false;
52 currentPackCount = 0;
53
54 m_currentNavigation = eSkinNavigation_Skin;
55 m_normalTabs.SetShow( TRUE );
56 m_selectedTabs.SetShow( FALSE );
57 m_packLeft.SetEnable(FALSE);
58 m_packRight.SetEnable(FALSE);
59
60
61 for(BYTE i = 0; i < sidePreviewControls; ++i)
62 {
63 //m_previewNextControl->SetAutoRotate(true);
64 m_previewNextControls[i]->SetFacing(CXuiCtrlMinecraftSkinPreview::e_SkinPreviewFacing_Left);
65 //m_previewPreviousControl->SetAutoRotate(true);
66 m_previewPreviousControls[i]->SetFacing(CXuiCtrlMinecraftSkinPreview::e_SkinPreviewFacing_Right);
67 }
68
69 // block input if we're waiting for DLC to install. The end of dlc mounting custom message will fill the save list
70 if(app.StartInstallDLCProcess(m_iPad))
71 {
72 // DLC mounting in progress, so disable input
73 m_bIgnoreInput=true;
74 m_timer.SetShow( TRUE );
75 m_charactersGroup.SetShow( FALSE );
76 m_skinDetails.SetShow( FALSE );
77 m_imagePadlock.SetShow( FALSE );
78 m_selectedGroup.SetShow( FALSE );
79 }
80 else
81 {
82 m_timer.SetShow( FALSE );
83
84 if(app.m_dlcManager.getPackCount(DLCManager::e_DLCType_Skin)>0)
85 {
86 // Change to display the favorites if there are any. The current skin will be in there (probably) - need to check for it
87 m_currentPack = app.m_dlcManager.getPackContainingSkin(m_currentSkinPath);
88 bool bFound;
89 if(m_currentPack != NULL)
90 {
91 m_packIndex = app.m_dlcManager.getPackIndex(m_currentPack,bFound,DLCManager::e_DLCType_Skin) + SKIN_SELECT_MAX_DEFAULTS;
92 }
93 }
94
95 // If we have any favourites, set this to the favourites
96 // first validate the favorite skins - we might have uninstalled the DLC needed for them
97 app.ValidateFavoriteSkins(m_iPad);
98
99 if(app.GetPlayerFavoriteSkinsCount(m_iPad)>0)
100 {
101 m_packIndex = SKIN_SELECT_PACK_FAVORITES;
102 }
103
104 handlePackIndexChanged();
105 updateCurrentFocus();
106 }
107
108 // Display the tooltips
109
110 // if we're not in the game, we need to use basescene 0
111 if(bNotInGame)
112 {
113 ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT_SKIN,IDS_TOOLTIPS_CANCEL,-1,-1,-1,-1,-1,-1,IDS_TOOLTIPS_NAVIGATE);
114 CXuiSceneBase::ShowBackground( DEFAULT_XUI_MENU_USER, TRUE );
115 }
116 else
117 {
118 ui.SetTooltips( m_iPad, IDS_TOOLTIPS_SELECT_SKIN,IDS_TOOLTIPS_CANCEL,-1,-1,-1,-1,-1,-1,IDS_TOOLTIPS_NAVIGATE);
119 CXuiSceneBase::ShowBackground( m_iPad, FALSE );
120 CXuiSceneBase::ShowDarkOverlay( m_iPad, TRUE );
121 }
122
123
124 if(app.GetLocalPlayerCount()>1)
125 {
126 app.AdjustSplitscreenScene(m_hObj,&m_OriginalPosition,m_iPad, false);
127 CXuiSceneBase::ShowLogo( m_iPad, FALSE );
128 }
129 else
130 {
131 if(bNotInGame)
132 {
133 CXuiSceneBase::ShowLogo( DEFAULT_XUI_MENU_USER, FALSE );
134 }
135 else
136 {
137 CXuiSceneBase::ShowLogo( m_iPad, FALSE );
138 }
139 }
140
141 return S_OK;
142}
143
144
145HRESULT CScene_SkinSelect::OnKeyUp(XUIMessageInput* pInputData, BOOL& rfHandled)
146{
147 if(m_bIgnoreInput) return S_OK;
148
149 switch(pInputData->dwKeyCode)
150 {
151 case VK_PAD_RTHUMB_LEFT:
152 m_previewControl->m_incYRot = false;
153 break;
154 case VK_PAD_RTHUMB_RIGHT:
155 m_previewControl->m_decYRot = false;
156 break;
157 case VK_PAD_RTHUMB_UP:
158 //m_previewControl->m_incXRot = false;
159 break;
160 case VK_PAD_RTHUMB_DOWN:
161 //m_previewControl->m_decXRot = false;
162 break;
163 case VK_PAD_RTHUMB_UPLEFT:
164 m_previewControl->m_incYRot = false;
165 //m_previewControl->m_incXRot = false;
166 break;
167 case VK_PAD_RTHUMB_UPRIGHT:
168 m_previewControl->m_decYRot = false;
169 //m_previewControl->m_incXRot = false;
170 break;
171 case VK_PAD_RTHUMB_DOWNRIGHT:
172 m_previewControl->m_decYRot = false;
173 //m_previewControl->m_decXRot = false;
174 break;
175 case VK_PAD_RTHUMB_DOWNLEFT:
176 m_previewControl->m_incYRot = false;
177 //m_previewControl->m_decXRot = false;
178 break;
179 }
180 return S_OK;
181}
182
183
184HRESULT CScene_SkinSelect::OnKeyDown(XUIMessageInput* pInputData, BOOL& rfHandled)
185{
186 if(m_bIgnoreInput) return S_OK;
187
188 // 4J Stu - We don't want the press anim to play for the scrolling unless we are actually scrolling
189 //ui.AnimateKeyPress(pInputData->UserIndex, pInputData->dwKeyCode);
190
191 // ignore any key press if we are animating a move
192 //if(m_bAnimatingMove) return S_OK;
193
194 HRESULT hr=S_OK;
195
196 // Explicitly handle B button presses
197 switch(pInputData->dwKeyCode)
198 {
199 case VK_PAD_A:
200 ui.AnimateKeyPress(pInputData->UserIndex, pInputData->dwKeyCode);
201 // if the profile data has been changed, then force a profile write
202 // It seems we're allowed to break the 5 minute rule if it's the result of a user action
203 switch(m_packIndex)
204 {
205 case SKIN_SELECT_PACK_DEFAULT:
206 app.SetPlayerSkin(pInputData->UserIndex, m_skinIndex);
207 app.SetPlayerCape(pInputData->UserIndex, 0);
208 m_currentSkinPath = app.GetPlayerSkinName(m_iPad);
209 m_originalSkinId = app.GetPlayerSkinId(m_iPad);
210 m_selectedGroup.SetShow( TRUE );
211 CXuiSceneBase::PlayUISFX(eSFX_Press);
212 break;
213 case SKIN_SELECT_PACK_FAVORITES:
214 if(app.GetPlayerFavoriteSkinsCount(m_iPad)>0)
215 {
216 // get the pack number from the skin id
217 wchar_t chars[256];
218 swprintf(chars, 256, L"dlcskin%08d.png", app.GetPlayerFavoriteSkin(m_iPad,m_skinIndex));
219
220 DLCPack *Pack=app.m_dlcManager.getPackContainingSkin(chars);
221
222 if(Pack)
223 {
224 DLCSkinFile *skinFile = Pack->getSkinFile(chars);
225 app.SetPlayerSkin(pInputData->UserIndex, skinFile->getPath());
226 app.SetPlayerCape(pInputData->UserIndex, skinFile->getParameterAsString(DLCManager::e_DLCParamType_Cape));
227 m_selectedGroup.SetShow( TRUE );
228 m_currentSkinPath = app.GetPlayerSkinName(m_iPad);
229 m_originalSkinId = app.GetPlayerSkinId(m_iPad);
230 app.SetPlayerFavoriteSkinsPos(m_iPad,m_skinIndex);
231 }
232 }
233 break;
234 default:
235 if( m_currentPack != NULL )
236 {
237 DLCSkinFile *skinFile = m_currentPack->getSkinFile(m_skinIndex);
238
239 // Is this a free skin?
240
241 if(!skinFile->getParameterAsBool( DLCManager::e_DLCParamType_Free ))
242 {
243 // do we have a license?
244 if(!m_currentPack->hasPurchasedFile( DLCManager::e_DLCType_Skin, skinFile->getPath() ))
245 {
246 // no
247 UINT uiIDA[1];
248 uiIDA[0]=IDS_OK;
249
250 // We need to upsell the full version
251 if(ProfileManager.IsGuest(m_iPad))
252 {
253 // can't buy
254 StorageManager.RequestMessageBox(IDS_PRO_GUESTPROFILE_TITLE, IDS_PRO_GUESTPROFILE_TEXT, uiIDA, 1);
255 }
256 // are we online?
257 else if(!ProfileManager.IsSignedInLive(pInputData->UserIndex))
258 {
259 // need to be signed in to live
260 StorageManager.RequestMessageBox(IDS_PRO_NOTONLINE_TITLE, IDS_PRO_XBOXLIVE_NOTIFICATION, uiIDA, 1);
261 }
262 else
263 {
264 // upsell
265
266 DLC_INFO *pDLCInfo = app.GetDLCInfoForTrialOfferID(m_currentPack->getPurchaseOfferId());
267 ULONGLONG ullOfferID_Full;
268
269 if(pDLCInfo!=NULL)
270 {
271 ullOfferID_Full=pDLCInfo->ullOfferID_Full;
272 }
273 else
274 {
275 ullOfferID_Full=m_currentPack->getPurchaseOfferId();
276 }
277
278 // tell sentient about the upsell of the full version of the skin pack
279 TelemetryManager->RecordUpsellPresented(pInputData->UserIndex, eSet_UpsellID_Skin_DLC, ullOfferID_Full & 0xFFFFFFFF);
280
281 UINT uiIDA[2];
282 uiIDA[0]=IDS_CONFIRM_OK;
283 uiIDA[1]=IDS_CONFIRM_CANCEL;
284
285 StorageManager.RequestMessageBox(IDS_UNLOCK_DLC_TITLE, IDS_UNLOCK_DLC_SKIN, uiIDA, 2, pInputData->UserIndex,&CScene_SkinSelect::UnlockSkinReturned,this,app.GetStringTable());
286 }
287 }
288 else
289 {
290 app.SetPlayerSkin(pInputData->UserIndex, skinFile->getPath());
291 app.SetPlayerCape(pInputData->UserIndex, skinFile->getParameterAsString(DLCManager::e_DLCParamType_Cape));
292 m_selectedGroup.SetShow( TRUE );
293 m_currentSkinPath = app.GetPlayerSkinName(m_iPad);
294 m_originalSkinId = app.GetPlayerSkinId(m_iPad);
295
296 // push this onto the favorite list
297 AddFavoriteSkin(m_iPad,GET_DLC_SKIN_ID_FROM_BITMASK(m_originalSkinId));
298 }
299 }
300 else
301 {
302 app.SetPlayerSkin(pInputData->UserIndex, skinFile->getPath());
303 app.SetPlayerCape(pInputData->UserIndex, skinFile->getParameterAsString(DLCManager::e_DLCParamType_Cape));
304 m_selectedGroup.SetShow( TRUE );
305 m_currentSkinPath = app.GetPlayerSkinName(m_iPad);
306 m_originalSkinId = app.GetPlayerSkinId(m_iPad);
307
308 // push this onto the favorite list
309 AddFavoriteSkin(m_iPad,GET_DLC_SKIN_ID_FROM_BITMASK(m_originalSkinId));
310
311 }
312 }
313
314 CXuiSceneBase::PlayUISFX(eSFX_Press);
315 break;
316 }
317
318 break;
319 case VK_PAD_B:
320 case VK_ESCAPE:
321 ui.AnimateKeyPress(pInputData->UserIndex, pInputData->dwKeyCode);
322 app.CheckGameSettingsChanged(true,pInputData->UserIndex);
323
324 app.NavigateBack(pInputData->UserIndex);
325 rfHandled = TRUE;
326 break;
327#if 0
328 case VK_PAD_RSHOULDER:
329 {
330 DWORD startingIndex = m_packIndex;
331 m_packIndex = getNextPackIndex(m_packIndex);
332 if(startingIndex != m_packIndex)
333 {
334 handlePackIndexChanged();
335 }
336 }
337 break;
338 case VK_PAD_LSHOULDER:
339 {
340 DWORD startingIndex = m_packIndex;
341 m_packIndex = getPreviousPackIndex(m_packIndex);
342 if(startingIndex != m_packIndex)
343 {
344 handlePackIndexChanged();
345 }
346 }
347 break;
348#endif
349 case VK_PAD_DPAD_UP:
350 case VK_PAD_LTHUMB_UP:
351 case VK_PAD_DPAD_DOWN:
352 case VK_PAD_LTHUMB_DOWN:
353 {
354 if(m_packIndex==SKIN_SELECT_PACK_FAVORITES)
355 {
356 if(app.GetPlayerFavoriteSkinsCount(m_iPad)==0)
357 {
358 // ignore this, since there are no skins being displayed
359 break;
360 }
361 }
362
363 ui.AnimateKeyPress(pInputData->UserIndex, pInputData->dwKeyCode);
364 CXuiSceneBase::PlayUISFX(eSFX_Scroll);
365 switch(m_currentNavigation)
366 {
367 case eSkinNavigation_Pack:
368 m_currentNavigation = eSkinNavigation_Skin;
369 break;
370 case eSkinNavigation_Skin:
371 m_currentNavigation = eSkinNavigation_Pack;
372 break;
373 };
374 updateCurrentFocus();
375 }
376 break;
377 case VK_PAD_DPAD_LEFT:
378 case VK_PAD_LTHUMB_LEFT:
379 {
380 if( m_currentNavigation == eSkinNavigation_Skin )
381 {
382 if(!m_bAnimatingMove)
383 {
384 ui.AnimateKeyPress(pInputData->UserIndex, pInputData->dwKeyCode);
385 CXuiSceneBase::PlayUISFX(eSFX_Scroll);
386
387 m_skinIndex = getPreviousSkinIndex(m_skinIndex);
388 //handleSkinIndexChanged();
389
390 m_bSlidingSkins = true;
391 m_bAnimatingMove = true;
392
393 m_previewControl->SetFacing(CXuiCtrlMinecraftSkinPreview::e_SkinPreviewFacing_Left, true);
394 m_previewPreviousControls[0]->SetFacing(CXuiCtrlMinecraftSkinPreview::e_SkinPreviewFacing_Forward, true);
395
396 int startFrame, endFrame;
397 HRESULT hr = m_charactersGroup.FindNamedFrame(L"CycleRight", &startFrame);
398 hr = m_charactersGroup.FindNamedFrame( L"EndCycleRight", &endFrame);
399 hr = m_charactersGroup.PlayTimeline(startFrame, startFrame,endFrame,FALSE,FALSE);
400 }
401 }
402 else if( m_currentNavigation == eSkinNavigation_Pack )
403 {
404 ui.AnimateKeyPress(pInputData->UserIndex, pInputData->dwKeyCode);
405 CXuiSceneBase::PlayUISFX(eSFX_Scroll);
406 DWORD startingIndex = m_packIndex;
407 m_packIndex = getPreviousPackIndex(m_packIndex);
408 if(startingIndex != m_packIndex)
409 {
410 handlePackIndexChanged();
411 }
412 }
413 }
414 break;
415 case VK_PAD_DPAD_RIGHT:
416 case VK_PAD_LTHUMB_RIGHT:
417 {
418 if( m_currentNavigation == eSkinNavigation_Skin )
419 {
420 if(!m_bAnimatingMove)
421 {
422 ui.AnimateKeyPress(pInputData->UserIndex, pInputData->dwKeyCode);
423 CXuiSceneBase::PlayUISFX(eSFX_Scroll);
424 m_skinIndex = getNextSkinIndex(m_skinIndex);
425 //handleSkinIndexChanged();
426
427 m_bSlidingSkins = true;
428 m_bAnimatingMove = true;
429
430 m_previewControl->SetFacing(CXuiCtrlMinecraftSkinPreview::e_SkinPreviewFacing_Right, true);
431 m_previewNextControls[0]->SetFacing(CXuiCtrlMinecraftSkinPreview::e_SkinPreviewFacing_Forward, true);
432
433 int startFrame, endFrame;
434 HRESULT hr = m_charactersGroup.FindNamedFrame(L"CycleLeft", &startFrame);
435 hr = m_charactersGroup.FindNamedFrame( L"EndCycleLeft", &endFrame);
436 hr = m_charactersGroup.PlayTimeline(startFrame, startFrame,endFrame,FALSE,FALSE);
437 }
438 }
439 else if( m_currentNavigation == eSkinNavigation_Pack )
440 {
441 ui.AnimateKeyPress(pInputData->UserIndex, pInputData->dwKeyCode);
442 CXuiSceneBase::PlayUISFX(eSFX_Scroll);
443 DWORD startingIndex = m_packIndex;
444 m_packIndex = getNextPackIndex(m_packIndex);
445 if(startingIndex != m_packIndex)
446 {
447 handlePackIndexChanged();
448 }
449 }
450 }
451 break;
452 case VK_PAD_RTHUMB_PRESS:
453 CXuiSceneBase::PlayUISFX(eSFX_Press);
454 if( m_currentNavigation == eSkinNavigation_Skin )
455 {
456 m_previewControl->ResetRotation();
457 }
458 break;
459 case VK_PAD_RTHUMB_LEFT:
460 if( m_currentNavigation == eSkinNavigation_Skin )
461 {
462 m_previewControl->m_incYRot = true;
463 }
464 else
465 {
466 CXuiSceneBase::PlayUISFX(eSFX_Scroll);
467 }
468 break;
469 case VK_PAD_RTHUMB_RIGHT:
470 if( m_currentNavigation == eSkinNavigation_Skin )
471 {
472 m_previewControl->m_decYRot = true;
473 }
474 else
475 {
476 CXuiSceneBase::PlayUISFX(eSFX_Scroll);
477 }
478 break;
479 case VK_PAD_RTHUMB_UP:
480 if( m_currentNavigation == eSkinNavigation_Skin )
481 {
482 //m_previewControl->m_incXRot = true;
483 m_previewControl->CyclePreviousAnimation();
484 }
485 else
486 {
487 CXuiSceneBase::PlayUISFX(eSFX_Scroll);
488 }
489 break;
490 case VK_PAD_RTHUMB_DOWN:
491 if( m_currentNavigation == eSkinNavigation_Skin )
492 {
493 //m_previewControl->m_decXRot = true;
494 m_previewControl->CycleNextAnimation();
495 }
496 else
497 {
498 CXuiSceneBase::PlayUISFX(eSFX_Scroll);
499 }
500 break;
501 case VK_PAD_RTHUMB_UPLEFT:
502 if( m_currentNavigation == eSkinNavigation_Skin )
503 {
504 m_previewControl->m_incYRot = true;
505 //m_previewControl->m_incXRot = true;
506 }
507 else
508 {
509 CXuiSceneBase::PlayUISFX(eSFX_Scroll);
510 }
511 break;
512 case VK_PAD_RTHUMB_UPRIGHT:
513 if( m_currentNavigation == eSkinNavigation_Skin )
514 {
515 m_previewControl->m_decYRot = true;
516 //m_previewControl->m_incXRot = true;
517 }
518 else
519 {
520 CXuiSceneBase::PlayUISFX(eSFX_Scroll);
521 }
522 break;
523 case VK_PAD_RTHUMB_DOWNRIGHT:
524 if( m_currentNavigation == eSkinNavigation_Skin )
525 {
526 m_previewControl->m_decYRot = true;
527 //m_previewControl->m_decXRot = true;
528 }
529 else
530 {
531 CXuiSceneBase::PlayUISFX(eSFX_Scroll);
532 }
533 break;
534 case VK_PAD_RTHUMB_DOWNLEFT:
535 if( m_currentNavigation == eSkinNavigation_Skin )
536 {
537 m_previewControl->m_incYRot = true;
538 //m_previewControl->m_decXRot = true;
539 }
540 else
541 {
542 CXuiSceneBase::PlayUISFX(eSFX_Scroll);
543 }
544 break;
545 }
546
547 return hr;
548}
549
550//----------------------------------------------------------------------------------
551// Handler for the button press message.
552//----------------------------------------------------------------------------------
553HRESULT CScene_SkinSelect::OnNotifyPressEx(HXUIOBJ hObjPressed, XUINotifyPress* pNotifyPressData, BOOL& rfHandled)
554{
555 if(m_bIgnoreInput) return S_OK;
556
557 // This assumes all buttons can only be pressed with the A button
558 ui.AnimateKeyPress(pNotifyPressData->UserIndex, VK_PAD_A);
559
560 return S_OK;
561}
562
563HRESULT CScene_SkinSelect::OnTransitionStart( XUIMessageTransition *pTransition, BOOL& bHandled )
564{
565 if(pTransition->dwTransAction==XUI_TRANSITION_ACTION_DESTROY ) return S_OK;
566
567 if(pTransition->dwTransType == XUI_TRANSITION_TO || pTransition->dwTransType == XUI_TRANSITION_BACKTO)
568 {
569
570 }
571
572 return S_OK;
573}
574
575HRESULT CScene_SkinSelect::OnTimelineEnd(HXUIOBJ hObjSource, BOOL& bHandled)
576{
577 if( hObjSource == m_charactersGroup )
578 {
579 if(m_bSlidingSkins)
580 {
581 m_bSlidingSkins = false;
582
583 int startFrame, endFrame;
584 HRESULT hr = m_charactersGroup.FindNamedFrame(L"Normal", &startFrame);
585 hr = m_charactersGroup.FindNamedFrame( L"Normal", &endFrame);
586 hr = m_charactersGroup.PlayTimeline(startFrame, startFrame,endFrame,FALSE,FALSE);
587 }
588 else
589 {
590 m_previewControl->SetFacing(CXuiCtrlMinecraftSkinPreview::e_SkinPreviewFacing_Forward, false);
591 m_previewNextControls[0]->SetFacing(CXuiCtrlMinecraftSkinPreview::e_SkinPreviewFacing_Left, false);
592 m_previewPreviousControls[0]->SetFacing(CXuiCtrlMinecraftSkinPreview::e_SkinPreviewFacing_Right, false);
593
594 handleSkinIndexChanged();
595
596 m_bAnimatingMove = false;
597
598 bHandled = TRUE;
599 }
600 }
601 return S_OK;
602}
603
604
605HRESULT CScene_SkinSelect::OnCustomMessage_Splitscreenplayer(bool bJoining, BOOL& bHandled)
606{
607 bHandled=true;
608 return app.AdjustSplitscreenScene_PlayerChanged(m_hObj,&m_OriginalPosition,m_iPad,bJoining,false);
609}
610
611
612
613
614HRESULT CScene_SkinSelect::OnBasePositionChanged()
615{
616 updateClipping();
617
618 return S_OK;
619}
620
621void CScene_SkinSelect::handleSkinIndexChanged()
622{
623 BOOL showPrevious = FALSE, showNext = FALSE;
624 DWORD previousIndex = 0, nextIndex = 0;
625 wstring skinName = L"";
626 wstring skinOrigin = L"";
627 bool bSkinIsFree=false;
628 bool bLicensed=false;
629 DLCSkinFile *skinFile=NULL;
630 DLCPack *Pack=NULL;
631 BYTE sidePreviewControlsL,sidePreviewControlsR;
632 bool bNoSkinsToShow=false;
633
634 TEXTURE_NAME backupTexture = TN_MOB_CHAR;
635 m_selectedGroup.SetShow( FALSE );
636 m_skinDetails.SetShow( FALSE );
637
638 if( m_currentPack != NULL )
639 {
640 skinFile = m_currentPack->getSkinFile(m_skinIndex);
641 m_selectedSkinPath = skinFile->getPath();
642 m_selectedCapePath = skinFile->getParameterAsString(DLCManager::e_DLCParamType_Cape);
643 m_vAdditionalSkinBoxes = skinFile->getAdditionalBoxes();
644
645 skinName = skinFile->getParameterAsString( DLCManager::e_DLCParamType_DisplayName );
646 skinOrigin = skinFile->getParameterAsString( DLCManager::e_DLCParamType_ThemeName );
647
648 if( m_selectedSkinPath.compare( m_currentSkinPath ) == 0 )
649 {
650 m_selectedGroup.SetShow( TRUE );
651 }
652 else
653 {
654 m_selectedGroup.SetShow( FALSE );
655 }
656
657 bSkinIsFree = skinFile->getParameterAsBool( DLCManager::e_DLCParamType_Free );
658 bLicensed = m_currentPack->hasPurchasedFile( DLCManager::e_DLCType_Skin, m_selectedSkinPath );
659
660 m_imagePadlock.SetShow( (bSkinIsFree || bLicensed) ?FALSE:TRUE );
661 m_previewControl->SetShow(TRUE);
662 m_skinDetails.SetShow( TRUE );
663 }
664 else
665 {
666 m_selectedSkinPath = L"";
667 m_selectedCapePath = L"";
668 m_vAdditionalSkinBoxes = NULL;
669
670 switch(m_packIndex)
671 {
672 case SKIN_SELECT_PACK_DEFAULT:
673 backupTexture = getTextureId(m_skinIndex);
674
675 if( m_skinIndex == eDefaultSkins_ServerSelected )
676 {
677 skinName = app.GetString(IDS_DEFAULT_SKINS);
678 }
679 else
680 {
681 skinName = wchDefaultNamesA[m_skinIndex];
682 }
683
684 if( m_originalSkinId == m_skinIndex )
685 {
686 m_selectedGroup.SetShow( TRUE );
687 }
688 else
689 {
690 m_selectedGroup.SetShow( FALSE );
691 }
692 m_imagePadlock.SetShow( FALSE );
693 m_previewControl->SetShow(TRUE);
694 m_skinDetails.SetShow( TRUE );
695
696 break;
697 case SKIN_SELECT_PACK_FAVORITES:
698
699 if(app.GetPlayerFavoriteSkinsCount(m_iPad)>0)
700 {
701 // get the pack number from the skin id
702 wchar_t chars[256];
703 swprintf(chars, 256, L"dlcskin%08d.png", app.GetPlayerFavoriteSkin(m_iPad,m_skinIndex));
704
705 Pack=app.m_dlcManager.getPackContainingSkin(chars);
706 if(Pack)
707 {
708 skinFile = Pack->getSkinFile(chars);
709
710 m_selectedSkinPath = skinFile->getPath();
711 m_selectedCapePath = skinFile->getParameterAsString(DLCManager::e_DLCParamType_Cape);
712 m_vAdditionalSkinBoxes = skinFile->getAdditionalBoxes();
713
714 skinName = skinFile->getParameterAsString( DLCManager::e_DLCParamType_DisplayName );
715 skinOrigin = skinFile->getParameterAsString( DLCManager::e_DLCParamType_ThemeName );
716
717 if( m_selectedSkinPath.compare( m_currentSkinPath ) == 0 )
718 {
719 m_selectedGroup.SetShow( TRUE );
720 }
721 else
722 {
723 m_selectedGroup.SetShow( FALSE );
724 }
725
726 bSkinIsFree = skinFile->getParameterAsBool( DLCManager::e_DLCParamType_Free );
727 bLicensed = Pack->hasPurchasedFile( DLCManager::e_DLCType_Skin, m_selectedSkinPath );
728
729 m_imagePadlock.SetShow( (bSkinIsFree || bLicensed) ?FALSE:TRUE );
730 m_skinDetails.SetShow( TRUE );
731 }
732 else
733 {
734 m_selectedGroup.SetShow( FALSE );
735 m_imagePadlock.SetShow( FALSE );
736 }
737 }
738 else
739 {
740 //disable the display
741 m_previewControl->SetShow(FALSE);
742 // change the tooltips
743 bNoSkinsToShow=true;
744 }
745 break;
746
747 }
748 }
749 m_text.SetText(skinName.c_str());
750 m_originText.SetText(skinOrigin.c_str());
751
752 if(m_vAdditionalSkinBoxes && m_vAdditionalSkinBoxes->size()!=0)
753 {
754 // add the boxes to the humanoid model, but only if we've not done this already
755 vector<ModelPart *> *pAdditionalModelParts = app.GetAdditionalModelParts(skinFile->getSkinID());
756 if(pAdditionalModelParts==NULL)
757 {
758 pAdditionalModelParts = app.SetAdditionalSkinBoxes(skinFile->getSkinID(),m_vAdditionalSkinBoxes);
759 }
760 }
761
762 if(skinFile!=NULL)
763 {
764 app.SetAnimOverrideBitmask(skinFile->getSkinID(),skinFile->getAnimOverrideBitmask());
765 }
766
767 m_previewControl->SetTexture(m_selectedSkinPath, backupTexture);
768 m_previewControl->SetCapeTexture(m_selectedCapePath);
769
770 showNext = TRUE;
771 showPrevious = TRUE;
772 nextIndex = getNextSkinIndex(m_skinIndex);
773 previousIndex = getPreviousSkinIndex(m_skinIndex);
774
775 wstring otherSkinPath = L"";
776 wstring otherCapePath = L"";
777 vector<SKIN_BOX *> *othervAdditionalSkinBoxes=NULL;
778 wchar_t chars[256];
779
780 // turn off all displays
781 for(BYTE i = 0; i < sidePreviewControls; ++i)
782 {
783 m_previewNextControls[i]->SetShow(FALSE);
784 m_previewPreviousControls[i]->SetShow(FALSE);
785 }
786
787 unsigned int uiCurrentFavoriteC=app.GetPlayerFavoriteSkinsCount(m_iPad);
788
789 if(m_packIndex==SKIN_SELECT_PACK_FAVORITES)
790 {
791 // might not be enough to cycle through
792 if(uiCurrentFavoriteC<((sidePreviewControls*2)+1))
793 {
794 if(uiCurrentFavoriteC==0)
795 {
796 sidePreviewControlsL=sidePreviewControlsR=0;
797 }
798 // might be an odd number
799 else if((uiCurrentFavoriteC-1)%2==1)
800 {
801 sidePreviewControlsL=1+(uiCurrentFavoriteC-1)/2;
802 sidePreviewControlsR=(uiCurrentFavoriteC-1)/2;
803 }
804 else
805 {
806 sidePreviewControlsL=sidePreviewControlsR=(uiCurrentFavoriteC-1)/2;
807 }
808 }
809 else
810 {
811 sidePreviewControlsL=sidePreviewControlsR=sidePreviewControls;
812 }
813 }
814 else
815 {
816 sidePreviewControlsL=sidePreviewControlsR=sidePreviewControls;
817 }
818
819 for(BYTE i = 0; i < sidePreviewControlsR; ++i)
820 {
821 if(showNext)
822 {
823 skinFile=NULL;
824 m_previewNextControls[i]->SetShow(TRUE);
825
826 if( m_currentPack != NULL )
827 {
828 skinFile = m_currentPack->getSkinFile(nextIndex);
829 otherSkinPath = skinFile->getPath();
830 otherCapePath = skinFile->getParameterAsString(DLCManager::e_DLCParamType_Cape);
831 othervAdditionalSkinBoxes = skinFile->getAdditionalBoxes();
832 backupTexture = TN_MOB_CHAR;
833 }
834 else
835 {
836 otherSkinPath = L"";
837 otherCapePath = L"";
838 othervAdditionalSkinBoxes=NULL;
839 switch(m_packIndex)
840 {
841 case SKIN_SELECT_PACK_DEFAULT:
842 backupTexture = getTextureId(nextIndex);
843 break;
844 case SKIN_SELECT_PACK_FAVORITES:
845 if(uiCurrentFavoriteC>0)
846 {
847 // get the pack number from the skin id
848 swprintf(chars, 256, L"dlcskin%08d.png", app.GetPlayerFavoriteSkin(m_iPad,nextIndex));
849
850 Pack=app.m_dlcManager.getPackContainingSkin(chars);
851 if(Pack)
852 {
853 skinFile = Pack->getSkinFile(chars);
854
855 otherSkinPath = skinFile->getPath();
856 otherCapePath = skinFile->getParameterAsString(DLCManager::e_DLCParamType_Cape);
857 othervAdditionalSkinBoxes = skinFile->getAdditionalBoxes();
858 backupTexture = TN_MOB_CHAR;
859 }
860 }
861 break;
862 default:
863 break;
864 }
865
866 }
867 if(othervAdditionalSkinBoxes && othervAdditionalSkinBoxes->size()!=0)
868 {
869 vector<ModelPart *> *pAdditionalModelParts = app.GetAdditionalModelParts(skinFile->getSkinID());
870 if(pAdditionalModelParts==NULL)
871 {
872 pAdditionalModelParts = app.SetAdditionalSkinBoxes(skinFile->getSkinID(),othervAdditionalSkinBoxes);
873 }
874 }
875 // 4J-PB - anim override needs set before SetTexture
876 if(skinFile!=NULL)
877 {
878 app.SetAnimOverrideBitmask(skinFile->getSkinID(),skinFile->getAnimOverrideBitmask());
879 }
880 m_previewNextControls[i]->SetTexture(otherSkinPath, backupTexture);
881 m_previewNextControls[i]->SetCapeTexture(otherCapePath);
882
883
884 }
885
886 nextIndex = getNextSkinIndex(nextIndex);
887 }
888
889
890
891 for(BYTE i = 0; i < sidePreviewControlsL; ++i)
892 {
893 if(showPrevious)
894 {
895 skinFile=NULL;
896 m_previewPreviousControls[i]->SetShow(TRUE);
897
898 if( m_currentPack != NULL )
899 {
900 skinFile = m_currentPack->getSkinFile(previousIndex);
901 otherSkinPath = skinFile->getPath();
902 otherCapePath = skinFile->getParameterAsString(DLCManager::e_DLCParamType_Cape);
903 othervAdditionalSkinBoxes = skinFile->getAdditionalBoxes();
904 backupTexture = TN_MOB_CHAR;
905 }
906 else
907 {
908 otherSkinPath = L"";
909 otherCapePath = L"";
910 othervAdditionalSkinBoxes=NULL;
911 switch(m_packIndex)
912 {
913 case SKIN_SELECT_PACK_DEFAULT:
914 backupTexture = getTextureId(previousIndex);
915 break;
916 case SKIN_SELECT_PACK_FAVORITES:
917 if(uiCurrentFavoriteC>0)
918 {
919 // get the pack number from the skin id
920 swprintf(chars, 256, L"dlcskin%08d.png", app.GetPlayerFavoriteSkin(m_iPad,previousIndex));
921
922 Pack=app.m_dlcManager.getPackContainingSkin(chars);
923 if(Pack)
924 {
925 skinFile = Pack->getSkinFile(chars);
926
927 otherSkinPath = skinFile->getPath();
928 otherCapePath = skinFile->getParameterAsString(DLCManager::e_DLCParamType_Cape);
929 othervAdditionalSkinBoxes = skinFile->getAdditionalBoxes();
930 backupTexture = TN_MOB_CHAR;
931 }
932 }
933
934 break;
935 default:
936 break;
937 }
938 }
939 if(othervAdditionalSkinBoxes && othervAdditionalSkinBoxes->size()!=0)
940 {
941 vector<ModelPart *> *pAdditionalModelParts = app.GetAdditionalModelParts(skinFile->getSkinID());
942 if(pAdditionalModelParts==NULL)
943 {
944 pAdditionalModelParts = app.SetAdditionalSkinBoxes(skinFile->getSkinID(),othervAdditionalSkinBoxes);
945 }
946 }
947 // 4J-PB - anim override needs set before SetTexture
948 if(skinFile)
949 {
950 app.SetAnimOverrideBitmask(skinFile->getSkinID(),skinFile->getAnimOverrideBitmask());
951 }
952 m_previewPreviousControls[i]->SetTexture(otherSkinPath, backupTexture);
953 m_previewPreviousControls[i]->SetCapeTexture(otherCapePath);
954 }
955
956 previousIndex = getPreviousSkinIndex(previousIndex);
957 }
958
959 // update the tooltips
960 bool bNotInGame=(Minecraft::GetInstance()->level==NULL);
961
962 if(bNoSkinsToShow)
963 {
964 if(bNotInGame)
965 {
966 ui.SetTooltips( DEFAULT_XUI_MENU_USER, -1,IDS_TOOLTIPS_CANCEL,-1,-1,-1,-1,-1,-1,IDS_TOOLTIPS_NAVIGATE);
967 CXuiSceneBase::ShowBackground( DEFAULT_XUI_MENU_USER, TRUE );
968 }
969 else
970 {
971 ui.SetTooltips( m_iPad, IDS_TOOLTIPS_SELECT_SKIN,IDS_TOOLTIPS_CANCEL,-1,-1,-1,-1,-1,-1,IDS_TOOLTIPS_NAVIGATE);
972 CXuiSceneBase::ShowBackground( m_iPad, FALSE );
973 CXuiSceneBase::ShowDarkOverlay( m_iPad, TRUE );
974 }
975
976 }
977 else
978 {
979 if(bNotInGame)
980 {
981 ui.SetTooltips( DEFAULT_XUI_MENU_USER, IDS_TOOLTIPS_SELECT_SKIN,IDS_TOOLTIPS_CANCEL,-1,-1,-1,-1,-1,-1,IDS_TOOLTIPS_NAVIGATE);
982 CXuiSceneBase::ShowBackground( DEFAULT_XUI_MENU_USER, TRUE );
983 }
984 else
985 {
986 ui.SetTooltips( m_iPad, IDS_TOOLTIPS_SELECT_SKIN,IDS_TOOLTIPS_CANCEL,-1,-1,-1,-1,-1,-1,IDS_TOOLTIPS_NAVIGATE);
987 CXuiSceneBase::ShowBackground( m_iPad, FALSE );
988 CXuiSceneBase::ShowDarkOverlay( m_iPad, TRUE );
989 }
990
991 }
992
993 updateCurrentFocus();
994}
995
996void CScene_SkinSelect::handlePackIndexChanged()
997{
998 if(m_packIndex >= SKIN_SELECT_MAX_DEFAULTS)
999 {
1000 m_currentPack = app.m_dlcManager.getPack(m_packIndex - SKIN_SELECT_MAX_DEFAULTS, DLCManager::e_DLCType_Skin);
1001 }
1002 else
1003 {
1004 m_currentPack = NULL;
1005 }
1006 m_skinIndex = 0;
1007 if(m_currentPack != NULL)
1008 {
1009 bool found;
1010 DWORD currentSkinIndex = m_currentPack->getSkinIndexAt(m_currentSkinPath, found);
1011 if(found) m_skinIndex = currentSkinIndex;
1012 }
1013 else
1014 {
1015 switch(m_packIndex)
1016 {
1017 case SKIN_SELECT_PACK_DEFAULT:
1018 if( !GET_IS_DLC_SKIN_FROM_BITMASK(m_originalSkinId) )
1019 {
1020 DWORD ugcSkinIndex = GET_UGC_SKIN_ID_FROM_BITMASK(m_originalSkinId);
1021 DWORD defaultSkinIndex = GET_DEFAULT_SKIN_ID_FROM_BITMASK(m_originalSkinId);
1022 if( ugcSkinIndex == 0 )
1023 {
1024 m_skinIndex = (EDefaultSkins) defaultSkinIndex;
1025 }
1026 }
1027 break;
1028 case SKIN_SELECT_PACK_FAVORITES:
1029 if(app.GetPlayerFavoriteSkinsCount(m_iPad)>0)
1030 {
1031 bool found;
1032 wchar_t chars[256];
1033 // get the pack number from the skin id
1034 swprintf(chars, 256, L"dlcskin%08d.png", app.GetPlayerFavoriteSkin(m_iPad,app.GetPlayerFavoriteSkinsPos(m_iPad)));
1035
1036 DLCPack *Pack=app.m_dlcManager.getPackContainingSkin(chars);
1037 if(Pack)
1038 {
1039 DWORD currentSkinIndex = Pack->getSkinIndexAt(m_currentSkinPath, found);
1040 if(found) m_skinIndex = app.GetPlayerFavoriteSkinsPos(m_iPad);
1041 }
1042 }
1043 break;
1044 default:
1045 break;
1046 }
1047 }
1048 handleSkinIndexChanged();
1049 updatePackDisplay();
1050}
1051
1052void CScene_SkinSelect::updatePackDisplay()
1053{
1054 currentPackCount = app.m_dlcManager.getPackCount(DLCManager::e_DLCType_Skin) + SKIN_SELECT_MAX_DEFAULTS;
1055
1056 m_packLeft.SetShow(TRUE);
1057 m_packRight.SetShow(TRUE);
1058
1059 if(m_packIndex >= SKIN_SELECT_MAX_DEFAULTS)
1060 {
1061 DLCPack *thisPack = app.m_dlcManager.getPack(m_packIndex - SKIN_SELECT_MAX_DEFAULTS, DLCManager::e_DLCType_Skin);
1062 m_packCenter.SetText(thisPack->getName().c_str());
1063 }
1064 else
1065 {
1066 switch(m_packIndex)
1067 {
1068 case SKIN_SELECT_PACK_DEFAULT:
1069 m_packCenter.SetText(app.GetString(IDS_NO_SKIN_PACK));
1070 break;
1071 case SKIN_SELECT_PACK_FAVORITES:
1072 m_packCenter.SetText(app.GetString(IDS_FAVORITES_SKIN_PACK));
1073 break;
1074 }
1075 }
1076
1077 int nextPackIndex = getNextPackIndex(m_packIndex);
1078 if(nextPackIndex >= SKIN_SELECT_MAX_DEFAULTS)
1079 {
1080 DLCPack *thisPack = app.m_dlcManager.getPack(nextPackIndex - SKIN_SELECT_MAX_DEFAULTS, DLCManager::e_DLCType_Skin);
1081 m_packRight.SetText(thisPack->getName().c_str());
1082 }
1083 else
1084 {
1085 switch(nextPackIndex)
1086 {
1087 case SKIN_SELECT_PACK_DEFAULT:
1088 m_packRight.SetText(app.GetString(IDS_NO_SKIN_PACK));
1089 break;
1090 case SKIN_SELECT_PACK_FAVORITES:
1091 m_packRight.SetText(app.GetString(IDS_FAVORITES_SKIN_PACK));
1092 break;
1093 }
1094 }
1095
1096 int previousPackIndex = getPreviousPackIndex(m_packIndex);
1097 if(previousPackIndex >= SKIN_SELECT_MAX_DEFAULTS)
1098 {
1099 DLCPack *thisPack = app.m_dlcManager.getPack(previousPackIndex - SKIN_SELECT_MAX_DEFAULTS, DLCManager::e_DLCType_Skin);
1100 m_packLeft.SetText(thisPack->getName().c_str());
1101 }
1102 else
1103 {
1104 switch(previousPackIndex)
1105 {
1106 case SKIN_SELECT_PACK_DEFAULT:
1107 m_packLeft.SetText(app.GetString(IDS_NO_SKIN_PACK));
1108 break;
1109 case SKIN_SELECT_PACK_FAVORITES:
1110 m_packLeft.SetText(app.GetString(IDS_FAVORITES_SKIN_PACK));
1111 break;
1112 }
1113 }
1114
1115}
1116
1117void CScene_SkinSelect::updateCurrentFocus()
1118{
1119 XUITimeline *timeline;
1120 XUINamedFrame *startFrame;
1121 XuiElementGetTimeline( m_skinDetails.m_hObj, &timeline);
1122 switch(m_currentNavigation)
1123 {
1124 case eSkinNavigation_Pack:
1125 XuiElementSetUserFocus( m_packCenter.m_hObj, m_iPad );
1126 startFrame = timeline->FindNamedFrame( L"Unselected" );
1127 m_normalTabs.SetShow( FALSE );
1128 m_selectedTabs.SetShow( TRUE );
1129 m_packLeft.SetEnable(TRUE);
1130 m_packRight.SetEnable(TRUE);
1131 break;
1132 case eSkinNavigation_Skin:
1133 XuiElementSetUserFocus( m_skinDetails.m_hObj, m_iPad );
1134 startFrame = timeline->FindNamedFrame( L"Selected" );
1135 m_normalTabs.SetShow( TRUE );
1136 m_selectedTabs.SetShow( FALSE );
1137 m_packLeft.SetEnable(FALSE);
1138 m_packRight.SetEnable(FALSE);
1139 break;
1140 };
1141 timeline->Play( startFrame->m_dwFrame, startFrame->m_dwFrame, startFrame->m_dwFrame, FALSE, FALSE );
1142}
1143
1144TEXTURE_NAME CScene_SkinSelect::getTextureId(int skinIndex)
1145{
1146 TEXTURE_NAME texture = TN_MOB_CHAR;
1147 switch(skinIndex)
1148 {
1149 case eDefaultSkins_ServerSelected:
1150 case eDefaultSkins_Skin0:
1151 texture = TN_MOB_CHAR;
1152 break;
1153 case eDefaultSkins_Skin1:
1154 texture = TN_MOB_CHAR1;
1155 break;
1156 case eDefaultSkins_Skin2:
1157 texture = TN_MOB_CHAR2;
1158 break;
1159 case eDefaultSkins_Skin3:
1160 texture = TN_MOB_CHAR3;
1161 break;
1162 case eDefaultSkins_Skin4:
1163 texture = TN_MOB_CHAR4;
1164 break;
1165 case eDefaultSkins_Skin5:
1166 texture = TN_MOB_CHAR5;
1167 break;
1168 case eDefaultSkins_Skin6:
1169 texture = TN_MOB_CHAR6;
1170 break;
1171 case eDefaultSkins_Skin7:
1172 texture = TN_MOB_CHAR7;
1173 break;
1174 };
1175
1176 return texture;
1177}
1178
1179int CScene_SkinSelect::getNextSkinIndex(DWORD sourceIndex)
1180{
1181 int nextSkin = sourceIndex;
1182
1183 // special case for favourites
1184 switch(m_packIndex)
1185 {
1186
1187 case SKIN_SELECT_PACK_FAVORITES:
1188 ++nextSkin;
1189 if(nextSkin>=app.GetPlayerFavoriteSkinsCount(m_iPad))
1190 {
1191 nextSkin=0;
1192 }
1193
1194 break;
1195 default:
1196 ++nextSkin;
1197
1198 if(m_packIndex == SKIN_SELECT_PACK_DEFAULT && nextSkin >= eDefaultSkins_Count)
1199 {
1200 nextSkin = eDefaultSkins_ServerSelected;
1201 }
1202 else if(m_currentPack != NULL && nextSkin>=m_currentPack->getSkinCount())
1203 {
1204 nextSkin = 0;
1205 }
1206 break;
1207 }
1208
1209
1210 return nextSkin;
1211}
1212
1213int CScene_SkinSelect::getPreviousSkinIndex(DWORD sourceIndex)
1214{
1215 int previousSkin = sourceIndex;
1216 switch(m_packIndex)
1217 {
1218
1219 case SKIN_SELECT_PACK_FAVORITES:
1220 if(previousSkin==0)
1221 {
1222 previousSkin = app.GetPlayerFavoriteSkinsCount(m_iPad) - 1;
1223 }
1224 else
1225 {
1226 --previousSkin;
1227 }
1228 break;
1229 default:
1230 if(previousSkin==0)
1231 {
1232 if(m_packIndex == SKIN_SELECT_PACK_DEFAULT)
1233 {
1234 previousSkin = eDefaultSkins_Count - 1;
1235 }
1236 else if(m_currentPack != NULL)
1237 {
1238 previousSkin = m_currentPack->getSkinCount()-1;
1239 }
1240 }
1241 else
1242 {
1243 --previousSkin;
1244 }
1245 break;
1246 }
1247
1248
1249 return previousSkin;
1250}
1251
1252int CScene_SkinSelect::getNextPackIndex(DWORD sourceIndex)
1253{
1254 int nextPack = sourceIndex;
1255 ++nextPack;
1256 if(nextPack > app.m_dlcManager.getPackCount(DLCManager::e_DLCType_Skin) - 1 + SKIN_SELECT_MAX_DEFAULTS)
1257 {
1258 nextPack = SKIN_SELECT_PACK_DEFAULT;
1259 }
1260
1261 return nextPack;
1262}
1263
1264int CScene_SkinSelect::getPreviousPackIndex(DWORD sourceIndex)
1265{
1266 int previousPack = sourceIndex;
1267 if(previousPack == SKIN_SELECT_PACK_DEFAULT)
1268 {
1269 if(app.m_dlcManager.getPackCount(DLCManager::e_DLCType_Skin) > 0)
1270 {
1271 previousPack = app.m_dlcManager.getPackCount(DLCManager::e_DLCType_Skin) - 1 + SKIN_SELECT_MAX_DEFAULTS;
1272 }
1273 else
1274 {
1275 previousPack = SKIN_SELECT_MAX_DEFAULTS - 1;
1276 }
1277 }
1278 else
1279 {
1280 --previousPack;
1281 }
1282
1283 return previousPack;
1284}
1285
1286void CScene_SkinSelect::updateClipping()
1287{
1288 DWORD dwPropertyId;
1289 XUIElementPropVal propertyVal;
1290 propertyVal.Clear();
1291 HRESULT hr = XuiObjectGetPropertyId( m_charactersGroup.m_hObj, L"ClipChildren", &dwPropertyId);
1292 switch( CXuiSceneBase::GetPlayerBasePosition(m_iPad) )
1293 {
1294 case CXuiSceneBase::e_BaseScene_Left:
1295 case CXuiSceneBase::e_BaseScene_Right:
1296 case CXuiSceneBase::e_BaseScene_Top_Left:
1297 case CXuiSceneBase::e_BaseScene_Top_Right:
1298 case CXuiSceneBase::e_BaseScene_Bottom_Left:
1299 case CXuiSceneBase::e_BaseScene_Bottom_Right:
1300 case CXuiSceneBase::e_BaseScene_Top:
1301 case CXuiSceneBase::e_BaseScene_Bottom:
1302 propertyVal.SetBoolVal(TRUE);
1303 break;
1304 case CXuiSceneBase::e_BaseScene_Fullscreen:
1305 default:
1306 propertyVal.SetBoolVal(FALSE);
1307 break;
1308 };
1309 hr = XuiObjectSetProperty(m_charactersGroup.m_hObj,dwPropertyId,0,&propertyVal);
1310}
1311
1312int CScene_SkinSelect::UnlockSkinReturned(void *pParam,int iPad,C4JStorage::EMessageResult result)
1313{
1314 CScene_SkinSelect* pScene = (CScene_SkinSelect*)pParam;
1315#ifdef _XBOX
1316 if(result==C4JStorage::EMessage_ResultAccept)
1317 {
1318 if(ProfileManager.IsSignedIn(iPad))
1319 {
1320 ULONGLONG ullIndexA[1];
1321 DLC_INFO *pDLCInfo = app.GetDLCInfoForTrialOfferID(pScene->m_currentPack->getPurchaseOfferId());
1322
1323 if(pDLCInfo!=NULL)
1324 {
1325 ullIndexA[0]=pDLCInfo->ullOfferID_Full;
1326 }
1327 else
1328 {
1329 ullIndexA[0]=pScene->m_currentPack->getPurchaseOfferId();
1330 }
1331
1332 // If we're in-game, then we need to enable DLC downloads. They'll be set back to Auto on leaving the pause menu
1333 if(Minecraft::GetInstance()->level!=NULL)
1334 {
1335 // need to allow downloads here, or the player would need to quit the game to let the download of a skin pack happen. This might affect the network traffic, since the download could take all the bandwidth...
1336 XBackgroundDownloadSetMode(XBACKGROUND_DOWNLOAD_MODE_ALWAYS_ALLOW);
1337 }
1338
1339 StorageManager.InstallOffer(1,ullIndexA,NULL,NULL);
1340
1341 // the license change coming in when the offer has been installed will cause this scene to refresh
1342 }
1343 }
1344 else
1345 {
1346 TelemetryManager->RecordUpsellResponded(iPad, eSet_UpsellID_Skin_DLC, ( pScene->m_currentPack->getPurchaseOfferId() & 0xFFFFFFFF ), eSen_UpsellOutcome_Declined);
1347 }
1348#endif
1349 return 0;
1350}
1351
1352HRESULT CScene_SkinSelect::OnCustomMessage_DLCInstalled()
1353{
1354 // mounted DLC may have changed
1355 if(app.StartInstallDLCProcess(m_iPad)==false)
1356 {
1357 // not doing a mount, so re-enable input
1358 m_bIgnoreInput=false;
1359 }
1360 else
1361 {
1362 m_bIgnoreInput=true;
1363 m_timer.SetShow( TRUE );
1364 m_charactersGroup.SetShow( FALSE );
1365 m_skinDetails.SetShow( FALSE );
1366 }
1367
1368 // this will send a CustomMessage_DLCMountingComplete when done
1369 return S_OK;
1370}
1371
1372HRESULT CScene_SkinSelect::OnCustomMessage_DLCMountingComplete()
1373{
1374
1375 m_timer.SetShow( FALSE );
1376 m_charactersGroup.SetShow( TRUE );
1377 m_skinDetails.SetShow( TRUE );
1378 m_packIndex = SKIN_SELECT_PACK_DEFAULT;
1379
1380 if(app.m_dlcManager.getPackCount(DLCManager::e_DLCType_Skin)>0)
1381 {
1382 m_currentPack = app.m_dlcManager.getPackContainingSkin(m_currentSkinPath);
1383 if(m_currentPack != NULL)
1384 {
1385 bool bFound = false;
1386 m_packIndex = app.m_dlcManager.getPackIndex(m_currentPack,bFound,DLCManager::e_DLCType_Skin) + SKIN_SELECT_MAX_DEFAULTS;
1387 }
1388 }
1389
1390 // If we have any favourites, set this to the favourites
1391 // first validate the favorite skins - we might have uninstalled the DLC needed for them
1392 app.ValidateFavoriteSkins(m_iPad);
1393
1394 if(app.GetPlayerFavoriteSkinsCount(m_iPad)>0)
1395 {
1396 m_packIndex = SKIN_SELECT_PACK_FAVORITES;
1397 }
1398
1399 handlePackIndexChanged();
1400 updateCurrentFocus();
1401 m_bIgnoreInput=false;
1402 app.m_dlcManager.checkForCorruptDLCAndAlert();
1403 bool bInGame=(Minecraft::GetInstance()->level!=NULL);
1404
1405 if(bInGame) XBackgroundDownloadSetMode(XBACKGROUND_DOWNLOAD_MODE_AUTO);
1406
1407 return S_OK;
1408}
1409
1410void CScene_SkinSelect::AddFavoriteSkin(int iPad,int iSkinID)
1411{
1412 // Is this favorite skin already in the array?
1413 unsigned int uiCurrentFavoriteSkinsCount=app.GetPlayerFavoriteSkinsCount(m_iPad);
1414
1415 for(int i=0;i<uiCurrentFavoriteSkinsCount;i++)
1416 {
1417 if(app.GetPlayerFavoriteSkin(m_iPad,i)==iSkinID)
1418 {
1419 app.SetPlayerFavoriteSkinsPos(m_iPad,i);
1420 return;
1421 }
1422 }
1423
1424 unsigned char ucPos=app.GetPlayerFavoriteSkinsPos(m_iPad);
1425 if(ucPos==(MAX_FAVORITE_SKINS-1))
1426 {
1427 ucPos=0;
1428 }
1429 else
1430 {
1431 if(uiCurrentFavoriteSkinsCount>0)
1432 {
1433 ucPos++;
1434 }
1435 else
1436 {
1437 ucPos=0;
1438 }
1439 }
1440
1441 app.SetPlayerFavoriteSkin(iPad,(int)ucPos,iSkinID);
1442 app.SetPlayerFavoriteSkinsPos(m_iPad,ucPos);
1443
1444}