Use of reflection and DRYing out some code

I have a function that needs to receive a type, determine the subtype, then create a copy of the subtype. I keep staring at this function and I feel this can be simplified, but I just can't figure out how to get it functioning. Here's the code:

func AddProp(prop prop, x, y int) []prop {

  v := reflect.ValueOf(prop)
  fmt.Printf("Prop type is %v", v.Type())

  switch v.Type() {
  case reflect.TypeOf(&Fence{}):
  	f := Fence{}
  	f.New(x, y)
  	props = append(props, &f)
  case reflect.TypeOf(&Rock{}):
  	f := Rock{}
  	f.New(x, y)
  	props = append(props, &f)
  }
  return props
}

It's actually quite a bit longer than this with many more cases. Thank you for taking a look!

Edit:
Perfectly reasonable question - what is a prop?

type prop interface {
	New(int, int)
}

Second Edit:
My structs looks like this:

type Prop struct {
	fullImage image.Image
	x, y int
}
type Fence struct {
	Prop
	horizontal bool
} 

I have New(x,y int) defined for both

func (p *Prop) New(x, y int)
func (p *Fence) New(x, y int)

I need to get the Fence struct and call the New based on the Fence and not the Prop

You can simplify this provided all types have the New method:

package main

import (
	"fmt"
	"reflect"
)

func main() {

	props := AddProp(&Rock{}, 1, 1)
	fmt.Printf("%#v\n", props)

	props = AddProp(&Fence{}, 1, 1)
	fmt.Printf("%#v\n", props)

}

type Rock struct{}

func (r *Rock) New(x, y int) {}

type Fence struct{}

func (r *Fence) New(x, y int) {}

type prop interface {
	New(x, y int)
}

func AddProp(p prop, x, y int) (props []prop) {
	newValue := reflect.New(reflect.TypeOf(p).Elem()).Interface()
	z := newValue.(prop)
	z.New(x, y)
	props = append(props, z)
	return props
}