Marvel Champions - Hero slim deck box

I wanted a box to hold :

• Hero

• Obligation

• 5 minions

• 40 deck cards

Total: 47 sleeved cards

It needed to be very slim and fit cards using Dragon Shield Perfect Fit sleeves.

I used Icy 's Transformer Card Box model to create a custom box for myself.

Here is the code is you want to edit my version:

//==============================================================================
// Transformer card box
//
// Author: Iaroslav Churinov
// Version: 1.10.4
// License: GPLv3 ( https://www.gnu.org/licenses/gpl-3.0.html )
//
//==============================================================================

/* [Content size] */
//Exact length of the card.
Length=88;//[25:0.1:200]
//Exact width of the card. You can swap length and width for horizontal/vertical orientation
Width=63.5;//[25:0.1:200]
//Height of the stack to store in the box.
Stack_height=32;//[11:0.1:200]
//Vertical space buffer between the deck and the lid.
Margin_vertical=1;//[0:0.1:5]
//Horizontal space buffer between the deck and box sides.
Margin_horizontal=1;//[0:0.1:5]

/* [Card protection sleeves] */
//Extra length added by protection sleeves. Leave at 0 when cards without protection sleeves.
Sleeve_padding_vertical=0;//[0:0.1:10]
//Extra width added by protection sleeves. Leave at 0 when cards without protection sleeves.
Sleeve_padding_horizontal=0;//[0:0.1:10]

/* [Divisions] */
//Number of equal divisions inside the box. 1 = no dividers.
Division_count=1;//[1:10]
//Dividers geometry. None = no dividers.
Divider_type="None";//[None,Wings,Grounded-Wings,Notched-Wall]
//Allows to maintain same capacity independently from amount of Subdivisions and Divider thickness.
Divider_compensation=true;
Divider_thickness=0.8;//[0.8:0.2:2.4]
//Custom(non-equal) division space allocated between dividers. Example [2,4,4]. Division_count is ignored when array is not empty. Any divider placed out of the box will be ignored.
Subdivisions=[];//[0.1:0.1:50]

/* [Box customization] */
//Cut a notch at the top of the box.
Box_top_notch=true;
//Cut a notch at the bottom of the box.
Box_bottom_notch=true;
//Hexagonal perforation on the back wall of the box.
Box_back_perforation=true;
//Geometry of the front wall that holds the deck.
Box_front_type="Wings";//[None,Wings,Grounded-Wings,Notched-Wall]
//Disable if you don't need L-shape snaping.
L_snapping=true;

/* [Lid customization] */
//Cut a notch at the top
Lid_top_notch=true;
//Cut a notch at the front bottom
Lid_bottom_notch=true;
//Hexagonal perforation on the front of the lid.
Lid_front_perforation=true;
//Cut window in the lid
Lid_window=true;
//Distance from window to the top wall of the lid
Lid_window_padding_top=5;//[0:0.1:100]
//Distance from window to the bottom wall of the lid
Lid_window_padding_bottom=33;//[0:0.1:100]
//Distance from window to the left/tight wall of the lid
Lid_window_padding_side=7;//[0:0.1:100]
//Window corners cut
Lid_window_chamfer=5;//[1:0.1:20]

/* [Fine-tuning] */
//Boxes of different sizes may require different printing orientation. IMPORTANT! Lid SHOULD be printed perpendicular if you want L-shape assembly.
Printing_position="a";//[a,b]
//Smaller boxes may be printed with thinner walls
Wall=1.6;//[1.2:0.2:2.4]
//Adjust according to your confidence in the dimensional accuracy of your printer and filament
Tolerance=0.14;//[0.1:0.01:0.2]
//Higher value = more grip when sliding the lid
Peg_collision=0.1;//[0:0.01:0.3]
//Distance from the side of the box to the notch edge
Notch_padding=9;//[1:0.1:100]
Notch_depth=5;//[1:0.1:20]

/* [Hidden] */
IN_X=Stack_height + (((Divider_type!="None")&&Divider_compensation)?
(len(Subdivisions)>0?len(Subdivisions):(Division_count-1))*Divider_thickness:0);
echo("Inner X: ",IN_X);
IN_Y=Width+Margin_horizontal+Sleeve_padding_horizontal;
echo("Inner Y: ",IN_Y);
IN_Z=Length+Margin_vertical+Sleeve_padding_vertical;
echo("Inner Z: ",IN_Z);

