Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-3-5-sonnet-20241022· AnthropicHugging Face LMArena Human Preference 140K

"the aboslute best most visually appealing beatufuil visualization of a town in the…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-3-7-sonnet-20250219’s answer.
  1. User

    "the aboslute best most visually appealing beatufuil visualization of a town in the 1500s, absolutely detailed and amazing. no pngs, 3d files will not be used. outupt 3d scene complete code, not examples. Use the following libraries: no loading screen

    always output entire code all in one htmlf ile, do not use jpgs/pngs "

  2. Claude Assistant

    Here's a complete HTML file creating a stylized 1500s town using Three.js with procedurally generated buildings and details:

    <!DOCTYPE html>
    <html>
    <head>
        <title>1500s Town Visualization</title>
        <style>
            body { margin: 0; overflow: hidden; }
            canvas { display: block; }
        </style>
    </head>
    <body>
        <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
        <script src="https://cdn.jsdelivr.net/npm/three@0.128.0/examples/js/controls/OrbitControls.js"></script>
    
        <script>
            const scene = new THREE.Scene();
            const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
            const renderer = new THREE.WebGLRenderer({ antialias: true });
            renderer.setSize(window.innerWidth, window.innerHeight);
            renderer.shadowMap.enabled = true;
            document.body.appendChild(renderer.domElement);
    
            // Lighting
            const ambientLight = new THREE.AmbientLight(0xcccccc, 0.4);
            scene.add(ambientLight);
    
            const dirLight = new THREE.DirectionalLight(0xffffff, 0.8);
            dirLight.position.set(50, 100, 50);
            dirLight.castShadow = true;
            scene.add(dirLight);
    
            // Ground
            const groundGeometry = new THREE.PlaneGeometry(100, 100);
            const groundMaterial = new THREE.MeshStandardMaterial({ 
                color: 0x8B4513,
                roughness: 0.8
            });
            const ground = new THREE.Mesh(groundGeometry, groundMaterial);
            ground.rotation.x = -Math.PI / 2;
            ground.receiveShadow = true;
            scene.add(ground);
    
            function createHouse(x, z) {
                const house = new THREE.Group();
    
                // Main building
                const buildingHeight = 2 + Math.random() * 2;
                const buildingGeometry = new THREE.BoxGeometry(2, buildingHeight, 2);
                const buildingMaterial = new THREE.MeshStandardMaterial({ 
                    color: 0xD2B48C,
                    roughness: 0.7
                });
                const building = new THREE.Mesh(buildingGeometry, buildingMaterial);
                building.position.y = buildingHeight / 2;
                building.castShadow = true;
                building.receiveShadow = true;
                house.add(building);
    
                // Roof
                const roofGeometry = new THREE.ConeGeometry(1.5, 1.5, 4);
                const roofMaterial = new THREE.MeshStandardMaterial({ 
                    color: 0x8B4513,
                    roughness: 0.6
                });
                const roof = new THREE.Mesh(roofGeometry, roofMaterial);
                roof.position.y = buildingHeight + 0.75;
                roof.rotation.y = Math.PI / 4;
                roof.castShadow = true;
                house.add(roof);
    
                // Door
                const doorGeometry = new THREE.PlaneGeometry(0.5, 1);
                const doorMaterial = new THREE.MeshStandardMaterial({ 
                    color: 0x4A3C2A,
                    roughness: 0.9
                });
                const door = new THREE.Mesh(doorGeometry, doorMaterial);
                door.position.z = 1.01;
                door.position.y = 0.5;
                house.add(door);
    
                // Windows
                for (let i = 0; i < 2; i++) {
                    const windowGeometry = new THREE.PlaneGeometry(0.4, 0.4);
                    const windowMaterial = new THREE.MeshStandardMaterial({ 
                        color: 0x87CEEB,
                        roughness: 0.3
                    });
                    const window = new THREE.Mesh(windowGeometry, windowMaterial);
                    window.position.z = 1.01;
                    window.position.y = 1.5;
                    window.position.x = i === 0 ? -0.5 : 0.5;
                    house.add(window);
                }
    
                house.position.set(x, 0, z);
                house.rotation.y = Math.random() * Math.PI * 2;
                return house;
            }
    
            // Create town layout
            for (let i = -4; i <= 4; i += 2) {
                for (let j = -4; j <= 4; j += 2) {
                    if (Math.random() > 0.2) { // 80% chance to place a house
                        const house = createHouse(i * 2, j * 2);
                        scene.add(house);
                    }
                }
            }
    
            // Add trees
            function createTree(x, z) {
                const tree = new THREE.Group();
    
                const trunkGeometry = new THREE.CylinderGeometry(0.2, 0.2, 2, 8);
                const trunkMaterial = new THREE.MeshStandardMaterial({ 
                    color: 0x4A3C2A,
                    roughness: 0.8
                });
                const trunk = new THREE.Mesh(trunkGeometry, trunkMaterial);
                trunk.position.y = 1;
                trunk.castShadow = true;
                tree.add(trunk);
    
                const leavesGeometry = new THREE.ConeGeometry(1, 2, 8);
                const leavesMaterial = new THREE.MeshStandardMaterial({ 
                    color: 0x228B22,
                    roughness: 0.7
                });
                const leaves = new THREE.Mesh(leavesGeometry, leavesMaterial);
                leaves.position.y = 2.5;
                leaves.castShadow = true;
                tree.add(leaves);
    
                tree.position.set(x, 0, z);
                return tree;
            }
    
            // Add trees around the town
            for (let i = 0; i < 20; i++) {
                const x = (Math.random() - 0.5) * 40;
                const z = (Math.random() - 0.5) * 40;
                if (Math.abs(x) > 10 || Math.abs(z) > 10) { // Only place trees outside the town
                    const tree = createTree(x, z);
                    scene.add(tree);
                }
            }
    
            // Camera and controls setup
            camera.position.set(20, 20, 20);
            const controls = new THREE.OrbitControls(camera, renderer.domElement);
            controls.enableDamping = true;
            controls.dampingFactor = 0.05;
            controls.minDistance = 5;
            controls.maxDistance = 50;
    
            // Animation
            function animate() {
                requestAnimationFrame(animate);
                controls.update();
                renderer.render(scene, camera);
            }
            animate();
    
            // Window resize handler
            window.addEventListener('resize', onWindowResize, false);
            function onWindowResize() {
                camera.aspect = window.innerWidth / window.innerHeight;
                camera.updateProjectionMatrix();
                renderer.setSize(window.innerWidth, window.innerHeight);
            }
        </script>
    </body>
    </html>
    

    This code creates a medieval town scene with:

    1. Procedurally generated houses with varying heights and rotations
    2. Detailed buildings with roofs, doors, and windows
    3. Random tree placement around the town
    4. Realistic lighting and shadows
    5. Orbit controls for camera movement
    6. Responsive design that adapts to window resizing

    The scene features:

    • Textured buildings with wooden doors and blue windows
    • Cone-shaped roofs
    • Trees with trunks and foliage
    • A ground plane
    • Ambient and directional lighting
    • Shadows for added realism
    • Random variation in building placement and rotation

    You can interact with the scene by:

    • Left-click and drag to rotate the view
    • Right-click and drag to pan
    • Scroll to zoom in/out

    The scene is completely procedural and doesn't use any external textures or image files.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.