697 lines
48 KiB
JavaScript
697 lines
48 KiB
JavaScript
const test = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const vm = require('node:vm');
|
|
const ts = require('typescript');
|
|
|
|
function fixture() {
|
|
const scheduled = [], tweens = [];
|
|
class Component { scheduleOnce(fn) { scheduled.push(fn); } }
|
|
class Node {
|
|
constructor(name = '') { this.name = name; this.children = []; this.scale = 1; this.opacity = 255; this.active = true; }
|
|
addChild(node) { this.children.push(node); node.parent=this; }
|
|
getChildByName(name) { return this.children.find(n => n.name === name); }
|
|
setPosition(x, y) { this.x = x; this.y = y; }
|
|
destroy() { this.destroyed = true; }
|
|
getComponent() { return this.component || null; }
|
|
addComponent() { return this.component={}; }
|
|
setContentSize(width,height) { this.width=width;this.height=height; }
|
|
off() {}
|
|
}
|
|
function tween(target) {
|
|
const actions = [];
|
|
return { target, actions, delay(n) { actions.push({delay:n}); return this; },
|
|
to(n, props, options) { actions.push({props, options, duration:n}); return this; }, call(fn) { actions.push({fn}); return this; },
|
|
start() { tweens.push(this); return this; } };
|
|
}
|
|
const cc = { Component, Node, Label:class{}, Sprite:class{static SizeMode={CUSTOM:0};}, SpriteFrame:class{}, String, Color:{WHITE:{}},color:()=>({}),
|
|
_decorator:{ccclass:c=>c, property:()=>()=>{}}, isValid:n=>!!n&&!n.destroyed, tween,
|
|
Tween:{stopAllByTarget(target) { for (const tween of tweens) if(tween.target === target) tween.stopped=true; }},
|
|
instantiate() { const slot=new Node();slot.addChild(new Node('Name'));slot.addChild(new Node('Status'));return slot; },
|
|
fx:{GameConfig:{GM_INFO:{username:'我',userId:1001}}} };
|
|
const exports={};
|
|
vm.runInNewContext(ts.transpileModule(fs.readFileSync('assets/cloud_rise_home/scripts/CloudRisePanel.ts','utf8'),
|
|
{compilerOptions:{module:ts.ModuleKind.CommonJS,target:ts.ScriptTarget.ES2017,experimentalDecorators:true}}).outputText,
|
|
{exports,cc,console,require:()=>({default:class{}})});
|
|
const panel=new exports.default();panel.node=new Node();panel.progressRoster=new Node();panel.progressStart={x:310,y:-950};
|
|
panel.rowTemplate={children:[new Node()]};panel.avatar=(slot,player)=>slot.player=player;
|
|
panel.matchingSlots=[new Node('left'),new Node('right'),new Node('front')];
|
|
panel.avatarTemplates=panel.matchingSlots;const matchingRoot=new Node();panel.matchingSlots.forEach(slot=>matchingRoot.addChild(slot));
|
|
panel.matchingSlots.forEach(slot=>{const face=new Node('Face');face.addChild(new Node('Photo'));face.addChild(new Node('Cat'));slot.addChild(face);});
|
|
panel.matchingSlots.forEach((slot,i)=>{slot.scale=i===2?1:110/140;slot.x=[-125,140,5][i];slot.y=[-620,-610,-660][i];});
|
|
panel.matchingPrompt=new Node();panel.matchingTitle={node:new Node(),string:''};panel.matchingCount={string:'1/100'};
|
|
panel.matchingReward={setValue:n=>panel.pool=n};
|
|
panel.progressArt={};panel.stageArt=[{}, {}, {}];panel.progressCount={string:''};panel.survivorCount={string:''};
|
|
panel.progressPool={setValue:n=>panel.pool=n};panel.updateClocks=()=>{};
|
|
panel.tracks=[4,6,8].map(n=>({children:Array.from({length:n},(_,i)=>({x:i%2?-200:200,y:-800+i*90}))}));
|
|
const progress=new Node('Progress');progress.activeInHierarchy=true;
|
|
for(const [name,x,y] of [['PrizeCloud',0,200],['StartingCloud',330,-1050]]){const cloud=new Node(name);cloud.setPosition(x,y);progress.addChild(cloud);}
|
|
panel.pages=[null,null,progress];
|
|
const stage = (alive, score=0) => ({stage:1,target:5,status:score===5?'won':'playing',success_num:score,
|
|
pool:10000,survivors:alive+1,opponents:Array.from({length:99},(_,i)=>({username:'玩家'+i,alive:i<alive}))});
|
|
const flushTweens=()=>{ for(const t of tweens.splice(0)) if(!t.stopped) for(const a of t.actions) {
|
|
if(a.props) Object.assign(t.target,a.props); if(a.fn) a.fn();
|
|
} };
|
|
const advance=async()=>{flushTweens();const fn=scheduled.shift();if(fn)fn();await Promise.resolve();await Promise.resolve();};
|
|
return {panel,stage,tweens,scheduled,advance,flushTweens,cc};
|
|
}
|
|
|
|
test('matching retains simulated avatars and appends exactly the remaining real profiles',async()=>{
|
|
const f=fixture();const stage=f.stage(99);stage.pool=23456;
|
|
f.panel.resetMatchingAvatars();f.flushTweens();
|
|
const self=f.panel.matchingAvatars[0];assert.equal(self.opacity,255);
|
|
f.panel.addSimulatedMatch();f.panel.mode='matching';f.panel.matchPhase='submitting';
|
|
f.panel.update(1.61);f.flushTweens();
|
|
assert.equal(f.panel.matchingCount.string,'6/100');
|
|
const simulated=f.panel.matchingAvatars.slice();
|
|
const simulatedPoses=simulated.map(n=>({x:n.x,y:n.y,scale:n.scale,z:n.zIndex}));
|
|
assert(simulated.slice(1).every(n=>Number(n.player.useravatarIcon)>=0&&Number(n.player.useravatarIcon)<=16));
|
|
f.panel.matchPhase='animating';
|
|
const task=f.panel.playMatching(stage);
|
|
for(let i=0;i<100;i++)await f.advance();await task;
|
|
assert.equal(f.panel.matchingAvatars.length,100);assert.equal(f.panel.pool,23456);
|
|
assert.equal(new Set(f.panel.matchingAvatars).size,100);
|
|
assert.equal(self.opacity,255,'already visible self is not hidden when opponents arrive');
|
|
const bindings=f.panel.matchingAvatars.map(n=>n.player);
|
|
await f.advance();assert.equal(f.panel.matchingCount.string,'99/100');
|
|
assert.equal(f.panel.matchingPrompt.active,true);
|
|
assert.equal(f.panel.matchingTitle.node.active,false);
|
|
assert(f.panel.matchingAvatars.every(slot=>slot.opacity===255&&slot.active));
|
|
assert.equal(self.scale,0.65*0.9);
|
|
const [left,right]=f.panel.matchingAvatars.slice(1,3);
|
|
assert(left.x<self.x&&right.x>self.x,'avatars fill both sides of the player');
|
|
assert(Math.abs(left.y-self.y)<15&&Math.abs(right.y-self.y)<15,'side avatars occupy the front row');
|
|
assert(f.panel.matchingAvatars.slice(1).every(n=>n.zIndex<self.zIndex),'player always renders in front');
|
|
assert(f.panel.matchingAvatars.slice(3).every(n=>n.scale<self.scale));
|
|
const boxes=f.panel.matchingAvatars.map(n=>({x:n.x,y:n.y,size:n.scale*140}));
|
|
assert.equal(new Set(boxes.map(b=>b.x+':'+b.y)).size,100,'each arrival has its own position');
|
|
assert(Math.max(...boxes.map(b=>b.x+b.size/2))-Math.min(...boxes.map(b=>b.x-b.size/2))>350);
|
|
assert(boxes.every(b=>Math.abs(b.x)+b.size/2<284),'stack stays within the cloud width');
|
|
assert.deepEqual(f.panel.matchingAvatars.slice(0,6),simulated);
|
|
assert.deepEqual(simulated.map(n=>({x:n.x,y:n.y,scale:n.scale,z:n.zIndex})),simulatedPoses,
|
|
'switching to real profiles must not reposition simulated arrivals');
|
|
for(let i=6;i<100;i++)assert.equal(bindings[i],stage.opponents[i-6]);
|
|
await f.advance();await task;
|
|
assert.deepEqual(f.panel.matchingAvatars.map(n=>n.player),bindings,'no replacement after more arrivals');
|
|
assert(f.panel.matchingAvatars.every(slot=>slot.opacity===255),'all remain until matching leaves');
|
|
});
|
|
|
|
function floatingFixture() {
|
|
const f=fixture(),p=f.panel;
|
|
const page=new p.node.constructor('Progress');page.activeInHierarchy=true;
|
|
['StageArt','PrizeCloud','Chest','ProgressReward','StartingCloud'].forEach((name,i)=>{
|
|
const node=new p.node.constructor(name);node.x=0;node.y=i*100;page.addChild(node);
|
|
});
|
|
p.pages=[null,null,page];p.mode='progress';p.progressRoster.y=0;
|
|
p.tracks.forEach((track,i)=>track.active=i===0);
|
|
return {...f,page};
|
|
}
|
|
|
|
test('matching and all three starting clouds use identical 100-avatar geometry within the 1.2x bounds',()=>{
|
|
const f=fixture(),p=f.panel;p.design={width:1080};p.resetMatchingAvatars();
|
|
for(let i=0;i<99;i++)p.appendMatchingAvatar({username:'player'+i});f.flushTweens();
|
|
const matched=p.matchingAvatars.map(n=>({x:n.x,y:n.y+760,scale:n.scale,z:n.zIndex}));
|
|
for(let stageNumber=1;stageNumber<=3;stageNumber++){
|
|
const prefab=JSON.parse(fs.readFileSync('assets/cloud_rise/stage'+stageNumber+'/prefab/CloudRise.prefab'));
|
|
const cloud=p.pages[2].getChildByName('StartingCloud');
|
|
const authoredCloud=prefab.find(n=>n._name==='StartingCloud'),start=prefab.find(n=>n._name==='ProgressStart');
|
|
cloud.width=authoredCloud._contentSize.width;cloud.scaleX=authoredCloud._trs.array[7];
|
|
[cloud.x,cloud.y]=authoredCloud._trs.array;
|
|
[p.progressStart.x,p.progressStart.y]=start._trs.array;
|
|
const stage={...f.stage(99),stage:stageNumber};
|
|
p.prepareProgressRoster(stage,Array.from({length:99},(_,i)=>i));
|
|
assert.equal(p.progressSlots.length,100);
|
|
p.progressSlots.forEach(({node:n},i)=>{
|
|
const m=matched[i];assert(Math.abs(n.x-p.progressStart.x-m.x)<0.001);assert(Math.abs(n.y-p.progressStart.y-m.y)<0.001);
|
|
assert.equal(n.scale,m.scale);assert.equal(n.zIndex,m.z);
|
|
});
|
|
for(const alive of [99,56,18,2,0]){
|
|
stage.opponents.forEach((o,i)=>o.alive=i<alive);
|
|
p.prepareProgressRoster(stage,Array.from({length:alive},(_,i)=>i));
|
|
const slots=p.progressSlots.map(s=>s.node),bounds=slots.map(n=>({left:n.x-n.scale*70,right:n.x+n.scale*70,bottom:n.y-n.scale*70,top:n.y+n.scale*70}));
|
|
assert(Math.max(...bounds.map(b=>b.right))-Math.min(...bounds.map(b=>b.left))<=409.281);
|
|
assert(Math.max(...bounds.map(b=>b.top))-Math.min(...bounds.map(b=>b.bottom))<=241.601);
|
|
assert(bounds.every(b=>b.right<=540-24));
|
|
assert(slots.every((n,i)=>n.scale===(i===0?0.65:0.52)*0.9));
|
|
}
|
|
}
|
|
});
|
|
|
|
test('each matching slot is reserved once for 100 players and new arrivals never move settled avatars',()=>{
|
|
const f=fixture(),p=f.panel;
|
|
const calculate=p.matchingPositions.bind(p);let calculated=0;
|
|
p.matchingPositions=()=>{calculated++;return calculate();};
|
|
p.resetMatchingAvatars();f.flushTweens();assert.equal(p.matchingLayout.length,99);
|
|
for(let i=0;i<99;i++){
|
|
const existing=p.matchingAvatars.map(n=>({x:n.x,y:n.y,scale:n.scale,z:n.zIndex}));
|
|
p.appendMatchingAvatar({username:'player'+i});
|
|
assert(f.tweens.every(t=>t.target===p.matchingAvatars.at(-1)), 'only the arriving avatar may animate');
|
|
f.flushTweens();
|
|
assert.deepEqual(p.matchingAvatars.slice(0,-1).map(n=>({x:n.x,y:n.y,scale:n.scale,z:n.zIndex})),existing);
|
|
const arrived=p.matchingAvatars.at(-1),pose=p.matchingLayout[i];
|
|
assert.equal(arrived.x,pose.x);assert.equal(arrived.y,pose.y);assert.equal(arrived.scale,pose.scale);
|
|
}
|
|
assert.equal(calculated,1);
|
|
});
|
|
|
|
test('all progress clouds float gently out of phase while chest, reward and standing avatars stay attached',()=>{
|
|
const f=floatingFixture(),p=f.panel,page=f.page;
|
|
p.prepareProgressRoster(f.stage(20,2),[0,1]);
|
|
const nodes=page.children.filter(n=>n.name!=='StageArt').concat(p.tracks[0].children);
|
|
const hidden=p.tracks.slice(1).flatMap(track=>track.children).map(node=>[node,node.y]);
|
|
const rest=new Map(nodes.map(node=>[node,node.y]));
|
|
const cloud=p.tracks[0].children[1];
|
|
for(let frame=0;frame<600;frame++) {
|
|
p.update(1/60);
|
|
nodes.forEach(node=>assert(Math.abs(node.y-rest.get(node))<=12.000001));
|
|
const delta=name=>{const node=page.getChildByName(name);return node.y-rest.get(node);};
|
|
assert(Math.abs(delta('PrizeCloud')-delta('Chest'))<1e-9);
|
|
assert(Math.abs(delta('PrizeCloud')-delta('ProgressReward'))<1e-9);
|
|
assert(Math.abs(p.progressSlots[0].node.y-cloud.y-60)<1e-9);
|
|
hidden.forEach(([node,y])=>assert.equal(node.y,y,'hidden stage stays at its authored position'));
|
|
}
|
|
assert(nodes.every(node=>Math.abs(node.y-rest.get(node))>0.01),'each cloud receives motion');
|
|
assert.notEqual(nodes[0].y-rest.get(nodes[0]),nodes[nodes.length-1].y-rest.get(nodes[nodes.length-1]));
|
|
assert.equal(f.tweens.length,0,'idle motion does not interfere with avatar tweens');
|
|
});
|
|
|
|
test('cloud floating continues during elimination and restores positions on page hiding and disable',()=>{
|
|
const f=floatingFixture(),p=f.panel;
|
|
p.prepareProgressRoster(f.stage(20,2),[0]);
|
|
const cloud=p.tracks[0].children[1],restY=cloud.y;
|
|
p.update(0.5);assert.notEqual(cloud.y,restY);
|
|
p.prepareProgressRoster(f.stage(19,2),[0]);
|
|
assert.equal(cloud.y,restY);assert.equal(p.progressRoster.y,0);
|
|
assert.equal(p.progressSlots[0].node.y,restY+60);
|
|
p.update(0.5);p.busy=true;p.mode='elimination';const previous=cloud.y;p.update(1/60);
|
|
assert.notEqual(cloud.y,previous);assert.equal(p.progressSlots[0].node.y,cloud.y+60);
|
|
p.busy=false;p.update(0.5);p.mode='participants';p.update(1/60);
|
|
assert.equal(cloud.y,restY);
|
|
p.mode='progress';p.update(0.5);p.onDisable();
|
|
assert.equal(cloud.y,restY);assert.equal(p.progressRoster.y,0);
|
|
p.update(0.5);p.onDestroy();assert.equal(cloud.y,restY);
|
|
});
|
|
|
|
test('during elimination, landed avatars follow the next floating cloud and falling avatars detach',async()=>{
|
|
const f=floatingFixture(),p=f.panel;p.mode='elimination';
|
|
const before=f.stage(79,1),after=f.stage(49,2);
|
|
const task=p.playElimination({before,after});
|
|
const from=p.tracks[0].children[0],to=p.tracks[0].children[1],self=p.progressSlots[0].node;
|
|
p.update(0.3);assert.equal(self.y,from.y+60);
|
|
await f.advance();assert.equal(p.restingAvatars.has(self),false,'jump is driven by its tween');
|
|
p.update(0.3);await f.advance();p.update(0.3);
|
|
assert.equal(self.y,to.y+60,'landed self follows the destination while other players jump');
|
|
await f.advance();
|
|
const falling=p.progressSlots.find(s=>s.index>=49).node;
|
|
assert.equal(p.restingAvatars.has(falling),false);
|
|
await f.advance();await f.advance();assert.equal(await task,true);
|
|
});
|
|
|
|
test('switching stage floats only the newly active Step nodes',()=>{
|
|
const f=floatingFixture(),p=f.panel;
|
|
const old=p.tracks[0].children.map(n=>n.y),next=p.tracks[1].children.map(n=>n.y);
|
|
p.update(0.4);p.tracks[0].active=false;p.tracks[1].active=true;p.update(0.4);
|
|
assert.deepEqual(p.tracks[0].children.map(n=>n.y),old);
|
|
assert(p.tracks[1].children.some((n,i)=>n.y!==next[i]));
|
|
p.onDisable();assert.deepEqual(p.tracks[1].children.map(n=>n.y),next);
|
|
});
|
|
|
|
test('starting another match disposes the previous roster only at the start of that match',async()=>{
|
|
const f=fixture();const task=f.panel.playMatching(f.stage(99));for(let i=0;i<101;i++)await f.advance();await task;
|
|
const clones=f.panel.matchingAvatars.slice(3);assert(clones.every(n=>!n.destroyed));
|
|
f.panel.resetMatchingAvatars();assert(clones.every(n=>n.destroyed));
|
|
assert.equal(f.panel.matchingAvatars.length,1);assert.equal(f.panel.matchingSlots[0].active,false);
|
|
});
|
|
|
|
test('destroying a matching page cancels the avatar tweens and stops later waves',async()=>{
|
|
const f=fixture();const task=f.panel.playMatching(f.stage(99));
|
|
f.panel.node.destroy();f.panel.onDestroy();await task;
|
|
assert(f.tweens.every(t=>t.stopped));assert.equal(f.panel.matchingCount.string,'2/100');
|
|
});
|
|
|
|
test('simulated arrivals add five per two seconds and never finish without the server',()=>{
|
|
const f=fixture(),p=f.panel;p.resetMatchingAvatars();p.addSimulatedMatch();
|
|
p.mode='matching';p.matchPhase='submitting';
|
|
assert.equal(p.matchingCount.string,'2/100');
|
|
p.update(2.001);assert.equal(p.matchingCount.string,'7/100');
|
|
p.update(100);assert.equal(p.matchingCount.string,'99/100');assert.equal(p.matchingAvatars.length,99);
|
|
p.update(100);assert.equal(p.matchingAvatars.length,99);
|
|
p.matchPhase='idle';p.update(10);assert.equal(p.matchingAvatars.length,99);
|
|
});
|
|
|
|
test('success: self jumps first, then all survivors jump, then all eliminated players fall',async()=>{
|
|
const f=fixture(),before=f.stage(79,1),after=f.stage(49,2);
|
|
const task=f.panel.playElimination({before,after});
|
|
assert.equal(f.panel.progressSlots.length,80);assert.equal(f.panel.survivorCount.string,'80/100');
|
|
assert(f.panel.progressSlots.every(s=>s.index<80),'earlier eliminated players are absent');
|
|
const self=f.panel.progressSlots[0].node;
|
|
const [left,right]=f.panel.progressSlots.slice(1,3).map(s=>s.node);
|
|
assert(left.x<self.x&&right.x>self.x&&left.y>self.y&&left.y-self.y<=8&&right.y===left.y);
|
|
assert(f.panel.progressSlots.slice(1).every(s=>s.node.zIndex<self.zIndex));
|
|
await f.advance();assert.deepEqual(f.tweens.map(t=>t.target),[self]);
|
|
await f.advance();assert.equal(f.panel.progressCount.string,'2/5');
|
|
assert(f.tweens.every(t=>f.panel.progressSlots.find(s=>s.node===t.target).index<49));
|
|
assert(f.tweens.every(t=>!t.actions.some(a=>a.props?.opacity===0)));
|
|
const launches=f.tweens.map(t=>t.actions.find(a=>'delay' in a).delay);
|
|
assert(launches[2]<launches[1],'nearby avatars launch in overlapping waves, not a uniform queue');
|
|
const tilts=f.tweens.map(t=>{const target={};t.actions.find(a=>a.props).options.onUpdate(target,.5);return target.angle;});
|
|
assert(tilts.some(n=>n<0)&&tilts.some(n=>n>0),'jump arcs lean in both directions');
|
|
assert(Math.max(...tilts.map(Math.abs))>=14,'staggered jumps retain different tilts');
|
|
await f.advance();assert(f.tweens.every(t=>t.actions.some(a=>a.props?.opacity===0)));
|
|
const drops=f.tweens.map(t=>t.actions.find(a=>a.props?.opacity===0).props);
|
|
assert(drops.some(p=>p.angle>0)&&drops.some(p=>p.angle<0),'eliminations tumble in both directions');
|
|
const counts=[];let displayed=f.panel.survivorCount.string;
|
|
Object.defineProperty(f.panel.survivorCount,'string',{get:()=>displayed,set:value=>{displayed=value;counts.push(Number(value.split('/')[0]));}});
|
|
f.tweens.reverse(); // Slower avatars may finish after those which launched later.
|
|
assert.equal(self.opacity,255);
|
|
await f.advance();assert.equal(f.panel.survivorCount.string,'50/100');
|
|
assert(counts.every((n,i)=>!i||n<=counts[i-1]),'out-of-order drops never increase remaining players');
|
|
assert(f.panel.progressSlots.filter(s=>s.index>=49).every(s=>!s.node.active));
|
|
assert(f.panel.progressSlots.filter(s=>s.index<49).every(s=>s.node.opacity===255));
|
|
assert(f.panel.progressSlots.filter(s=>s.index<49).every(s=>s.node.angle===0),'survivors straighten after landing');
|
|
await f.advance();assert.equal(await task,true);
|
|
});
|
|
|
|
test('failure: survivors jump first, self falls second, other eliminated players fall last',async()=>{
|
|
const f=fixture(),before=f.stage(79,2),after=f.stage(39,2);after.status='lost';after.survivors=39;after.round=3;
|
|
const task=f.panel.playElimination({before,after}),self=f.panel.progressSlots[0].node;
|
|
await f.advance();assert(f.tweens.length>0);assert(f.tweens.every(t=>t.target!==self));
|
|
assert(f.tweens.every(t=>!t.actions.some(a=>a.props?.opacity===0)));
|
|
await f.advance();assert.deepEqual(f.tweens.map(t=>t.target),[self]);
|
|
assert.equal(f.panel.survivorCount.string,'80/100');
|
|
await f.advance();assert.equal(self.opacity,0);assert.equal(f.panel.survivorCount.string,'79/100');
|
|
assert(f.tweens.every(t=>t.target!==self&&t.actions.some(a=>a.props?.opacity===0)));
|
|
await f.advance();assert.equal(f.panel.survivorCount.string,'39/100');
|
|
assert.equal(f.panel.progressCount.string,'2/5','failure does not advance the player score');
|
|
const destination=f.panel.cloudPosition(after,3);
|
|
assert(f.panel.progressSlots.filter(s=>s.index>=0&&s.index<39).every(s=>s.node.y>=destination.y));
|
|
await f.advance();assert.equal(await task,true);
|
|
});
|
|
|
|
test('final win with no eliminations still moves the stack to the reward cloud',async()=>{
|
|
const f=fixture(),before=f.stage(49,4),after=f.stage(49,5),task=f.panel.playElimination({before,after});
|
|
await f.advance();await f.advance();await f.advance();await f.advance();assert.equal(await task,true);
|
|
assert.equal(f.panel.progressCount.string,'5/5');assert.equal(f.panel.survivorCount.string,'50/100');
|
|
assert.equal(f.panel.progressSlots[0].node.y,f.panel.cloudPosition(after,5).y);
|
|
assert(f.panel.progressSlots.every(s=>s.node.active));
|
|
});
|
|
|
|
test('each stage final round sends survivors to the chest cloud on both win and loss',async()=>{
|
|
for(const [stage,target] of [[1,5],[2,7],[3,9]])for(const won of [true,false]){
|
|
const f=fixture(),p=f.panel,prize=p.pages[2].getChildByName('PrizeCloud');
|
|
const before={...f.stage(20,target-1),stage,target,status:'playing'};
|
|
const after={...f.stage(10,won?target:target-1),stage,target,round:target,status:won?'won':'lost',survivors:won?11:10};
|
|
const task=p.playElimination({before,after});
|
|
for(let i=0;i<10;i++)await f.advance();
|
|
assert.equal(await task,true);
|
|
const self=p.progressSlots[0].node;
|
|
assert.equal(self.active,won);
|
|
const landed=p.progressSlots.filter(s=>s.node.active);
|
|
assert(landed.length>0);
|
|
for(const slot of landed)assert.equal(p.restingAvatars.get(slot.node).cloud,prize);
|
|
if(won){assert.equal(self.x,prize.x);assert.equal(self.y,prize.y);}
|
|
const ys=landed.map(s=>s.node.y);prize.y+=8;p.followRestingClouds();
|
|
landed.forEach((s,i)=>assert.equal(s.node.y,ys[i]+8));
|
|
// Reopening a completed stage also uses the reward cloud, with no out-of-range Step access.
|
|
if(won){p.prepareProgressRoster(after,[0,1]);assert.equal(p.restingAvatars.get(p.progressSlots[0].node).cloud,prize);}
|
|
}
|
|
});
|
|
|
|
test('destroying the panel cancels cloud jumps and leaves presentation unacknowledged',async()=>{
|
|
const f=fixture(),task=f.panel.playElimination({before:f.stage(99),after:f.stage(49,1)});
|
|
await f.advance();f.panel.node.destroy();f.panel.onDestroy();
|
|
assert.equal(await task,false);assert.equal(f.panel.animationWaits.length,0);assert(f.tweens.every(t=>t.stopped));
|
|
});
|
|
|
|
test('failure with no surviving opponents drops self first and finishes at zero',async()=>{
|
|
const f=fixture(),before=f.stage(2,0),after=f.stage(0,0);after.status='lost';after.survivors=0;
|
|
const task=f.panel.playElimination({before,after}),self=f.panel.progressSlots[0].node;
|
|
await f.advance();assert.deepEqual(f.tweens.map(t=>t.target),[self]);
|
|
await f.advance();assert.equal(f.panel.survivorCount.string,'2/100');
|
|
await f.advance();assert.equal(f.panel.survivorCount.string,'0/100');
|
|
await f.advance();assert.equal(await task,true);assert(f.panel.progressSlots.every(s=>!s.node.active));
|
|
});
|
|
|
|
test('all stage timeouts move survivors to the next cloud and drop self plus eliminated opponents',async()=>{
|
|
for(const stage of [1,2,3]) for(const score of [0,[5,7,9][stage-1]-1]){
|
|
const f=fixture(),before={...f.stage(99,score),stage,target:[5,7,9][stage-1]},
|
|
after={...f.stage(49,score),stage,target:before.target,round:score+1,status:'expired',survivors:49};
|
|
const task=f.panel.playElimination({before,after}),self=f.panel.progressSlots[0].node;
|
|
for(let i=0;i<8;i++)await f.advance();assert.equal(await task,true);
|
|
assert.equal(self.opacity,0);assert.equal(f.panel.progressCount.string,score+'/'+before.target);
|
|
assert.equal(f.panel.survivorCount.string,'49/100');assert.equal(f.panel.keepEliminationRoster,true);
|
|
const cloud=f.panel.cloudForScore(after,score+1);
|
|
const survivors=f.panel.progressSlots.filter(s=>s.index>=0&&s.index<49);
|
|
const eliminated=f.panel.progressSlots.filter(s=>s.index>=49);
|
|
assert(survivors.length>0&&eliminated.length>0);
|
|
assert(survivors.every(s=>s.node.opacity===255));assert(eliminated.every(s=>s.node.opacity===0));
|
|
assert(survivors.every(s=>f.panel.restingAvatars.get(s.node)?.cloud===cloud));
|
|
}
|
|
});
|
|
|
|
test('elimination falls half as far, emits fading smoke, and retains floating survivors on the failure page',async()=>{
|
|
const f=floatingFixture(),p=f.panel,Node=p.node.constructor;
|
|
f.page.getChildByName('PrizeCloud').component={spriteFrame:{}};
|
|
const avatar=new Node();avatar.setPosition(100,200);let done=0;
|
|
p.dropAvatar(avatar,0,()=>done++,0);const fall=f.tweens[0].actions.find(a=>a.props?.opacity===0);
|
|
assert.equal(fall.props.y,55);f.flushTweens();assert.equal(done,1);assert.equal(avatar.active,false);
|
|
const smoke=p.progressRoster.children.filter(n=>n.name==='EliminationSmoke');
|
|
assert.equal(smoke.length,5);assert(smoke.every(n=>n.x===55&&n.y===55&&n.opacity===210));
|
|
assert(f.tweens.every(t=>t.actions.some(a=>a.props?.opacity===0)));f.flushTweens();assert(smoke.every(n=>n.destroyed));
|
|
p.prepareProgressRoster(f.stage(20,2),[0,1],false);p.mode='result';p.keepEliminationRoster=true;
|
|
const before=p.progressSlots[0].node.y;p.update(.5);assert.notEqual(p.progressSlots[0].node.y,before);
|
|
assert(p.progressSlots.every(s=>s.index>=0&&s.node.active));
|
|
});
|
|
|
|
test('loss and expiry show failure text immediately while avatar motion still completes',async()=>{
|
|
for(const status of ['lost','expired','playing']){
|
|
const f=fixture(),p=f.panel,before=f.stage(8,1),after={...f.stage(4,1),status,round:2};
|
|
p.failureMessage={active:false};p.progressStatsContents=[{active:true},{active:true}];
|
|
const task=p.playElimination({before,after}),failed=status!=='playing';
|
|
assert.equal(p.failureMessage.active,failed,'text is correct before the first animation wait');
|
|
assert(p.progressStatsContents.every(n=>n.active===!failed));
|
|
assert.equal(p.busy,true,'Continue still waits for avatar movement');
|
|
for(let i=0;i<8;i++)await f.advance();
|
|
assert.equal(await task,true);assert.equal(p.failureMessage.active,failed);
|
|
assert.equal(p.keepEliminationRoster,failed);
|
|
if(failed)assert.equal(p.progressSlots[0].node.active,false,'the player still falls off the cloud');
|
|
}
|
|
});
|
|
|
|
test('avatar sizes stay fixed while stack spacing follows cloud size and screen edges',()=>{
|
|
const f=fixture(),p=f.panel;p.design={width:1080};const stage=f.stage(99,1),cloud=p.tracks[0].children[0];
|
|
Object.assign(cloud,{width:240,scaleX:1});p.prepareProgressRoster(stage,Array.from({length:18},(_,i)=>i));
|
|
const small=p.progressSlots[0].node.scale;assert(Math.abs(small-.65*.9)<1e-10);
|
|
const smallDensity=Math.abs(p.progressSlots[1].node.x-cloud.x)/small;cloud.width=360;p.prepareProgressRoster(stage,Array.from({length:18},(_,i)=>i));
|
|
assert.equal(p.progressSlots[0].node.scale,small);
|
|
assert(p.progressSlots.slice(1).every(s=>Math.abs(s.node.scale-.52*.9)<1e-10));
|
|
assert(Math.abs(p.progressSlots[1].node.x-cloud.x)/p.progressSlots[0].node.scale>smallDensity,'larger clouds have looser spacing relative to avatar size');
|
|
const start=p.pages[2].getChildByName('StartingCloud');start.width=900;stage.success_num=0;p.prepareProgressRoster(stage,Array.from({length:18},(_,i)=>i));
|
|
assert(p.progressSlots.every(({node:n})=>Math.abs(n.x)+70*n.scale<540));
|
|
assert(p.progressSlots.slice(1).every(s=>s.node.zIndex<p.progressSlots[0].node.zIndex));
|
|
});
|
|
|
|
test('all three stages keep avatar sizes from the last step through the chest landing and redraw',async()=>{
|
|
for(const [stageIndex,target] of [[1,5],[2,7],[3,9]]){
|
|
const f=fixture(),p=f.panel;
|
|
const before={...f.stage(18,target-1),stage:stageIndex,target,status:'playing'};
|
|
const after={...f.stage(18,target),stage:stageIndex,target,status:'won'};
|
|
Object.assign(p.tracks[stageIndex-1].children.at(-1),{width:240,scaleX:1});
|
|
Object.assign(p.pages[2].getChildByName('PrizeCloud'),{width:600,scaleX:1});
|
|
const task=p.playElimination({before,after});
|
|
const sizes=p.progressSlots.map(s=>s.node.scale);
|
|
for(let i=0;i<5;i++){
|
|
await f.advance();assert.deepEqual(p.progressSlots.map(s=>s.node.scale),sizes);
|
|
}
|
|
assert.equal(await task,true);
|
|
assert.equal(p.restingAvatars.get(p.progressSlots[0].node).cloud,p.pages[2].getChildByName('PrizeCloud'));
|
|
const landed=p.progressSlots.map(s=>({x:s.node.x,y:s.node.y}));
|
|
p.prepareProgressRoster(after,Array.from({length:18},(_,i)=>i));
|
|
assert.deepEqual(p.progressSlots.map(s=>s.node.scale),sizes);
|
|
assert.deepEqual(p.progressSlots.map(s=>({x:s.node.x,y:s.node.y})),landed,'redraw must use the same final landing positions');
|
|
}
|
|
});
|
|
|
|
test('loss settlement prevents duplicate exit actions and checks scene liveness after playback',async()=>{
|
|
const source=fs.readFileSync('assets/Script/Map.ts','utf8');
|
|
const begin=source.indexOf(' private cloudRiseLossPlaying = false;'),end=source.indexOf(' async againLevel()',begin);
|
|
const exports={},calls=[];let resolve,alive=true;
|
|
vm.runInNewContext(ts.transpileModule('export default class MapFixture {'+source.slice(begin,end)+'}',
|
|
{compilerOptions:{module:ts.ModuleKind.CommonJS,target:ts.ScriptTarget.ES2017}}).outputText,
|
|
{exports,cc:{find:()=>({})},CloudRiseService:{finish:won=>calls.push(won)},
|
|
CloudRiseView:{playElimination:()=>new Promise(done=>resolve=done)}});
|
|
const map=new exports.default();map.isMapRuntimeAlive=()=>alive;
|
|
const first=map.settleCloudRiseLoss();assert.equal(await map.settleCloudRiseLoss(),false);
|
|
assert.deepEqual(calls,[false]);resolve();assert.equal(await first,true);
|
|
const stale=map.settleCloudRiseLoss();alive=false;resolve();assert.equal(await stale,false);
|
|
alive=true;resolve=null;
|
|
assert.equal(await map.settleCloudRiseLoss(false),true);
|
|
assert.equal(resolve,null,'abandon records failure without starting a scene animation');
|
|
assert.deepEqual(calls,[false,false,false]);
|
|
});
|
|
|
|
test('victory reveals title and chest together, then coins, then people; close stays locked until complete',async()=>{
|
|
const f=fixture(),p=f.panel;
|
|
p.victoryGroups=['title','chest','coins','people'].map(name=>new f.cc.Node(name));
|
|
p.buttons=Array.from({length:6},()=>({active:true}));p.errorLabel={node:{active:true}};
|
|
let rendered=0;p.render=()=>rendered++;
|
|
const task=p.animateVictory();assert.equal(p.busy,true);assert.equal(p.buttons[0].active,false);
|
|
for(const names of [['title','chest'],['coins'],['people']]) {
|
|
assert.deepEqual(f.tweens.map(t=>t.target.name),names);
|
|
assert(p.victoryGroups.filter(g=>names.includes(g.name)).every(g=>g.opacity===0));
|
|
await f.advance();assert(p.victoryGroups.filter(g=>names.includes(g.name)).every(g=>g.opacity===255));
|
|
}
|
|
await task;assert.equal(p.busy,false);assert.equal(rendered,1);
|
|
});
|
|
|
|
test('leaving during victory stops later reveal groups',async()=>{
|
|
const f=fixture(),p=f.panel;
|
|
p.victoryGroups=['title','chest','coins','people'].map(name=>new f.cc.Node(name));
|
|
p.buttons=Array.from({length:6},()=>({}));p.errorLabel={node:{}};
|
|
p.render=()=>assert.fail('destroyed victory must not render');
|
|
const task=p.animateVictory();await f.advance();p.node.destroy();p.onDestroy();await task;
|
|
assert.equal(p.victoryGroups[2].opacity,0);assert(f.tweens.every(t=>t.stopped));
|
|
});
|
|
|
|
test('main Next and hidden-button guide continuations both wait for activity presentation',async()=>{
|
|
const source=fs.readFileSync('assets/Script/Map.ts','utf8');
|
|
const begin=source.indexOf(' async winLevel('),end=source.indexOf(' this.clearLayerTwoWinCoinFly();',begin);
|
|
let resolve,calls=0;const exports={};
|
|
vm.runInNewContext(ts.transpileModule('export default class NextFixture {'+source.slice(begin,end)+'return true;}}',
|
|
{compilerOptions:{module:ts.ModuleKind.CommonJS,target:ts.ScriptTarget.ES2017}}).outputText,
|
|
{exports,cc:{find:()=>({}),isValid:()=>true},CloudRiseView:{continueFromNextLevel:()=>{calls++;return new Promise(done=>resolve=done);}}});
|
|
const map=new exports.default(),control={_touch:true,setTouch(v){this._touch=v;}};
|
|
map.isMapRuntimeAlive=()=>true;map.getSettlementNextButton=()=>({getComponent:()=>control});
|
|
const first=map.winLevel();assert.equal(control._touch,false);await map.winLevel();assert.equal(calls,1);
|
|
resolve(false);await first;assert.equal(control._touch,true);
|
|
const retry=map.winLevel();resolve(true);assert.equal(await retry,true);assert.equal(calls,2);
|
|
control._touch=true;const guided=map.winLevel(true);assert.equal(calls,3);assert.equal(control._touch,false);
|
|
resolve(true);assert.equal(await guided,true);
|
|
});
|
|
|
|
test('passing a level shows the main win popup without automatically presenting CloudRise',()=>{
|
|
const source=fs.readFileSync('assets/Script/Map.ts','utf8');
|
|
const begin=source.indexOf(' this.check_NewMode();',source.indexOf(' nextLevel('));
|
|
const end=source.indexOf(' }, 660);',begin)+' }, 660);'.length;
|
|
let callback,shown=0;const context={check_NewMode(){},node:{},showWinWhenReady:()=>shown++};
|
|
vm.runInNewContext('(function(){'+source.slice(begin,end)+'}).call(context)',{
|
|
context,cc:{isValid:()=>true},setTimeout:fn=>callback=fn,
|
|
CloudRiseView:{playElimination:()=>assert.fail('must wait for the Next click')}});
|
|
assert.equal(shown,0);callback();assert.equal(shown,1);
|
|
});
|
|
|
|
test('Retry waits for loss presentation before restarting the level',async()=>{
|
|
const source=fs.readFileSync('assets/Script/Map.ts','utf8');
|
|
const begin=source.indexOf(' async againLevel()'),end=source.indexOf(' if (this.SceneManager',begin);
|
|
const exports={},order=[];let release;
|
|
const cc={fx:{AudioManager:{_instance:{playEffect(){}}},GameConfig:{GM_INFO:{hp:5}},GameTool:{getUserPowerTime:()=>false}}};
|
|
vm.runInNewContext(ts.transpileModule('export default class RetryFixture {'+source.slice(begin,end)+"order.push('restart');}}",
|
|
{compilerOptions:{module:ts.ModuleKind.CommonJS,target:ts.ScriptTarget.ES2017}}).outputText,
|
|
{exports,cc,order,MapConroler:{_instance:{powerState:false}}});
|
|
const map=new exports.default();map.isMapRuntimeAlive=()=>true;map.againCanTouch=true;
|
|
map.settleCloudRiseLoss=(play=true)=>{assert.equal(play,true);order.push('animation');return new Promise(done=>release=done);};
|
|
const retry=map.againLevel();assert.deepEqual(order,['animation']);release(true);await retry;
|
|
assert.deepEqual(order,['animation','restart']);
|
|
});
|
|
|
|
test('win return-home buttons wait for CloudRise Continue before navigating, and allow retry if presentation fails',async()=>{
|
|
for(const route of ['Map','SceneManager']) {
|
|
const source=fs.readFileSync('assets/Script/'+route+'.ts','utf8');
|
|
const method=route==='Map'?'returnHome':'returnHomeScene';
|
|
const begin=source.indexOf(' async '+method+'(');
|
|
const end=source.indexOf(route==='Map'?' cc.fx.AudioManager':' cc.fx.GameConfig.locatePositionOnHome',begin);
|
|
assert(begin>=0 && end>begin);
|
|
const exports={},order=[],MapConroler={};let release,alive=true;
|
|
vm.runInNewContext(ts.transpileModule('export default class HomeFixture {'+source.slice(begin,end)+"order.push('transition/home');return true;}}",
|
|
{compilerOptions:{module:ts.ModuleKind.CommonJS,target:ts.ScriptTarget.ES2017}}).outputText,
|
|
{exports,order,MapConroler,cc:{find:()=>({})},CloudRiseView:{continueFromNextLevel:()=>{
|
|
order.push('settlement');return new Promise(done=>release=done);
|
|
}}});
|
|
const view=new exports.default();view.gameWin=true;MapConroler._instance=view;
|
|
view.isMapRuntimeAlive=view.isPopupRuntimeAlive=()=>alive;
|
|
view.settleCloudRiseLoss=()=>assert.fail('a won level must not record a loss');
|
|
const first=view[method](null,'');
|
|
assert.deepEqual(order,['settlement']);
|
|
await view[method](null,'');assert.deepEqual(order,['settlement'],'ignore duplicate taps while waiting');
|
|
release(false);await first;assert.equal(view.returningHome,false);
|
|
const retry=view[method](null,'');assert.deepEqual(order,['settlement','settlement']);
|
|
release(true);assert.equal(await retry,true);
|
|
assert.deepEqual(order,['settlement','settlement','transition/home']);
|
|
await view[method](null,'');assert.equal(order.length,3,'ignore duplicate taps during transition');
|
|
view.returningHome=false;
|
|
const destroyed=view[method](null,'');alive=false;release(true);await destroyed;
|
|
assert.equal(order.at(-1),'settlement','do not navigate from a destroyed scene');
|
|
}
|
|
});
|
|
|
|
test('victory chest sparkles and reward glow pulse while coins stay opaque, then restore on exit',async()=>{
|
|
const f=fixture(),p=f.panel;
|
|
p.victoryGroups=['title','chest','coins','people'].map(name=>new f.cc.Node(name));
|
|
const chest=new f.cc.Node('Chest'),sparkles=new f.cc.Node('ChestSparkles');
|
|
const star=new f.cc.Node('Stars'),glow=new f.cc.Node('Glow'),coins=new f.cc.Node('Coins');
|
|
star.opacity=220;glow.opacity=190;
|
|
p.victoryGroups[1].addChild(chest);chest.addChild(sparkles);sparkles.addChild(star);
|
|
p.victoryGroups[2].addChild(glow);p.victoryGroups[2].addChild(coins);
|
|
p.buttons=Array.from({length:6},()=>({}));p.errorLabel={node:{}};p.render=()=>{};
|
|
p.mode='result';p.victoryPage={active:true};
|
|
const task=p.animateVictory();
|
|
const authoredChildren=sparkles.children.length;
|
|
p.update(0.3);
|
|
assert(star.opacity<220);assert(glow.opacity<190);assert.equal(coins.opacity,255);
|
|
assert.equal(sparkles.children.length,authoredChildren,'collecting lights must not change the hierarchy');
|
|
await f.advance();await f.advance();await f.advance();await task;
|
|
p.mode='overview';p.update(0.1);
|
|
assert.equal(star.opacity,220);assert.equal(glow.opacity,190);assert.equal(p.victorySparkles.length,0);
|
|
});
|
|
|
|
test('Map and pause return-home paths play loss before scene transition',async()=>{
|
|
const mapSource=fs.readFileSync('assets/Script/Map.ts','utf8');
|
|
const begin=mapSource.indexOf(' async returnHome(event, customEventData)'),end=mapSource.indexOf(' cc.fx.AudioManager',begin);
|
|
let recorded=0;const exports={},MapConroler={};
|
|
vm.runInNewContext(ts.transpileModule('export default class ReturnFixture {'+mapSource.slice(begin,end)+'return true;}}',
|
|
{compilerOptions:{module:ts.ModuleKind.CommonJS,target:ts.ScriptTarget.ES2017}}).outputText,{exports,MapConroler});
|
|
const map=new exports.default();MapConroler._instance=map;
|
|
let release,finished=false;
|
|
map.settleCloudRiseLoss=play=>{assert.equal(play,true);recorded++;return new Promise(resolve=>release=resolve);};
|
|
const returning=map.returnHome(null,false).then(result=>{finished=true;return result;});
|
|
await Promise.resolve();assert.equal(finished,false);assert.equal(recorded,1);
|
|
release(true);assert.equal(await returning,true);
|
|
const pauseSource=fs.readFileSync('assets/Script/SceneManager.ts','utf8');
|
|
const a=pauseSource.indexOf(' async returnHome()'),b=pauseSource.indexOf(' this.closePause();',a);
|
|
const pauseExports={};
|
|
vm.runInNewContext(ts.transpileModule('export default class PauseFixture {'+pauseSource.slice(a,b)+'return true;}}}',
|
|
{compilerOptions:{module:ts.ModuleKind.CommonJS,target:ts.ScriptTarget.ES2017}}).outputText,{exports:pauseExports,MapConroler});
|
|
const pause=new pauseExports.default(),control={_touch:true,setTouch(v){this._touch=v;}};
|
|
pause.isPopupRuntimeAlive=()=>true;pause.getDynamicPopup=()=>({getChildByName:()=>({getChildByName:()=>({getComponent:()=>control})})});
|
|
finished=false;
|
|
const exiting=pause.returnHome().then(result=>{finished=true;return result;});
|
|
await Promise.resolve();assert.equal(finished,false);assert.equal(recorded,2);assert.equal(control._touch,false);
|
|
release(true);assert.equal(await exiting,true);
|
|
});
|
|
|
|
test('overview opens with the monthly-card bounce and closes after its reverse animation',()=>{
|
|
const f=fixture(),p=f.panel;p.design=new f.cc.Node();p.background=new f.cc.Node();p.popupScale=0.37;
|
|
p.openPopup();assert.equal(p.popupAnimating,true);assert.equal(p.design.scale,0.37/7);
|
|
const open=f.tweens.find(t=>t.target===p.design);
|
|
assert.deepEqual(Array.from(open.actions.filter(a=>a.props),a=>[a.duration,a.props.scale]),[
|
|
[0.08,0.37*8/7],[0.08,0.37*6/7],[0.08,0.37]]);
|
|
f.flushTweens();assert.equal(p.design.scale,0.37);assert.equal(p.popupAnimating,false);
|
|
let closed=0;p.closePopup(()=>closed++);p.closePopup(()=>closed++);
|
|
assert.equal(closed,0);assert.equal(p.popupAnimating,true);
|
|
const close=f.tweens.find(t=>t.target===p.design);
|
|
assert(close.actions[0].props.scale>p.popupScale);assert(close.actions[1].props.scale<p.popupScale);
|
|
f.flushTweens();assert.equal(closed,1);assert.equal(p.design.opacity,0);
|
|
});
|
|
|
|
test('overview stars pulse, victory rays loop without rotating coins, and both reset on exit',async()=>{
|
|
const f=fixture(),p=f.panel,Node=f.cc.Node;
|
|
const overview=new Node(),top=new Node('PanelTop'),lights=new Node('ChestSparkles'),star=new Node('Stars');
|
|
overview.addChild(top);top.addChild(lights);lights.addChild(star);star.opacity=200;p.pages[0]=overview;
|
|
p.update(0.3);assert(star.opacity<200);p.mode='matching';p.update(0.1);assert.equal(star.opacity,200);
|
|
p.victoryGroups=Array.from({length:4},()=>new Node());
|
|
const rays=new Node('Rays'),coin=new Node('Coins');rays.angle=15;coin.angle=0;
|
|
p.victoryGroups[2].addChild(rays);p.victoryGroups[2].addChild(coin);
|
|
p.buttons=Array.from({length:6},()=>({}));p.errorLabel={node:{}};p.render=()=>{};
|
|
p.mode='result';p.victoryPage={active:true};const task=p.animateVictory();
|
|
p.update(6);assert.equal(rays.angle,195);assert.equal(coin.angle,0);
|
|
p.update(6);assert.equal(rays.angle,15);
|
|
await f.advance();await f.advance();await f.advance();await task;
|
|
p.mode='progress';p.update(0.1);assert.equal(rays.angle,15);assert.equal(p.victoryRays,null);
|
|
});
|
|
|
|
test('only the current badge has one reusable white-gold halo with a 20px bright rim',()=>{
|
|
const f=fixture(),p=f.panel,badge=new f.cc.Node('Badge1');badge.width=228;badge.height=223;
|
|
const strokes=[];
|
|
f.cc.Node.prototype.addComponent=function(){return {ellipse(x,y,rx,ry){assert.equal(rx,120);assert.equal(ry,117.5);},stroke(){strokes.push(this.lineWidth);}};};
|
|
p.highlightStage(badge,true);assert.deepEqual(strokes,[31,25,20]);assert.equal(badge.children.length,1);
|
|
p.highlightStage(badge,false);assert.equal(badge.children[0].active,false);
|
|
p.highlightStage(badge,true);assert.equal(badge.children.length,1);assert.equal(badge.children[0].active,true);
|
|
});
|
|
|
|
test('the Lose prefab abandon action records cloudRise without animation before Health and prevents repeated clicks',async()=>{
|
|
const source=fs.readFileSync('assets/Script/Map.ts','utf8');
|
|
const begin=source.indexOf(' async homeBtn('),end=source.indexOf(' //打开健康条',begin);
|
|
const exports={},order=[];let resolve;
|
|
const tween=()=>({to(){return this;},start(){}});
|
|
const cc={isValid:()=>true,tween,fx:{AudioManager:{_instance:{playEffect(){}}},
|
|
GameConfig:{GM_INFO:{winStreak:0,otherLevel:0,revive:0}},GameTool:{getUserPowerTime:()=>true,shushu_Track(){}}}};
|
|
vm.runInNewContext(ts.transpileModule('export default class AbandonFixture {'+source.slice(begin,end)+'}',
|
|
{compilerOptions:{module:ts.ModuleKind.CommonJS,target:ts.ScriptTarget.ES2017}}).outputText,{exports,cc});
|
|
const children={Health:{active:false,getChildByName:()=>({})},WinStreak:{active:false}};
|
|
const lose={getChildByName:name=>children[name]},root={getChildByName:()=>lose};
|
|
const map=new exports.default();map.node={active:true};map.homeCanTouch=true;
|
|
map.isMapRuntimeAlive=()=>true;map.getLoseRoot=()=>root;map.hideLoseReasonPanels=()=>order.push('health');map.trackFinishi=()=>{};
|
|
map.settleCloudRiseLoss=play=>{assert.equal(play,false);order.push('settle');return new Promise(done=>resolve=done);};
|
|
const abandoned=map.homeBtn(null,'time');
|
|
assert.deepEqual(order,['settle']);assert.equal(children.Health.active,false);
|
|
await map.homeBtn(null,'time');assert.deepEqual(order,['settle']);
|
|
resolve(true);await abandoned;assert.deepEqual(order,['settle','health']);assert.equal(children.Health.active,true);
|
|
// Merely showing revival choices must not call the final-failure path.
|
|
map.homeCanTouch=true;map.reviewState=true;await map.homeBtn(null,'time');assert.deepEqual(order,['settle','health']);
|
|
const prefab=JSON.parse(fs.readFileSync('assets/lose/prefab/Lose.prefab'));
|
|
assert(prefab.filter(o=>o.handler==='homeBtn').length>5,'all reason panels share the real abandon handler');
|
|
});
|
|
|
|
|
|
test('Help TA confirmation waits for CloudRise, prevents duplicate scheduling and restores buttons on failure',async()=>{
|
|
const source=fs.readFileSync('assets/Script/Map.ts','utf8');
|
|
const begin=source.indexOf(' async winLevel('),end=source.indexOf(' this.clearLayerTwoWinCoinFly();',begin);
|
|
const confirmStart=source.indexOf(' onNewModeConfirmed()'),confirmEnd=source.indexOf(' // 点击新功能弹窗的返回按钮',confirmStart);
|
|
let release,calls=0,settlements=0;const scheduled=[],exports={};
|
|
const cc={find:()=>({}),isValid:()=>true};
|
|
vm.runInNewContext(ts.transpileModule('export default class MapFixture {'+source.slice(confirmStart,confirmEnd)+source.slice(begin,end)+'this.transitioned=true;return true;}}',
|
|
{compilerOptions:{module:ts.ModuleKind.CommonJS,target:ts.ScriptTarget.ES2017}}).outputText,
|
|
{exports,cc,CloudRiseView:{continueFromNextLevel:()=>{calls++;return new Promise(done=>release=done);}}});
|
|
const map=new exports.default(),control={_touch:true,setTouch(v){this._touch=v;}};
|
|
const next={active:true,getComponent:()=>control},home={active:true};
|
|
map.gameOverNode={active:false,getChildByName:()=>home};map.getSettlementNextButton=()=>next;
|
|
map.getNewModeRoot=()=>null;map.isMapRuntimeAlive=()=>true;map.releaseNewModePanel=()=>{};
|
|
map.playWinSettlement=()=>settlements++;map.scheduleOnce=fn=>scheduled.push(fn);
|
|
// Execute the actual NewMode confirmation button rather than invoking winLevel directly.
|
|
const modeExports={};
|
|
vm.runInNewContext(ts.transpileModule(fs.readFileSync('assets/NewMode/script/NewMode.ts','utf8'),
|
|
{compilerOptions:{module:ts.ModuleKind.CommonJS,target:ts.ScriptTarget.ES2017,experimentalDecorators:true}}).outputText,
|
|
{exports:modeExports,cc:{_decorator:{ccclass:c=>c,property:(...args)=>args.length>1?undefined:()=>{}},Component:class{},Label:class{},
|
|
fx:{AudioManager:{_instance:{playEffect(){}}}}}});
|
|
const mode=new modeExports.default();mode.node={active:true,emit:name=>{assert.equal(name,'new-mode-confirmed');map.onNewModeConfirmed();}};
|
|
let pending;const continueLevel=map.winLevel.bind(map);map.winLevel=automatic=>pending=continueLevel(automatic);
|
|
mode.clickBtn();map.onNewModeConfirmed();assert.equal(scheduled.length,1);assert.equal(settlements,1);
|
|
assert.equal(home.active,false);assert.equal(next.active,false);assert.equal(calls,0);
|
|
scheduled.shift()();assert.equal(calls,1);assert.equal(map.transitioned,undefined);
|
|
release(false);await pending;
|
|
assert.equal(next.active,true);assert.equal(home.active,true);assert.equal(control._touch,true);
|
|
assert.equal(map.autoNextAfterNewMode,false);assert.equal(map.transitioned,undefined);
|
|
const retry=map.winLevel();await map.winLevel();assert.equal(calls,2);
|
|
release(true);await retry;assert.equal(map.transitioned,true);assert.equal(settlements,1);
|
|
});
|
|
|
|
test('maximum-level confirmation uses the same continuation gate',async()=>{
|
|
const source=fs.readFileSync('assets/Script/Map.ts','utf8');
|
|
const begin=source.indexOf(' winLevel2()'),end=source.indexOf(' // ============================================',begin);
|
|
for(const atMaximum of [false,true]) {
|
|
let stored='',calls=0;const exports={};
|
|
vm.runInNewContext(ts.transpileModule('export default class MaxFixture {'+source.slice(begin,end)+'}',
|
|
{compilerOptions:{module:ts.ModuleKind.CommonJS,target:ts.ScriptTarget.ES2017}}).outputText,
|
|
{exports,cc:{fx:{StorageMessage:{getStorage:()=>stored,setStorage:(key,value)=>stored=value},GameTool:{maxLevel:()=>atMaximum}}}});
|
|
const map=new exports.default();map.isMapRuntimeAlive=()=>true;map.setWinSpecialTipsVisible=()=>{};
|
|
map.winLevel=()=>calls++;map.winLevel2();if(atMaximum){assert.equal(calls,0);map.winLevel2();}
|
|
assert.equal(calls,1);
|
|
}
|
|
});
|
|
|
|
test('promotion follows one smooth curve bounded just above its destination and lands straight',()=>{
|
|
const f=fixture();
|
|
for(const [x,y] of [[250,500],[-220,100],[0,0]])for(let variation=-1;variation<5;variation++){
|
|
const avatar=new f.cc.Node();avatar.x=0;avatar.y=0;
|
|
f.panel.jumpAvatar(avatar,{x,y},.1,{y},variation);
|
|
const t=f.tweens.pop(),motion=t.actions.filter(a=>a.props);assert.equal(motion.length,1);
|
|
assert(!('scale' in motion[0].props),'jumping never changes avatar size');
|
|
const points=[];for(let i=0;i<=100;i++){const n={};motion[0].options.onUpdate(n,i/100);points.push(n);}
|
|
assert.equal(points[0].x,0);assert.equal(points[0].y,0);
|
|
assert.equal(points.at(-1).x,x);assert.equal(points.at(-1).y,y);assert(Math.abs(points.at(-1).angle)<1e-10);
|
|
assert(Math.max(...points.map(n=>n.y))<=Math.max(0,y)+42);
|
|
const speeds=points.slice(1).map((p,i)=>Math.hypot(p.x-points[i].x,p.y-points[i].y));
|
|
assert(speeds[0]<1&&speeds.at(-1)<1,'soft takeoff and landing');
|
|
}
|
|
});
|