OUT_X=Wall+IN_X+Wall+Tolerance+Wall;
echo("Outer X: ",OUT_X);
OUT_Y=IN_Y+(Wall*2+Tolerance)*2;
echo("Outer Y: ",OUT_Y);
OUT_Z=IN_Z+(Wall*2+Tolerance);
echo("Outer Z: ",OUT_Z);

SNAP_DEPTH=Wall>1.2?0.8:0.4;
SNAP_HOOK_HEIGHT=SNAP_DEPTH+Tolerance+Peg_collision;
SNAP_HOLE=4;
SNAP_HOLE_DEPTH=SNAP_HOOK_HEIGHT+Tolerance;
SNAP_WINDOW=SNAP_HOLE+Wall*2;
SNAP_WINDOW_BUFFERED=SNAP_WINDOW+(Wall+Tolerance)*2;

//Main
translate([-(OUT_X+Wall+OUT_Z)/2,0,0]){
box();
lid();
}

module box(){
rotate([90,0,0])copyMirror([0,0,1])difference(){
union(){
boxProfile();
boxSideWallAssembly();
};
boxBottomChamfer();
#boxTopNotch();
#boxBottomNotch();
if(Box_back_perforation)#boxBackPerforation();
}
}

module boxProfile(){
linear_extrude(IN_Y/2+0.001)polygon([
[0,OUT_Z-Wall-Tolerance],
[Wall,OUT_Z-Wall-Tolerance],
[Wall,Wall],
[Wall*2+IN_X,Wall],
[Wall*2+IN_X,0],
[0,0]
]);
}

module boxSideWallAssembly(){
translate([0,0,IN_Y/2]) union(){
difference(){
boxSideWall();
boxSnapHoles();
boxSnapRails();
}
boxSideWallGuide();
if (Box_front_type!="None")
boxFrontWall();
if (Divider_type!="None")
boxDividers();
};
}

module boxSideWall(){
linear_extrude(Wall)polygon([
[0,OUT_Z-Wall-Tolerance],
[SNAP_WINDOW,OUT_Z-Wall-Tolerance],
[SNAP_WINDOW*2,OUT_Z-Wall-Tolerance-SNAP_WINDOW],
[Wall*2+IN_X,OUT_Z-Wall-Tolerance-SNAP_WINDOW],
[Wall*2+IN_X,0],
[0,0]
]);
}

module boxSideWallGuide(){
guideHeight=Wall+Tolerance;
if(!L_snapping){
points=[
[0,OUT_Z-SNAP_WINDOW_BUFFERED],
[SNAP_WINDOW,OUT_Z-SNAP_WINDOW_BUFFERED-SNAP_WINDOW],
[SNAP_WINDOW,Wall*3+SNAP_WINDOW_BUFFERED],
[SNAP_WINDOW/2,Wall*3+SNAP_WINDOW_BUFFERED-SNAP_WINDOW/2],
[0,Wall*3+SNAP_WINDOW_BUFFERED],
];
difference() {
translate([0,0,Wall])linear_extrude(guideHeight)polygon(points);
prism_chamfer_mask(points,start_edge=0,end_edge=4,height=guideHeight+Wall,
side=guideHeight,side2=guideHeight,corner_slope="deep");
}
}else if(Stack_height 0?dividerPositionsCustom():dividerPositionsEqual();
echo(dividerPositions);
if (len(dividerPositions)>0){
for (pos=dividerPositions) {
if(pos SNAP_WINDOW*2+Tolerance)
prism_chamfer_mask_e([SNAP_WINDOW*2+Tolerance,0],[OUT_X-Wall,0],side=Wall);
prism_chamfer_mask_e([-(SNAP_WINDOW+Tolerance-Wall),OUT_Z-Wall*4],
[0,OUT_Z-SNAP_WINDOW_BUFFERED-Wall], side=Wall);
prism_chamfer_mask(points,start_edge=3,end_edge=5,height=0,
side=Wall, side2=Wall, corner_slope="deep");
translate([0,0,Wall])prism_chamfer_mask_e([0,OUT_Z],[0,OUT_Z-Wall*2-SNAP_WINDOW_BUFFERED],
side=Wall,top=1);
}
}

module lidSnapHooks(){
snapHook([Wall,OUT_Z-Tolerance-SNAP_WINDOW]);
snapHook([OUT_X-Wall*2-SNAP_HOLE-Tolerance,OUT_Z-Tolerance-SNAP_WINDOW*2]);
snapHook([OUT_X-Wall*2-SNAP_HOLE-Tolerance,SNAP_WINDOW+Wall]);
}

module lidFrontPerforation(){
hexD=8;
intersection(){
translate([OUT_X-Wall,-hexD/2,-hexD/2])rotate([90,0,90])hexgrid([OUT_Z+hexD,OUT_Y/2+hexD,Wall],hexD);
difference(){
translate([OUT_X-Wall-0.1,Wall,0])cube([Wall+0.2,OUT_Z-Wall*2,OUT_Y/2-Wall]);
if(Lid_bottom_notch)translate([OUT_X-Wall,0,0])notchNwall();
if(Lid_window)lidWindowWall();
}
}
}

module snapHook(start){
hookHeight=SNAP_DEPTH+Tolerance*2;
points = [
start,
[start.x,start.y+SNAP_HOLE],
[start.x+SNAP_HOLE,start.y+SNAP_HOLE],
[start.x+SNAP_HOLE,start.y]
];
translate([0,0,Wall-hookHeight+.001])difference(){
linear_extrude(hookHeight)polygon(points);
prism_chamfer_mask(points,start_edge=0,end_edge=3,height=0,
side=hookHeight, side2=hookHeight, corner_slope="deep");
}
}

module copyMirror(vec){
children();
mirror(vec)
children();
}

module hex(hole, thick){
translate([0,0,-0.1])rotate([0,0,30])cylinder(d=hole,h=thick+0.2,$fn=6);
}

module hexgrid(box,hexD){
a=hexD*sin(60)+Wall;
for(x =[hexD/2:a:box[0]]) {
for(y =[hexD/2:2*a*sin(60):box[1]]){
translate([x,y,0])hex(hexD,box[2]);
translate([x+a*cos(60),y+a*sin(60),0])hex(hexD,box[2]);
}
}
}

//==============================================================================
//
// prism-chamfer - the missing chamfer tool for OpenSCAD
//
// Author: Heath Raftery
// Origin: http://github.com/hraftery/prism-chamfer
// License: GPLv3, see LICENSE for terms.
//
// See the accompanying README for instructions on use.
//
//==============================================================================

//===========
// Variables
//===========

ff=0.001; // Fudge factor: amount of extra mask to prevent zero thickness planes.

//===========
// Functions
//===========

function translate_towards(p0, p1, dist) = p0 + (dist/norm(p1-p0))*(p1-p0);
function min_index(v, only_first=false) = search(min(v), v, only_first?1:0);
function max_index(v, only_first=false) = search(max(v), v, only_first?1:0);
function mod(a,n) = (a+n)%n; // add support for (slightly) negative modulo

//Find the cartesian angle of a vector from p0 to p1.
//Note contrary to docs, atan2 returns [-180,180]
function angle_of(p0, p1) = atan2(p1.y-p0.y, p1.x-p0.x);

//Calculate angle halfway between the angles of a vertex.
//Ref: https://math.stackexchange.com/a/4750179/787256
function corner_angle(p0, p1, p2) =
let (a0 = angle_of(p0,p1),
a1 = angle_of(p1,p2),
deltaA = a1 - a0,
inner_dA = deltaA 180 ? deltaA - 360 :
deltaA)
a0 + (inner_dA/2);

//Return the three points that define the vertex at the point specified
function vertex_points(polygon_points, point_index) =
let (num_pts = len(polygon_points))
[ polygon_points[mod(point_index-1, num_pts)],
polygon_points[mod(point_index , num_pts)],
polygon_points[mod(point_index+1, num_pts)] ];

//Determine orientation of polygon. Ref:
// https://en.wikipedia.org/wiki/Curve_orientation#Orientation_of_a_simple_polygon
function is_polygon_orientation_clockwise(polygon_points) =
let (min_x_indices = min_index([for (pt = polygon_points) pt.x]),
min_y_index_in_min_x_indices = min_index([for (i = min_x_indices) polygon_points[i].y]),
min_x_min_y_index = min_x_indices[min_y_index_in_min_x_indices[0]],
vertex_pts = vertex_points(polygon_points, min_x_min_y_index))
is_vertex_convex(vertex_pts, true);

function is_vertex_convex(pts, cw) =
let (A = pts[0], B = pts[1], C = pts[2],
//This determinate calc is the same as cross(AB,BC). But we have points,
//so use the simplification from the polygon orientation reference above.
det = (B.x-A.x)*(C.y-A.y) - (C.x-A.x)*(B.y-A.y),
right_turn = det = 3);
assert(end_edge >= start_edge);
// Allow specifying edges past the first point, in the -ve or +ve direction,
// up to but not including a complete rotation. Allows the corner at the
// first point to be included in a contiguous range.
assert(start_edge > -num_pts && end_edge 1);
for(i = [0:num_points-2]) {
prism_chamfer_mask_e(points[i], points[i+1], side, side2, cw, top,
include_p0 = i==0 ? include_start : true,
include_p1 = i==num_points-2 ? include_end : true);

if(i 0 : top; //set top to positivity of z unless specified
assert(p0.z == p1.z); //only points in the same x-y plane are supported
assert(side>0 && side2>0);
assert(p0!=p1);

//Conditional transforms don't seem to be supported. Fortunately mirror
//seems to be a nop if the argument is [0,0,0], so we can use a variable
//and this dodgy conditional assignment construct instead:
mr_args = (!top && cw) ? [[1,0,0],[ 90,0,-90]] : //bottom, cw
( top && cw) ? [[0,0,0],[-90,0,-90]] : //top, cw
( top && !cw) ? [[1,0,0],[-90,0, 90]] : //top, ccw
[[0,0,0],[ 90,0, 90]]; //bottom, ccw

length = norm(p1-p0) + (include_p0?ff:-ff) + (include_p1?ff:-ff);
p0_fudged = translate_towards(p0, p1, include_p0?-ff:ff); //shift p0 fwd or back by fudge factor
translate(p0_fudged) rotate([0, 0, angle_of(p0, p1)]) //align with p0 -> p1
mirror(mr_args[0]) rotate(mr_args[1]) //orient to x-y plane, in +x direction
linear_extrude(height=length)
polygon([[-ff,-ff],[side,-ff],[-ff,side2]]);
}

//Create a chamfer mask for the corner between two prism edges.
module prism_chamfer_mask_c(p0, p1, p2, side=1, side2=0, cw=false, top=undef,
slope="medium") {
side2 = side2 == 0 ? side : side2; //set sides equal unless side2 is specified
top = is_undef(top) ? p0.z > 0 : top; //set top to positivity of z unless specified
assert(p0.z == p1.z && p1.z == p2.z); //only points in the same x-y plane are supported
assert(side>0 && side2>0);
assert(p0!=p1 && p1!=p2 && p0!=p2);

corner_angle = corner_angle(p0, p1, p2);

if(is_vertex_convex([p0,p1,p2],cw)) {
//no mask needed for outside corners
}
else if(slope=="deep") { //then carve out as much as possible
intersection() {
//Just extend the two edge chamfers so they overlap fully.
prism_chamfer_mask_e(p1, translate_towards(p1,p0,-side), side, side2, cw, top);
prism_chamfer_mask_e(translate_towards(p1,p2,-side), p1, side, side2, cw, top);
}
}
else if(slope=="shallow") { //then carve out as little as possible. Inspired by corner-tools.scad
translate(p1) rotate([0, 0, corner_angle])
rotate([0, 0, 45]) //rotate to put it symmetrical around the x axis
polyhedron(points = [[-ff,-ff,ff], [side,-ff,ff], [-ff,side,ff], [-ff,-ff,-side2]],
faces = [[0,2,1], [0,1,3], [0,3,2], [1,2,3]],
convexity = 100);
}
else { //otherwise, do a "medium" half-way corner
c0 = [p1.x - side*cos(corner_angle), p1.y - side*sin(corner_angle), p1.z];
c1 = [p1.x + side*cos(corner_angle), p1.y + side*sin(corner_angle), p1.z];
intersection() {
//Same as "deep", but also intersect a third mask with angle half-way between
//the first two. c0 and c1 just extend the edge either side of the corner point.
prism_chamfer_mask_e(p1, translate_towards(p1,p0,-side), side, side2, cw, top);
prism_chamfer_mask_e(translate_towards(p1,p2,-side), p1, side, side2, cw, top);
prism_chamfer_mask_e(c0, c1, side, side2, cw, top);
}
}
}